MCP Server Do

🚀 SSE + MCP Server + Durable Objects

This project provides an SSE transport layer and an MCP server as a Durable Object, along with end - to - end running steps.

🚀 Quick Start

Steps to run the project:

1. Clone this repository.
2. Install dependencies using npm install.
3. Start the Durable Object (DO) with npm start. The access address is http://localhost:8787.
4. Run the MCP Inspector using npx @modelcontextprotocol/inspector.
5. Open the Inspector and enter http://localhost:8787/sse.

You should see the expected results.

📦 Installation

1. Clone the repository:
   • Use the following command to clone this repository:

     git clone <repository_url>
     

2. Install dependencies:
   • Run the following command to install the necessary dependencies:

     npm install
     

3. Start the DO:
   • Start the Durable Object using the command:

     npm start
     

   • You can access it at http://localhost:8787.
4. Run the MCP Inspector:
   • Use the following command to run the MCP Inspector:

     npx @modelcontextprotocol/inspector
     

5. Open the Inspector:
   • Open the Inspector and enter http://localhost:8787/sse.

💻 Usage Examples

Basic Usage

The project consists of the following main components:

1. An SSE transport layer used in conjunction with @modelcontextprotocol/typescript-sdk (located at /src/sse.ts).
2. An MCP server as a Durable Object (located at /src/mcp-server-do.ts).

Advanced Usage

The following is the code example inspired by the @modelcontextprotocol/typescript-sdk project:

import express from "express";
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";

const server = new McpServer({
  name: "example-server",
  version: "1.0.0"
});

// ... Set up server resources, tools, and prompts ...

const app = express();

app.get("/sse", async (req, res) => {
  const transport = new SSEServerTransport("/messages", res);
  await server.connect(transport);
});

app.post("/messages", async (req, res) => {
  // Note: To support multiple simultaneous connections, these messages need to be routed to specific transports. For simplicity, this logic is not implemented here.
  await transport.handlePostMessage(req, res);
});

app.listen(3001);

📚 Documentation

I got inspiration from this example from @modelcontextprotocol/typescript-sdk. I implemented it as a Durable Object. First, a transport layer running on Workers was needed. Referring to sse.ts from @modelcontextprotocol/typescript-sdk, I implemented a similar version, trying to mimic the structure and functionality of the existing code. It should be noted that there are some design assumptions in the SDK that are deeply coupled with Node.js's http module, and these assumptions leak into the SSE transport layer and its input types. The only meaningful interface change is that handlePostMessage accepts a request and returns a response. It seems there is a clever way to upstream it?