Workers MCP Server

🚀 Worker MCP Project

This project demonstrates how to expose a class named WorkerEntrypoint as an MCP (Model Context Protocol) service. Through Wrangler and some custom tools, we can achieve local development and deployment.

🚀 Quick Start

1. Clone the project repository.
2. Run npm install to install dependencies.
3. Run node local-proxy.ts in the scripts/ directory to start the proxy server.
4. Use MCP tools to test the interaction with WorkerEntrypoint.

✨ Features

• Expose the WorkerEntrypoint class as an MCP service.
• Support local development and testing through a proxy server.
• Generate static documentation for MCP tools.

📦 Installation

1. Clone the project repository.
2. Run npm install to install dependencies.

💻 Usage Examples

Basic Usage

// src/index.ts - Worker Entrypoint
export class WorkerEntrypoint {
    async greet(name: string): Promise<string> {
        return `Hello, ${name}!`;
    }
}

This class defines the service we want to provide via MCP. Currently, there is only one method greet, which accepts a string parameter and returns a greeting.

Advanced Usage

// lib/WorkerMCP.ts - Public HTTP Handler
import { expose } from '@modelcontextprotocol/sdk';
import { WorkerEntrypoint } from '../src/index';

class WorkerMCP {
    static async fetch(req: Request): Promise<Response> {
        const endpoint = new URL('/rpc', req.url);
        if (req.method !== 'POST' || !req.headers.get('Content-Type')?.includes('application/json')) {
            return Response.json({ error: 'Invalid request' }, 400);
        }

        try {
            const body = await req.json();
            const { method } = body;
            const instance = new WorkerEntrypoint();
            const result = await Reflect.apply(instance[method], instance, body.args || []);

            return Response.json({ result });
        } catch (error) {
            return Response.json({ error: error.message }, 500);
        }
    }
}

expose(WorkerMCP);

This file defines how to handle incoming HTTP requests. It exposes an endpoint via the /rpc path, receives JSON requests, and calls the corresponding WorkerEntrypoint method.

📚 Documentation

Project Structure

project/
├── src/
│   └── index.ts               # Main entry point for the worker
├── lib/
│   └── WorkerMCP.ts          # Public HTTP handler
├── scripts/
│   ├── local-proxy.ts        # Local MCP proxy
│   └── generate-docs.ts      # Documentation generation script
└── package.json             # Project dependency management

Key Files Explanation

src/index.ts - Worker Entrypoint

export class WorkerEntrypoint {
    async greet(name: string): Promise<string> {
        return `Hello, ${name}!`;
    }
}

Defines the service provided via MCP, with a single method greet.

lib/WorkerMCP.ts - Public HTTP Handler

import { expose } from '@modelcontextprotocol/sdk';
import { WorkerEntrypoint } from '../src/index';

class WorkerMCP {
    static async fetch(req: Request): Promise<Response> {
        const endpoint = new URL('/rpc', req.url);
        if (req.method !== 'POST' || !req.headers.get('Content-Type')?.includes('application/json')) {
            return Response.json({ error: 'Invalid request' }, 400);
        }

        try {
            const body = await req.json();
            const { method } = body;
            const instance = new WorkerEntrypoint();
            const result = await Reflect.apply(instance[method], instance, body.args || []);

            return Response.json({ result });
        } catch (error) {
            return Response.json({ error: error.message }, 500);
        }
    }
}

expose(WorkerMCP);

Handles incoming HTTP requests and calls WorkerEntrypoint methods.

scripts/local-proxy.ts - Local MCP Proxy

import { serve } from 'std/server';
import { expose } from '@modelcontextprotocol/sdk';

async function main() {
    const port = 8080;
    await serve(async (req) => {
        if (req.method === 'GET' && req.url.pathname === '/tools/list') {
            // Return the MCP tool list
            return Response.json({
                tools: [{
                    name: 'WorkerEntrypoint',
                    methods: ['greet']
                }]
            });
        } else if (req.method === 'POST' && req.url.pathname === '/rpc') {
            // Handle RPC requests
            const body = await req.json();
            const instance = new WorkerEntrypoint();
            return Response.json({ result: await Reflect.apply(instance[body.method], instance, body.args || []) });
        }
    }, { port });
}

main();

Runs a local proxy server to handle MCP tools/list and /rpc requests for local testing.

scripts/generate-docs.ts - Documentation Generation Script

import { writeFileSync } from 'fs';

const docGenerator = () => {
    const workerEntrypoint = require.resolve('../src/index');
    const content = `See the source file: ${workerEntrypoint}`;
    
    return { 
        entrypoints: [
            {
                name: 'WorkerEntrypoint',
                description: 'A simple MCP service example.',
                docUrl: 'https://example.com/docs'
            }
        ],
        tools: [{
            name: 'greet',
            description: 'Greets a person.',
            arguments: [{ name: 'name', type: 'string' }],
            returns: { type: 'string' }
        }]
    };
};

const docs = docGenerator();
writeFileSync('docs.json', JSON.stringify(docs, null, 2));

Generates documentation for MCP tools.

🔧 Technical Details

This project uses Wrangler and custom scripts to expose the WorkerEntrypoint class as an MCP service. It includes a local proxy server for testing and a documentation generation script. The key technologies involved are TypeScript, Node.js, and the MCP SDK.

📄 License

No license information provided in the original document.