MCP Server Server

🚀 mcp-server-server

This repository is a proof-of-concept implementation of an MCP server that exposes another standard input-output (stdio)-based MCP server via WebSocket.

🤔 But... Why?

Using MCP servers is challenging.

The primary transmission mechanism of MCP servers is stdio. That means in your MCP client program, you need to start a new process for each MCP server you want to use. This approach has several drawbacks:

1. Inconvenience: Each MCP client needs to act as a process manager. The configuration method of Claude Desktop is a good example - it needs to maintain a list of processes to run.
2. Infrastructure issues: If you have multiple users, each of them may have different MCP server configurations (e.g., they may use different credentials to access the underlying MCP servers such as Github, Google Drive, etc.), then you'll face a large number of process management and request routing problems.
3. Slow speed: By default, the way to start an MCP server is npx ... or uvx ..., which brings the inherent latency of these tools (usually 2 - 3 seconds of startup time).

💡 A Better Approach

What if MCP servers were actually... network servers? That is, they communicate over the network instead of using stdio. This way, you can use them more easily in your programs.

Step 1: Convert an existing stdio MCP server to a WebSocket MCP server

This repository contains a wrapper program that can expose an existing MCP server (some official ones are listed here) via WebSocket:

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

For faster startup time, install and run directly using node:

pnpm install -g @modelcontextprotocol/server-puppeteer@latest
bun run mcp-server-wrapper -p 3001 -- node ~/Library/pnpm/global/5/node_modules/@modelcontextprotocol/server-puppeteer/dist/index.js

Step 2: Interact with the MCP server 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: Package it into a Docker image

For a given MCP server configuration, for example:

{
  "mcpServers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    }
  }
}

We want to generate a Docker image for this MCP server configuration so that it can be run anywhere. This repository contains a script that will output a Dockerfile based on the MCP server configuration:

# There should be an example command here, but no specific command is provided in the current document.

This solution solves the problems of complex management and slow startup of existing MCP servers and provides a more efficient way for programmatic interaction. Exposing MCP servers via WebSocket makes them easier to manage and scale, while also improving performance and user experience.