基本概念

• 架构：MCP遵循客户端-服务器架构，其中主机是发起连接的LLM应用程序，如Claude for Desktop等；客户端在主机应用程序内部与服务器保持1：1连接，负责协议通信；服务器供客户端访问，向客户提供上下文、工具和提示。
• 资源：资源表示MCP服务器想要向客户端提供的任何类型的数据，如文件内容、数据库记录、API响应等。每个资源由唯一的URI标识，并且可以包含文本或二进制数据。

协议说明

• 通信方式：MCP的通信层是整个系统的核心，通过定义标准协议协调客户端与服务器之间的交互。其主要功能包括格式定义、兼容性保障以及安全与健壮性。例如，它为请求和响应制定统一的结构，如基于JSON-RPC的数据格式，确保通信双方能够准确解析彼此的信息。
• 能力交换机制：MCP通过能力交换机制使系统更加动态灵活。服务器可以随时更新其功能而无需客户端重写代码。例如，当服务器新增一个工具或更新现有工具的功能时，客户端能够通过能力交换机制自动感知并使用这些新功能。
• 安全性：协议内置了严格的权限控制机制，数据源的所有者始终掌握访问权。模型在获取数据时需要经过明确授权，避免数据泄露和滥用问题。

工作流程

• 客户端发起请求：客户端通过MCP协议向服务器发送请求，以访问工具或获取信息。
• 服务器处理请求并返回结果：服务器接收来自客户端的请求，执行相应的操作（如查询数据库或调用工具），然后将结果以标准格式返回给客户端。
• 客户端将结果反馈给LLM：客户端将服务器返回的结果反馈给LLM，LLM根据工具返回结果和用户问题进行回答。

优势

• 标准化：MCP通过定义一个标准化的协议，使开发者在无需重复开发的情况下快速连接模型与数据源，降低了模型与多样化数据源之间的连接复杂度。
• 灵活性：MCP通过帮助LLM直接与数据和工具集成，保证LLM切换的灵活性。
• 开放性：作为开放协议，允许任何开发者为其产品创建MCP服务器，有助于快速扩展生态。
• 安全性：协议内置了严格的权限控制机制，数据源的所有者始终掌握访问权。

设计目标

• MCP协议：旨在实现大型语言模型（LLM）与外部数据源和工具的无缝集成，为AI模型与应用程序之间的交互提供标准化方法。其目标是打破AI模型与外部数据之间的信息孤岛，让模型能够更灵活、高效地集成各类数据源。
• HTTP协议：是互联网上应用最为广泛的网络协议，主要用于客户端和服务器之间的信息传输，是万维网（WWW）的基础协议。它允许客户端（如浏览器）请求服务器上的资源（如网页、图片等），并接收服务器返回的响应。

应用场景

• MCP协议：主要应用于AI领域，用于连接大型语言模型与各种外部资源，如数据库、文件系统、API、实时系统数据等。例如，AI助手可以通过MCP协议调用外部工具来获取实时数据或执行特定任务。
• HTTP协议：广泛应用于互联网的各种场景，如网页浏览、在线购物、社交媒体等。它支持多种类型的资源传输，包括文本、图片、视频等，是互联网上信息共享和交互的基础。

通信机制

• MCP协议：遵循客户端-服务器架构，支持两种主要的通信机制：
  • 基于标准输入输出的本地通信：通过stdio传输数据，适用于在同一台机器上运行的客户端和服务器之间的通信。
  • 基于SSE（Server-Sent Events）的远程通信：利用SSE与HTTP结合，实现跨网络的实时数据传输，适用于需要访问远程资源或分布式部署的场景。
• HTTP协议：基于请求-响应模型，客户端向服务器发送请求，服务器处理请求后返回响应。HTTP协议支持多种请求方法（如GET、POST、PUT、DELETE等），用于不同的资源操作。

消息格式

• MCP协议：使用JSON-RPC 2.0作为其传输格式，将消息转换为JSON-RPC格式进行传输，并将接收到的JSON-RPC消息转换回MCP协议消息。MCP定义了4类消息类型，包括请求、结果、错误和通知。
• HTTP协议：消息格式包括请求行、请求头部、请求体（对于POST等方法）和响应状态行、响应头部、响应体。请求行和响应状态行分别包含方法、URI、版本号和状态码、状态消息等信息。

安全性

• MCP协议：协议内置了严格的权限控制机制，数据源的所有者始终掌握访问权，模型在获取数据时需要经过明确授权，避免数据泄露和滥用问题。
• HTTP协议：本身没有内置的权限控制机制，但可以通过其他技术（如HTTPS、身份验证、授权等）来增强安全性。

JSON-RPC 2.0 消息结构

1. 请求（Request）

• 普通请求：
  JSON

  Copy

  {
    "jsonrpc": "2.0",  // 协议版本，固定为"2.0"
    "method": "MethodName",  // 要调用的方法名称
    "params": {  // 方法的参数，可以是对象或数组
      "param1": "value1",
      "param2": "value2"
    },
    "id": 123  // 请求的唯一标识符，用于匹配请求和响应
  }
• 通知（Notification）：
  JSON

  Copy

  {
    "jsonrpc": "2.0",
    "method": "MethodName",
    "params": {
      "param1": "value1",
      "param2": "value2"
    }
  }

  • 通知消息没有id字段，服务器不会返回响应。

2. 响应（Response）

• 成功响应：
  JSON

  Copy

  {
    "jsonrpc": "2.0",
    "result": {  // 方法调用的结果
      "key": "value"
    },
    "id": 123  // 对应请求的唯一标识符
  }
• 错误响应：
  JSON

  Copy

  {
    "jsonrpc": "2.0",
    "error": {  // 错误信息
      "code": -32601,  // 错误代码
      "message": "Method not found",  // 错误描述
      "data": "Optional additional error information"  // 可选的附加错误信息
    },
    "id": 123
  }

示例

示例 1：普通请求与成功响应

{
  "jsonrpc": "2.0",
  "method": "add",
  "params": {
    "a": 5,
    "b": 10
  },
  "id": 1
}

{
  "jsonrpc": "2.0",
  "result": 15,
  "id": 1
}

示例 2：普通请求与错误响应

{
  "jsonrpc": "2.0",
  "method": "nonExistentMethod",
  "params": {
    "a": 5,
    "b": 10
  },
  "id": 2
}

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32601,
    "message": "Method not found"
  },
  "id": 2
}

示例 3：通知

{
  "jsonrpc": "2.0",
  "method": "log",
  "params": {
    "message": "Something happened"
  }
}

错误代码

• -32700: Parse error
• -32600: Invalid Request
• -32601: Method not found
• -32602: Invalid params
• -32603: Internal error
• -32000 to -32099: Server error

总结

JSON-RPC 2.0 封装内容

请求（Request）

• jsonrpc：字符串，指定 JSON-RPC 的版本号，对于 2.0 规范来说，这个值必须是 "2.0"。
• method：字符串，指定要调用的远程方法的名称。
• params：结构化值，可以是数组或者对象，传递给远程方法的参数。如果方法不需要参数可以省略。
• id：唯一标识符，可以是字符串或数字，用于关联请求和响应，服务端必须返回相同的值。如果请求是一个通知类型，则此参数可以被省略。

{
  "jsonrpc": "2.0",
  "method": "subtract",
  "params": [42, 23],
  "id": 1
}

响应（Response）

• jsonrpc：字符串，指定 JSON-RPC 的版本号，对于 2.0 规范来说，这个值必须是 "2.0"。
• result：当请求成功时，包含由远程方法返回的结果。如果请求失败，则不包含此成员。
• error：当请求失败时，包含一个错误对象。如果请求成功，则不包含此成员。
• id：与请求中的 id 相同，用于识别哪个请求对应的响应。

{
  "jsonrpc": "2.0",
  "result": 19,
  "id": 1
}

{
  "jsonrpc": "2.0",
  "error": {
    "code": -32601,
    "message": "Method not found"
  },
  "id": 1
}

错误对象

• code：整数，用于说明错误类型。JSON-RPC 2.0 定义了一组标准的错误码，例如：
  • -32700：Parse error
  • -32600：Invalid Request
  • -32601：Method not found
  • -32602：Invalid params
  • -32603：Internal error
• message：字符串，提供关于错误的简短描述。
• data：可选，可以包含额外的错误信息，比如堆栈信息等。

通知（Notification）

{
  "jsonrpc": "2.0",
  "method": "updateStatus",
  "params": ["online"]
}

批量请求（Batch Request）

[
  {
    "jsonrpc": "2.0",
    "method": "sum",
    "params": [1, 3, 5, 7, 9],
    "id": "1"
  },
  {
    "jsonrpc": "2.0",
    "method": "notify_hello",
    "params": ["Alice"]
  },
  {
    "jsonrpc": "2.0",
    "method": "subtract",
    "params": [42, 23],
    "id": "2"
  }
]

客户端和服务器的工作流程

客户端封装传输给服务器

1. 创建请求对象：客户端根据需要调用的方法和参数，创建一个 JSON-RPC 2.0 请求对象。如果需要调用多个方法，可以创建一个批量请求。
2. 序列化为 JSON：将请求对象序列化为 JSON 格式。
3. 发送请求：通过网络将 JSON 格式的请求发送到服务器。可以使用 HTTP、WebSocket 等传输协议。

