本文翻译整理自： https://modelcontextprotocol.io/introduction

---

开始使用

简介

开始使用模型上下文协议（MCP）

一、关于 MCP

MCP 是一个开放协议，它标准化了应用程序如何向大型语言模型提供上下文。将 MCP 想象成 AI 应用程序的 USB-C 接口。就像 USB-C 提供了一种标准化的方式将您的设备连接到各种外围设备和配件一样，MCP 也提供了一种标准化的方式将 AI 模型连接到不同的数据源和工具。

---

二、为什么选择MCP？

MCP 帮助你在 LLMs 之上构建代理和复杂的流程。LLMs 经常需要与数据和工具集成，MCP 提供：

• 一个不断增长的预构建集成列表，您的LLM可以直接接入
• 能够在LLM提供者和供应商之间进行切换的灵活性
• 最佳实践：在您的基础设施中保护您的数据

---

通用架构

在其核心，MCP遵循客户端-服务器架构，其中主机应用程序可以连接到多个服务器：

---

---

• MCP 主机: 像Claude Desktop、IDE或希望通过MCP访问数据的AI工具等程序
• MCP 客户端: 与服务器保持1:1连接的协议客户端
• MCP 服务器: 每个服务器通过标准化的模型上下文协议公开特定功能的轻量级程序
• 本地数据源: MCP服务器可以安全访问的您的计算机文件、数据库和服务
• 远程服务: 通过互联网（例如，通过API）可用的外部系统，MCP服务器可以连接到

---

三、开始使用

选择最适合您需求的路径：

---

1、快速入门

• 为服务器开发者：https://modelcontextprotocol.io/quickstart/server
  开始构建您自己的服务器，用于 Claude for Desktop 和其他客户端
• 为客户端开发者：https://modelcontextprotocol.io/quickstart/client
  开始构建自己的客户端，使其能够与所有 MCP 服务器集成
• 为 Claude Desktop 用户：https://modelcontextprotocol.io/quickstart/user
  开始使用 Claude for Desktop 中的预构建服务器

---

2、示例

• 示例服务器：https://modelcontextprotocol.io/examples
  查看我们的官方MCP服务器和实现展示
• 示例客户端：https://modelcontextprotocol.io/clients
  查看支持MCP集成的客户端列表

---

四、教程

• 使用 LLMs 构建 MCP：https://modelcontextprotocol.io/tutorials/building-mcp-with-llms
  学习如何使用 Claude 等LLMs 来加速您的 MCP 开发
• 调试指南：https://modelcontextprotocol.io/docs/tools/debugging
  学习如何有效地调试 MCP 服务器和集成](/docs/tools/debugging)
• MCP 检查器：https://modelcontextprotocol.io/docs/tools/inspector
  使用我们的交互式调试工具测试和检查您的 MCP 服务器
• MCP 实战（视频，2 小时）: https://www.youtube.com/watch?v=kQmXtrmQ5Zg

---

五、探索 MCP

深入探索MCP的核心概念和功能：

• 核心架构：https://modelcontextprotocol.io/docs/concepts/architecture
  理解MCP如何连接客户端、服务器和LLMs
• 资源： https://modelcontextprotocol.io/docs/concepts/resources
  展示您服务器上的数据和内容以供LLMs使用
• 提示：https://modelcontextprotocol.io/docs/concepts/prompts
  创建可重用的提示模板和工作流程
• 工具：https://modelcontextprotocol.io/docs/concepts/tools
  启用 LLMs 通过您的服务器执行操作
• 样本抽取：https://modelcontextprotocol.io/docs/concepts/sampling
  让你的服务器从LLMs请求完成项
• Transports : https://modelcontextprotocol.io/docs/concepts/transports
  了解MCP的通信机制

---

六、贡献和支持反馈

贡献

想要贡献力量？查看我们的 贡献指南 了解您如何帮助改进MCP。

---

支持和反馈

以下是获取帮助或提供反馈的方法：

• 对于与MCP规范、SDK或文档（开源）相关的错误报告和功能请求，请在GitHub上创建一个issue
• 对于关于MCP规范的讨论或问答，请使用规范讨论
• 对于关于其他MCP开源组件的讨论或问答，请使用组织讨论
• 对于有关Claude.app和claude.ai的MCP集成的错误报告、功能请求和问题，请通过电子邮件发送到 mcp-support@anthropic.com

---

---

服务器开发者

https://modelcontextprotocol.io/quickstart/server

一、构建服务器

开始构建您自己的服务器，以便在 Claude for Desktop 和其他客户端中使用。
在这篇教程中，我们将构建一个简单的MCP天气服务器并将其连接到主机，Claude for Desktop。我们将从一个基本的设置开始，然后逐步过渡到更复杂的使用案例。

---

1、我们将要构建的内容

许多LLM（包括Claude）目前没有获取天气预报和恶劣天气警报的能力。让我们使用MCP来解决这个问题吧！
我们将构建一个服务器，该服务器公开两个工具：get-alerts 和 get-forecast。然后我们将服务器连接到一个MCP主机（在这种情况下，是Claude for Desktop）：

---

---

服务器可以连接到任何客户端。我们在这里为了简便选择了Claude for Desktop，但我们也提供了构建自己的客户端的指南，以及其他客户端列表。
为什么是桌面版的Claude而不是Claude.ai？
因为服务器是本地运行的，MCP目前仅支持桌面主机。远程主机正在积极开发中。

---

2、核心MCP概念

MCP 服务器可以提供三种主要类型的特性：

1. 资源：可以被客户端读取的文件样数据（如API响应或文件内容）
2. 工具: 可以由LLM调用（需用户同意）的功能
3. 提示：预先编写的模板，帮助用户完成特定任务

---

这个教程将主要关注工具。

让我们开始构建我们的天气服务器！

Python : 您可以在此处找到我们将会构建的完整代码。

---

3、前置知识

此快速入门假定您熟悉：

• Python
• 类似于Claude的LLMs

---

4、系统要求

• Python 3.10 或更高版本已安装。
• 您必须使用 Python MCP SDK 1.2.0 或更高版本。

---

5、设置你的环境

首先，让我们安装 uv 并设置我们的 Python 项目和环境：
MacOS/Linux

curl -LsSf https://astral.sh/uv/install.sh | sh 

---

Windows

powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex" 

---

确保随后重新启动您的终端，以确保uv命令被拾取。
现在，让我们创建和设置我们的项目：
MacOS/Linux

# Create a new directory for our project
uv init weather
cd weather# Create virtual environment and activate it
uv venv
source .venv/bin/activate# Install dependencies
uv add "mcp[cli]" httpx# Create our server file
touch weather.py

---

Windows

# Create a new directory for our project
uv init weather
cd weather# Create virtual environment and activate it
uv venv
.venv\Scripts\activate# Install dependencies
uv add mcp[cli] httpx# Create our server file
new-item weather.py

---

现在让我们深入了解如何构建你的服务器。

---

二、构建您的服务器

---

1、导入包和设置实例

将这些添加到您的 weather.py 顶部：

from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP# Initialize FastMCP server
mcp = FastMCP("weather")# Constants
NWS_API_BASE = "https://api.weather.gov"
USER_AGENT = "weather-app/1.0"

FastMCP类使用Python类型的提示 和docstring自动生成工具定义，使得创建和维护MCP工具变得容易。

---

2、辅助函数

接下来，让我们添加用于查询和格式化国家气象服务API数据的辅助函数：

async def make_nws_request(url: str) -> dict[str, Any] | None:"""Make a request to the NWS API with proper error handling."""headers = {"User-Agent": USER_AGENT,"Accept": "application/geo+json"}async with httpx.AsyncClient() as client:try:response = await client.get(url, headers=headers, timeout=30.0)response.raise_for_status()return response.json()except Exception:return Nonedef format_alert(feature: dict) -> str:"""Format an alert feature into a readable string."""props = feature["properties"]return f"""
Event: {props.get('event', 'Unknown')}
Area: {props.get('areaDesc', 'Unknown')}
Severity: {props.get('severity', 'Unknown')}
Description: {props.get('description', 'No description available')}
Instructions: {props.get('instruction', 'No specific instructions provided')}
"""

---

3、实现工具执行

工具执行处理器负责实际执行每个工具的逻辑。让我们添加它：

The tool execution handler is responsible for actually executing the logic of each tool. Let’s add it:

@mcp.tool()
async def get_alerts(state: str) -> str:"""Get weather alerts for a US state.Args:state: Two-letter US state code (e.g. CA, NY)"""url = f"{NWS_API_BASE}/alerts/active/area/{state}"data = await make_nws_request(url)if not data or "features" not in data:return "Unable to fetch alerts or no alerts found."if not data["features"]:return "No active alerts for this state."alerts = [format_alert(feature) for feature in data["features"]]return "\n---\n".join(alerts)@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:"""Get weather forecast for a location.Args:latitude: Latitude of the locationlongitude: Longitude of the location"""# First get the forecast grid endpointpoints_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"points_data = await make_nws_request(points_url)if not points_data:return "Unable to fetch forecast data for this location."# Get the forecast URL from the points responseforecast_url = points_data["properties"]["forecast"]forecast_data = await make_nws_request(forecast_url)if not forecast_data:return "Unable to fetch detailed forecast."# Format the periods into a readable forecastperiods = forecast_data["properties"]["periods"]forecasts = []for period in periods[:5]:  # Only show next 5 periodsforecast = f"""
{period['name']}:
Temperature: {period['temperature']}°{period['temperatureUnit']}
Wind: {period['windSpeed']} {period['windDirection']}
Forecast: {period['detailedForecast']}
"""forecasts.append(forecast)return "\n---\n".join(forecasts)

---

4、运行服务器

最后，让我们初始化并运行服务器：

if __name__ == "__main__":# Initialize and run the servermcp.run(transport='stdio')

你的服务器已完成！运行 uv run weather.py 以确认一切正常。
让我们现在从现有的MCP主机，Claude for Desktop，测试您的服务器。

---

三、使用 Claude for Desktop 测试您的服务器

Claude for Desktop 目前尚未在 Linux 上提供。Linux 用户可以继续前往 构建客户端 教程，以构建一个连接到我们刚刚构建的服务器的 MCP 客户端。
首先，确保您已经安装了Claude for Desktop。[您可以安装最新版本*]
这里。](https://claude.ai/download) 如果你已经安装了 Claude for Desktop，请确保它已更新到最新版本。
我们需要为要使用的任何MCP服务器配置Claude for Desktop。为此，请使用文本编辑器打开您在~/Library/Application Support/Claude/claude_desktop_config.json中的Claude for Desktop App配置文件。确保如果文件不存在，则创建该文件。

例如，如果您已安装 VS Code：

MacOS/Linux

code ~/Library/Application\ Support/Claude/claude_desktop_config.json

---

Windows

code $env:AppData\Claude\claude_desktop_config.json

---

您将在 mcpServers 键中添加您的服务器。只有当至少有一个服务器配置正确时，MCP UI 元素才会显示在 Claude for Desktop 中。
在这种情况下，我们将以如下方式添加我们的单个天气服务器：

MacOS/Linux

{"mcpServers": {"weather": {"command": "uv","args": ["--directory","/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather","run","weather.py"]}}
}

---

Windows

{"mcpServers": {"weather": {"command": "uv","args": ["--directory","C:\\ABSOLUTE\\PATH\\TO\\PARENT\\FOLDER\\weather","run","weather.py"]}}
}

---

您可能需要在“命令”字段中输入 uv 可执行文件的完整路径。您可以通过在 MacOS/Linux 上运行 which uv 或者在 Windows 上运行 where uv 来获取这个路径。

---

确保您传入服务器的绝对路径。
这告诉 Claude for Desktop:

1. 有一个名为“weather”的MCP服务器
2. 通过运行 uv --directory /ABSOLUTE/PATH/TO/PARENT/FOLDER/weather run weather.py 来启动它
   保存文件，并重新启动 Claude for Desktop。

---

使用命令进行测试

让我们确保 Claude for Desktop 能够获取到我们在 weather 服务器中暴露的两个工具。你可以通过查找 锤子按钮 来做这件事。

---

---

在点击锤子图标后，您应该看到列出了两个工具：

---

---

如果您桌面版的 Claude 服务器没有被识别，请前往 故障排除 部分，获取调试技巧。
如果锤子图标已经出现，你现在可以通过在 Claude for Desktop 中运行以下命令来测试您的服务器：

• 什么天气在萨克拉门托？
• 什么是德克萨斯州的活跃天气警报？

---

---

---

---

由于这是美国国家气象服务，查询只适用于美国位置。

---

四、内部发生了什么

当你提问时：

1. 客户将您的问题发送给Claude
2. Claude 分析可用的工具并决定使用哪个（些）
3. 客户端通过MCP服务器执行所选的工具(们)
4. 结果发送回Claude
5. Claude 构建一个自然语言响应
6. 响应显示给您！

---

五、故障排除

---

1、Claude桌面集成问题

从 Claude for Desktop 获取日志
Claude.app 与 MCP 相关的日志被写入到 ~/Library/Logs/Claude 的日志文件中：

• mcp.log 将包含关于 MCP 连接和连接失败的一般日志。
• 文件名为 mcp-server-SERVERNAME.log 的文件将包含名为服务器的错误（stderr）日志。

---

您可以使用以下命令列出最近的日志，并跟随任何新的日志：

# Check Claude's logs for errors
tail -n 20 -f ~/Library/Logs/Claude/mcp*.log

---

服务器未在Claude中显示

1. 检查您的 claude_desktop_config.json 文件语法
2. 确保您的项目路径是绝对路径，而不是相对路径
3. 完全重启 Claude for Desktop

---

工具调用静默失败
如果Claude尝试使用工具但它们失败了：

1. 检查Claude的日志以查找错误
2. 验证您的服务器构建和运行时没有错误
3. 尝试重新启动 Claude for Desktop

---

没有任何一个方法有效。我该怎么办？
请参阅我们的调试指南以获取更好的调试工具和更详细的指导。

---

2、天气API问题

错误：无法检索网格点数据
这通常意味着以下两种情况：

1. 坐标在美國之外
2. NWS API 存在问题
3. 你正在被速率限制

---

Fix:

• 验证您是否正在使用美国坐标
• 在请求之间添加一个小的延迟
• 检查NWS API状态页面
  错误：[STATE] 没有活跃警报
  这不是错误 - 这只是意味着该州当前没有天气警报。尝试不同的州或在大气恶劣时进行检查。
  为了更高级的故障排除，查看我们关于 调试 MCP 的指南

---

下一步骤

• 构建客户端 https://modelcontextprotocol.io/quickstart/client
  学习如何构建自己的MCP客户端，使其能够连接到您的服务器
• 示例服务器 https://modelcontextprotocol.io/examples
  查看我们的官方MCP服务器和实现方案画廊
• 调试指南 https://modelcontextprotocol.io/docs/tools/debugging
  学习如何有效地调试MCP服务器和集成
• 使用LLM构建MCP https://modelcontextprotocol.io/tutorials/building-mcp-with-llms
  学习如何使用Claude等LLM来加速您的MCP开发

---

---

https://modelcontextprotocol.io/quickstart/client

---

快速入门 - 为客户端开发者

一、客户端开发

开始构建您自己的客户端，使其能够与所有MCP服务器集成。
在这篇教程中，你将学习如何构建一个由LLM（大型语言模型）驱动的聊天机器人客户端，该客户端连接到MCP服务器。如果已经阅读了服务器快速入门教程，那会有助于你了解构建第一个服务器的基本知识。
Python: 您可以在这里找到本教程的完整代码。
Node 和 Java 详见文档：https://modelcontextprotocol.io/quickstart/client

---

二、系统要求

在开始之前，请确保您的系统满足以下要求：

• Mac 或 Windows 计算机
• 最新安装的 Python 版本
• 安装了 uv 的最新版本

---

三、设置您的环境

首先，使用 uv 创建一个新的 Python 项目：

# Create project directory
uv init mcp-client
cd mcp-client# Create virtual environment
uv venv# Activate virtual environment
# On Windows:
.venv\Scripts\activate
# On Unix or MacOS:
source .venv/bin/activate# Install required packages
uv add mcp anthropic python-dotenv# Remove boilerplate files
rm hello.py# Create our main file
touch client.py

四、设置您的API密钥

您需要从 Anthropic 控制台 获取一个 Anthropic API 密钥。
创建一个 .env 文件来存储它：

# Create .env file
touch .env

---

将你的密钥添加到 .env 文件中：

ANTHROPIC_API_KEY=<your key here>

---

将 .env 添加到您的 .gitignore 文件中：

echo ".env" >> .gitignore

确保您的 ANTHROPIC_API_KEY 安全！

---

五、创建客户端

---

1、基本客户端结构

首先，让我们设置导入并创建基本的客户端类：

import asyncio
from typing import Optional
from contextlib import AsyncExitStackfrom mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_clientfrom anthropic import Anthropic
from dotenv import load_dotenvload_dotenv()  # load environment variables from .envclass MCPClient:def __init__(self):# Initialize session and client objectsself.session: Optional[ClientSession] = Noneself.exit_stack = AsyncExitStack()self.anthropic = Anthropic()# methods will go here

---

2、服务器连接管理

接下来，我们将实现连接到 MCP 服务器的函数：

async def connect_to_server(self, server_script_path: str):"""Connect to an MCP serverArgs:server_script_path: Path to the server script (.py or .js)"""is_python = server_script_path.endswith('.py')is_js = server_script_path.endswith('.js')if not (is_python or is_js):raise ValueError("Server script must be a .py or .js file")command = "python" if is_python else "node"server_params = StdioServerParameters(command=command,args=[server_script_path],env=None)stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))self.stdio, self.write = stdio_transportself.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))await self.session.initialize()# List available toolsresponse = await self.session.list_tools()tools = response.toolsprint("\nConnected to server with tools:", [tool.name for tool in tools])

---

3、查询处理逻辑

现在让我们添加处理查询和处理工具调用的核心功能：

async def process_query(self, query: str) -> str:"""Process a query using Claude and available tools"""messages = [{"role": "user","content": query}]response = await self.session.list_tools()available_tools = [{"name": tool.name,"description": tool.description,"input_schema": tool.inputSchema} for tool in response.tools]# Initial Claude API callresponse = self.anthropic.messages.create(model="claude-3-5-sonnet-20241022",max_tokens=1000,messages=messages,tools=available_tools)# Process response and handle tool callsfinal_text = []assistant_message_content = []for content in response.content:if content.type == 'text':final_text.append(content.text)assistant_message_content.append(content)elif content.type == 'tool_use':tool_name = content.nametool_args = content.input# Execute tool callresult = await self.session.call_tool(tool_name, tool_args)final_text.append(f"[Calling tool {tool_name} with args {tool_args}]")assistant_message_content.append(content)messages.append({"role": "assistant","content": assistant_message_content})messages.append({"role": "user","content": [{"type": "tool_result","tool_use_id": content.id,"content": result.content}]})# Get next response from Clauderesponse = self.anthropic.messages.create(model="claude-3-5-sonnet-20241022",max_tokens=1000,messages=messages,tools=available_tools)final_text.append(response.content[0].text)return "\n".join(final_text)

---

4、交互式聊天界面

现在我们将添加聊天循环和清理功能：

async def chat_loop(self):"""Run an interactive chat loop"""print("\nMCP Client Started!")print("Type your queries or 'quit' to exit.")while True:try:query = input("\nQuery: ").strip()if query.lower() == 'quit':breakresponse = await self.process_query(query)print("\n" + response)except Exception as e:print(f"\nError: {str(e)}")async def cleanup(self):"""Clean up resources"""await self.exit_stack.aclose()

---

5、主入口点

最后，我们将添加主要的执行逻辑：

async def main():if len(sys.argv) < 2:print("Usage: python client.py <path_to_server_script>")sys.exit(1)client = MCPClient()try:await client.connect_to_server(sys.argv[1])await client.chat_loop()finally:await client.cleanup()if __name__ == "__main__":import sysasyncio.run(main())

您可以在这里找到完整的 client.py 文件。

---

六、关键组件解释

---

1. 客户端初始化

• MCPClient 类初始化时包含会话管理和 API 客户端
• 使用 AsyncExitStack 进行适当的资源管理
• 配置 Anthropic 客户端以进行 Claude 交互

---

2. 服务器连接

• 支持Python和Node.js服务器
• 验证服务器脚本类型
• 设置适当的通信通道
• 初始化会话并列出可用工具

---

3. 查询处理

• 维持对话上下文
• 处理Claude的响应和工具调用
• 管理Claude和工具之间的消息流
• 将结果组合成一个连贯的响应

---

4. 交互式界面

• 提供简单的命令行界面
• 处理用户输入并显示响应
• 包含基本的错误处理
• 允许优雅退出

---

5. 资源管理

• 正确清理资源
• 连接问题的错误处理
• 优雅的关闭程序流程

---

七、常见自定义点

1. 工具处理

   • 修改 process_query() 以处理特定工具类型
   • 为工具调用添加自定义错误处理
   • 实现特定工具的响应格式化

2. 响应处理

   • 定制工具结果的格式
   • 添加响应过滤或转换
   • 实现自定义日志记录

3. 用户界面

   • 添加图形用户界面或网页界面
   • 实现丰富的控制台输出
   • 添加命令历史记录或自动完成

---

八、运行客户端

要在任何 MCP 服务器上运行您的客户端：

uv run client.py path/to/server.py # python server
uv run client.py path/to/build/index.js # node server

---

如果您正在继续从服务器快速入门教程中的天气教程，您的命令可能看起来像这样：python client.py .../weather/src/weather/server.py

---

客户端将会:

1. 连接到指定的服务器

2. 列出可用的工具

3. 开始一个交互式聊天会话，您可以在其中进行以下操作：

   • 输入查询
   • 查看工具执行
   • 从Claude获取响应

---

以下是从天气服务器连接到服务器快速启动时的示例外观：

---

---

九、它是如何工作的

当您提交一个查询：

1. 客户端从服务器获取可用工具的列表
2. 您的查询连同工具描述一起发送到Claude
3. Claude 决定使用哪些工具（如果有的话）
4. 客户端通过服务器执行任何请求的工具调用
5. 结果返回给Claude
6. Claude 提供自然语言响应
7. 响应将显示给您

---

十、最佳实践

1. 错误处理

   • 总是在工具调用中包裹 try-catch 块
   • 提供有意义的错误信息
   • 优雅地处理连接问题

2. 资源管理

   • 使用 AsyncExitStack 进行适当的清理
   • 完成后关闭连接
   • 处理服务器断开连接

3. 安全

   • 在 .env 中安全地存储 API 密钥
   • 验证服务器响应
   • 对工具权限保持谨慎

---

十一、故障排除

---

1、服务器路径问题

• 请再次确认您的服务器脚本路径是否正确
• 如果相对路径不起作用，请使用绝对路径
• 对于Windows用户，请确保在路径中使用正斜杠 (/) 或转义的反斜杠 ()
• 请验证服务器文件具有正确的扩展名 (.py 用于Python或 .js 用于Node.js)

---

示例：正确路径的使用

# Relative path
uv run client.py ./server/weather.py# Absolute path
uv run client.py /Users/username/projects/mcp-server/weather.py# Windows path (either format works)
uv run client.py C:/projects/mcp-server/weather.py
uv run client.py C:\\projects\\mcp-server\\weather.py

---

2、响应时间

• 第一次响应可能需要30秒才能返回
• 这是正常的，发生在以下情况：
  • 服务器初始化
  • Claude处理查询
  • 工具正在执行
• 随后的响应通常更快
• 在这个初始等待期间不要中断处理过程

---

3、常见错误信息

如果您看到：

• FileNotFoundError: 检查您的服务器路径
• 连接被拒绝：确保服务器正在运行且路径正确
• 工具执行失败: 验证工具所需的环境变量是否已设置
• 超时错误：考虑在您的客户端配置中增加超时时间

---

---

https://modelcontextprotocol.io/quickstart/user

---

快速入门 - 对于Claude桌面用户

开始使用Claude for Desktop中的预构建服务器。
在这个教程中，你将扩展 Claude for Desktop 以使其能够从你的计算机文件系统中读取，写入新文件，移动文件，甚至搜索文件。

别担心 —— 在执行这些操作之前，它会询问您的许可！

---

1. 下载桌面版 Claude

首先，请下载 Claude for Desktop，选择 macOS 或 Windows。(Linux 目前不支持 Claude for Desktop.)
遵循安装说明。
如果你已经安装了Claude桌面版，请确保它是最新版本，通过点击电脑上的Claude菜单并选择“检查更新…”来操作。
为什么选择桌面版的Claude而不是Claude.ai？
因为服务器是本地运行的，MCP目前仅支持桌面主机。远程主机正在积极开发中。

---

2. 添加文件系统 MCP 服务器

为了添加此文件系统功能，我们将在 Claude for Desktop 中安装一个预构建的文件系统 MCP 服务器。这是Anthropic和社区创建的数十个服务器之一。
开始使用吧，在您的电脑上打开 Claude 菜单并选择“设置…”。请注意，这些不是在应用窗口本身中找到的 Claude 账户设置。

这是在Mac上应有的样子：

---

点击设置面板左侧栏中的“开发者”，然后点击“编辑配置”：

---

这将创建一个配置文件在：

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json
  如果您还没有一个，它将显示在您的文件系统中。
  打开任意文本编辑器中的配置文件。将文件内容替换为以下内容：
  MacOS/Linux

{"mcpServers": {"filesystem": {"command": "npx","args": ["-y","@modelcontextprotocol/server-filesystem","/Users/username/Desktop","/Users/username/Downloads"]}}
}

---

Windows

{"mcpServers": {"filesystem": {"command": "npx","args": ["-y","@modelcontextprotocol/server-filesystem","C:\\Users\\username\\Desktop","C:\\Users\\username\\Downloads"]}}
}

---

确保将 username 替换为您的电脑用户名。路径应指向您希望 Claude 能够访问和修改的有效目录。它已设置为适用于桌面和下载，但您也可以添加更多路径。
您还需要在您的电脑上安装 Node.js 才能正常运行。要验证您已安装 Node，请打开电脑上的命令行。

• 在 macOS 上，从您的应用程序文件夹中打开终端
• 在 Windows 上，按 Windows + R，输入“cmd”，然后按 Enter

---

一旦进入命令行，通过输入以下命令来验证您已安装 Node：

Once in the command line, verify you have Node installed by entering in the following command:

node --version

---

如果您收到“命令未找到”或“node未识别”的错误信息，请从nodejs.org下载Node。

---

配置文件是如何工作的？
这个配置文件告诉 Claude for Desktop 每次启动应用程序时应该启动哪些 MCP 服务器。在这种情况下，我们添加了一个名为“filesystem”的服务器，该服务器将使用 Node npx 命令来安装和运行 @modelcontextprotocol/server-filesystem。这个服务器，在这里 描述，将允许你在 Claude for Desktop 中访问你的文件系统。

---

命令权限
Claude for Desktop 将使用您用户账户的权限运行配置文件中的命令，并访问您的本地文件。只有当您理解并信任来源时，才添加命令。

---

3. 重启 Claude

在更新您的配置文件后，您需要重新启动 Claude for Desktop。
在重启后，你应该会看到一个锤子按钮，在输入框的右下角：

---

点击锤子图标后，你应该能看到与文件系统MCP服务器一起提供的工具：

---

如果您的服务器没有被 Claude for Desktop 捕获，请转到 故障排除 部分以获取调试提示。

---

4. 尝试一下！

现在你可以和Claude对话，询问有关你的文件系统的问题。它应该知道何时调用相关的工具。
以下是你可能尝试询问 Claude 的事情：

Things you might try asking Claude:

• 你能写一首诗并保存到我的桌面吗？
• 下载文件夹中有些哪些与工作相关的文件？
• 你能将我桌面上所有的图片移动到一个名为“Images”的新文件夹中吗？

---

根据需要，Claude将在采取行动之前调用相关工具并征求您的批准：

---

故障排除

---

服务器未在 Claude / hammer 图标缺失

1. 完全重启 Claude for Desktop
2. 检查你的 claude_desktop_config.json 文件语法
3. 确保包含在 claude_desktop_config.json 中的文件路径是有效的，并且它们是绝对路径而不是相对路径
4. 查看 日志，以了解服务器连接失败的原因
5. 在你的命令行中，尝试手动运行服务器（将 username 替换为你在 claude_desktop_config.json 中所做的），以查看是否有任何错误：

---

MacOS/Linux

npx -y @modelcontextprotocol/server-filesystem /Users/username/Desktop /Users/username/Downloads

---

Windows

npx -y @modelcontextprotocol/server-filesystem /Users/username/Desktop /Users/username/Downloads

---

从 Claude for Desktop 获取日志

Claude.app 与 MCP 相关的日志被写入以下日志文件中：

• macOS: ~/Library/Logs/Claude
• Windows: %APPDATA%\Claude\logs
• mcp.log 将包含有关 MCP 连接和连接失败的通用日志信息。
• 以 mcp-server-SERVERNAME.log 命名的文件将包含名为服务器的错误（stderr）日志。

---

您可以使用以下命令来列出最近的日志并跟踪任何新的日志（在Windows上，它只会显示最近的日志）：

MacOS/Linux

# Check Claude's logs for errors
tail -n 20 -f ~/Library/Logs/Claude/mcp*.log

---

Windows

type "%APPDATA%\Claude\logs\mcp*.log"

---

工具调用静默失败

如果Claude尝试使用工具但它们失败了：

1. 检查 Claude 的日志以查找错误
2. 验证您的服务器构建和运行时没有错误
3. 尝试重新启动 Claude for Desktop

---

这一切都不起作用。我该怎么办？

请参阅我们的调试指南，以获取更好的调试工具和更详细的指导。

---

ENOENT 错误和 Windows 中的 ${APPDATA} 路径

如果您的配置服务器无法加载，并且在它的日志中看到一个关于路径中${APPDATA}的错误，您可能需要将 %APPDATA% 的展开值添加到 claude_desktop_config.json 文件的 env 键中：

{"brave-search": {"command": "npx","args": ["-y", "@modelcontextprotocol/server-brave-search"],"env": {"APPDATA": "C:\\Users\\user\\AppData\\Roaming\\","BRAVE_API_KEY": "..."}}
}

使用此更改后，再次启动 Claude Desktop。

---

NPM 应该全局安装
npx 命令可能会继续失败，如果您还没有全局安装 NPM。如果 NPM 已经全局安装，您将在系统中找到 %APPDATA%\npm。如果没有，您可以通过运行以下命令全局安装 NPM：

npm install -g npm

---

---

https://modelcontextprotocol.io/examples

---

开始使用

服务示例

示例服务和实现 列表
这个页面展示了各种模型上下文协议（MCP）服务器，它们展示了该协议的能力和多功能性。这些服务器使大型语言模型（LLMs）能够安全地访问工具和数据源。

---

一、参考实现

这些官方参考服务器展示了核心MCP功能和SDK的使用：

---

1、数据和文件系统

• 文件系统 - 使用可配置的访问控制进行安全文件操作
• PostgreSQL - 具有模式检查功能的只读数据库访问
• SQLite - 数据库交互和商业智能功能
• Google Drive - Google Drive 的文件访问和搜索功能

---

2、开发工具

• Git - 用于读取、搜索和操作 Git 仓库的工具
• GitHub - 仓库管理、文件操作和 GitHub API 集成
• GitLab - GitLab API 集成，实现项目管理
• Sentry - 从 Sentry.io 获取和分析问题

---

3、网页和浏览器自动化

• Brave Search - 使用Brave的Search API进行网页和本地搜索
• Fetch - 优化用于LLM使用的网页内容抓取和转换
• Puppeteer - 浏览器自动化和网页抓取功能

---

4、生产力与沟通

• Slack - 频道管理和消息功能
• Google Maps - 位置服务、路线和地点详情
• Memory - 基于知识图谱的持久内存系统

---

5、AI 和专用工具

• EverArt - 使用各种模型进行AI图像生成
• Sequential Thinking - 通过思维序列进行动态问题解决
• AWS KB Retrieval - 使用Bedrock Agent Runtime从AWS知识库中进行检索

---

二、官方集成

这些MCP服务器由公司维护，用于其平台：

• Axiom - 使用自然语言查询和分析日志、跟踪和事件数据
• Browserbase - 在云端自动化浏览器交互
• Cloudflare - 在 Cloudflare 开发者平台上部署和管理资源
• E2B - 在安全的云沙箱中执行代码
• Neon - 与 Neon 无服务器 Postgres 平台交互
• Obsidian Markdown Notes - 阅读和搜索 Obsidian 保险库中的 Markdown 笔记
• Qdrant - 使用 Qdrant 向量搜索引擎实现语义记忆
• Raygun - 访问崩溃报告和监控数据
• Search1API - 统一用于搜索、爬取和网站地图的API
• Stripe - 与 Stripe API 交互
• Tinybird - 与 Tinybird 服务器端 ClickHouse 平台接口
• Weaviate - 通过您的 Weaviate 集合（们）启用 Agentic RAG

---

三、社区亮点

一个不断发展的由社区开发的服务器生态系统扩展了MCP的功能：

• Docker - 管理容器、镜像、卷和网络
• Kubernetes - 管理Pods、部署和服务
• Linear - 项目管理和问题跟踪
• Snowflake - 与 Snowflake 数据库交互
• Spotify - 控制Spotify播放和管理播放列表
• Todoist - 任务管理集成

---

注意： 社区服务器未经测试，应自行承担使用风险。它们与Anthropic无关，也未获得其认可。
关于完整的服务器列表，请访问 MCP 服务器仓库。

---

四、入门

---

1、使用参考服务器

基于 TypeScript 的服务器可以直接与 npx 一起使用：

npx -y @modelcontextprotocol/server-memory

---

Python-based servers can be used with uvx (recommended) or pip:

# Using uvx
uvx mcp-server-git# Using pip
pip install mcp-server-git
python -m mcp_server_git

---

2、使用 Claude 配置

要使用 Claude 与 MCP 服务器一起使用，将其添加到您的配置中：

{"mcpServers": {"memory": {"command": "npx","args": ["-y", "@modelcontextprotocol/server-memory"]},"filesystem": {"command": "npx","args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]},"github": {"command": "npx","args": ["-y", "@modelcontextprotocol/server-github"],"env": {"GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_TOKEN>"}}}
}

---

五、附加资源

• MCP 服务器仓库 - 完整的参考实现和社区服务器的集合
• 令人惊叹的 MCP 服务器 - 精选的 MCP 服务器列表
• MCP CLI - 用于测试 MCP 服务器的命令行检查器
• MCP Get - 用于安装和管理 MCP 服务器的工具
• Supergateway - 在 SSE 上运行 MCP stdio 服务器

访问我们的 GitHub 讨论区 与 MCP 社区互动。

---

---

https://modelcontextprotocol.io/clients

---

开始使用

客户端示例

一个支持MCP集成的应用程序列表
本页概述了支持模型上下文协议（MCP）的应用程序。每个客户端可以支持不同的MCP功能，允许与MCP服务器进行不同级别的集成。

---

一、功能支持矩阵

Client	Resources	Prompts	Tools	Sampling	Roots	Notes
Claude Desktop App	✅	✅	✅	❌	❌	Full support for all MCP features
5ire	❌	❌	✅	❌	❌	Supports tools.
BeeAI Framework	❌	❌	✅	❌	❌	Supports tools in agentic workflows.
Cline	✅	❌	✅	❌	❌	Supports tools and resources.
Continue	✅	✅	✅	❌	❌	Full support for all MCP features
Cursor	❌	❌	✅	❌	❌	Supports tools.
Emacs Mcp	❌	❌	✅	❌	❌	Supports tools in Emacs.
Firebase Genkit	⚠️	✅	✅	❌	❌	Supports resource list and lookup through tools.
GenAIScript	❌	❌	✅	❌	❌	Supports tools.
Goose	❌	❌	✅	❌	❌	Supports tools.
LibreChat	❌	❌	✅	❌	❌	Supports tools for Agents
mcp-agent	❌	❌	✅	⚠️	❌	Supports tools, server connection management, and agent workflows.
oterm	❌	❌	✅	❌	❌	Supports tools.
Roo Code	✅	❌	✅	❌	❌	Supports tools and resources.
Sourcegraph Cody	✅	❌	❌	❌	❌	Supports resources through OpenCTX
Superinterface	❌	❌	✅	❌	❌	Supports tools
TheiaAI/TheiaIDE	❌	❌	✅	❌	❌	Supports tools for Agents in Theia AI and the AI-powered Theia IDE
Windsurf Editor	❌	❌	✅	❌	❌	Supports tools with AI Flow for collaborative development.
Zed	❌	✅	❌	❌	❌	Prompts appear as slash commands
SpinAI	❌	❌	✅	❌	❌	Supports tools for Typescript AI Agents
OpenSumi	❌	❌	✅	❌	❌	Supports tools in OpenSumi
Daydreams Agents	✅	✅	✅	❌	❌	Support for drop in Servers to Daydreams agents

---

二、客户端详情

---

Claude Desktop App

The Claude 桌面应用程序提供了对 MCP 的全面支持，使其能够与本地工具和数据源深度集成。
关键特性:

• 完全支持资源，允许附加本地文件和数据
• 支持提示模板
• 工具集成以执行命令和脚本
• 本地服务器连接，以增强隐私和安全

ⓘ 注意：Claude.ai 网络应用程序目前不支持 MCP。MCP 功能仅在桌面应用程序中可用。

---

5ire

5ire 是一个开源的跨平台桌面AI助手，通过MCP服务器支持工具。

关键特性：

• 内置 MCP 服务器可以快速启用和禁用。
• 用户可以通过修改配置文件来添加更多服务器。
• 是开源的且用户友好，适合初学者。
• 未来对MCP的支持将不断改进。

---

BeeAI 框架

BeeAI框架是一个开放源代码框架，用于大规模构建、部署和服务强大的代理工作流。该框架包括MCP工具，这是一个本机功能，可简化MCP服务器与代理工作流的集成。

主要功能:

• 无缝地将MCP工具集成到代理工作流程中。
• 快速从连接的 MCP 客户端实例化框架原生的工具。
• 计划中的未来对代理MCP功能的支持。

---

了解更多：

• 使用MCP工具在代理工作流程中的示例

---

Cline

cline
关键特性：

• 通过自然语言创建和添加工具（例如：“添加一个搜索网络的工具”）

• 与他人分享Cline创建的自定义MCP服务器，通过~/Documents/Cline/MCP目录进行

• 显示配置的MCP服务器及其工具、资源以及任何错误日志

---

Continue

Continue 是一个开源的AI代码助手，内置支持所有MCP功能。

关键特性

• 输入“@”来提及MCP资源

• 提示模板以斜杠命令的形式呈现

• 使用内置和MCP工具直接在聊天中

• 支持 VS Code 和 JetBrains IDEs，以及任何 LLM

---

Cursor

Cursor is an AI code editor.
关键特性:

• 支持在光标作曲家中使用MCP工具
  支持STDIO和SSE

---

Emacs Mcp

Emacs Mcp is an Emacs client designed to interface with MCP servers, enabling seamless connections and interactions. It provides MCP tool invocation support for AI plugins like gptel and llm, adhering to Emacs’ standard tool invocation format. This integration enhances the functionality of AI tools within the Emacs ecosystem.

Emacs Mcp是一个Emacs客户端，设计用于与MCP服务器接口，实现无缝连接和交互。它为gptel 等AI插件提供MCP工具调用支持和llm，遵循Emacs的标准工具调用格式。这种集成增强了Emacs生态系统中AI工具的功能。

关键特性：

• 提供MCP工具对Emacs的支持。

---

Firebase Genkit

Genkit是Firebase的SDK，用于构建GenAI功能并将其集成到应用程序中。genkitx mcp插件支持将MCP服务器作为客户端使用，或通过Genkit工具和提示创建MCP服务器。

关键特性：

• 客户端对工具和提示（资源部分支持）的支持
• 丰富的发现，支持Genkit的Dev UI沙盒
• 与Genkit现有工具和提示的无缝互操作性
• 在众多顶级供应商的GenAI模型上都能工作*

---

GenAIScript

使用 GenAIScript（JavaScript）编程组装 LLMs 的提示。在 JavaScript 中编排 LLMs、工具和数据。
关键特性：

• JavaScript 工具箱，用于处理提示框
• 抽象化以使其变得容易和高效
• 无缝 Visual Studio Code 集成

---

Goose

Goose 是一个开源的AI代理，通过自动化编码任务来增强软件开发。

关键特性:

• 将MCP功能通过工具暴露给Goose。
• MCPs 可以通过 扩展目录、CLI 或 UI 直接安装。
• Goose 允许你通过 构建自己的 MCP 服务器 来扩展其功能。
• 包含用于开发、网络抓取、自动化、内存以及与 JetBrains 和 Google Drive 集成的内置工具。

---

LibreChat

LibreChat 是一个开源的、可定制的AI聊天UI，支持多个AI提供商，现在包括MCP集成。
关键特性：

• 扩展当前工具生态系统，包括 代码解释器 和图像生成工具，通过 MCP 服务器
• 将工具添加到可定制的 代理，使用来自顶级提供商的各种 LLM
• 开源和自托管，支持安全的多用户
• 未来路线图包括扩展的MCP功能支持

---

mcp-agent

mcp-agent 是一个简单、可组合的框架，用于使用模型上下文协议构建代理。
关键特性:

• 自动连接管理 MCP 服务器。
• 将来自多个服务器的工具暴露给LLM。
• 实现Building Effective Agents中定义的每一个模式。
• 支持工作流程暂停/恢复信号，例如等待人工反馈。

---

oterm

oterm 是Ollama的终端客户端，允许用户创建聊天室/代理。
关键特性：

• 支持与 Ollama 连接的多个可完全自定义的聊天会话。
• 支持MCP工具。

---

Roo Code

Roo Code 通过MCP启用AI编码协助。
关键特性：

• 支持MCP工具和资源
• 集成到开发工作流程
• 可扩展的AI能力

---

Sourcegraph Cody

Cody 是Sourcegraph的AI编码助手，它通过OpenCTX实现MCP。

主要特性：

• 支持MCP资源
• 与Sourcegraph的代码智能集成
• 使用 OpenCTX 作为抽象层
• 未来计划支持额外的MCP功能

---

SpinAI

SpinAI 是一个用于构建可观察AI代理的开源TypeScript框架。该框架提供了本机MCP兼容性，允许代理与MCP服务器和工具无缝集成。

关键特性：

• 内置MCP兼容性，适用于AI代理
• 开源 TypeScript 框架
• 可观察代理架构
• 原生支持 MCP 工具集成

---

Superinterface

Superinterface 是AI基础设施和开发人员平台，用于构建应用程序内AI助手，支持MCP、交互组件、客户端功能调用等。

关键特性：

• 使用通过 React 组件或脚本标签嵌入的助手中的 MCP 服务器工具
• SSE传输支持
• 使用任何来自任何AI提供商（OpenAI、Anthropic、Ollama等）的AI模型

---

TheiaAI/TheiaIDE

Theia AI 是构建AI增强工具和IDE的框架。AI驱动的Theia IDE是一个基于Theia AI构建的开放灵活的开发环境。
关键特性：

• 工具集成：Theia AI 允许 AI 代理，包括 Theia IDE 中的代理，利用 MCP 服务器实现无缝的工具交互。
• 自定义提示: Theia IDE 允许用户定义和调整提示，动态集成 MCP 服务器以实现定制的工作流程。
• 自定义代理: Theia IDE 支持创建利用 MCP 功能的自定义代理，使用户能够实时设计专属工作流程。
  Theia AI 和 Theia IDE 的 MCP 集成为用户提供灵活性，使它们成为探索和适应 MCP 的强大平台。
  了解更多：
• Theia IDE 和 Theia AI 支持MCP公告
• 下载 AI 驱动的 Theia IDE

---

Windsurf Editor

Windsurf Editor 是一个代理IDE，它将AI协助与开发人员工作流相结合。它具有一个创新的人工智能流程系统，支持协作和独立的人工智能交互，同时保持开发人员的控制。

关键特性：

• 革命性的人机协作人工智能流程范式 *
• 智能代码生成和理解
• 丰富的开发工具，支持多模型

---

Zed

Zed 是一个具有内置MCP支持的高性能代码编辑器，侧重于提示模板和工具集成。
关键特性：

• 提示模板以斜杠命令的形式在编辑器中呈现
• 工具集成，以增强编码工作流程
• 与编辑器功能和工作区上下文的紧密集成
• 不支持MCP资源

---

OpenSumi

OpenSumi 是一个帮助您快速构建AI原生IDE产品的框架。
关键特性：

• 支持OpenSumi中的MCP工具
• 支持内置 IDE MCP 服务器和自定义 MCP 服务器

---

Daydreams

Daydreams 是一个生成代理框架，用于在链上执行任何操作

主要功能:

• 支持在配置中使用 MCP 服务器
• 暴露 MCP 客户端

---

三、为您的应用程序添加MCP支持

如果您已经将MCP支持添加到您的应用程序中，我们鼓励您提交一个拉取请求，将其添加到这个列表中。MCP集成可以为您的用户提供强大的上下文AI功能，并使您的应用程序成为不断增长的MCP生态系统的一部分。
添加 MCP 支持的优点：

• 启用用户携带自己的上下文和工具

• 加入一个不断增长的互操作AI应用生态系统

• 为用户提供灵活的集成选项

• 支持本地优先的 AI 工作流程

要开始在您的应用程序中实现MCP，请查看我们的Python或TypeScript SDK 文档

---

更新和修正

这份列表由社区维护。如果您发现任何不准确之处或希望更新您应用程序中 MCP 支持的信息，请提交一个 pull request 或 在我们的文档仓库中打开一个问题。

---

---

https://modelcontextprotocol.io/tutorials/building-mcp-with-llms

---

教程 - 使用LLMs构建MCP

使用Claude等LLMs加速您的MCP开发！
这份指南将帮助您使用LLMs来构建定制的模型上下文协议（MCP）服务器和客户端。我们将专注于Claude进行本教程，但您可以使用任何前沿的LLM完成这项工作。

---

一、准备文档

在开始之前，收集必要的文档以帮助Claude理解MCP：

1. 访问 https://modelcontextprotocol.io/llms-full.txt 并复制完整的文档文本
2. 导航至 MCP TypeScript SDK 或 Python SDK 仓库
3. 复制 README 文件和其他相关文档
4. 将这些文档粘贴到您与Claude的对话中

---

二、描述您的服务器

一旦你提供了文档，请向Claude清楚地描述你想要构建的服务器类型。具体说明：

• 服务器将公开哪些资源
• 它将提供哪些工具
• 任何它应该提供的提示
• 需要与之交互的外部系统

---

例如：

构建MCP服务器：

• 连接到我公司的PostgreSQL数据库

• 将表架构公开为资源

• 提供用于运行只读SQL查询的工具

• 包括常见数据分析任务的提示

---

三、与 Claude 合作

当在与 Claude 在 MCP 服务器上工作时：

1. 首先从核心功能开始，然后迭代添加更多功能
2. 请Claude解释你不懂的代码部分
3. 根据需要请求修改或改进
4. 让Claude帮助你测试服务器并处理边缘情况

---

Claude可以帮助实现所有关键MCP功能：

• 资源管理和暴露
• 工具定义和实现
• 提示模板和处理程序
• 错误处理和日志记录
• 连接和传输设置

---

四、最佳实践

在构建带有Claude的MCP服务器时：

• 将复杂的服务器分解成更小的部分
• 在继续之前，彻底测试每个组件
• 保持安全意识 - 验证输入并适当限制访问
• 仔细记录你的代码，以便未来的维护
• 仔细遵循 MCP 协议规范

---

五、下一步骤

在Claude帮助你构建服务器之后：

1. 仔细审查生成的代码
2. 使用 MCP Inspector 工具测试服务器
3. 将其连接到 Claude.app 或其他 MCP 客户端
4. 根据实际使用和反馈进行迭代

记住，Claude可以帮助您根据时间推移的需求变化来修改和改进您的服务器。
需要更多指导？只需向 Claude 提出有关实施 MCP 功能或解决出现的问题的具体问题。

---

---

https://modelcontextprotocol.io/docs/tools/debugging

---

教程 - 调试

一份关于调试模型上下文协议（MCP）集成的全面指南
有效的调试对于开发MCP服务器或将其与应用程序集成至关重要。本指南涵盖了MCP生态系统中可用的调试工具和方法。
这个指南适用于macOS。其他平台的指南即将推出。

---

一、调试工具概述

MCP提供了在不同级别上进行调试的几个工具：

1、MCP Inspector

• 交互式调试界面
• 直接服务器测试
• 查看详情，请参阅Inspector指南

---

2、Claude桌面开发者工具

• 集成测试
• 日志收集
• Chrome DevTools 集成

---

3、服务器日志

• 自定义日志实现
• 错误跟踪
• 性能监控

---

二、在 Claude 桌面版中进行调试

---

1、检查服务器状态

The Claude.app 界面提供基本的 服务器状态信息：

1. 点击 icon to view:

• 已连接的服务器
• 可用提示和资源

2. 点击 icon to view:

• 模型可用工具

---

2、查看日志

从 Claude 桌面审查详细的 MCP 日志：

# Follow logs in real-time
tail -n 20 -F ~/Library/Logs/Claude/mcp*.log

---

日志捕获：

• 服务器连接事件
• 配置问题
• 运行时错误
• 消息交换

---

3、使用 Chrome DevTools

在 Claude Desktop 中访问 Chrome 的开发者工具以调查客户端错误：
1、创建一个 developer_settings.json 文件，将 allowDevTools 设置为 true:

echo '{"allowDevTools": true}' > ~/Library/Application\ Support/Claude/developer_settings.json 

---

2、打开开发者工具: Command-Option-Shift-i
注意：您将看到两个开发者工具窗口：

• 主要内容窗口
• 应用程序标题栏窗口

---

使用控制台面板来检查客户端错误。
使用网络面板来检查：

• 消息负载
• 连接计时

---

三、常见问题

---

1、工作目录

当使用 Claude Desktop 与 MCP 服务器一起使用时：

• 服务器通过 claude_desktop_config.json 启动的工作目录可能未定义（如 macOS 上的 /），因为 Claude Desktop 可以从任何位置启动
• 总是在您的配置和 .env 文件中使用绝对路径以确保可靠运行 *
• 对于通过命令行直接测试服务器，工作目录将是您运行命令的位置

---

例如，在 claude_desktop_config.json 中，使用：

{"command": "npx","args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/username/data"]
}

---

而不是相对路径，例如 ./data

---

2、环境变量

MCP 服务器只自动继承了一部分环境变量，例如 USER、HOME 和 PATH。
要覆盖默认变量或提供您自己的，您可以在 claude_desktop_config.json 中指定一个 env 键：

{"myserver": {"command": "mcp-server-myapp","env": {"MYAPP_API_KEY": "some_key",}}
}

---

3、服务器初始化

常见初始化问题：

1. 路径问题

• 错误的服务器可执行路径
• 缺少必需的文件
• 权限问题
• 尝试使用绝对路径来指定 command

2. 配置错误

• 无效的 JSON 语法
• 缺少必要的字段
• 类型不匹配

3. 环境问题

• 缺少的环境变量
• 错误的变量值
• 权限限制

---

4、连接问题

当服务器无法连接时：

1. 检查 Claude 桌面日志
2. 验证服务器进程正在运行
3. 使用 Inspector 独立测试
4. 验证协议兼容性

---

四、实现日志记录

---

1、服务器端日志

当构建一个使用本地stdio 传输的服务器时，所有记录到stderr（标准错误）的消息将被主机应用程序（例如，Claude桌面）自动捕获。
本地MCP服务器不应将消息记录到stdout（标准输出），因为这会干扰协议操作。
对于所有transports，您还可以通过发送日志消息通知来向客户端提供日志记录：
Python

server.request_context.session.send_log_message(level="info",data="Server started successfully",
)

---

TypeScript

server.sendLoggingMessage({level: "info",data: "Server started successfully",
});

---

重要的事件记录：

• 初始化步骤
• 资源访问
• 工具执行
• 错误条件
• 性能指标

---

2、客户端日志

在客户端应用程序中：

1. 启用调试日志
2. 监控网络流量
3. 跟踪消息交流
4. 记录错误状态

---

五、调试工作流程

---

1、开发周期

1. 初始开发

   • 使用 Inspector 进行基本测试
   • 实现核心功能
   • 添加日志点

2. 集成测试

   • 在 Claude Desktop 中进行测试
   • 监控日志
   • 检查错误处理

---

2、测试更改

为了高效地测试更改：

• 配置更改：重启 Claude 桌面

• 服务器代码更改: 使用 Command-R 来重新加载
• 快速迭代：在开发期间使用 Inspector

---

六、最佳实践

---

1、日志记录策略

1. 结构化日志记录

   • 使用一致的格式
   • 包含上下文
   • 添加时间戳
   • 跟踪请求ID

2. 错误处理

   • 记录堆栈跟踪
   • 包含错误上下文
   • 跟踪错误模式
   • 监控恢复

3. 性能跟踪

   • 记录操作时间
   • 监控资源使用
   • 跟踪消息大小
   • 测量延迟

---

2、安全注意事项

当调试时：

1. 敏感数据

• 清理日志
• 保护凭证
• 隐藏个人信息

2. 访问控制

• 验证权限
• 检查认证
• 监控访问模式

---

七、获取帮助

当遇到问题时：

1. 第一步

• 检查服务器日志
• 使用 Inspector 进行测试
• 审查配置
• 验证环境

2. 支持渠道

• GitHub issues
• GitHub 讨论

3. 提供信息

• 日志摘录
• 配置文件
• 重复步骤
• 环境详细信息

---

---

https://modelcontextprotocol.io/docs/tools/inspector

---

教程 - 检查器

深入指南：使用MCP Inspector进行测试和调试模型上下文协议服务器
MCP 检查员是一个交互式开发工具，用于测试和调试MCP服务器。虽然调试指南涵盖了检查员作为整体调试工具集的一部分，但这份文档提供了对检查员功能和能力的详细探索。

---

一、入门

---

安装和基本用法

The Inspector runs directly through npx without requiring installation:

npx @modelcontextprotocol/inspector <command>

npx @modelcontextprotocol/inspector <command> <arg1> <arg2>

---

从 NPM 或 PyPi 检查服务器

A common way to start server packages from NPM or PyPi.
NPM 包

npx -y @modelcontextprotocol/inspector npx <package-name> <args>
# For example
npx -y @modelcontextprotocol/inspector npx server-postgres postgres://127.0.0.1/testdb

---

PyPi软件包

npx @modelcontextprotocol/inspector uvx <package-name> <args>
# For example
npx @modelcontextprotocol/inspector uvx mcp-server-git --repository ~/code/mcp/servers.git

---

检查本地开发的服务器

要检查本地开发或作为存储库下载的服务器，最常见的是：
以下是您提供的Markdown文档内容的中文翻译：

方式是：

TypeScript

npx @modelcontextprotocol/inspector node path/to/server/index.js args...

---

Python

npx @modelcontextprotocol/inspector \uv \--directory path/to/server \run \package-name \args...

---

请仔细阅读任何附带的 README 文件，以获取最准确的说明。

---

二、特性概述

MCP Inspector界面

---

Inspector提供了几个与MCP服务器交互的功能：

---

服务器连接面板

• 允许选择连接到服务器的 传输方式
• 对于本地服务器，支持自定义命令行参数和环境

---

资源标签

• 列出所有可用资源
• 显示资源元数据（MIME 类型，描述）
• 允许检查资源内容
• 支持订阅测试

---

提示标签

• 显示可用的提示模板
• 显示提示参数和描述
• 允许使用自定义参数进行提示测试
• 预览生成的消息

---

工具标签

• 列出可用的工具
• 显示工具模式和描述
• 允许使用自定义输入进行工具测试
• 显示工具执行结果

---

通知面板

• 展示服务器记录的所有日志
• 显示从服务器接收到的通知

---

三、最佳实践

---

开发工作流程

1. 开始开发

   • 使用服务器启动检查器
   • 验证基本连接性
   • 检查能力协商

2. 迭代测试

   • 对服务器进行更改
   • 重新构建服务器
   • 重新连接检查器
   • 测试受影响的特性
   • 监控消息

3. 测试边缘情况

   • 无效输入
   • 缺少提示参数
   • 并发操作
   • 验证错误处理和错误响应

---

---

https://modelcontextprotocol.io/docs/concepts/architecture

---

概念 - 核心架构

理解MCP如何连接客户端、服务器和LLMs
The Model Context Protocol (MCP) is built on a flexible, extensible architecture that enables seamless communication between LLM applications and integrations. This document covers the core architectural components and concepts.

---

一、概述

MCP遵循客户端-服务器架构，其中：

• 主机 是 LLM 应用程序（如 Claude 桌面或 IDEs），它们发起连接
• 客户端 与服务器在主机应用程序内保持 1:1 的连接
• 服务器 为客户端提供上下文、工具和提示

---

---

二、核心组件

---

1、协议层

协议层处理消息封装、请求/响应连接以及高级通信模式。
TypeScript

class Protocol<Request, Notification, Result> {// Handle incoming requestssetRequestHandler<T>(schema: T, handler: (request: T, extra: RequestHandlerExtra) => Promise<Result>): void// Handle incoming notificationssetNotificationHandler<T>(schema: T, handler: (notification: T) => Promise<void>): void// Send requests and await responsesrequest<T>(request: Request, schema: T, options?: RequestOptions): Promise<T>// Send one-way notificationsnotification(notification: Notification): Promise<void>
}

---

Python

class Session(BaseSession[RequestT, NotificationT, ResultT]):async def send_request(self,request: RequestT,result_type: type[Result]) -> Result:"""Send request and wait for response. Raises McpError if response contains error."""# Request handling implementationasync def send_notification(self,notification: NotificationT) -> None:"""Send one-way notification that doesn't expect response."""# Notification handling implementationasync def _received_request(self,responder: RequestResponder[ReceiveRequestT, ResultT]) -> None:"""Handle incoming request from other side."""# Request handling implementationasync def _received_notification(self,notification: ReceiveNotificationT) -> None:"""Handle incoming notification from other side."""# Notification handling implementation

