Idea: Marketplace for MCP Servers with Simple Dynamic Installation in Theia

[planger]

Edit: I opened a discussion on this topic in the MCP discussion group: modelcontextprotocol/discussions/274
Also I opened issues in the other AI IDEs

• Cursor
• Windsurf
• VS Code

---

This proposal outlines a system to dynamically integrate Model Context Protocol (MCP) servers with Eclipse Theia through VS Code extensions (VSX). The architecture leverages Theia's VSX compatibility to allow MCP server providers to package and distribute their servers via OpenVSX, enabling runtime installation and management.

Components

1. Theia MCP Server Provider Extension

Individual VSX extensions that package MCP server binaries and register them with the central registry.

• Packages the MCP server executable
• Declares dependency on the Theia MCP Registry Extension (see below)
• Registers server configuration during activation

Implementation Example:

// Extension activation in server provider extension
export function activate(context: vscode.ExtensionContext) {
    const mcpRegistryExtension = vscode.extensions.getExtension('theia-mcp.registry');
    if (mcpRegistryExtension) {
        const api = mcpRegistryExtension.exports;
        const serverPath = context.asAbsolutePath('./bin/my-mcp-server');
        
        api.registerServer({
            name: "MyMCPServer",
            command: serverPath,
            args: ["--port", "9000"],
            env: { "NODE_ENV": "production" },
            autostart: true,
            version: "1.0.0"
        });
    }
}

2. Theia MCP Registry Extension

Central VSX extension that exposes an API for registering MCP servers and communicates with the Theia backend via Commands.

• Exposes an API for MCP server registration
• Issues commands to communicate with the Theia backend
• Maintains registry of available servers

API Interface:

export interface MCPRegistryAPI {
  registerServer(config: MCPServerConfig): Promise<string>;
  unregisterServer(serverId: string): Promise<void>;
  updateServerConfig(serverId: string, config: Partial<MCPServerConfig>): Promise<void>;
}

export interface MCPServerConfig {
  name: string;
  command: string;
  args?: string[];
  env?: Record<string, string>;
  autostart?: boolean;
  capabilities?: string[];
  version: string;
}

Implementation Example:

export function activate(context: vscode.ExtensionContext) {
    const api: MCPRegistryAPI = {
        registerServer: async (config) => {
            const serverId = generateServerId(config);
            await vscode.commands.executeCommand('theia-mcp.register-server', config);
            return serverId;
        },
        // Other API methods...
    };
    
    return api;
}

3. Theia MCP VSX Extension Bridge

A Theia backend service that handles VS Code commands and integrates with the existing MCP server infrastructure.

• Registers VS Code command handlers
• Translates between VS Code extension API and Theia internal APIs
• Communicates with MCPServerManagerImpl

Integration with Existing Theia Code:

@injectable()
export class MCPVSXExtensionBridge {
    @inject(MCPServerManager)
    protected readonly mcpServerManager: MCPServerManager;
    
    initialize(): void {
        commands.registerCommand('theia-mcp.register-server', (config: MCPServerConfig) => {
            const serverDescription: MCPServerDescription = {
                name: config.name,
                command: config.command,
                args: config.args,
                env: config.env,
                autostart: config.autostart
            };
            
            this.mcpServerManager.addOrUpdateServer(serverDescription);
        });
    }
}

Distribution via OpenVSX

MCP server providers can publish their Theia MCP Server Provider Extensions to OpenVSX, allowing:

• Easy discovery of available MCP servers via open-vsx.org
• Simplified installation directly within Theia
• Version management and updates of MCP servers

Critical Discussion

• Lightweight Implementation: This approach requires minimal additional code in Theia, leveraging existing infrastructure and integration.

• Reuse of Extension Registry: The solution takes advantage of OpenVSX's runtime installation capabilities and discovery mechanisms. Using tags like mcp in OpenVSX may enhance discoverability of MCP server providers.

• Standard Communication: The architecture relies on the generic VS Code Extension API and commands for communication between Theia and extensions, avoiding custom protocols.

• API Limitations: Ideally, the API for registering MCP servers would be more explicit, perhaps through declarative definitions in package.json or dedicated APIs rather than commands. However, this would require extending the VS Code Extension API with Theia-specific concepts.

• Process Management Trade-offs: While it would be beneficial for VS Code extensions to manage their own MCP server processes, the current StdioClientTransport implementation in Theia makes it more practical for the Theia backend to handle this. Supporting WebSocketClientTransport would allow extensions to start their own servers and have Theia connect via websocket, offering more flexibility.

[JonasHelming]

Two comments:

• MCP supports SSE, there is an on-going PR for this: feat(mcp-server): add support for SSE transport and enhance server co… #15233
• One core advantages would be that users can check the publisher of a VS Code extensions to decide whether they trust them. However, we would need to bootstrap this by publishing some MCP servers I think. So an interesting question would be: Are we legally allowed to publish MCP binaries e.g. the core ones from https://github.com/modelcontextprotocol/servers which are under MIT?

[JonasHelming]

Another comment: there is also https://github.com/anaisbetts/mcp-installer , but AFAIU, it only supports installing MCP servers into Claude Desktop. However, we could follow a similar approach and provide functions for users to basically modify the settings.json
This would be more lightweight and we could access existing MCP repos.
The downside is that we let the user consume arbitrary binaries.