MCP双向通信WebSocket配置Skill mcp-transport-websocket-setup

---

name: mcp-transport-websocket-setup description: 配置WebSocket传输以实现双向MCP通信，包含连接管理和重连处理。 allowed-tools: Read, Write, Edit, Bash, Glob, Grep

MCP传输WebSocket配置

为双向MCP通信配置WebSocket传输。

功能

• 为MCP配置WebSocket传输
• 实现连接生命周期管理
• 设置带退避机制的重连
• 处理消息帧
• 实现心跳/乒乓机制
• 配置安全WebSocket（WSS）

使用场景

当您需要以下功能时调用此技能：

• 建立双向MCP通信
• 实现基于WebSocket的MCP传输
• 配置连接管理
• 启用实时双向消息传递

输入参数

参数	类型	必填	描述
language	string	是	目标语言
server	boolean	否	生成服务器代码（默认：true）
client	boolean	否	生成客户端代码（默认：false）
secure	boolean	否	使用WSS（默认：true）

生成模式

TypeScript WebSocket服务器

import { WebSocketServer, WebSocket } from 'ws';
import { Server } from '@modelcontextprotocol/sdk/server/index.js';

interface Connection {
  ws: WebSocket;
  server: Server;
  lastPing: number;
}

const connections = new Map<string, Connection>();

const wss = new WebSocketServer({
  port: parseInt(process.env.WS_PORT || '8080'),
  path: '/mcp',
});

// 心跳间隔
const HEARTBEAT_INTERVAL = 30000;

wss.on('connection', (ws, req) => {
  const connectionId = crypto.randomUUID();
  console.log(`新连接: ${connectionId}`);

  // 为此连接创建MCP服务器
  const server = new Server(
    { name: 'my-mcp-server', version: '1.0.0' },
    { capabilities: { tools: {}, resources: {} } }
  );

  // 注册处理器
  registerToolHandlers(server);

  // 存储连接
  connections.set(connectionId, {
    ws,
    server,
    lastPing: Date.now(),
  });

  // 处理消息
  ws.on('message', async (data) => {
    try {
      const message = JSON.parse(data.toString());
      await handleMessage(connectionId, message);
    } catch (error) {
      console.error('处理消息失败:', error);
      ws.send(JSON.stringify({
        jsonrpc: '2.0',
        error: { code: -32700, message: '解析错误' },
      }));
    }
  });

  // 处理关闭
  ws.on('close', () => {
    console.log(`连接关闭: ${connectionId}`);
    connections.delete(connectionId);
  });

  // 处理错误
  ws.on('error', (error) => {
    console.error(`连接错误: ${connectionId}`, error);
  });

  // 响应ping
  ws.on('pong', () => {
    const conn = connections.get(connectionId);
    if (conn) conn.lastPing = Date.now();
  });
});

// 心跳检查
setInterval(() => {
  const now = Date.now();
  connections.forEach((conn, id) => {
    if (now - conn.lastPing > HEARTBEAT_INTERVAL * 2) {
      console.log(`终止陈旧连接: ${id}`);
      conn.ws.terminate();
      connections.delete(id);
    } else {
      conn.ws.ping();
    }
  });
}, HEARTBEAT_INTERVAL);

async function handleMessage(connectionId: string, message: any) {
  const conn = connections.get(connectionId);
  if (!conn) return;

  // 处理MCP消息并发送响应
  // 实现取决于消息类型
}

console.log(`WebSocket MCP服务器运行在端口 ${process.env.WS_PORT || 8080}`);

TypeScript WebSocket客户端

import WebSocket from 'ws';

interface MCPClientOptions {
  url: string;
  reconnect?: boolean;
  maxRetries?: number;
}

class MCPWebSocketClient {
  private ws: WebSocket | null = null;
  private reconnectAttempts = 0;
  private maxRetries: number;
  private reconnectDelay = 1000;

  constructor(private options: MCPClientOptions) {
    this.maxRetries = options.maxRetries ?? 5;
  }

  async connect(): Promise<void> {
    return new Promise((resolve, reject) => {
      this.ws = new WebSocket(this.options.url);

      this.ws.on('open', () => {
        console.log('已连接到MCP服务器');
        this.reconnectAttempts = 0;
        this.reconnectDelay = 1000;
        resolve();
      });

      this.ws.on('message', (data) => {
        const message = JSON.parse(data.toString());
        this.handleMessage(message);
      });

      this.ws.on('close', () => {
        console.log('与MCP服务器断开连接');
        if (this.options.reconnect) {
          this.attemptReconnect();
        }
      });

      this.ws.on('error', (error) => {
        console.error('WebSocket错误:', error);
        reject(error);
      });
    });
  }

  private attemptReconnect() {
    if (this.reconnectAttempts >= this.maxRetries) {
      console.error('达到最大重连尝试次数');
      return;
    }

    this.reconnectAttempts++;
    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);

    console.log(`在${delay}ms后重连（尝试${this.reconnectAttempts}次）`);

    setTimeout(() => {
      this.connect().catch(() => {
        // 将触发另一次重连尝试
      });
    }, delay);
  }

  async send(message: any): Promise<void> {
    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
      throw new Error('未连接');
    }
    this.ws.send(JSON.stringify(message));
  }

  private handleMessage(message: any) {
    // 处理传入的MCP消息
    console.log('收到:', message);
  }

  close() {
    this.options.reconnect = false;
    this.ws?.close();
  }
}

工作流程

1. 配置服务器 - WebSocket服务器设置
2. 添加处理器 - 消息处理
3. 实现心跳 - 连接健康检查
4. 添加重连 - 客户端重连机制
5. 配置安全 - WSS设置
6. 添加监控 - 连接指标

目标流程

• mcp-transport-layer
• mcp-server-bootstrap
• mcp-client-implementation