服务器按 JSON-RPC 2.0 解包

1. 接收请求：服务器接收客户端发送的 JSON 格式的请求。
2. 解析 JSON：将 JSON 格式的请求解析为 JSON-RPC 2.0 请求对象。
3. 验证请求：检查请求是否符合 JSON-RPC 2.0 规范，包括版本号、方法名、参数等。
4. 调用方法：根据请求中的 method 字段，调用对应的远程方法，并将 params 字段中的参数传递给该方法。
5. 处理结果：如果方法调用成功，将结果封装到响应对象的 result 字段中；如果方法调用失败，将错误信息封装到响应对象的 error 字段中。
6. 序列化响应：将响应对象序列化为 JSON 格式。
7. 发送响应：将 JSON 格式的响应发送回客户端。如果请求是通知，则不发送响应。

客户端封装传输数据

1. 创建MCP请求：客户端首先根据MCP协议创建一个请求，这个请求可能包括特定的方法调用、参数等。例如，初始化MCP会话时，客户端会创建一个initialize方法的请求。
   JSON

   Copy

   {
     "jsonrpc": "2.0",
     "id": 1,
     "method": "initialize",
     "params": {
       "protocolVersion": "2024-11-05",
       "clientInfo": {
           "name": "wasmvision",
           "version": "0.3.0-dev"
       }
     }
   }
2. 封装为JSON-RPC 2.0格式：将MCP请求封装为符合JSON-RPC 2.0规范的JSON对象。这包括添加jsonrpc字段（值为"2.0"）和id字段（用于标识请求）。
3. 选择传输方式：客户端根据实际需求选择合适的传输方式将封装好的JSON-RPC 2.0消息发送给服务器。MCP支持多种传输方式，如标准输入/输出（stdio）和基于HTTP的Server-Sent Events（SSE）。例如，使用SSE时，客户端通过HTTP POST请求将消息发送到服务器指定的端点。

服务器解包并执行指定方法

1. 接收并解析JSON-RPC 2.0消息：服务器接收到客户端发送的JSON-RPC 2.0格式的消息后，首先解析该消息，提取出MCP协议的相关内容。
2. 识别MCP请求：服务器根据解析后的消息内容，识别出具体的MCP请求，包括请求的方法、参数等。
3. 执行对应方法：服务器根据识别出的MCP请求，调用相应的处理逻辑来执行指定的方法。例如，如果请求是initialize方法，服务器会进行初始化操作，并返回相应的结果。
4. 封装响应数据：服务器将执行结果封装为MCP响应数据，并再次按照JSON-RPC 2.0的格式进行封装，准备发送回客户端。

响应数据的封装与解包

1. 服务器封装响应：服务器将MCP响应数据封装为JSON-RPC 2.0格式的响应消息。例如，对于initialize方法的成功响应：
   JSON

   Copy

   {
       "jsonrpc": "2.0",
       "id": 1,
       "result": {
           "protocolVersion": "2024-11-05",
           "capabilities": {
               "resources": {}
           },
           "serverInfo": {
               "name": "wasmvision",
               "version": "0.3.0-dev"
           }
       }
   }
2. 客户端解包响应：客户端接收到服务器返回的JSON-RPC 2.0格式的响应消息后，解析该消息，提取出MCP协议的响应数据。然后根据响应数据中的内容，进行相应的处理，例如显示结果或进行下一步操作。

1. 环境准备

• 安装Node.js：确保系统已安装Node.js 16或更高版本，以及npm（随Node.js一起安装）。可以通过以下命令检查是否已安装：
  plain

  Copy

  node --version
  npm --version

  如果未安装，可从Node.js官网下载安装包。
• 设置环境变量：从Anthropic Console获取Anthropic API密钥，并创建.env文件进行配置，将.env添加到.gitignore中。

2. 安装MCP客户端相关依赖

• 创建一个新的Node.js项目，并更新package.json添加必要的配置。
• 安装MCP客户端SDK和其他相关依赖：
  bash

  Copy

  npm install @modelcontextprotocol/sdk/client
  npm install openai

3. 配置MCP客户端

• 初始化客户端：创建一个MCP客户端类，初始化会话管理和API客户端，使用AsyncExitStack进行资源管理，并配置Anthropic客户端以进行Claude交互。
• 连接到MCP服务器：实现连接到MCP服务器的方法，支持不同类型的服务器（如通过命令行启动的服务器或通过SSE连接的服务器）。根据服务器配置，选择合适的传输方式（如StdioClientTransport或SSEClientTransport）。
  JavaScript

  Copy

  import { Client } from "@modelcontextprotocol/sdk/client/index.js";
  import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
  import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
  
  class MCPClient {
      async connectToServer(serverConfig) {
          let transport;
          if (serverConfig.type === 'command' && serverConfig.command) {
              transport = await this.createCommandTransport(serverConfig.command);
          } else if (serverConfig.type === 'sse' && serverConfig.url) {
              transport = await this.createSSETransport(serverConfig.url);
          } else {
              throw new Error(`Invalid server configuration for: ${serverConfig.name}`);
          }
  
          const client = new Client(
              { name: "mcp-client", version: "1.0.0" },
              { capabilities: { prompts: {}, resources: {}, tools: {} } }
          );
          await client.connect(transport);
  
          // 列出可用工具
          const response = await client.listTools();
          console.log(`Connected to server '${serverConfig.name}' with tools:`, response.tools.map(tool => tool.name));
      }
  
      async createCommandTransport(shell) {
          const [command, ...shellArgs] = shell.split(' ');
          const serverParams = {
              command,
              args: shellArgs,
              env: process.env
          };
          return new StdioClientTransport(serverParams);
      }
  
      async createSSETransport(url) {
          return new SSEClientTransport(new URL(url));
      }
  }
• 查询处理逻辑：添加处理查询和工具调用的核心功能。客户端需要维护对话上下文，处理从Claude返回的响应和工具调用，管理Claude和工具之间的消息流，并将结果合并为连贯的响应。
  JavaScript

  Copy

  async processQuery(query) {
      const messages = [{ role: "user", content: query }];
      const availableTools = []; // 获取所有服务器的工具列表
  
      // 调用OpenAI API或其他模型API
      // 处理响应和工具调用
      // ...
  }
• 交互式聊天界面：添加聊天循环和清理功能，提供简单的命令行界面，处理用户输入并显示响应，包括基本错误处理，允许正常退出。
  JavaScript

  Copy

  async chatLoop() {
      console.log("\nMCP Client Started!");
      console.log("Type your queries or 'quit' to exit.");
      const readline = require('readline').createInterface({
          input: process.stdin,
          output: process.stdout
      });
  
      const askQuestion = () => {
          return new Promise(resolve => {
              readline.question("\nQuery: ", resolve);
          });
      };
  
      try {
          while (true) {
              const query = (await askQuestion()).trim();
              if (query.toLowerCase() === 'quit') {
                  break;
              }
              try {
                  const response = await this.processQuery(query);
                  console.log("\n" + response);
              } catch (error) {
                  console.error("\nError:", error);
              }
          }
      } finally {
          readline.close();
      }
  }
  
  async cleanup() {
      // 清理资源
  }

4. 配置MCP服务器

• 安装MCP服务器：根据需要的功能，安装相应的MCP服务器包。例如，安装顺序思维服务器：
  bash

  Copy

  npm install -g @modelcontextprotocol/server-sequential-thinking

  或其他服务包，如文件系统访问服务器、浏览器搜索服务器等。
• 启动MCP服务器：根据服务器的配置方式，通过命令行启动服务器或配置SSE服务器的URL。

5. 测试MCP功能

• 连接到服务器：启动客户端后，连接到已配置的MCP服务器，客户端会列出服务器提供的可用工具。
• 进行远程调用：在客户端的交互式聊天界面中输入查询，客户端会根据查询内容调用相应的工具，并返回结果。

1. 前置准备

• 安装Node.js环境：确保系统已安装Node.js（版本≥18，推荐使用最新的LTS版本），因为MCP服务器可能需要Node.js环境来运行。
• 安装最新版本的Cursor：确保使用的是支持MCP功能的最新版本的Cursor。
• 准备外部服务的访问凭证：如果要连接的外部服务（如Apifox项目）需要认证，需提前获取相应的访问凭证，如API Key或Access Token。

2. 获取必要的凭证

• 获取外部服务的访问凭证：例如，若要连接Apifox项目，需要在Apifox应用中创建一个新的API访问令牌并保存，同时获取需要连接的Apifox项目的ID。

3. 配置Cursor的MCP设置

• 全局配置（推荐）：
  • 打开Cursor，点击右上角「设置」图标，选择左侧「MCP」选项，然后点击「+ Add new global MCP server」按钮。
  • 在打开的mcp.json文件中添加配置，指定要连接的MCP服务器的相关信息，如启动命令、参数和环境变量等。
  • 例如，连接Apifox MCP Server的配置如下（需替换<your_project_id>和<your_access_token>为实际值）：
    JSON

    Copy

    {
      "mcpServers": {
        "API 文档": {
          "command": "npx",
          "args": [
            "-y",
            "apifox-mcp-server@latest",
            "--project=<your_project_id>"
          ],
          "env": {
            "APIFOX_ACCESS_TOKEN": "<your_access_token>"
          }
        }
      }
    }

    如果使用的是Windows系统，可能需要使用以下配置：
    JSON

    Copy

    {
      "mcpServers": {
        "API 文档": {
          "command": "cmd",
          "args": [
            "/c",
            "npx",
            "-y",
            "apifox-mcp-server@latest",
            "--project=<your_project_id>"
          ],
          "env": {
            "APIFOX_ACCESS_TOKEN": "<your_access_token>"
          }
        }
      }
    }
