Rgarcia MCP Server Server

🚀 MCP Server Server

This repository is a proof-of-concept project for an MCP server that allows you to launch other MCP servers.

🤔 But... Why?

Using MCP servers is inconvenient.

The main transmission mechanism of MCP servers is standard input-output (stdio). That is, in your MCP client program, you need to spawn a new process for each MCP server you want to use. This has drawbacks:

1. It's cumbersome - every MCP client needs to be a process manager. The configuration method of Claude Desktop is a good example - it needs to maintain a list of processes to run.
2. It poses an infrastructure problem: if you have multiple users, each of them requires a different MCP server configuration (e.g., they all have authentication credentials to access different underlying MCP servers such as Github, Google Drive, etc.), then you'll face a large number of processes to manage and route client requests.

💡 A Better Approach

What if MCP servers were actually... servers? That is, they communicate over the network instead of using stdio? Then you can interact with them programmatically more easily.

Step 1: Convert Existing Stdio MCP Servers to WebSocket MCP Servers

This repository contains a wrapper program that exposes existing MCP servers (a list of official ones can be found here, but they are currently scattered) via WebSocket:

bun run mcp-server -p 3001 -- npx -y @modelcontextprotocol/server-puppeteer@latest

Step 2: Interact with MCP Servers Programmatically without Managing Processes

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";

const transport = new WebSocketClientTransport(new URL("ws://localhost:3001"));

const client = new Client(
  {
    name: "example-client",
    version: "1.0.0",
  },
  {
    capabilities: {},
  }
);
await client.connect(transport);
const tools = await client.listTools();
console.log(
  "Tools:",
  tools.tools.map((t) => t.name)
);
await client.close();

bun run mcp-server-wrapper-client
$ bun run src/mcp-server-wrapper/example-client/example-client.ts
Tools: [ "puppeteer_navigate", "puppeteer_screenshot", "puppeteer_click", "puppeteer_fill",
  "puppeteer_evaluate"
]

Step 3: Build MCP Servers

TODO: Currently, we haven't solved the second problem. As an MCP client developer, you still need to spawn a program for a specific MCP server and user configuration in Step 1. What if there was a single MCP server that could expose tools to start...

🎯 Project Objectives

This repository aims to demonstrate how to convert traditional stdio-based MCP servers into network servers that communicate via WebSocket, thereby simplifying the way clients interact with them.

🌟 Core Advantages

1. Eliminate Process Management: There's no need to spawn multiple processes in the client to manage different MCP servers.
2. Enhance Scalability: Network communication enables more efficient management and routing of requests for multiple users and different configurations.

🚶‍♂️ Implementation Steps

1. Wrap Existing MCP Servers as WebSocket Services

Using the provided wrapper program, you can easily convert any existing MCP server (e.g., Puppeteer) into a WebSocket-based service. For example:

bun run mcp-server -p 3001 -- npx -y @modelcontextprotocol/server-puppeteer@latest

This command starts a WebSocket service on port 3001, wrapping the Puppeteer MCP server.

2. Interact Programmatically Using the SDK

With the MCP SDK and the WebSocket client transport module, you can easily interact with the new WebSocket MCP server. For example:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { WebSocketClientTransport } from "@modelcontextprotocol/sdk/client/websocket.js";

const transport = new WebSocketClientTransport(new URL("ws://localhost:3001"));

const client = new Client(
  {
    name: "example-client",
    version: "1.0.0",
  },
  {
    capabilities: {},
  }
);
await client.connect(transport);
const tools = await client.listTools();
console.log(
  "Tools:",
  tools.tools.map((t) => t.name)
);
await client.close();

Run this code:

bun run mcp-server-wrapper-client
$ bun run src/mcp-server-wrapper/example-client/example-client.ts
Tools: [ "puppeteer_navigate", "puppeteer_screenshot", "puppeteer_click", "puppeteer_fill",
  "puppeteer_evaluate"
]

The output will display the list of available tools.

3. Expand to MCP Server as a Service

TODO: Currently, we haven't solved the second problem. As an MCP client developer, you still need to spawn a program for a specific MCP server and user configuration in Step 1. What if there was a single MCP server that could expose tools to start...

Through these steps, we can see the great potential of converting traditional stdio-based MCP servers into network services. This not only simplifies the client usage but also paves the way for building a more complex MCP ecosystem.

🚀 Future Directions

1. Unified Interface: Develop a universal MCP server interface that allows any server to be easily exposed via WebSocket or other protocols.
2. Automated Configuration: Implement automated user configuration management to reduce the need for manual process spawning.
3. Multi-Tenant Support: Build a multi-user architecture that allows each user to customize and start different MCP server instances according to their needs.

📝 Conclusion

Converting MCP servers into network services is a revolutionary improvement that can significantly enhance development efficiency and system scalability. Although there are still some issues to be resolved, this direction is undoubtedly worth in-depth exploration and practice.