---

关键类包括：

• Protocol
• Client
• Server

---

2、传输层

传输层处理客户端和服务器之间的实际通信。MCP支持多种传输机制：

1. 标准输入输出传输

• 使用标准输入/输出进行通信
• 适用于本地进程

2. 使用SSE传输的HTTP

• 使用服务器发送事件进行服务器到客户端的消息
• HTTP POST 用于客户端到服务器的消息

---

所有传输都使用 JSON-RPC 2.0 来交换消息。有关模型上下文协议消息格式的详细信息，请参阅 规范。

---

3、消息类型

MCP主要有以下几种消息类型：
1、Requests 期待从另一端收到响应：

interface Request {method: string;params?: { ... };
}

---

2、结果是请求的成功响应：

interface Result {[key: string]: unknown;
}

---

3、错误表示请求失败：

interface Error {code: number;message: string;data?: unknown;
}

---

4、通知是单向消息，不需要响应：

interface Notification {method: string;params?: { ... };
}

---

三、连接生命周期

---

1. 初始化

---

---

1. 客户端发送带有协议版本和功能的 initialize 请求
2. 服务器响应其协议版本和功能
3. 客户端发送 initialized 通知作为确认
4. 正常的消息交换开始

---

2. 消息交换

初始化之后，以下模式被支持：

• 请求-响应: 客户端或服务器发送请求，另一方做出响应
• 通知：任一方发送单向消息

---

3. 终止

任何一方都可以终止连接：

• 通过 close() 进行干净关闭
• 传输断开
• 错误条件

---

四、错误处理

MCP 定义了以下标准错误代码：

enum ErrorCode {// Standard JSON-RPC error codesParseError = -32700,InvalidRequest = -32600,MethodNotFound = -32601,InvalidParams = -32602,InternalError = -32603
}

---

SDKs 和应用程序可以定义它们自己的错误代码，其值大于 -32000。
错误通过以下方式传播：

• 请求的错误响应
  错误事件在传输上
• 协议级错误处理器

---

五、实现示例

Here’s a basic example of implementing an MCP server:
Python

import asyncio
import mcp.types as types
from mcp.server import Server
from mcp.server.stdio import stdio_serverapp = Server("example-server")@app.list_resources()
async def list_resources() -> list[types.Resource]:return [types.Resource(uri="example://resource",name="Example Resource")]async def main():async with stdio_server() as streams:await app.run(streams[0],streams[1],app.create_initialization_options())if __name__ == "__main__":asyncio.run(main)

---

TypeScript

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";const server = new Server({name: "example-server",version: "1.0.0"
}, {capabilities: {resources: {}}
});// Handle requests
server.setRequestHandler(ListResourcesRequestSchema, async () => {return {resources: [{uri: "example://resource",name: "Example Resource"}]};
});// Connect transport
const transport = new StdioServerTransport();
await server.connect(transport);

---

六、最佳实践

---

1、运输选择

1. 本地通信

   • 使用stdio传输方式用于本地进程
   • 针对同一机器通信高效
   • 简单的过程管理

2. 远程通信

   • 在需要HTTP兼容性的场景中使用SSE
   • 考虑安全性影响，包括身份验证和授权

---

2、消息处理

1. 请求处理

   • 仔细验证输入
   • 使用类型安全的模式
   • 优雅地处理错误
   • 实现超时

2. 进度报告

   • 使用进度令牌进行长时间操作
   • 逐步报告进度
   • 当知道总进度时，包括总进度

3. 错误管理

   • 使用适当的错误代码
   • 包含有用的错误消息
   • 错误发生时清理资源

---

七、安全考虑

1. 传输安全

   • 使用 TLS 进行远程连接
   • 验证连接来源
   • 需要时实现身份验证

2. 消息验证

   • 验证所有传入消息
   • 清理输入
   • 检查消息大小限制
   • 验证 JSON-RPC 格式

3. 资源保护

   • 实施访问控制
   • 验证资源路径
   • 监控资源使用
   • 限制请求速率

4. 错误处理

   • 不要泄露敏感信息
   • 记录与安全相关的错误
   • 实施适当的清理
   • 处理 DoS 场景

---

八、调试和监控

1. 日志记录

   • 记录协议事件
   • 跟踪消息流程
   • 监控性能
   • 记录错误

2. 诊断

   • 实施健康检查
   • 监控连接状态
   • 跟踪资源使用
   • 分析性能

3. 测试

   • 测试不同的传输方式
   • 验证错误处理
   • 检查边缘情况
   • 进行服务器负载测试

---

---

https://modelcontextprotocol.io/docs/concepts/resources

---

概念 - 资源 Resources

一、关于资源

将您的服务器上的数据和内容暴露给大型语言模型
资源是模型上下文协议（MCP）中的一个核心原语，它允许服务器公开数据内容，这些数据可以被客户端读取，并用作与大型语言模型（LLM）交互的上下文。

---

资源被设计为 应用控制，这意味着客户端应用程序可以决定如何以及何时使用它们。
不同的MCP客户端可能对资源的处理方式不同。例如：

• Claude Desktop 目前要求用户在可以使用资源之前必须明确选择它们 *
• 其他客户端可能会根据启发式算法自动选择资源
• 一些实现甚至允许AI模型本身决定使用哪些资源

---

服务器作者在实现资源支持时应该准备好处理这些交互模式中的任何一种。为了自动将数据暴露给模型，服务器作者应使用模型控制的原始类型，例如工具。

---

二、概述

资源代表任何 MCP 服务器希望提供给客户端的数据。这可以包括：
文件内容

• 数据库记录
• API 响应
• 实时系统数据
• 截图和图片
• 日志文件
• 更多
  每个资源都由一个唯一的URI标识，可以包含文本或二进制数据。

---

三、资源 URI

资源使用遵循此格式的 URI 进行标识：

[protocol]://[host]/[path] 

例如：

• file:///home/user/documents/report.pdf
• postgres://database/customers/schema
• screen://localhost/display1
  协议和路径结构由 MCP 服务器实现定义。服务器可以定义自己的自定义 URI 方案。

---

四、资源类型

资源可以包含两种类型的内容：

---

1、文本资源

文本资源包含UTF-8编码的文本数据。这些适用于：

• 源代码
• 配置文件
• 日志文件
• JSON/XML 数据
  纯文本

---

2、二进制资源

二进制资源包含以base64编码的原始二进制数据。这些适用于：

• 图片
• PDFs
• 音频文件
• 视频文件
• 其他非文本格式

---

五、资源发现

客户可以通过两种主要方法发现可用资源：

---

1、直接资源

服务器通过 resources/list 端点公开一系列具体资源。每个资源包括：

{uri: string;           // Unique identifier for the resourcename: string;          // Human-readable namedescription?: string;  // Optional descriptionmimeType?: string;     // Optional MIME type
}

---

2、资源模板

对于动态资源，服务器可以公开URI模板，客户端可以使用这些模板来构建有效的资源URI：

{uriTemplate: string;   // URI template following RFC 6570name: string;          // Human-readable name for this typedescription?: string;  // Optional descriptionmimeType?: string;     // Optional MIME type for all matching resources
}

---

六、阅读资源

要读取一个资源，客户端通过带有资源 URI 的 resources/read 请求来读取资源。
服务器响应一个资源内容列表：

{contents: [{uri: string;        // The URI of the resourcemimeType?: string;  // Optional MIME type// One of:text?: string;      // For text resourcesblob?: string;      // For binary resources (base64 encoded)}]
}

服务器可能会在响应一个 resources/read 请求时返回多个资源。例如，当读取目录时，这可以用来返回目录内的文件列表。

---

七、资源更新

MCP支持通过两种机制对资源进行实时更新：

---

列表更改

服务器可以通过 notifications/resources/list_changed 通知来通知客户端它们可用资源列表发生变化。

---

内容更改

用户可以订阅特定资源的更新：

1. 客户端发送 resources/subscribe 与资源 URI
2. 服务器在资源发生变化时发送 notifications/resources/updated
3. 客户端可以使用 resources/read 获取最新内容
4. 客户端可以通过 resources/unsubscribe 进行退订

---

八、示例实现

这里是一个在MCP服务器中实现资源支持的简单示例：

Python

app = Server("example-server")@app.list_resources()
async def list_resources() -> list[types.Resource]:return [types.Resource(uri="file:///logs/app.log",name="Application Logs",mimeType="text/plain")]@app.read_resource()
async def read_resource(uri: AnyUrl) -> str:if str(uri) == "file:///logs/app.log":log_contents = await read_log_file()return log_contentsraise ValueError("Resource not found")# Start server
async with stdio_server() as streams:await app.run(streams[0],streams[1],app.create_initialization_options())

---

TypeScript

const server = new Server({name: "example-server",version: "1.0.0"
}, {capabilities: {resources: {}}
});// List available resources
server.setRequestHandler(ListResourcesRequestSchema, async () => {return {resources: [{uri: "file:///logs/app.log",name: "Application Logs",mimeType: "text/plain"}]};
});// Read resource contents
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {const uri = request.params.uri;if (uri === "file:///logs/app.log") {const logContents = await readLogFile();return {contents: [{uri,mimeType: "text/plain",text: logContents}]};}throw new Error("Resource not found");
});

---

九、最佳实践

当实现资源支持时：

1. 使用清晰、描述性的资源名称和URI
2. 包含有助于引导LLM理解的描述
3. 当已知时，设置适当的 MIME 类型
4. 实现用于动态内容的资源模板
5. 使用订阅来处理经常变化的资源
6. 以清晰的错误信息优雅地处理错误
7. 考虑为大型资源列表实现分页
8. 在适当的时候缓存资源内容
9. 在处理之前验证 URI
10. 记录您自定义的 URI 方案

---

十、安全考虑

当暴露资源时：
验证所有资源URI

• 实现适当的访问控制
  对文件路径进行清理，以防止目录遍历
• 注意二进制数据处理
• 考虑对资源读取进行速率限制
• 审计资源访问
• 加密传输中的敏感数据
• 验证 MIME 类型
• 实现长时间读取的超时功能
• 适当处理资源清理
  是或否核心架构提示github

---

---

https://modelcontextprotocol.io/docs/concepts/prompts

---

概念 - 提示 Prompts

一、关于 提示

创建可重复使用的提示模板和工作流程
提示（Prompts）使服务器能够定义可重用的提示模板和工作流程，客户端可以轻松地将其展示给用户和大型语言模型（LLMs）。它们提供了一种强大的方式来标准化和共享常见的LLM交互。
提示符被设计为 用户可控，这意味着它们从服务器暴露给客户端，目的是让用户能够明确选择它们来使用。

---

二、概述

MCP中的提示是预定义的模板，可以：

• 接受动态参数
• 包含来自资源的上下文
• 链接多个交互
• 指定工作流程指南
• 以 UI 元素（如斜杠命令）呈现

---

三、提示结构

每个提示都由以下定义：

{name: string;              // Unique identifier for the promptdescription?: string;      // Human-readable descriptionarguments?: [              // Optional list of arguments{name: string;          // Argument identifierdescription?: string;  // Argument descriptionrequired?: boolean;    // Whether argument is required}]
}

---

四、发现提示

客户端可以通过 prompts/list 端点发现可用的提示：

// Request
{method: "prompts/list"
}// Response
{prompts: [{name: "analyze-code",description: "Analyze code for potential improvements",arguments: [{name: "language",description: "Programming language",required: true}]}]
}

---

五、使用提示

要使用一个提示，客户端发起一个 prompts/get 请求：

// Request
{method: "prompts/get",params: {name: "analyze-code",arguments: {language: "python"}}
}// Response
{description: "Analyze Python code for potential improvements",messages: [{role: "user",content: {type: "text",text: "Please analyze the following Python code for potential improvements:\n\n```python\ndef calculate_sum(numbers):\n    total = 0\n    for num in numbers:\n        total = total + num\n    return total\n\nresult = calculate_sum([1, 2, 3, 4, 5])\nprint(result)\n```"}}]
}

---

六、动态提示

提示可以是动态的，包括：

---

1、嵌入式资源上下文

{"name": "analyze-project","description": "Analyze project logs and code","arguments": [{"name": "timeframe","description": "Time period to analyze logs","required": true},{"name": "fileUri","description": "URI of code file to review","required": true}]
}

---

当处理 prompts/get 请求时：

{"messages": [{"role": "user","content": {"type": "text","text": "Analyze these system logs and the code file for any issues:"}},{"role": "user","content": {"type": "resource","resource": {"uri": "logs://recent?timeframe=1h","text": "[2024-03-14 15:32:11] ERROR: Connection timeout in network.py:127\n[2024-03-14 15:32:15] WARN: Retrying connection (attempt 2/3)\n[2024-03-14 15:32:20] ERROR: Max retries exceeded","mimeType": "text/plain"}}},{"role": "user","content": {"type": "resource","resource": {"uri": "file:///path/to/code.py","text": "def connect_to_service(timeout=30):\n    retries = 3\n    for attempt in range(retries):\n        try:\n            return establish_connection(timeout)\n        except TimeoutError:\n            if attempt == retries - 1:\n                raise\n            time.sleep(5)\n\ndef establish_connection(timeout):\n    # Connection implementation\n    pass","mimeType": "text/x-python"}}}]
}

---

2、多步骤工作流程

const debugWorkflow = {name: "debug-error",async getMessages(error: string) {return [{role: "user",content: {type: "text",text: `Here's an error I'm seeing: ${error}`}},{role: "assistant",content: {type: "text",text: "I'll help analyze this error. What have you tried so far?"}},{role: "user",content: {type: "text",text: "I've tried restarting the service, but the error persists."}}];}
};

---

七、示例实现

以下是一个在MCP服务器中实现提示的完整示例：
TypeScript

import { Server } from "@modelcontextprotocol/sdk/server";
import {ListPromptsRequestSchema,GetPromptRequestSchema
} from "@modelcontextprotocol/sdk/types";const PROMPTS = {"git-commit": {name: "git-commit",description: "Generate a Git commit message",arguments: [{name: "changes",description: "Git diff or description of changes",required: true}]},"explain-code": {name: "explain-code",description: "Explain how code works",arguments: [{name: "code",description: "Code to explain",required: true},{name: "language",description: "Programming language",required: false}]}
};const server = new Server({name: "example-prompts-server",version: "1.0.0"
}, {capabilities: {prompts: {}}
});// List available prompts
server.setRequestHandler(ListPromptsRequestSchema, async () => {return {prompts: Object.values(PROMPTS)};
});// Get specific prompt
server.setRequestHandler(GetPromptRequestSchema, async (request) => {const prompt = PROMPTS[request.params.name];if (!prompt) {throw new Error(`Prompt not found: ${request.params.name}`);}if (request.params.name === "git-commit") {return {messages: [{role: "user",content: {type: "text",text: `Generate a concise but descriptive commit message for these changes:\n\n${request.params.arguments?.changes}`}}]};}if (request.params.name === "explain-code") {const language = request.params.arguments?.language || "Unknown";return {messages: [{role: "user",content: {type: "text",text: `Explain how this ${language} code works:\n\n${request.params.arguments?.code}`}}]};}throw new Error("Prompt implementation not found");
});

---

Python

from mcp.server import Server
import mcp.types as types# Define available prompts
PROMPTS = {"git-commit": types.Prompt(name="git-commit",description="Generate a Git commit message",arguments=[types.PromptArgument(name="changes",description="Git diff or description of changes",required=True)],),"explain-code": types.Prompt(name="explain-code",description="Explain how code works",arguments=[types.PromptArgument(name="code",description="Code to explain",required=True),types.PromptArgument(name="language",description="Programming language",required=False)],)
}# Initialize server
app = Server("example-prompts-server")@app.list_prompts()
async def list_prompts() -> list[types.Prompt]:return list(PROMPTS.values())@app.get_prompt()
async def get_prompt(name: str, arguments: dict[str, str] | None = None
) -> types.GetPromptResult:if name not in PROMPTS:raise ValueError(f"Prompt not found: {name}")if name == "git-commit":changes = arguments.get("changes") if arguments else ""return types.GetPromptResult(messages=[types.PromptMessage(role="user",content=types.TextContent(type="text",text=f"Generate a concise but descriptive commit message "f"for these changes:\n\n{changes}"))])if name == "explain-code":code = arguments.get("code") if arguments else ""language = arguments.get("language", "Unknown") if arguments else "Unknown"return types.GetPromptResult(messages=[types.PromptMessage(role="user",content=types.TextContent(type="text",text=f"Explain how this {language} code works:\n\n{code}"))])raise ValueError("Prompt implementation not found")

---

八、最佳实践

当实现提示时：

1. 使用清晰、描述性的提示名称
2. 为提示和参数提供详细描述
3. 验证所有必需的参数
4. 优雅地处理缺失的参数
5. 考虑为提示模板进行版本控制
6. 在适当的时候缓存动态内容
7. 实现错误处理
8. 文档预期的参数格式
9. 考虑提示的组合性
10. 使用各种输入测试提示

---

九、UI集成

提示可以在客户端用户界面中以以下方式呈现：

• 斜杠命令
• 快速操作
• 菜单上下文选项
• 命令面板条目
• 指导工作流程
• 交互式表单

---

十、更新和变更

服务器可以通知客户端关于即时变更：

1. 服务器功能：prompts.listChanged
2. 通知：notifications/prompts/list_changed
3. 客户端重新获取提示列表

---

十一、安全考虑

在实现提示时：

• 验证所有参数
• 清理用户输入
• 考虑速率限制
• 实现访问控制
• 审计提示使用
• 正确处理敏感数据
• 验证生成内容
• 实现超时
• 考虑提示注入风险
• 文档安全要求

---

---

https://modelcontextprotocol.io/docs/concepts/tools

---

概念 - 工具 Tools

一、关于 Tools

启用 LLMs 通过您的服务器执行操作
工具是模型上下文协议（MCP）中的一个强大原语，它使服务器能够向客户端暴露可执行功能。通过工具，LLMs 可以与外部系统交互，执行计算，并在现实世界中采取行动。
工具被设计为模型控制，意味着工具从服务器暴露给客户端，目的是让AI模型能够自动调用它们（人类在循环中授予批准）。

---

二、概述

MCP中的工具允许服务器暴露可由客户端调用并由LLM执行动作的可执行函数。工具的关键方面包括：

• 发现: 客户端可以通过 tools/list 端点列出可用的工具
• 调用: 使用 tools/call 端点调用工具，服务器执行请求的操作并返回结果
• 灵活性: 工具可以从简单的计算到复杂的API交互
  与资源一样，工具通过唯一的名称来识别，并且可以包含描述以指导其使用。然而，与资源不同，工具代表动态操作，可以修改状态或与外部系统交互。

---

三、工具定义结构

每个工具都使用以下结构定义：

{name: string;          // Unique identifier for the tooldescription?: string;  // Human-readable descriptioninputSchema: {         // JSON Schema for the tool's parameterstype: "object",properties: { ... }  // Tool-specific parameters}
}

---

四、实现工具

以下是一个在MCP服务器中实现基本工具的示例：

Python

app = Server("example-server")@app.list_tools()
async def list_tools() -> list[types.Tool]:return [types.Tool(name="calculate_sum",description="Add two numbers together",inputSchema={"type": "object","properties": {"a": {"type": "number"},"b": {"type": "number"}},"required": ["a", "b"]})]@app.call_tool()
async def call_tool(name: str,arguments: dict
) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:if name == "calculate_sum":a = arguments["a"]b = arguments["b"]result = a + breturn [types.TextContent(type="text", text=str(result))]raise ValueError(f"Tool not found: {name}")

---

TypeScript

const server = new Server({name: "example-server",version: "1.0.0"
}, {capabilities: {tools: {}}
});// Define available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {return {tools: [{name: "calculate_sum",description: "Add two numbers together",inputSchema: {type: "object",properties: {a: { type: "number" },b: { type: "number" }},required: ["a", "b"]}}]};
});// Handle tool execution
server.setRequestHandler(CallToolRequestSchema, async (request) => {if (request.params.name === "calculate_sum") {const { a, b } = request.params.arguments;return {content: [{type: "text",text: String(a + b)}]};}throw new Error("Tool not found");
});

---

五、示例工具模式

以下是一些服务器可能提供工具类型的示例：

---

1、系统操作

与本地系统交互的工具：

{name: "execute_command",description: "Run a shell command",inputSchema: {type: "object",properties: {command: { type: "string" },args: { type: "array", items: { type: "string" } }}}
}

---

2、API集成

工具，用于封装外部API：

{name: "github_create_issue",description: "Create a GitHub issue",inputSchema: {type: "object",properties: {title: { type: "string" },body: { type: "string" },labels: { type: "array", items: { type: "string" } }}}
}

---

3、数据处理

工具，用于转换或分析数据：

{name: "analyze_csv",description: "Analyze a CSV file",inputSchema: {type: "object",properties: {filepath: { type: "string" },operations: {type: "array",items: {enum: ["sum", "average", "count"]}}}}
}

---

六、最佳实践

在实现工具时：

1. 提供清晰、描述性的名称和描述
2. 使用详细的 JSON Schema 定义参数
3. 在工具描述中包含示例，以展示模型应该如何使用它们
4. 实现适当的错误处理和验证
5. 使用进度报告进行长时间操作
6. 保持工具操作集中和原子化
7. 文档预期返回值结构
8. 实现适当的超时
9. 考虑对资源密集型操作进行速率限制
10. 记录工具使用情况以供调试和监控

---

七、安全考虑

当暴露工具时：

---

1、输入验证

• 验证所有参数与模式
• 清理文件路径和系统命令
• 验证URL和外部标识符
• 检查参数大小和范围
• 防止命令注入

---

2、访问控制

• 在需要的地方实现身份验证
• 使用适当的授权检查
• 审计工具使用
• 限制请求速率
• 监控滥用行为

---

3、错误处理

• 不要向客户端暴露内部错误
• 记录与安全相关的错误
• 适当地处理超时
• 在错误后清理资源
• 验证返回值

---

八、工具发现和更新

MCP 支持动态工具发现：

1. 客户可以随时列出可用的工具
2. 服务器可以使用 notifications/tools/list_changed 通知客户端工具已更改
3. 工具可以在运行时添加或移除
4. 工具定义可以更新（尽管这应该谨慎进行）

---

九、错误处理

工具错误应在结果对象中报告，而不是作为MCP协议级别的错误。这允许LLM看到并可能处理该错误。当工具遇到错误时：

1. 将 result 中的 isError 设置为 true
2. 在 content 数组中包含错误详情

---

以下是正确处理工具错误的示例：
Python

try:# Tool operationresult = perform_operation()return types.CallToolResult(content=[types.TextContent(type="text",text=f"Operation successful: {result}")])
except Exception as error:return types.CallToolResult(isError=True,content=[types.TextContent(type="text",text=f"Error: {str(error)}")])

---

TypeScript

try {// Tool operationconst result = performOperation();return {content: [{type: "text",text: `Operation successful: ${result}`}]};
} catch (error) {return {isError: true,content: [{type: "text",text: `Error: ${error.message}`}]};
}

这种方法允许LLM看到发生了错误，并可能采取纠正措施或请求人工干预。

---

十、测试工具

一份针对MCP工具的全面测试策略应包括：

• 功能测试：验证工具在有效输入下正确执行，并适当地处理无效输入
• 集成测试：使用真实和模拟的依赖项测试工具与外部系统的交互
• 安全测试：验证身份验证、授权、输入清理和速率限制
• 性能测试: 检查负载下的行为、超时处理和资源清理
• 错误处理：确保工具通过MCP协议正确报告错误并清理资源

---

---

https://modelcontextprotocol.io/docs/concepts/sampling

---

概念 - 采样 Sampling

一、关于 Sampling

让你的服务器从LLMs请求完成项
采样是MCP（多客户端协议）的一个强大功能，允许服务器通过客户端请求LLM（大型语言模型）的完成，同时保持安全性和隐私，实现复杂的代理行为。
这个MCP功能在Claude桌面客户端中尚未支持。

---

二、采样如何工作

采样流程遵循以下步骤：

1. 服务器向客户端发送一个 sampling/createMessage 请求
2. 客户查看请求并可以修改它
3. 从大型语言模型（LLM）中获取客户端样本
4. 客户审查完成
5. 客户端将结果返回给服务器
   这种人机交互式设计确保用户保持对LLM所见和所生成内容的控制。

---

三、消息格式

采样请求使用标准化的消息格式：