• 项目特定配置：
  • 在项目根目录下创建.cursor文件夹（如果不存在）。
  • 在此文件夹中创建mcp.json文件，并使用与全局配置相同的格式进行配置。

4. 验证MCP连接

配置的目的解释

• 扩展AI能力：通过配置MCP，Cursor能够访问外部的数据源和工具，从而让AI助手能够执行更复杂的任务，如直接操作数据库、生成代码、访问API文档等。
• 提高开发效率：让AI直接访问项目相关的接口文档，可以自动生成代码、同步更新代码与文档，减少人工干预，提高开发效率。
• 实现动态交互：MCP协议支持实时双向通信，使得AI能够根据实时数据做出决策，例如在物理AI网络中动态调整交通信号灯配时。
• 简化对接流程：采用标准化的协议，减少了AI应用与外部系统之间的对接成本，实现了一次配置，无限扩展。

配置文件示例

{
  "mcpServers": {
    "API 文档": {
      "command": "npx",
      "args": [
        "-y",
        "apifox-mcp-server@latest",
        "--project=<your_project_id>"
      ],
      "env": {
        "APIFOX_ACCESS_TOKEN": "<your_access_token>"
      }
    }
  }
}

配置项解释

1. mcpServers

• 目的：定义一个或多个MCP服务器的配置。
• 用途：这是一个对象，每个键值对表示一个MCP服务器的名称和对应的配置。键（如"API 文档"）是服务器的名称，值是一个对象，包含启动和连接该服务器所需的具体配置。

2. command

• 目的：指定启动MCP服务器的命令。
• 用途：这是运行MCP服务器的命令行工具。例如，"npx"是一个Node.js工具，用于运行npm包中的命令。在这里，它用于启动apifox-mcp-server。
• 示例：
  • "command": "npx"：使用npx命令来运行apifox-mcp-server。

3. args

• 目的：指定启动命令的参数。
• 用途：这是一个数组，包含启动MCP服务器时需要传递的参数。这些参数用于配置服务器的行为，例如指定要连接的项目ID。
• 示例：
  • "args": ["-y", "apifox-mcp-server@latest", "--project=<your_project_id>"]：
    • -y：自动确认安装。
    • apifox-mcp-server@latest：指定安装最新版本的apifox-mcp-server。
    • --project=<your_project_id>：指定要连接的Apifox项目的ID。

4. env

• 目的：定义运行MCP服务器时的环境变量。
• 用途：这是一个对象，包含在启动MCP服务器时需要设置的环境变量。这些环境变量通常用于认证或其他配置信息。
• 示例：
  • "env": {"APIFOX_ACCESS_TOKEN": "<your_access_token>"}：
    • APIFOX_ACCESS_TOKEN：Apifox的访问令牌，用于认证。
    • <your_access_token>：替换为你的实际Apifox访问令牌。

配置项的详细用途

1. mcpServers 对象

• 用途：组织和管理多个MCP服务器的配置。可以同时配置多个服务器，每个服务器都有一个唯一的名称，便于识别和管理。
• 示例：
  JSON

  Copy

  {
    "mcpServers": {
      "API 文档": {
        "command": "npx",
        "args": ["-y", "apifox-mcp-server@latest", "--project=<your_project_id>"],
        "env": {"APIFOX_ACCESS_TOKEN": "<your_access_token>"}
      },
      "数据库访问": {
        "command": "node",
        "args": ["path/to/database-server.js"],
        "env": {"DATABASE_URL": "your_database_url"}
      }
    }
  }

  • 在这个例子中，同时配置了两个MCP服务器：API 文档和数据库访问。

2. command 字段

• 用途：指定启动MCP服务器的具体命令。这个命令通常是通过命令行工具运行的，例如npx、node等。
• 示例：
  • 使用npx运行apifox-mcp-server：
    JSON

    Copy

    "command": "npx"
  • 使用node运行本地脚本：
    JSON

    Copy

    "command": "node"

3. args 数组

• 用途：传递给command的参数，用于配置MCP服务器的行为。这些参数可以包括版本号、项目ID、配置文件路径等。
• 示例：
  • 启动apifox-mcp-server并指定项目ID：
    JSON

    Copy

    "args": ["-y", "apifox-mcp-server@latest", "--project=<your_project_id>"]
  • 启动本地Node.js脚本：
    JSON

    Copy

    "args": ["path/to/database-server.js"]

4. env 对象

• 用途：设置运行MCP服务器时的环境变量。这些环境变量通常用于认证、配置数据库连接、设置API密钥等。
• 示例：
  • 设置Apifox访问令牌：
    JSON

    Copy

    "env": {"APIFOX_ACCESS_TOKEN": "<your_access_token>"}
  • 设置数据库连接URL：
    JSON

    Copy

    "env": {"DATABASE_URL": "your_database_url"}

总结

1. 明确连接目标：通过mcpServers对象，客户端可以管理多个MCP服务器的连接配置。
2. 启动服务器：通过command和args字段，客户端可以指定启动MCP服务器的具体命令和参数。
3. 提供认证信息：通过env对象，客户端可以传递必要的认证信息和配置参数，确保服务器能够正确运行。

SSE（Server-Sent Events）介绍

SSE与HTTP协议的区别

• 通信方向：HTTP协议是客户端请求、服务器响应的模式，而SSE是服务器主动向客户端推送数据。
• 数据传输：SSE的数据传输是单向的，只能从服务器到客户端，而HTTP协议是双向的。
• 连接持久性：SSE建立的是一个持久的HTTP连接，服务器可以持续推送数据，而HTTP协议通常是一次请求一次响应。
• 数据格式：SSE的数据以纯文本格式传输，而HTTP协议可以传输多种格式的数据。
• 自动重连：SSE内置支持自动重连，而HTTP协议本身不支持自动重连。

SSE的使用方法

客户端使用SSE

const eventSource = new EventSource('https://example.com/sse'); // 替换为你的SSE接口地址

// 监听默认消息
eventSource.onmessage = (event) => {
    console.log('Received message:', event.data);
};

// 监听特定事件类型
eventSource.addEventListener('customEvent', (event) => {
    console.log('Received customEvent:', event.data);
});

// 处理连接错误
eventSource.onerror = () => {
    console.log('Connection error, attempting to reconnect...');
};

服务端实现SSE

const http = require('http');

http.createServer((req, res) => {
    if (req.url === '/sse-endpoint') {
        res.writeHead(200, {
            'Content-Type': 'text/event-stream',
            'Cache-Control': 'no-cache',
            'Connection': 'keep-alive',
        });

        const sendEvent = (data) => {
            res.write(`data: ${JSON.stringify(data)}\n\n`);
        };

        // 定时发送数据
        const interval = setInterval(() => {
            sendEvent({ timestamp: Date.now(), message: 'Hello, SSE!' });
        }, 1000);

        // 清理资源
        req.on('close', () => {
            clearInterval(interval);
        });
    }
}).listen(3000, () => console.log('Server running on http://localhost:3000'));

对于服务端原有的Web服务是否需要改进

1. 设置响应头：服务器需要设置Content-Type: text/event-stream，以声明这是一个SSE数据流。
2. 保持连接：服务器需要保持与客户端的连接，而不是像传统的HTTP请求那样在响应后关闭连接。
3. 发送事件流：服务器需要按照SSE的格式发送数据，即每条消息以data:开头，以两个换行符结束。

服务器端

1. 设置适当的响应头：
   • Content-Type：设置为text/event-stream，这是SSE的标准内容类型。
   • Cache-Control：设置为no-cache，防止浏览器缓存响应。
   • Connection：设置为keep-alive，确保连接保持打开状态。
   JavaScript

   Copy

   res.writeHead(200, {
       'Content-Type': 'text/event-stream',
       'Cache-Control': 'no-cache',
       'Connection': 'keep-alive',
   });
2. 定期发送心跳消息：
   • 即使没有实际数据需要发送，服务器也可以定期发送心跳消息（例如每30秒一次），以保持连接活跃。心跳消息可以是一个简单的空消息或特定的保持活动消息。
   • 这样可以防止客户端或中间代理（如负载均衡器或防火墙）关闭空闲连接。
   JavaScript

   Copy

   const interval = setInterval(() => {
       res.write(': keep-alive\n\n'); // 心跳消息
   }, 30000); // 每30秒发送一次
3. 处理客户端关闭连接：
   • 监听客户端关闭连接的事件，并在连接关闭时清理资源（如定时器）。
   • 这可以防止资源泄漏，并确保服务器能够正确响应客户端的断开操作。
   JavaScript

   Copy

   req.on('close', () => {
       clearInterval(interval); // 清理心跳定时器
       console.log('Client disconnected');
   });

客户端

