What is Mcp Server Server

mcp-server-server is a proof of concept MCP server that transforms standard input/output (stdio) MCP servers into websocket-based servers, facilitating easier programmatic access and management.

Use cases

Use cases include integrating various MCP servers into a single application, managing user-specific configurations without the overhead of multiple processes, and enhancing the performance of MCP server interactions in client applications.

How to use

To use mcp-server-server, you need to wrap an existing stdio MCP server with the provided wrapper program, which exposes it over a websocket. You can run it using commands like bun run mcp-server-wrapper -p 3001 -- npx -y @modelcontextprotocol/server-puppeteer@latest for standard usage or install it for faster startup times.

Key features

Key features include the ability to convert stdio MCP servers to websocket servers, improved performance with faster startup times, and simplified process management for multiple users and configurations.

Where to use

mcp-server-server can be used in software development environments where MCP servers are required, particularly in applications that need to manage multiple MCP server configurations efficiently.

mcp-server-server

This repo is a proof of concept MCP server that exposes another stdio MCP server over a websocket.

But…why?

MCP servers are hard to use.

The primary transport mechanism for MCP servers is stdio, i.e. in your MCP client program you need to spawn a new process for the MCP server you want to use.
This has downsides:

1. It’s cumbersome–every MCP client needs to be a process manager now. The way you configure Claude Desktop to use MCP servers is a good demonstration of this–it needs a list of processes to run.
2. It creates an infra problem: if you have many users, all of which require different MCP server configurations (e.g. they all have different credentials for underlying MCP servers like Github, Google Drive, etc.), then you now have tons of processes to operate and route client requests to.
3. It’s slow: the default way to spin up an MCP server is npx ... or uvx ... which comes with all of the slowness of these tools (2-3s spinup times are normal).

A better way

What if MCP servers were actually… servers? I.e. communication with them happened over the network instead of stdio.
Then you could have an easier time using them programatically.

Step 1: Convert a stdio MCP server to a websocket MCP server

This repo contains a wrapper program that will take an existing MCP server (here is a list of the official ones, but they’re all over now) and expose it via websocket:

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

and for faster spin up times, install it and invoke it using node directly:

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 programatically 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 it into a docker image

For a given MCP server configuration, e.g.

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

We’d like to build it into a docker image that exposes a websocket, that we can run anywhere.
This repo contains a script that will output a Dockerfile for a given MCP server configuration: