MCP Transport 与部署

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import { z } from 'zod'

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

server.registerTool(
  'greet',
  {
    title: '问候',
    description: '向用户问候',
    inputSchema: { name: z.string() },
  },
  async ({ name }) => ({
    content: [{ type: 'text', text: `你好，${name}！` }],
  })
)

// stdio 传输
const transport = new StdioServerTransport()
await server.connect(transport)

// 日志使用 stderr（stdout 被协议占用）
console.error('Server started on stdio')

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
import express from 'express'
import { z } from 'zod'

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

server.registerTool(
  'add',
  {
    title: '加法',
    description: '计算两数之和',
    inputSchema: { a: z.number(), b: z.number() },
    outputSchema: { result: z.number() },
  },
  async ({ a, b }) => {
    const result = a + b
    return {
      content: [{ type: 'text', text: `${a} + ${b} = ${result}` }],
      structuredContent: { result },
    }
  }
)

// Express 服务器
const app = express()
app.use(express.json())

app.post('/mcp', async (req, res) => {
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: undefined,
    enableJsonResponse: true,
  })

  res.on('close', () => transport.close())

  await server.connect(transport)
  await transport.handleRequest(req, res, req.body)
})

const PORT = process.env.PORT || 3000
app.listen(PORT, () => {
  console.log(`MCP Server running on http://localhost:${PORT}/mcp`)
})

version: '3.8'

services:
  mcp-server:
    build: .
    ports:
      - '3000:3000'
    environment:
      - NODE_ENV=production
      - API_KEY=${API_KEY}
    healthcheck:
      test: ['CMD', 'curl', '-f', 'http://localhost:3000/health']
      interval: 30s
      timeout: 10s
      retries: 3
    restart: unless-stopped

upstream mcp_backend {
    server 127.0.0.1:3000;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name mcp.example.com;

    ssl_certificate /etc/ssl/certs/mcp.crt;
    ssl_certificate_key /etc/ssl/private/mcp.key;

    location /mcp {
        proxy_pass http://mcp_backend;
        proxy_http_version 1.1;

        # SSE 支持
        proxy_set_header Connection '';
        proxy_buffering off;
        proxy_cache off;

        # 超时设置
        proxy_read_timeout 86400s;
        proxy_send_timeout 86400s;

        # 安全头
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

module.exports = {
  apps: [
    {
      name: 'mcp-server',
      script: './dist/server.js',
      instances: 'max',
      exec_mode: 'cluster',
      env_production: {
        NODE_ENV: 'production',
        PORT: 3000,
      },
      max_memory_restart: '500M',
      error_file: './logs/error.log',
      out_file: './logs/out.log',
      merge_logs: true,
    },
  ],
}

import {
  McpServer,
  ResourceTemplate,
} from '@modelcontextprotocol/sdk/server/mcp.js'
import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js'
import express from 'express'
import cors from 'cors'
import helmet from 'helmet'
import { z } from 'zod'

// 创建 MCP Server
function createMcpServer() {
  const server = new McpServer({
    name: 'production-server',
    version: '1.0.0',
  })

  // 注册 Tools
  server.registerTool(
    'echo',
    {
      title: 'Echo',
      description: '返回输入的消息',
      inputSchema: { message: z.string() },
    },
    async ({ message }) => ({
      content: [{ type: 'text', text: `Echo: ${message}` }],
    })
  )

  // 注册 Resources
  server.registerResource(
    'status',
    'status://server',
    { title: '服务状态', description: '服务器运行状态' },
    async (uri) => ({
      contents: [
        {
          uri: uri.href,
          mimeType: 'application/json',
          text: JSON.stringify(
            {
              status: 'running',
              uptime: process.uptime(),
              memory: process.memoryUsage(),
            },
            null,
            2
          ),
        },
      ],
    })
  )

  return server
}

// Express 应用
const app = express()

// 安全中间件
app.use(helmet())
app.use(
  cors({
    origin: process.env.ALLOWED_ORIGINS?.split(',') || '*',
    methods: ['POST', 'OPTIONS'],
    allowedHeaders: ['Content-Type', 'Authorization'],
  })
)
app.use(express.json({ limit: '10mb' }))

// 健康检查
app.get('/health', (req, res) => {
  res.json({ status: 'healthy' })
})

// MCP 端点
app.post('/mcp', async (req, res) => {
  const mcpServer = createMcpServer()

  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: undefined,
    enableJsonResponse: true,
  })

  res.on('close', () => {
    transport.close()
  })

  try {
    await mcpServer.connect(transport)
    await transport.handleRequest(req, res, req.body)
  } catch (error) {
    console.error('MCP request error:', error)
    if (!res.headersSent) {
      res.status(500).json({ error: 'Internal server error' })
    }
  }
})

// 启动服务器
const PORT = parseInt(process.env.PORT || '3000')
const HOST = process.env.HOST || '127.0.0.1'

app.listen(PORT, HOST, () => {
  console.log(`MCP Server running on http://${HOST}:${PORT}`)
  console.log(`MCP endpoint: http://${HOST}:${PORT}/mcp`)
  console.log(`Health check: http://${HOST}:${PORT}/health`)
})