1. 自动重连机制：
   • 客户端需要实现自动重连机制，以便在连接意外中断时能够自动重新建立连接。
   • EventSource接口本身支持自动重连，但可以通过自定义逻辑来增强重连策略（例如，设置重连间隔时间）。
   JavaScript

   Copy

   const eventSource = new EventSource('https://example.com/sse');
   
   eventSource.onerror = (error) => {
       console.error('EventSource failed:', error);
       eventSource.close(); // 关闭当前连接
       // 可以在这里实现自定义重连逻辑
       setTimeout(() => {
           console.log('Attempting to reconnect...');
           eventSource = new EventSource('https://example.com/sse');
       }, 5000); // 5秒后重连
   };
2. 处理心跳消息：
   • 客户端可以忽略心跳消息，或者使用它们来更新UI或日志，表明连接仍然活跃。
   JavaScript

   Copy

   eventSource.onmessage = (event) => {
       if (event.data.trim() === ': keep-alive') {
           console.log('Received keep-alive message');
       } else {
           console.log('Received data:', event.data);
       }
   };

总结

WebSocket vs. SSE

1. 功能

• WebSocket：
  • 双向通信：WebSocket支持客户端和服务器之间的双向通信，即客户端可以随时向服务器发送消息，服务器也可以随时向客户端发送消息。
  • 灵活性：WebSocket支持多种数据格式（如文本、二进制等），可以传输更复杂的数据。
  • 适用场景：适用于需要实时双向通信的应用，如在线游戏、实时聊天、实时协作工具等。
• SSE：
  • 单向通信：SSE只支持服务器到客户端的单向通信，客户端不能向服务器发送消息。
  • 简单性：SSE只支持文本数据，通常用于简单的实时通知或数据推送。
  • 适用场景：适用于服务器需要向客户端推送数据的场景，如实时新闻、股票行情、日志流等。

2. 实现复杂度

• WebSocket：
  • 复杂度较高：WebSocket需要处理连接的建立、保持、关闭等生命周期事件，还需要处理心跳机制、重连机制等。
  • 客户端支持：需要使用WebSocket API，代码相对复杂。
• SSE：
  • 简单易用：SSE的实现相对简单，客户端只需要使用EventSource API即可。
  • 客户端支持：EventSource API非常简单，易于使用。

3. 浏览器支持

• WebSocket：
  • 广泛支持：几乎所有现代浏览器都支持WebSocket。
  • 兼容性：在一些旧版本的浏览器中可能需要使用polyfill。
• SSE：
  • 部分支持：SSE在现代浏览器中也有广泛支持，但在一些旧版本的浏览器中可能不支持。
  • 兼容性：在不支持SSE的浏览器中，可以使用polyfill（如EventSourcePolyfill）。

为什么在支持WebSocket的情况下不需要再使用SSE

1. 功能覆盖：
   • 如果你的系统已经支持WebSocket，那么WebSocket已经提供了更强大的双向通信功能，可以覆盖SSE的所有功能。你可以在WebSocket连接中实现服务器到客户端的单向通信，而不需要额外引入SSE。
2. 减少复杂性：
   • 使用WebSocket可以避免引入额外的技术栈，减少系统的复杂性。维护一个统一的通信协议（如WebSocket）通常比同时维护多个协议（如WebSocket和SSE）更简单。
3. 性能和资源：
   • WebSocket连接通常比SSE连接更高效，因为它可以复用同一个连接进行双向通信，而SSE需要为每个客户端保持一个独立的HTTP连接。

示例：在WebSocket中实现SSE的功能

服务器端（Node.js）

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', (ws) => {
    console.log('Client connected');

    // 定时发送消息
    const interval = setInterval(() => {
        ws.send(JSON.stringify({ timestamp: Date.now(), message: 'Hello, WebSocket!' }));
    }, 1000);

    ws.on('close', () => {
        clearInterval(interval);
        console.log('Client disconnected');
    });
});

客户端（JavaScript）

const ws = new WebSocket('ws://localhost:8080');

ws.onopen = () => {
    console.log('Connected to WebSocket server');
};

ws.onmessage = (event) => {
    const data = JSON.parse(event.data);
    console.log('Received message:', data);
};

ws.onerror = (error) => {
    console.error('WebSocket error:', error);
};

总结

Go语言实现的MCP Server

• 从零开始开发：有教程详细介绍了如何使用Go语言从零开始开发一个MCP Server，包括理解CS架构和JSON-RPC协议，以及如何创建简单的Server并测试。
• 具体实现：在Go语言的实现中，可以使用github.com/mark3labs/mcp-go库来构建MCP Server。示例代码中展示了如何处理initialize请求、tools/list请求以及如何定义工具的输入参数和描述信息。

Python语言实现的MCP Server

• 使用Python SDK：Python社区提供了MCP SDK，可以方便地开发MCP Server。通过uv工具初始化项目、创建虚拟环境、安装依赖，并使用FastMCP类来快速搭建服务。
• 示例代码：示例代码展示了如何使用Python SDK创建一个简单的天气服务端，包括初始化FastMCP服务端、设置常量、导入必要的包等。

其他语言实现的MCP Server

• Go语言的Kubernetes Server：有一个基于Go语言的MCP Server实现，用于浏览Kubernetes的Pods及其日志、事件、命名空间等。
• 基于MasterGO的MCP Server：还有基于MasterGO构建的MCP服务，虽然具体细节未在搜索结果中详细说明，但表明了MCP Server的实现不仅仅局限于Node.js和Python。

在旧项目中集成 MCP Server

1. 理解 MCP Server 的角色

2. 选择合适的集成方式

• 使用现有的 MCP SDK：如果旧项目使用的是 Python 或 Node.js，可以直接使用官方提供的 MCP SDK。例如，使用 Python SDK 可以快速将旧项目中的某些功能暴露为 MCP Server。
• 编写适配器：如果旧项目使用的是其他语言（如 Go 或 PHP），可以编写适配器来实现 MCP 协议。适配器可以将旧项目的功能转换为符合 MCP 协议的接口，从而与 MCP 客户端通信。

3. 配置和启动 MCP Server

• 本地模式：在旧项目中配置启动命令，通过标准输入输出（stdio）与客户端通信。例如，可以在旧项目的配置文件中添加 MCP Server 的启动参数。
• 远程模式：虽然目前远程部署方式还不完善，但也可以考虑将 MCP Server 部署为独立进程，通过网络与旧项目通信。

4. 与客户端通信

• 标准输入输出（stdio）：适用于本地快速集成的场景，客户端通过启动服务器子进程并使用标准输入输出建立双向通信。
• 服务器发送事件（SSE）：适用于需要多个客户端连接的场景，服务器作为独立进程运行，客户端和服务器代码完全解耦。

集成的好处

• 简化 LLM 应用：旧项目中的功能可以通过 MCP Server 以标准化的方式暴露给 LLM 应用。
• 快速扩展：随时可以“插拔”新的 MCP Server，灵活扩展旧项目的能力。
• 适应变化：如果旧项目中的接口发生变化，只需要修改 MCP Server，而不需要修改所有依赖它的 LLM 应用。

示例

1. 安装 MCP Python SDK。
2. 编写适配器代码，将旧项目中的某些功能暴露为 MCP Server。
3. 在旧项目的配置文件中添加 MCP Server 的启动参数。
4. 启动旧项目时，自动启动 MCP Server。

1. 解析配置文件

• 客户端首先会解析配置文件（如mcp.json），获取MCP服务器的相关信息，包括服务器的名称、启动命令、参数和环境变量等。
• 例如，配置文件可能包含以下内容：
  JSON

  Copy

  {
    "mcpServers": {
      "listdesktopfiles": {
        "command": "python d:\\temp\\mcp-demo\\file.py"
      }
    }
  }

  这里定义了一个名为listdesktopfiles的MCP服务器，其启动命令是运行一个Python脚本。

2. 启动MCP服务器

• 客户端会根据配置文件中的command和args字段启动MCP服务器。
• 如果配置的是本地脚本（如Python或Node.js脚本），客户端会通过标准输入输出（stdio）与服务器通信。
• 如果配置的是远程服务器，客户端会通过服务器发送事件（SSE）与服务器通信。

3. 建立连接

• 客户端与MCP服务器建立连接后，会发送一个initialize请求，以初始化会话并获取服务器的能力列表。
• 服务器响应initialize请求，返回其支持的工具（tools）列表，包括每个工具的名称、描述和输入参数模式。

4. 获取工具列表

• 客户端从服务器获取工具列表后，会将其存储起来，以便后续根据用户查询调用相应的工具。
• 例如，服务器返回的工具列表可能包含一个名为get_desktop_files的工具，其描述为“获取桌面上的文件列表”。

5. 处理用户查询

• 当用户通过客户端发送查询时，客户端会根据查询内容和已获取的工具列表，决定调用哪个工具。
• 客户端将查询发送给LLM（如Claude），并附带可用的工具列表。
• LLM根据查询内容和工具描述，选择并调用相应的工具。

6. 调用工具并处理结果

• 客户端通过MCP协议调用选定的工具，并将工具的返回结果传递给LLM。
• LLM根据工具的返回结果生成最终的响应，并将其返回给用户。

7. 持续通信

• 在整个过程中，客户端与MCP服务器保持通信，以便实时获取工具的输出并更新LLM的上下文。
• 如果需要，客户端还可以处理工具调用期间发生的任何错误或异常。

示例解析

{
  "mcpServers": {
    "listdesktopfiles": {
      "command": "python",
      "args": ["d:\\temp\\mcp-demo\\file.py"]
    }
  }
}

• command：指定启动MCP服务器的命令，这里是python。
• args：指定传递给python命令的参数，这里是d:\\temp\\mcp-demo\\file.py，即要运行的Python脚本路径。

Python脚本的作用

1. 导入必要的库：例如，导入MCP SDK或其他必要的库。
2. 定义工具：定义MCP服务器提供的工具及其功能。
3. 启动服务器：启动MCP服务器，使其能够接收客户端的连接和请求。

示例Python脚本

# file.py
from mcp_sdk import Server, Tool

# 定义一个工具
class GetDesktopFilesTool(Tool):
    name = "get_desktop_files"
    description = "获取桌面上的文件列表"

    async def run(self, params):
        # 实现工具的具体功能
        import os
        desktop_path = os.path.join(os.path.expanduser("~"), "Desktop")
        files = os.listdir(desktop_path)
        return {"files": files}

# 创建MCP服务器
server = Server(
    name="listdesktopfiles",
    version="1.0.0",
    tools=[GetDesktopFilesTool()]
)

# 启动服务器
if __name__ == "__main__":
    server.run()

详细说明

1. 导入必要的库：
   • mcp_sdk：这是MCP的Python SDK，提供了创建MCP服务器和工具的工具类。
2. 定义工具：
   • GetDesktopFilesTool：这是一个自定义工具类，继承自Tool。它定义了一个工具get_desktop_files，用于获取桌面上的文件列表。
   • run方法：这是工具的具体实现，当客户端调用这个工具时，run方法会被执行。
3. 创建MCP服务器：
   • Server：这是MCP服务器的类，用于初始化和启动MCP服务器。
   • tools：这是一个列表，包含服务器提供的所有工具。
4. 启动服务器：
   • server.run()：启动MCP服务器，使其能够接收客户端的连接和请求。

客户端如何与这个MCP Server交互

1. 解析配置文件：
   • 客户端解析mcp.json文件，获取MCP服务器的启动命令和参数。
2. 启动MCP服务器：
   • 客户端执行python d:\\temp\\mcp-demo\\file.py，启动MCP服务器。
3. 建立连接：
   • 客户端与MCP服务器建立连接，发送initialize请求，初始化会话。
4. 获取工具列表：
   • 客户端从MCP服务器获取工具列表，例如get_desktop_files工具。
5. 调用工具：
   • 客户端根据用户查询，调用get_desktop_files工具，获取桌面上的文件列表。
6. 处理结果：
   • 客户端将工具的返回结果传递给LLM，LLM生成最终的响应并返回给用户。

总结

1. 配置文件中指定

{
  "mcpServers": {
    "myMcpServer": {
      "command": "node",
      "args": ["path/to/mcp-server.js"],
      "env": {
        "MCP_SERVER_PORT": "9876" // 指定端口号
      }
    }
  }
}

2. 通过命令行参数

node path/to/mcp-server.js --port 9876

3. 使用默认端口号

4. 通过环境变量

export MCP_SERVER_PORT=9876

5. 动态发现端口号

6. 网页版MCP客户端

https://example.com/mcp:9876

总结

1. MCP客户端如何找到MCP服务器的地址和端口号

• 配置文件指定：MCP客户端通常通过配置文件（如mcp.json或claude_desktop_config.json）来获取MCP服务器的地址和端口号。例如：
  JSON

  Copy

  {
    "mcpServers": {
      "myMcpServer": {
        "command": "node",
        "args": ["path/to/mcp-server.js"],
        "env": {
          "MCP_SERVER_PORT": "9876",
          "MCP_SERVER_HOST": "localhost"
        }
      }
    }
  }

  在这个例子中，通过环境变量MCP_SERVER_PORT和MCP_SERVER_HOST指定了MCP服务器的端口号和主机地址。
• 命令行参数：在启动MCP服务器时，可以通过命令行参数指定端口号。例如：
  bash

  Copy

  node path/to/mcp-server.js --port 9876

  客户端在连接时，会根据配置文件或内部逻辑使用这个端口号。
• 环境变量：对于一些MCP服务器实现，可以通过环境变量来设置端口号。例如：
  bash

  Copy

  export MCP_SERVER_PORT=9876

  然后启动MCP服务器，它会使用这个环境变量中指定的端口号。

2. MCP服务器是否默认采用80端口

• 默认端口号：根据搜索结果，MCP服务器的默认端口号并不是80。例如，BlenderMCP的默认端口号是9876。另外，一些MCP服务器实现可能会使用其他默认端口号，如8000。
• HTTP服务的默认端口：80端口是HTTP服务的默认端口，用于普通的Web服务。如果MCP服务器是通过HTTP协议（如SSE）运行的，可能会使用80端口，但这并不是MCP协议的默认端口。

总结

示例代码

1. 安装必要的库

pip install mcp-sdk

2. 创建 MCP Server

from mcp_sdk import Server, Tool

# 定义一个工具类
class EchoTool(Tool):
    name = "echo"
    description = "简单的回声工具，返回输入的字符串"

    async def run(self, params):
        # 获取输入参数
        input_text = params.get("text", "")
        # 返回相同的字符串
        return {"result": input_text}

# 创建MCP服务器
server = Server(
    name="echo-server",
    version="1.0.0",
    tools=[EchoTool()]
)

# 启动服务器
if __name__ == "__main__":
    server.run()

代码解释

1. 导入必要的库：
   • mcp_sdk：这是 MCP 的 Python SDK，提供了创建 MCP 服务器和工具的工具类。
2. 定义工具类：
   • EchoTool：这是一个自定义工具类，继承自 Tool。它定义了一个工具 echo，用于接收一个字符串并返回相同的字符串。
   • name：工具的名称，客户端将通过这个名称调用工具。
   • description：工具的描述，用于说明工具的功能。
   • run 方法：这是工具的具体实现，当客户端调用这个工具时，run 方法会被执行。它接收一个参数 params，从中获取输入字符串，并返回相同的字符串。
3. 创建 MCP 服务器：
   • Server：这是 MCP 服务器的类，用于初始化和启动 MCP 服务器。
   • name：服务器的名称。
   • version：服务器的版本号。
   • tools：这是一个列表，包含服务器提供的所有工具。
4. 启动服务器：
   • server.run()：启动 MCP 服务器，使其能够接收客户端的连接和请求。

配置文件

{
  "mcpServers": {
    "echo-server": {
      "command": "python",
      "args": ["path/to/mcp_server.py"]
    }
  }
}

客户端调用示例

from mcp_sdk import Client

# 创建客户端
client = Client(
    name="echo-client",
    version="1.0.0"
)

# 连接到MCP服务器
client.connect("echo-server")

# 调用echo工具
response = client.call_tool("echo", {"text": "Hello, MCP!"})

# 打印结果
print(response)

输出结果

{
  "result": "Hello, MCP!"
}

总结

示例代码

1. 安装必要的库

pip install mcp-sdk

2. 创建 MCP Server

from mcp_sdk import Server, Tool

# 定义一个工具类：EchoTool
class EchoTool(Tool):
    name = "echo"
    description = "简单的回声工具，返回输入的字符串"

    async def run(self, params):
        # 获取输入参数
        input_text = params.get("text", "")
        # 返回相同的字符串
        return {"result": input_text}

# 定义另一个工具类：MirrorTool
class MirrorTool(Tool):
    name = "mirror"
    description = "镜像工具，返回输入字符串的反转版本"

    async def run(self, params):
        # 获取输入参数
        input_text = params.get("text", "")
        # 返回反转后的字符串
        return {"result": input_text[::-1]}

# 创建MCP服务器
server = Server(
    name="multi-tool-server",
    version="1.0.0",
    tools=[EchoTool(), MirrorTool()]
)

# 启动服务器
if __name__ == "__main__":
    server.run()

代码解释

1. 导入必要的库：
   • mcp_sdk：这是MCP的Python SDK，提供了创建MCP服务器和工具的工具类。
2. 定义工具类：
   • EchoTool：定义了一个名为echo的工具，用于接收一个字符串并返回相同的字符串。
     • name：工具的名称，客户端将通过这个名称调用工具。
     • description：工具的描述，用于说明工具的功能。
     • run方法：这是工具的具体实现，当客户端调用这个工具时，run方法会被执行。它接收一个参数params，从中获取输入字符串，并返回相同的字符串。
   • MirrorTool：定义了一个名为mirror的工具，用于接收一个字符串并返回其反转版本。
     • name：工具的名称，客户端将通过这个名称调用工具。
     • description：工具的描述，用于说明工具的功能。
     • run方法：这是工具的具体实现，当客户端调用这个工具时，run方法会被执行。它接收一个参数params，从中获取输入字符串，并返回其反转版本。
3. 创建MCP服务器：
   • Server：这是MCP服务器的类，用于初始化和启动MCP服务器。
   • name：服务器的名称。
   • version：服务器的版本号。
   • tools：这是一个列表，包含服务器提供的所有工具。在这个例子中，服务器提供了EchoTool和MirrorTool两个工具。
4. 启动服务器：
   • server.run()：启动MCP服务器，使其能够接收客户端的连接和请求。

客户端调用示例

from mcp_sdk import Client