{messages: [{role: "user" | "assistant",content: {type: "text" | "image",// For text:text?: string,// For images:data?: string,             // base64 encodedmimeType?: string}}],modelPreferences?: {hints?: [{name?: string                // Suggested model name/family}],costPriority?: number,         // 0-1, importance of minimizing costspeedPriority?: number,        // 0-1, importance of low latencyintelligencePriority?: number  // 0-1, importance of capabilities},systemPrompt?: string,includeContext?: "none" | "thisServer" | "allServers",temperature?: number,maxTokens: number,stopSequences?: string[],metadata?: Record<string, unknown>
}

---

四、请求参数

---

1、消息

messages 数组包含要发送给 LLM 的对话历史。每个消息都有：

• 角色: 要么是“用户”要么是“助手”
• content: 消息内容，可以是：

• 文本内容，包含一个 text 字段
• 带有 data（base64）和 mimeType 字段的图片内容

---

2、模型偏好

modelPreferences 对象允许服务器指定它们的模型选择偏好：

• hints: 客户可以使用以选择适当模型的模型名称建议的数组：

• name: 字符串，可以匹配完整或部分模型名称（例如，“claude-3”，“sonnet”）
• 客户可以将提示映射到不同提供商的等效模型
• 多个提示按优先级顺序进行评估

• 优先级值（0-1归一化）：

• costPriority: 成本优先级的重要性
• speedPriority: 低延迟响应的重要性
• intelligencePriority: 先进模型能力的重要性
  客户根据这些偏好和可用的模型进行最终模型选择。

---

3、系统提示

可选的 systemPrompt 字段允许服务器请求特定的系统提示。客户端可以修改或忽略此选项。

---

4、上下文包含

includeContext 参数指定要包含哪个 MCP 上下文：

• "none": 无附加上下文
• "thisServer": 包含来自请求服务器的上下文
• "allServers": 包含所有连接的MCP服务器中的上下文

客户端控制实际包含的上下文。

---

5、采样参数

微调LLM采样，使用以下方法：

• 温度: 控制随机性（0.0 到 1.0）
  maxTokens: 最大生成令牌数
• stopSequences: 停止生成的序列数组
• metadata: 其他提供者特定的参数

---

五、响应格式

客户端返回一个完成结果：

{model: string,  // Name of the model usedstopReason?: "endTurn" | "stopSequence" | "maxTokens" | string,role: "user" | "assistant",content: {type: "text" | "image",text?: string,data?: string,mimeType?: string}
}

---

六、示例请求

以下是从客户端请求采样的示例：

{"method": "sampling/createMessage","params": {"messages": [{"role": "user","content": {"type": "text","text": "What files are in the current directory?"}}],"systemPrompt": "You are a helpful file system assistant.","includeContext": "thisServer","maxTokens": 100}
}

---

七、最佳实践

在实现采样时：

1. 总是提供清晰、结构良好的提示
2. 适当处理文本和图像内容
3. 设置合理的令牌限制
4. 通过 includeContext 包含相关上下文
5. 在使用之前验证响应
6. 优雅地处理错误
7. 考虑对采样请求进行速率限制
8. 文档预期采样行为
9. 使用各种模型参数进行测试
10. 监控采样成本

---

八、人类在环控制

采样设计时考虑了人工监督：

---

对于提示

• 客户应向用户展示提出的提示
• 用户应能够修改或拒绝提示
• 系统提示可以被过滤或修改
• 上下文包含由客户控制

---

For completions

• 客户应向用户展示完成情况
• 用户应能够修改或拒绝完成情况
• 客户可以对完成情况进行筛选或修改
• 用户控制使用哪个模型

---

九、安全考虑

在实施采样时：

• 验证所有消息内容
• 清洗敏感信息
• 实现适当的速率限制
• 监控采样使用
• 加密传输中的数据
• 处理用户数据隐私
• 审计抽样请求
• 控制成本暴露
• 实现超时
• 处理模型错误要优雅

---

十、常见模式

---

1、代理工作流

采样可以启用如下代理模式：

• 阅读和分析资源
• 基于上下文做决策
• 生成结构化数据
• 处理多步骤任务
• 提供交互式帮助

---

2、上下文管理

最佳实践：

• 请求最少的必要上下文
• 结构上下文清晰
• 处理上下文大小限制
• 更新上下文，如有需要
• 清理过期的上下文

---

3、错误处理

健壮的错误处理应该：

• 捕获采样失败
• 处理超时错误
• 管理速率限制
• 验证响应
• 提供后备行为
• 正确记录错误

---

十一、局限性

请注意这些限制：

• 样本采集取决于客户端能力
• 用户控制采样行为
• 上下文大小有限
• 可能会应用速率限制
• 成本应予以考虑
• 模型可用性各异
• 响应时间各异
• 不支持所有内容类型

---

---

https://modelcontextprotocol.io/docs/concepts/roots

---

概念 - 根 Roots

理解MCP中的根
根是MCP中的一个概念，它定义了服务器可以操作的范围。它们提供了一种方式，让客户端告知服务器有关资源及其位置的信息。

---

一、Roots 是什么？

一个根是客户端建议服务器应该关注的URI。当客户端连接到服务器时，它声明了服务器应该与哪些根一起工作。虽然主要用于文件系统路径，但根可以是任何有效的URI，包括HTTP URL。
例如，根可以是：

file:///home/user/projects/myapp
https://api.example.com/v1

---

二、为什么使用Roots？

根系统具有几个重要功能：

1. 指导：它们向服务器通知相关资源和位置
2. 清晰度：Roots 清晰地表明哪些资源是您工作空间的一部分
3. 组织: 多个根让您可以同时处理不同的资源

---

三、根的工作原理

当客户端支持根时，它：

1. 在连接期间声明 roots 功能
2. 提供给服务器一个建议的根列表
3. 当根目录发生变化时通知服务器（如果支持）

---

虽然根是信息性的且不是强制执行的，服务器应该：

1. 尊重提供的根
2. 使用根 URI 定位和访问资源
3. 优先处理根边界内的操作

---

四、常见用例

根通常用来定义：

• 项目目录
• 仓库位置
• API 端点
• 配置位置
• 资源边界

---

五、最佳实践

当与根一起工作时：

1. 只建议必要的资源
2. 使用清晰、描述性的名称作为根
3. 监控root可访问性
4. 优雅地处理根更改

---

六、示例

这里是一个典型的MCP客户端如何暴露根的示例：

{"roots": [{"uri": "file:///home/user/projects/frontend","name": "Frontend Repository"},{"uri": "https://api.example.com/v1","name": "API Endpoint"}]
}

这个配置建议服务器同时关注本地仓库和API端点，同时保持它们在逻辑上分离。

---

---

https://modelcontextprotocol.io/docs/concepts/transports

---

概念 - 传输

了解MCP的通信机制
在模型上下文协议（MCP）中，传输提供客户端和服务器之间通信的基础。传输处理消息发送和接收的底层机制。

---

一、消息格式

MCP 使用 JSON-RPC 2.0 作为其传输格式。传输层负责将 MCP 协议消息转换为 JSON-RPC 格式进行传输，并将接收到的 JSON-RPC 消息转换回 MCP 协议消息。
使用了三种类型的JSON-RPC消息：

---

1、请求

{jsonrpc: "2.0",id: number | string,method: string,params?: object
}

---

2、响应

{jsonrpc: "2.0",id: number | string,result?: object,error?: {code: number,message: string,data?: unknown}
}

---

3、通知

{jsonrpc: "2.0",method: string,params?: object
}

---

二、内置传输类型

MCP 包含两个标准的传输实现：

1、标准输入输出 (stdio)

stdio传输允许通过标准输入和输出流进行通信。这对于本地集成和命令行工具特别有用。
使用 stdio 时的条件：

• 构建命令行工具
• 实现本地集成
• 需要简单的进程通信
• 使用shell脚本

---

Python 服务器

app = Server("example-server")async with stdio_server() as streams:await app.run(streams[0],streams[1],app.create_initialization_options())

---

Python 客户端

params = StdioServerParameters(command="./server",args=["--option", "value"]
)async with stdio_client(params) as streams:async with ClientSession(streams[0], streams[1]) as session:await session.initialize()

---

TypeScript (服务器)

const server = new Server({name: "example-server",version: "1.0.0"
}, {capabilities: {}
});const transport = new StdioServerTransport();
await server.connect(transport);

---

TypeScript (客户端)

const client = new Client({name: "example-client",version: "1.0.0"
}, {capabilities: {}
});const transport = new StdioClientTransport({command: "./server",args: ["--option", "value"]
});
await client.connect(transport);

---

2、Server-Sent Events (SSE)

SSE 传输通过 HTTP POST 请求实现服务器到客户端的流式传输，以及客户端到服务器的通信。
使用 SSE 当：

• 仅需要服务器到客户端的流式传输
• 与受限网络协作
• 实现简单更新

---

Python (服务器)

from mcp.server.sse import SseServerTransport
from starlette.applications import Starlette
from starlette.routing import Routeapp = Server("example-server")
sse = SseServerTransport("/messages")async def handle_sse(scope, receive, send):async with sse.connect_sse(scope, receive, send) as streams:await app.run(streams[0], streams[1], app.create_initialization_options())async def handle_messages(scope, receive, send):await sse.handle_post_message(scope, receive, send)starlette_app = Starlette(routes=[Route("/sse", endpoint=handle_sse),Route("/messages", endpoint=handle_messages, methods=["POST"]),]
)

---

Python (客户端)

async with sse_client("http://localhost:8000/sse") as streams:async with ClientSession(streams[0], streams[1]) as session:await session.initialize()

---

TypeScript (服务器)

import express from "express";const app = express();const server = new Server({name: "example-server",version: "1.0.0"
}, {capabilities: {}
});let transport: SSEServerTransport | null = null;app.get("/sse", (req, res) => {transport = new SSEServerTransport("/messages", res);server.connect(transport);
});app.post("/messages", (req, res) => {if (transport) {transport.handlePostMessage(req, res);}
});app.listen(3000);

---

TypeScript (客户端)

const client = new Client({name: "example-client",version: "1.0.0"
}, {capabilities: {}
});const transport = new SSEClientTransport(new URL("http://localhost:3000/sse")
);
await client.connect(transport);

---

三、自定义传输

MCP使实现针对特定需求的自定义传输变得容易。任何传输实现只需符合传输接口：
您可以为以下内容实现自定义传输：

• 自定义网络协议
• 专用通信通道
• 集成现有系统
• 性能优化

---

Python
请注意，尽管MCP服务器通常使用asyncio实现，但我们建议使用anyio实现低级接口（如传输），以实现更广泛的兼容性。

@contextmanager
async def create_transport(read_stream: MemoryObjectReceiveStream[JSONRPCMessage | Exception],write_stream: MemoryObjectSendStream[JSONRPCMessage]
):"""Transport interface for MCP.Args:read_stream: Stream to read incoming messages fromwrite_stream: Stream to write outgoing messages to"""async with anyio.create_task_group() as tg:try:# Start processing messagestg.start_soon(lambda: process_messages(read_stream))# Send messagesasync with write_stream:yield write_streamexcept Exception as exc:# Handle errorsraise excfinally:# Clean uptg.cancel_scope.cancel()await write_stream.aclose()await read_stream.aclose()

---

TypeScript

interface Transport {// Start processing messagesstart(): Promise<void>;// Send a JSON-RPC messagesend(message: JSONRPCMessage): Promise<void>;// Close the connectionclose(): Promise<void>;// Callbacksonclose?: () => void;onerror?: (error: Error) => void;onmessage?: (message: JSONRPCMessage) => void;
}

---

四、错误处理

运输实现应处理各种错误场景：

1. 连接错误
2. 消息解析错误
3. 协议错误
4. 网络超时
5. 资源清理

---

示例错误处理：

Python

请注意，尽管MCP服务器通常使用asyncio实现，但我们建议使用anyio实现低级接口（如传输），以提高更广泛的兼容性。

@contextmanager
async def example_transport(scope: Scope, receive: Receive, send: Send):try:# Create streams for bidirectional communicationread_stream_writer, read_stream = anyio.create_memory_object_stream(0)write_stream, write_stream_reader = anyio.create_memory_object_stream(0)async def message_handler():try:async with read_stream_writer:# Message handling logicpassexcept Exception as exc:logger.error(f"Failed to handle message: {exc}")raise excasync with anyio.create_task_group() as tg:tg.start_soon(message_handler)try:# Yield streams for communicationyield read_stream, write_streamexcept Exception as exc:logger.error(f"Transport error: {exc}")raise excfinally:tg.cancel_scope.cancel()await write_stream.aclose()await read_stream.aclose()except Exception as exc:logger.error(f"Failed to initialize transport: {exc}")raise exc

---

TypeScript

class ExampleTransport implements Transport {async start() {try {// Connection logic} catch (error) {this.onerror?.(new Error(`Failed to connect: ${error}`));throw error;}}async send(message: JSONRPCMessage) {try {// Sending logic} catch (error) {this.onerror?.(new Error(`Failed to send message: ${error}`));throw error;}}
}

---

五、最佳实践

当实现或使用MCP传输时：

1. 正确处理连接生命周期
2. 实现适当的错误处理
3. 清理连接关闭时的资源
4. 使用适当的超时时间
5. 在发送前验证消息
6. 为调试记录日志传输事件
7. 在适当的时候实现重连逻辑
8. 处理消息队列中的背压
9. 监控连接健康
10. 实施适当的安全措施

---

六、安全考虑

当实现 transport:

---

1、认证和授权

• 实现适当的认证机制
• 验证客户端凭证
• 使用安全的令牌处理
• 实施授权检查

---

2、数据安全

• 使用TLS进行网络传输
• 加密敏感数据
• 验证消息完整性
• 实现消息大小限制
• 清洗输入数据

---

3、网络安全

• 实现速率限制
• 使用合适的超时时间
• 处理拒绝服务场景
• 监控异常模式
• 实现适当的防火墙规则

---

七、调试传输

调试传输问题的小贴士：

1. 启用调试日志
2. 监控消息流
3. 检查连接状态
4. 验证消息格式
5. 测试错误场景
6. 使用网络分析工具
7. 实现健康检查
8. 监控资源使用
9. 测试边缘情况
10. 使用适当的错误跟踪

---

---

https://modelcontextprotocol.io/development/roadmap

---

开发

路线图

我们的计划是进化模型上下文协议（H1 2025）
模型上下文协议正在迅速发展。本页概述了我们当前对2025年上半年的关键优先事项和未来方向的思考，尽管随着项目的进展，这些内容可能会有显著变化。
这里提出的想法并非承诺——我们可能以不同的方式解决这些挑战，或者其中一些可能根本不会实现。这也不是一个 详尽无遗 的列表；我们可能会纳入此处未提及的工作。
我们鼓励社区参与！每个部分都链接到相关的讨论，您可以在那里了解更多信息并贡献您的想法。

---

一、远程MCP支持

我们的首要任务是改进远程MCP连接，允许客户端通过互联网安全地连接到MCP服务器。关键举措包括：

• 认证 & 授权: 添加标准化的认证功能，特别是关注 OAuth 2.0 支持。
• 服务发现: 定义客户端如何发现并连接到远程MCP服务器。
• 无状态操作：考虑MCP是否也可以涵盖无服务器环境，在这些环境中它们将主要需要是无状态的。

---

二、参考实现

为了帮助开发者使用MCP进行开发，我们希望提供以下文档：

• 客户端示例: 完整的参考客户端实现（们），展示了所有协议功能
• 协议起草: 优化提出和纳入新协议功能的流程

---

三、分布式与发现

展望未来，我们正在探索让MCP服务器更加易于访问的方法。我们可能会调查的领域包括：

• 包管理: MCP服务器的标准化打包格式
• 安装工具：简化MCP客户端的服务器安装
• 沙盒化：通过服务器隔离提升安全性
• 服务器注册表: 一个用于发现可用MCP服务器的公共目录

---

四、代理支持

我们正在扩展MCP（模型上下文协议）的功能，以支持复杂的代理工作流程，尤其是专注于：

• 分层代理系统: 通过命名空间和拓扑感知增强了代理树的支持。
• 交互式工作流程：更好地处理跨代理层次结构的用户权限和信息请求，以及将输出发送给用户而不是模型的方法。
• 流式结果: 来自长时间运行代理操作的实时更新。

---

五、更广泛的生态系统

我们也在投资以下领域：

• 社区主导的标准制定：培育一个协作生态系统，使所有AI提供商能够通过平等参与和共享治理来塑造MCP作为一个开放标准，确保它满足多样化的AI应用和用例需求。
• 附加模式：扩展文本之外，以支持音频、视频和其他格式。
• [标准化] 考虑通过标准化机构进行标准化。

---

六、参与其中

我们欢迎社区参与塑造MCP的未来。访问我们的GitHub Discussions加入对话并贡献你的想法。
是的没有什么是新功能贡献github

---

---