HTTP OAuth Auth0

🚀 Stateless MCP Server for Real - Time AI Communication

This project implements a stateless MCP server supporting two protocols (SSE and Streamable HTTP), aiming to provide high - performance and low - latency communication for AI applications.

🚀 Quick Start

This project offers a stateless MCP server implementation based on the Model Context Protocol (MCP). It is designed to meet the real - time communication needs of AI applications.

✨ Features

• Protocol Support: Supports both SSE (Server - Sent Events) and Streamable HTTP protocols.
• State Management: Implements a stateless service using temporary in - memory storage, suitable for serverless deployment.
• Horizontal Scalability: Supports simple horizontal scaling, though limited by in - memory storage.
• Low - Latency Optimization: Designed for real - time AI applications to reduce communication latency.

💻 Usage Examples

Basic Usage

The following is the code implementation of the stateless MCP server in src/app.stateless.ts:

import { v4 as uuidv4 } from 'uuid';
import type { TextResponse, StreamableHTTPTransport } from '@modelcontextprotocol/sdk/server';

const port = Number(process.env.PORT) || 5050;
const app = express();

// 基于 UUID 的临时内存存储
const inMemoryStorage: Map<string, any> = new Map();

app.use(express.json());

app.get('/mcp', async (req, res) => {
    const id = uuidv4();
    inMemoryStorage.set(id, {});

    res.setHeader('Content-Type', 'text/event-stream');
    res.setHeader('Cache-Control', 'no-cache');
    res.setHeader('Connection', 'keep-alive');

    // 监听客户端连接断开事件
    req.on('close', () => {
        inMemoryStorage.delete(id);
    });

    const stream = new ReadableStream({
        async start(controller) {
            while (true) {
                try {
                    const data = await getMCPData();
                    controller.enqueue(data);
                } catch (error) {
                    controller.error(error);
                    break;
                }
            }
        },
    });

    res.end(stream);
});

server.listen(port, () => {
    console.log(`Server running at http://localhost:${port}`);
});

📦 Installation

The project provides two different server implementations:

Stateless Version

bun run src/app.stateless.ts

Stateful Version

bun run src/app.stateful.ts

📚 Documentation

Configure the MCP Client

Use the mcp - remote tool to connect to the MCP server:

bunx mcp-remote --transport http-first https://some-domain.server.com/mcp

Supported transport modes include:

• http - first: The default mode, uses HTTP protocol first and falls back to SSE if it fails.
• sse - first: Uses SSE protocol first and falls back to HTTP if it fails.
• http - only: Connects using only the HTTP protocol.
• sse - only: Connects using only the SSE protocol.

Integrate in JavaScript/TypeScript Proxy

import { createMCPClient } from '@modelcontextprotocol/sdk/client';

const client = createMCPClient({
    serverUrl: 'http://localhost:5050',
    authProvider: new MyAuthProvider(),
});

client.connect().then(() => {
    // 处理连接成功逻辑
}).catch((error) => {
    console.error('连接 MCP 服务器失败:', error);
});

⚠️ Important Note

• Limitations of the stateless implementation: All session data is only temporarily stored in memory and will be lost after the service restarts.
• Horizontal scalability: Suitable for simple stateless service deployment scenarios.
• Protocol compatibility: Ensure that the client and server use the same protocol version.

Summary

This project provides a stateless implementation solution based on the MCP protocol, mainly targeting AI application scenarios that require real - time communication capabilities and lightweight service design.