# 创建客户端
client = Client(
    name="multi-tool-client",
    version="1.0.0"
)

# 连接到MCP服务器
client.connect("multi-tool-server")

# 调用echo工具
echo_response = client.call_tool("echo", {"text": "Hello, MCP!"})
print("Echo Response:", echo_response)

# 调用mirror工具
mirror_response = client.call_tool("mirror", {"text": "Hello, MCP!"})
print("Mirror Response:", mirror_response)

输出结果

{
  "result": "Hello, MCP!"
}

{
  "result": "!PCM, olleH"
}

总结

实际实现 MCP Server 的方法

实现 MCP Server 的正确方法

安装必要的库

pip install aiohttp

创建 MCP Server

import asyncio
from aiohttp import web

# 定义处理函数
async def handle_request(request):
    data = await request.json()
    method = data.get('method')
    params = data.get('params', {})
    id = data.get('id')

    if method == 'echo':
        result = params.get('text', '')
    elif method == 'mirror':
        result = params.get('text', '')[::-1]
    else:
        return web.json_response({
            'jsonrpc': '2.0',
            'error': {'code': -32601, 'message': 'Method not found'},
            'id': id
        }, status=400)

    return web.json_response({
        'jsonrpc': '2.0',
        'result': result,
        'id': id
    })

# 创建应用并启动服务器
async def start_server():
    app = web.Application()
    app.router.add_post('/mcp', handle_request)
    runner = web.AppRunner(app)
    await runner.setup()
    site = web.TCPSite(runner, 'localhost', 8080)
    await site.start()
    print('Server started at http://localhost:8080')

# 启动服务器
if __name__ == '__main__':
    asyncio.run(start_server())

代码解释

1. 定义处理函数：
   • handle_request：这是处理客户端请求的函数。它解析 JSON-RPC 2.0 格式的请求，根据方法名调用相应的逻辑，并返回结果。
   • 支持的方法：
     • echo：返回输入的字符串。
     • mirror：返回输入字符串的反转版本。
   • 如果方法名不匹配，返回错误响应。
2. 创建应用并启动服务器：
   • 使用 aiohttp 创建一个简单的 HTTP 服务器，监听 localhost 的 8080 端口。
   • 定义了一个 POST 路由 /mcp，用于处理 MCP 请求。
3. 启动服务器：
   • 使用 asyncio.run 启动服务器。

客户端调用示例

import requests

# 定义请求
def call_method(method, params):
    url = 'http://localhost:8080/mcp'
    headers = {'Content-Type': 'application/json'}
    payload = {
        'jsonrpc': '2.0',
        'method': method,
        'params': params,
        'id': 1
    }
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# 调用 echo 方法
echo_response = call_method('echo', {'text': 'Hello, MCP!'})
print('Echo Response:', echo_response)

# 调用 mirror 方法
mirror_response = call_method('mirror', {'text': 'Hello, MCP!'})
print('Mirror Response:', mirror_response)

输出结果

{
  "jsonrpc": "2.0",
  "result": "Hello, MCP!",
  "id": 1
}

{
  "jsonrpc": "2.0",
  "result": "!PCM, olleH",
  "id": 1
}

总结

1. 配置文件

配置文件示例 (mcp_config.json)

{
  "servers": {
    "multi-tool-server": {
      "host": "localhost",
      "port": 8080,
      "protocol": "http"
    }
  }
}

客户端代码示例

import requests
import json

# 读取配置文件
def load_config(file_path):
    with open(file_path, 'r') as file:
        return json.load(file)

# 定义请求
def call_method(config, server_name, method, params):
    server_info = config['servers'][server_name]
    url = f"{server_info['protocol']}://{server_info['host']}:{server_info['port']}/mcp"
    headers = {'Content-Type': 'application/json'}
    payload = {
        'jsonrpc': '2.0',
        'method': method,
        'params': params,
        'id': 1
    }
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# 加载配置
config = load_config('mcp_config.json')

# 调用 echo 方法
echo_response = call_method(config, 'multi-tool-server', 'echo', {'text': 'Hello, MCP!'})
print('Echo Response:', echo_response)

# 调用 mirror 方法
mirror_response = call_method(config, 'multi-tool-server', 'mirror', {'text': 'Hello, MCP!'})
print('Mirror Response:', mirror_response)

2. 环境变量

设置环境变量

export MCP_SERVER_HOST=localhost
export MCP_SERVER_PORT=8080
export MCP_SERVER_PROTOCOL=http

客户端代码示例

import requests
import os

# 从环境变量中读取配置
def get_server_config():
    return {
        'host': os.getenv('MCP_SERVER_HOST', 'localhost'),
        'port': os.getenv('MCP_SERVER_PORT', '8080'),
        'protocol': os.getenv('MCP_SERVER_PROTOCOL', 'http')
    }

# 定义请求
def call_method(server_config, method, params):
    url = f"{server_config['protocol']}://{server_config['host']}:{server_config['port']}/mcp"
    headers = {'Content-Type': 'application/json'}
    payload = {
        'jsonrpc': '2.0',
        'method': method,
        'params': params,
        'id': 1
    }
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# 获取服务器配置
server_config = get_server_config()

# 调用 echo 方法
echo_response = call_method(server_config, 'echo', {'text': 'Hello, MCP!'})
print('Echo Response:', echo_response)

# 调用 mirror 方法
mirror_response = call_method(server_config, 'mirror', {'text': 'Hello, MCP!'})
print('Mirror Response:', mirror_response)

3. 命令行参数

使用 argparse 模块

import requests
import argparse

# 解析命令行参数
def parse_args():
    parser = argparse.ArgumentParser(description='MCP Client')
    parser.add_argument('--host', default='localhost', help='MCP server host')
    parser.add_argument('--port', default=8080, type=int, help='MCP server port')
    parser.add_argument('--protocol', default='http', help='MCP server protocol')
    return parser.parse_args()

# 定义请求
def call_method(args, method, params):
    url = f"{args.protocol}://{args.host}:{args.port}/mcp"
    headers = {'Content-Type': 'application/json'}
    payload = {
        'jsonrpc': '2.0',
        'method': method,
        'params': params,
        'id': 1
    }
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# 解析命令行参数
args = parse_args()

# 调用 echo 方法
echo_response = call_method(args, 'echo', {'text': 'Hello, MCP!'})
print('Echo Response:', echo_response)

# 调用 mirror 方法
mirror_response = call_method(args, 'mirror', {'text': 'Hello, MCP!'})
print('Mirror Response:', mirror_response)

4. 硬编码

客户端代码示例

import requests

# 定义请求
def call_method(method, params):
    url = 'http://localhost:8080/mcp'
    headers = {'Content-Type': 'application/json'}
    payload = {
        'jsonrpc': '2.0',
        'method': method,
        'params': params,
        'id': 1
    }
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# 调用 echo 方法
echo_response = call_method('echo', {'text': 'Hello, MCP!'})
print('Echo Response:', echo_response)

# 调用 mirror 方法
mirror_response = call_method('mirror', {'text': 'Hello, MCP!'})
print('Mirror Response:', mirror_response)

总结

安装必要的库

pip install aiohttp

创建 MCP Server

import asyncio
from aiohttp import web

# 定义 echo 方法
async def echo(params):
    input_text = params.get('text', '')
    return {'result': input_text}

# 定义 mirror 方法
async def mirror(params):
    input_text = params.get('text', '')
    return {'result': input_text[::-1]}

# 定义处理函数
async def handle_request(request):
    data = await request.json()
    method = data.get('method')
    params = data.get('params', {})
    id = data.get('id')

    if method == 'echo':
        result = await echo(params)
    elif method == 'mirror':
        result = await mirror(params)
    else:
        return web.json_response({
            'jsonrpc': '2.0',
            'error': {'code': -32601, 'message': 'Method not found'},
            'id': id
        }, status=400)

    return web.json_response({
        'jsonrpc': '2.0',
        'result': result['result'],
        'id': id
    })

# 创建应用并启动服务器
async def start_server():
    app = web.Application()
    app.router.add_post('/mcp', handle_request)
    runner = web.AppRunner(app)
    await runner.setup()
    site = web.TCPSite(runner, 'localhost', 8080)
    await site.start()
    print('Server started at http://localhost:8080')

# 启动服务器
if __name__ == '__main__':
    asyncio.run(start_server())

代码解释

1. 定义方法：
   • echo 方法：接收一个字符串并返回相同的字符串。
   • mirror 方法：接收一个字符串并返回其反转版本。
2. 处理函数：
   • handle_request：解析客户端发送的 JSON-RPC 2.0 格式的请求，根据方法名调用相应的逻辑，并返回结果。
   • 如果方法名不匹配，返回错误响应。
3. 创建应用并启动服务器：
   • 使用 aiohttp 创建一个简单的 HTTP 服务器，监听 localhost 的 8080 端口。
   • 定义了一个 POST 路由 /mcp，用于处理 MCP 请求。
4. 启动服务器：
   • 使用 asyncio.run 启动服务器。

客户端调用示例

import requests

# 定义请求
def call_method(method, params):
    url = 'http://localhost:8080/mcp'
    headers = {'Content-Type': 'application/json'}
    payload = {
        'jsonrpc': '2.0',
        'method': method,
        'params': params,
        'id': 1
    }
    response = requests.post(url, json=payload, headers=headers)
    return response.json()

# 调用 echo 方法
echo_response = call_method('echo', {'text': 'Hello, MCP!'})
print('Echo Response:', echo_response)

# 调用 mirror 方法
mirror_response = call_method('mirror', {'text': 'Hello, MCP!'})
print('Mirror Response:', mirror_response)

输出结果

{
  "jsonrpc": "2.0",
  "result": "Hello, MCP!",
  "id": 1
}

{
  "jsonrpc": "2.0",
  "result": "!PCM, olleH",
  "id": 1
}

总结

MCP Server 示例代码

from mcp.server.fastmcp import FastMCP

# 创建一个 MCP Server
mcp = FastMCP("EchoMirrorServer")

# 定义 echo 方法
@mcp.tool()
def echo(text: str) -> str:
    """返回输入的字符串"""
    return text

# 定义 mirror 方法
@mcp.tool()
def mirror(text: str) -> str:
    """返回输入字符串的反转版本"""
    return text[::-1]

# 主程序入口
if __name__ == "__main__":
    mcp.run()

如何在 Cursor 中接入这个 MCP Server

1. 安装 Python 3.12：确保已安装 Python 3.12。
2. 安装 MCP SDK：在项目中安装 mcp 包，可以使用以下命令：
   bash

   Copy

   pip install mcp
3. 创建并运行 MCP Server：将上述代码保存为 server.py，然后运行以下命令启动服务器：
   bash

   Copy

   python server.py
4. 在 Cursor 中配置 MCP Server：
   • 打开 Cursor，进入设置（Settings）。
   • 在新版本中，MCP 单独独立出来，找到“Features”下的“MCP”选项。
   • 点击“add new MCP server”，在弹出的窗口中输入服务器名称（如 EchoMirrorServer）和启动命令（如 python server.py）。
   • 点击“Save”保存配置。

MCP Server 示例代码（Python 3.12）

from mcp.server.fastmcp import FastMCP

# 创建一个 MCP Server
mcp = FastMCP("EchoMirrorServer")

# 定义 echo 方法
@mcp.tool()
def echo(text: str) -> str:
    """返回输入的字符串"""
    return text

# 定义 mirror 方法
@mcp.tool()
def mirror(text: str) -> str:
    """返回输入字符串的反转版本"""
    return text[::-1]

# 主程序入口
if __name__ == "__main__":
    mcp.run()

在 Cursor 中接入 MCP Server

1. 创建 MCP Server 配置文件

{
  "mcpServers": {
    "EchoMirrorServer": {
      "type": "command",
      "name": "EchoMirrorServer",
      "command": "python",
      "args": ["path/to/mcp_server.py"]
    }
  }
}

• type：指定连接类型，这里使用 command 表示通过命令行启动的服务器。
• name：为服务器设置一个易识别的昵称。
• command：指定启动服务器的命令。
• args：指定命令的参数，这里是 Python 脚本的路径。

2. 将配置文件放置在正确位置

• 全局配置：C:\Users\<用户名>\.cursor\mcp.json（Windows）或 ~/.cursor/mcp.json（Mac/Linux）。
• 项目配置：在项目目录下创建 .cursor 文件夹，并将 mcp.json 放置其中。

3. 启动 Cursor 并验证配置

4. 使用 Cursor 调用 MCP Server

• 调用 echo 方法：
  plain

  Copy

  /echo text="Hello, MCP!"
• 调用 mirror 方法：
  plain

  Copy

  /mirror text="Hello, MCP!"

注意事项

• 确保 Python 3.12 已安装，并且 mcp 包已正确安装。
• 如果在配置过程中遇到问题，可以检查 MCP Server 的日志以获取更多信息。
• 确保路径和命令的准确性，尤其是文件路径和命令路径。

1. 在云端部署MCP Server

• 将MCP Server代码部署到云服务器或云平台（如AWS、Azure、Google Cloud等）。
• 确保服务器可以接受外部连接，并配置好相应的端口和安全组规则。
• 启动MCP Server，并确保它可以通过网络访问。

2. 配置Cursor客户端

JSON配置示例

{
  "mcpServers": {
    "EchoMirrorServer": {
      "type": "sse",
      "name": "EchoMirrorServer",
      "url": "https://your-cloud-server.com/mcp"
    }
  }
}

• type：指定连接类型为sse，表示通过Server-Sent Events连接。
• name：为服务器设置一个易识别的昵称，例如EchoMirrorServer。
• url：云端MCP Server的完整URL，包括协议（https）和路径。

3. 将配置文件放置在正确位置

• 全局配置：C:\Users\<用户名>\.cursor\mcp.json（Windows）或~/.cursor/mcp.json（Mac/Linux）。
• 项目配置：在项目目录下创建.cursor文件夹，并将mcp.json放置其中。

4. 验证配置

注意事项

• 确保云端服务器的URL和端口是可访问的，并且没有被防火墙阻止。
• 如果你的MCP Server需要认证（如API密钥），确保在配置中正确设置了认证信息。
• 如果在配置过程中遇到问题，可以检查MCP Server的日志以获取更多信息。

云部署 MCP Server 的 URL 格式

云端部署的 URL 格式

https://<your-cloud-domain>/mcp

• https：协议，表示使用 HTTPS（推荐，因为它是安全的）。
• <your-cloud-domain>：你的云服务器的域名或IP地址。例如，如果你使用的是 AWS，可能是 mcp.example.com。
• /mcp：路径，表示 MCP Server 的端点。这个路径需要与你的服务器配置一致。

示例：云部署的 MCP Server

https://mcp.example.com/mcp

配置 Cursor 客户端

JSON 配置文件示例

{
  "mcpServers": {
    "EchoMirrorServer": {
      "type": "sse",
      "name": "EchoMirrorServer",
      "url": "https://mcp.example.com/mcp"
    }
  }
}

详细说明

1. type：
   • 指定连接类型为 sse，表示通过 Server-Sent Events 连接到 MCP Server。
2. name：
   • 为服务器设置一个易识别的昵称，例如 EchoMirrorServer。这个名称将显示在 Cursor 的设置中。
3. url：
   • 云端 MCP Server 的完整 URL，包括协议（https）和路径（/mcp）。
   • https://mcp.example.com/mcp：
     • https：使用 HTTPS 协议，确保数据传输的安全性。
     • mcp.example.com：你的云服务器的域名。
     • /mcp：MCP Server 的端点路径。

将配置文件放置在正确位置

• 全局配置：C:\Users\<用户名>\.cursor\mcp.json（Windows）或 ~/.cursor/mcp.json（Mac/Linux）。
• 项目配置：在项目目录下创建 .cursor 文件夹，并将 mcp.json 放置其中。

验证配置

1. 启动 Cursor：
   • 打开 Cursor，进入设置（Settings）。
   • 在 “Features” 下找到 “MCP” 选项。
   • 如果配置正确，你会看到 EchoMirrorServer 显示为可用状态。
2. 测试连接：
   • 在 Cursor 的聊天面板中，尝试调用 echo 或 mirror 方法：
     plain

     Copy

     /echo text="Hello, MCP!"

     plain

     Copy

     /mirror text="Hello, MCP!"
   • 如果配置正确，Cursor 将调用云端 MCP Server 并返回相应的结果。

注意事项

• 域名解析：确保 mcp.example.com 能够正确解析到你的云服务器的IP地址。
• 防火墙设置：确保云服务器的防火墙允许从客户端的IP地址访问端口 443（HTTPS）。
• SSL 证书：确保你的云服务器配置了有效的 SSL 证书，以支持 HTTPS 连接。
• 路径一致性：确保 MCP Server 的端点路径（如 /mcp）与配置文件中的路径一致。

示例代码

package main

import (
    "log"
    "net"
    "net/http"

    "github.com/soheilhy/cmux"
    "github.com/mark3labs/mcp-go/server"
)

// 定义 MCP Server 的处理函数
func mcpHandler(w http.ResponseWriter, r *http.Request) {
    // 解析 MCP 请求
    // 这里需要根据 MCP 协议解析请求和响应
    // 以下是一个简单的示例
    if r.Method == "POST" && r.URL.Path == "/mcp" {
        // 处理 MCP 请求
        // 例如，返回一个简单的响应
        w.WriteHeader(http.StatusOK)
        w.Write([]byte("MCP Response"))
    } else {
        // 如果不是 MCP 请求，返回 404
        http.NotFound(w, r)
    }
}

func main() {
    // 创建一个监听器
    l, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal(err)
    }

    // 创建一个 cmux
    m := cmux.New(l)

    // 匹配 HTTP 请求
    httpL := m.Match(cmux.HTTP1Fast())

    // 创建 HTTP 服务器
    httpS := &http.Server{
        Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            // 处理旧的 HTTP 接口请求
            if r.URL.Path == "/old-api" {
                w.Write([]byte("Old API Response"))
            } else {
                // 将其他请求转发到 MCP Server
                mcpHandler(w, r)
            }
        }),
    }

    // 启动 HTTP 服务器
    go httpS.Serve(httpL)

    // 匹配 MCP 请求
    mcpL := m.Match(cmux.Any())

    // 创建 MCP Server
    mcp := server.NewMCP()
    mcp.HandleFunc("/mcp", mcpHandler)

    // 启动 MCP Server
    go mcp.Serve(mcpL)

    // 启动 cmux
    log.Println("Server started on :8080")
    if err := m.Serve(); err != nil {
        log.Fatal(err)
    }
}

代码解释

1. 创建监听器：
   • 使用 net.Listen 创建一个 TCP 监听器，监听在 :8080 端口。
2. 创建 cmux：
   • 使用 cmux.New 创建一个 cmux 实例，用于多路复用不同的服务。
3. 匹配 HTTP 请求：
   • 使用 cmux.HTTP1Fast 匹配 HTTP/1 请求。
4. 创建 HTTP 服务器：
   • 创建一个 http.Server 实例，用于处理旧的 HTTP 接口请求。
   • 在 http.HandlerFunc 中，根据请求路径处理旧的 HTTP 接口请求，或者将请求转发到 MCP Server。
5. 启动 HTTP 服务器：
   • 使用 httpS.Serve 启动 HTTP 服务器。
6. 匹配 MCP 请求：
   • 使用 cmux.Any 匹配所有其他请求。
7. 创建 MCP Server：
   • 使用 server.NewMCP 创建一个 MCP Server 实例。
   • 使用 mcp.HandleFunc 注册 MCP 请求处理函数。
8. 启动 MCP Server：
   • 使用 mcp.Serve 启动 MCP Server。
9. 启动 cmux：
   • 使用 m.Serve 启动 cmux，开始监听和分发请求。

配置 Cursor 客户端

{
  "mcpServers": {
    "EchoMirrorServer": {
      "type": "sse",
      "name": "EchoMirrorServer",
      "url": "https://your-cloud-server.com/mcp"
    }
  }
}

• type：指定连接类型为 sse，表示通过 Server-Sent Events 连接到 MCP Server。
• name：为服务器设置一个易识别的昵称。
• url：云端 MCP Server 的完整 URL，包括协议（https）和路径。

• 全局配置：C:\Users\<用户名>\.cursor\mcp.json（Windows）或 ~/.cursor/mcp.json（Mac/Linux）。
• 项目配置：在项目目录下创建 .cursor 文件夹，并将 mcp.json 放置其中。

使用 logiscape/mcp-sdk-php 实现 MCP Server

安装 SDK

composer require logiscape/mcp-sdk-php

创建 MCP Server

<?php

require 'vendor/autoload.php';

use Mcp\Server\Server;
use Mcp\Server\ServerRunner;
use Mcp\Types\Tool;
use Mcp\Types\ToolArgument;
use Mcp\Types\ToolResult;
use Mcp\Types\TextContent;
use Mcp\Types\Role;

// 创建一个 MCP Server 实例
$server = new Server('EchoMirrorServer');

// 注册 echo 方法
$server->registerHandler('echo', function($params) {
    $inputText = $params['text'] ?? '';
    return new ToolResult([
        'result' => $inputText
    ]);
});

// 注册 mirror 方法
$server->registerHandler('mirror', function($params) {
    $inputText = $params['text'] ?? '';
    return new ToolResult([
        'result' => strrev($inputText)
    ]);
});

// 创建初始化选项并运行服务器
$initOptions = $server->createInitializationOptions();
$runner = new ServerRunner($server, $initOptions);
$runner->run();

配置 Cursor 客户端以连接到 MCP Server

JSON 配置文件

{
  "mcpServers": {
    "EchoMirrorServer": {
      "type": "sse",
      "name": "EchoMirrorServer",
      "url": "http://localhost:8080/mcp" // 或者云端服务器的 URL，例如 "https://your-cloud-server.com/mcp"
    }
  }
}

• type：指定连接类型为 sse，表示通过 Server-Sent Events 连接到 MCP Server。
• name：为服务器设置一个易识别的昵称。
• url：MCP Server 的完整 URL，包括协议（http 或 https）和路径。

将配置文件放置在正确位置

• 全局配置：C:\Users\<用户名>\.cursor\mcp.json（Windows）或 ~/.cursor/mcp.json（Mac/Linux）。
• 项目配置：在项目目录下创建 .cursor 文件夹，并将 mcp.json 放置其中。

注意事项

• 确保 PHP 环境已安装并配置正确。
• 如果部署到云端，确保服务器的防火墙和安全组设置允许外部访问。
• 如果使用 HTTPS，确保配置了有效的 SSL 证书。

完整的 PHP 示例代码

安装 SDK

composer require logiscape/mcp-sdk-php

创建 MCP Server

<?php

require 'vendor/autoload.php';

use Mcp\Server\Server;
use Mcp\Server\ServerRunner;
use Mcp\Types\Tool;
use Mcp\Types\ToolArgument;
use Mcp\Types\ToolResult;
use Mcp\Types\TextContent;
use Mcp\Types\Role;

// 创建一个 MCP Server 实例
$server = new Server('EchoMirrorServer');

// 定义 echo 方法的能力描述
$echoTool = new Tool(
    'echo',
    '返回输入的字符串',
    [
        new ToolArgument('text', '要返回的字符串', 'string')
    ]
);

// 定义 mirror 方法的能力描述
$mirrorTool = new Tool(
    'mirror',
    '返回输入字符串的反转版本',
    [
        new ToolArgument('text', '要反转的字符串', 'string')
    ]
);

// 注册 echo 方法
$server->registerHandler($echoTool, function($params) {
    $inputText = $params['text'] ?? '';
    return new ToolResult([
        'result' => $inputText
    ]);
});

// 注册 mirror 方法
$server->registerHandler($mirrorTool, function($params) {
    $inputText = $params['text'] ?? '';
    return new ToolResult([
        'result' => strrev($inputText)
    ]);
});

// 创建初始化选项并运行服务器
$initOptions = $server->createInitializationOptions();
$runner = new ServerRunner($server, $initOptions);
$runner->run();

代码解释

1. 定义工具的能力描述：
   • 使用 Tool 类定义每个方法的能力描述，包括方法名称、描述和参数。
   • ToolArgument 类用于定义方法的参数，包括参数名称、描述和类型。
2. 注册方法：
   • 使用 registerHandler 方法注册每个工具的处理函数。
   • 处理函数接收一个参数数组，并返回一个 ToolResult 对象，包含方法的返回结果。
3. 运行服务器：
   • 使用 ServerRunner 运行 MCP Server。

配置 Cursor 客户端以连接到 MCP Server

JSON 配置文件

{
  "mcpServers": {
    "EchoMirrorServer": {
      "type": "sse",
      "name": "EchoMirrorServer",
      "url": "http://localhost:8080/mcp" // 或者云端服务器的 URL，例如 "https://your-cloud-server.com/mcp"
    }
  }
}

• type：指定连接类型为 sse，表示通过 Server-Sent Events 连接到 MCP Server。
• name：为服务器设置一个易识别的昵称。
• url：MCP Server 的完整 URL，包括协议（http 或 https）和路径。

将配置文件放置在正确位置

• 全局配置：C:\Users\<用户名>\.cursor\mcp.json（Windows）或 ~/.cursor/mcp.json（Mac/Linux）。
• 项目配置：在项目目录下创建 .cursor 文件夹，并将 mcp.json 放置其中。

注意事项

• 确保 PHP 环境已安装并配置正确。
• 如果部署到云端，确保服务器的防火墙和安全组设置允许外部访问。
• 如果使用 HTTPS，确保配置了有效的 SSL 证书。

PHP 实现 MCP Server 的正确方法

创建 MCP Server

<?php

// 定义处理函数
function handleRequest($data) {
    $method = $data['method'] ?? null;
    $params = $data['params'] ?? [];
    $id = $data['id'] ?? null;

    if ($method === 'echo') {
        $inputText = $params['text'] ?? '';
        return [
            'jsonrpc' => '2.0',
            'result' => $inputText,
            'id' => $id
        ];
    } elseif ($method === 'mirror') {
        $inputText = $params['text'] ?? '';
        return [
            'jsonrpc' => '2.0',
            'result' => strrev($inputText),
            'id' => $id
        ];
    } else {
        return [
            'jsonrpc' => '2.0',
            'error' => [
                'code' => -32601,
                'message' => 'Method not found'
            ],
            'id' => $id
        ];
    }
}

// 处理 POST 请求
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $input = file_get_contents('php://input');
    $data = json_decode($input, true);

    if (json_last_error() === JSON_ERROR_NONE) {
        $response = handleRequest($data);
        header('Content-Type: application/json');
        echo json_encode($response);
    } else {
        http_response_code(400);
        echo 'Invalid JSON';
    }
} else {
    http_response_code(405);
    echo 'Method Not Allowed';
}

启动 PHP 内置 HTTP 服务器

php -S localhost:8080 mcp_server.php

客户端调用示例

# 调用 echo 方法
curl -X POST -H "Content-Type: application/json" -d '{"jsonrpc": "2.0", "method": "echo", "params": {"text": "Hello, MCP!"}, "id": 1}' http://localhost:8080

# 调用 mirror 方法
curl -X POST -H "Content-Type: application/json" -d '{"jsonrpc": "2.0", "method": "mirror", "params": {"text": "Hello, MCP!"}, "id": 1}' http://localhost:8080

输出结果

{
  "jsonrpc": "2.0",
  "result": "Hello, MCP!",
  "id": 1
}

{
  "jsonrpc": "2.0",
  "result": "!PCM, olleH",
  "id": 1
}