MCP协议与无状态更新：构建可插拔AI智能体基础设施的实践指南

最近在尝试将 AI 智能体（Agent）集成到自己的开发工作流中时，发现一个普遍痛点：智能体本身的核心推理逻辑迭代很快，但与之配套的工具调用、数据访问、状态管理等“基础设施”部分却异常脆弱且难以复用。每次想给智能体增加一个新能力，比如连接数据库、调用搜索 API 或操作文件系统，都免不了一番复杂的代码嵌入和环境配置，过程繁琐且容易破坏原有逻辑。

这正是MCP（Model Context Protocol）及其倡导的无状态更新理念所要解决的核心问题。本文将深入探讨 MCP 如何作为一种标准化的“插座”协议，将 AI 智能体的核心逻辑与其所需的外部能力解耦，从而实现智能体基础设施的灵活、安全扩展。无论你是正在构建 AI 应用的开发者，还是希望优化现有智能体工作流的工程师，都能通过本文理解 MCP 的核心概念、掌握其使用方法，并最终能独立开发和集成 MCP 服务器来扩展你的智能体能力。

1. MCP 与无状态更新：重新定义 AI 智能体基础设施

在深入技术细节之前，我们首先要厘清几个关键概念：什么是 MCP？什么是无状态更新？以及它们为何对 AI 智能体至关重要。

1.1 什么是 MCP（Model Context Protocol）？

MCP，即模型上下文协议，是一个开放标准，旨在为大型语言模型（LLM）或 AI 智能体提供一种标准化、安全的方式来访问外部工具、数据和计算资源。你可以把它想象成智能体的“USB-C 接口”或“插件系统”。

在传统的 AI 智能体架构中，工具能力（如搜索、读写文件、执行代码）通常被硬编码到智能体的提示词（Prompt）或函数调用（Function Calling）逻辑中。这种方式存在明显缺陷：

• 耦合度高：增加或修改工具需要改动智能体核心代码。
• 安全性差：智能体可能获得过高或不当的权限。
• 复用性低：为 A 智能体开发的工具很难直接给 B 智能体使用。

MCP 通过引入“服务器（Server）”和“客户端（Client）”的架构解决了这些问题：

• MCP 服务器：提供具体的工具能力（例如，一个“文件系统服务器”提供读写文件工具，一个“SQLite 服务器”提供数据库查询工具）。它独立于任何特定的 AI 模型运行。
• MCP 客户端：通常是 AI 应用或平台（如 Claude Desktop、Cursor、Windsurf），它负责运行 AI 模型，并通过 MCP 协议与一个或多个服务器通信，从而为模型动态提供工具。
• 协议本身：定义了一套标准的 JSON-RPC over STDIO/SSE 通信方式，规范了工具发现、调用和资源传输的格式。

1.2 无状态更新（Stateless Updates）的核心思想

“无状态更新”是 MCP 架构带来的一个关键优势。这里的“无状态”并非指服务器完全不存储数据，而是指MCP 服务器与 AI 智能体（客户端）之间的交互是无会话状态的。

具体来说：

1. 每次调用都是独立的：智能体每次发起工具调用时，提供的上下文是自包含的。服务器不依赖于之前的调用历史来处理当前请求。
2. 服务器不管理智能体状态：服务器不知道也不关心是哪个智能体、在哪个会话中调用了它。它只专注于执行收到的指令并返回结果。
3. 客户端负责状态管理：会话历史、用户偏好、多轮对话的上下文等状态，完全由客户端（AI 应用）来维护。

这种设计带来了巨大的灵活性：

• 动态绑定：你可以在智能体运行时，动态地添加或移除 MCP 服务器，即时扩展或收缩其能力范围，而无需重启智能体或修改其代码。
• 安全隔离：每个工具服务器运行在独立的、权限受限的进程中。一个负责搜索的服务器无需（也不应该）拥有文件系统的访问权限。
• 易于开发和部署：开发者可以专注于编写单一功能的工具服务器，无需考虑复杂的智能体状态管理逻辑。

1.3 为什么需要扩展 AI 智能体基础设施？

AI 智能体的核心是“思考”和“决策”，但它的价值需要通过“行动”来体现。这些行动就是与外部世界的交互：

• 获取信息：从网络、数据库、知识库中查询数据。
• 操作资源：创建、修改、删除文件，发送邮件，调用 API。
• 控制环境：执行命令行指令，操作浏览器，控制 IDE。

这些交互能力构成了智能体的“基础设施”。一个强大的智能体，必须拥有丰富、可靠、安全的基础设施。MCP 将这套基础设施标准化、模块化，使得：

• 能力扩展像安装插件一样简单：需要搜索能力？连接一个tavily-mcp服务器。需要操作数据库？连接一个sqlite-mcp服务器。
• 生态得以繁荣：开发者可以专注于构建好用的单一功能服务器，并共享给社区。
• 企业可以定制私有基础设施：在内网部署专用的 MCP 服务器，让智能体安全地访问内部系统，而无需将核心智能体模型部署在内网。

2. 环境准备与核心工具

在开始动手实践前，我们需要准备好开发环境。本文将使用 Python 作为开发 MCP 服务器的主要语言，因为它拥有丰富的库和简洁的语法。同时，我们会使用一个流行的 MCP 客户端来测试我们的服务器。

2.1 基础环境要求

• 操作系统：Windows 10/11, macOS, 或 Linux (如 Ubuntu 20.04+)。
• Python：版本 3.8 或更高。这是开发 MCP 服务器的推荐语言。
• 包管理工具：pip(通常随 Python 安装)。
• 代码编辑器或 IDE：VS Code (推荐，因其对 AI 和 MCP 有良好支持)、PyCharm 等。
• 终端：用于运行命令。

2.2 安装 MCP 协议 Python SDK

MCP 协议本身是语言无关的，但为了方便开发，社区提供了各种语言的 SDK。我们将使用官方推荐的mcpPython 库。

打开你的终端，创建一个新的虚拟环境（推荐，以避免包冲突），并安装 SDK：

# 创建并进入项目目录 mkdir my-mcp-server && cd my-mcp-server # 创建 Python 虚拟环境 (可选但推荐) python -m venv .venv # 激活虚拟环境 # Windows: .venv\Scripts\activate # macOS/Linux: source .venv/bin/activate # 安装 mcp 库 pip install mcp

这个mcp库提供了构建 MCP 服务器所需的所有工具和类型定义。

2.3 安装 MCP 客户端（用于测试）

为了测试我们开发的服务器，我们需要一个 MCP 客户端。这里有几个选择：

1. Claude Desktop：Anthropic 官方的 Claude 应用，内置 MCP 客户端支持。最简单，适合初学者测试。
2. Cursor或Windsurf：集成了 AI 的代码编辑器，支持 MCP。
3. Node.js MCP 客户端：适合开发者进行更底层的测试。

对于快速入门，推荐使用Claude Desktop。从 Anthropic 官网下载安装后，需要在配置文件中声明要使用的 MCP 服务器。

2.4 项目结构初始化

我们的示例项目结构将如下所示：

my-mcp-server/ ├── .venv/ # Python 虚拟环境 (可选) ├── simple_server.py # 简单的 MCP 服务器示例 ├── calculator_server.py # 计算器功能服务器示例 ├── requirements.txt # Python 依赖列表 └── README.md # 项目说明

现在，环境已经就绪，我们可以开始探索 MCP 的核心组件了。

3. MCP 核心组件与协议拆解

理解 MCP 的通信模型和核心组件，是开发和调试服务器的基础。MCP 协议基于 JSON-RPC，通过标准输入输出（STDIO）或服务器发送事件（SSE）进行通信。

3.1 通信模型：客户端与服务器

MCP 采用请求-响应模型。客户端（AI 应用）是发起方，服务器是响应方。

+----------------+ JSON-RPC over STDIO/SSE +------------------+ | | ------------------------------> | | | MCP Client | | MCP Server | | (e.g., Claude)| <------------------------------ | (e.g., Calculator)| | | | | +----------------+ +------------------+ | | | 1. 初始化握手 (`initialize`) | |--------------------------------------------------->| |<---------------------------------------------------| 2. 返回能力列表 (`initialized`) | | | 3. 请求可用工具列表 (`tools/list`) | |--------------------------------------------------->| |<---------------------------------------------------| 4. 返回工具定义 (`tools/list` 响应) | | | 5. 调用工具 `add` (`tools/call`) | |--------------------------------------------------->| |<---------------------------------------------------| 6. 返回结果 `5` (`tools/call` 响应)

所有消息都是 JSON 格式的 RPC 请求或通知。

3.2 关键协议接口

MCP 定义了几个核心的 JSON-RPC 方法：

1. initialize&initialized：握手过程。客户端发送initialize请求，服务器回复initialized通知，并附带服务器提供的协议版本和能力信息。
2. tools/list：客户端调用此方法请求服务器公开的所有工具列表。服务器返回一个工具描述数组。
3. tools/call：客户端调用此方法来实际执行一个工具。请求中包含工具名和输入参数。服务器执行后返回结果或错误。
4. resources/list/resources/read：（可选）用于提供静态或动态的上下文资源（如文档片段）。本文重点在工具，资源部分暂不展开。
5. notifications：（可选）服务器可以向客户端发送通知，例如提示进度更新。

3.3 工具（Tool）的定义

工具是 MCP 服务器的核心产出。每个工具都需要一个清晰的定义：

{ "name": "calculate", "description": "执行一个简单的数学计算。支持加(+)、减(-)、乘(*)、除(/)。", "inputSchema": { "type": "object", "properties": { "expression": { "type": "string", "description": "数学表达式，例如 '3 + 5 * 2'" } }, "required": ["expression"] } }

• name：工具的唯一标识符，客户端通过此名称调用工具。
• description：对工具功能的自然语言描述。这至关重要，因为 AI 智能体会根据描述来决定是否以及如何使用该工具。
• inputSchema：一个 JSON Schema 对象，严格定义了调用此工具所需的参数。这为 AI 提供了结构化的指导，确保它能生成正确的调用参数。

理解了这些基础，我们就可以动手创建第一个 MCP 服务器了。

4. 实战：构建你的第一个 MCP 服务器

我们将从最简单的“回声”服务器开始，逐步构建一个功能更完整的计算器服务器。

4.1 示例一：简单的“回声”服务器

这个服务器只提供一个工具：echo，它将客户端发送的文本原样返回。

创建文件simple_server.py：

#!/usr/env python3 import asyncio import sys from mcp import Client, Server from mcp.types import Tool, TextContent # 创建 MCP 服务器实例 server = Server() # 定义我们的工具 @server.list_tools() async def handle_list_tools(): """返回服务器提供的工具列表""" tools = [ Tool( name="echo", description="将输入的文本原样返回。用于测试连接。", inputSchema={ "type": "object", "properties": { "message": { "type": "string", "description": "需要被回显的文本信息" } }, "required": ["message"] } ) ] return tools @server.call_tool() async def handle_call_tool(name: str, arguments: dict): """处理工具调用请求""" if name == "echo": message = arguments.get("message", "") # 返回结果。MCP 要求结果是一个 Content 对象列表，这里我们返回文本内容。 return [TextContent(type="text", text=f"服务器收到并返回：{message}")] else: # 如果工具名未找到，抛出错误 raise ValueError(f"未知工具: {name}") async def main(): """主函数，启动服务器""" # 使用标准输入输出与客户端通信 stdin = sys.stdin.buffer stdout = sys.stdout.buffer # 运行服务器 await server.run(stdin=stdin, stdout=stdout, debug=True) # debug=True 会打印通信日志 if __name__ == "__main__": asyncio.run(main())

代码解释：

1. from mcp import Server：导入 MCP SDK 的服务器类。
2. server = Server()：创建一个服务器实例。
3. @server.list_tools()：这是一个装饰器，用于注册处理tools/list请求的函数。该函数返回一个Tool对象列表。
4. @server.call_tool()：注册处理tools/call请求的函数。参数name是工具名，arguments是客户端传来的参数字典。
5. TextContent：MCP 定义的一种内容类型，表示纯文本结果。
6. server.run()：启动服务器，绑定到标准输入输出。这是 MCP 服务器最常见的运行方式。

运行与测试： 由于 MCP 服务器设计为通过 STDIO 与客户端通信，直接运行python simple_server.py会立刻等待输入。我们需要通过客户端来测试。为了快速验证，我们可以写一个极简的测试脚本，或者使用像mcp-cli这样的测试工具。但更直接的方法是将其配置到 Claude Desktop 中。

4.2 配置 Claude Desktop 使用自定义服务器

1. 找到 Claude Desktop 的配置文件位置：
   • macOS:~/Library/Application Support/Claude/claude_desktop_config.json
   • Windows:%APPDATA%\Claude\claude_desktop_config.json
2. 编辑该 JSON 文件（如果不存在则创建）：

   { "mcpServers": { "my-echo-server": { "command": "python", "args": [ "/ABSOLUTE/PATH/TO/your/my-mcp-server/simple_server.py" ], "env": { "PYTHONPATH": "/ABSOLUTE/PATH/TO/your/my-mcp-server" } } } }

   注意：必须使用绝对路径。args是启动服务器的命令参数。
3. 重启 Claude Desktop。
4. 在 Claude 的对话窗口中，你现在可以尝试说：“请使用 echo 工具，发送消息 ‘Hello MCP!’”。Claude 应该会识别到这个工具并调用它，返回结果。

4.3 示例二：功能完整的计算器服务器

现在我们来构建一个更实用的服务器，提供数学计算和单位转换工具。

创建文件calculator_server.py：

#!/usr/env python3 import asyncio import sys import math from mcp import Server from mcp.types import Tool, TextContent server = Server() @server.list_tools() async def handle_list_tools(): """返回计算器服务器的工具列表""" tools = [ Tool( name="calculate", description="计算一个数学表达式的结果。支持加减乘除(+, -, *, /)、乘方(**)、括号和常见数学函数如sin, cos, sqrt, log。", inputSchema={ "type": "object", "properties": { "expression": { "type": "string", "description": "数学表达式，例如 '(3 + 5) * 2 / sqrt(4)'" } }, "required": ["expression"] } ), Tool( name="convert_units", description="在常见单位之间进行转换。", inputSchema={ "type": "object", "properties": { "value": { "type": "number", "description": "要转换的数值" }, "from_unit": { "type": "string", "description": "原单位，支持: m, km, mile, kg, lb, °C, °F, L, gal", "enum": ["m", "km", "mile", "kg", "lb", "°C", "°F", "L", "gal"] }, "to_unit": { "type": "string", "description": "目标单位，支持: m, km, mile, kg, lb, °C, °F, L, gal", "enum": ["m", "km", "mile", "kg", "lb", "°C", "°F", "L", "gal"] } }, "required": ["value", "from_unit", "to_unit"] } ) ] return tools @server.call_tool() async def handle_call_tool(name: str, arguments: dict): """处理工具调用""" try: if name == "calculate": expression = arguments["expression"] # 警告：在生产环境中，直接使用 eval 是极度危险的！ # 这里仅作演示。实际应用应使用安全的表达式求值库（如 ast.literal_eval 配合自定义解析器）。 # 为了示例安全，我们限制在一个非常小的安全命名空间内。 safe_globals = {"__builtins__": None} safe_locals = { "sin": math.sin, "cos": math.cos, "tan": math.tan, "sqrt": math.sqrt, "log": math.log, "log10": math.log10, "pi": math.pi, "e": math.e, } # 更安全的做法是使用像 `asteval` 这样的库 result = eval(expression, {"__builtins__": None}, safe_locals) return [TextContent(type="text", text=f"表达式 `{expression}` 的计算结果是: {result}")] elif name == "convert_units": value = arguments["value"] from_unit = arguments["from_unit"] to_unit = arguments["to_unit"] # 定义转换因子 conversions = { ("km", "m"): 1000, ("m", "km"): 1/1000, ("mile", "km"): 1.60934, ("km", "mile"): 1/1.60934, ("kg", "lb"): 2.20462, ("lb", "kg"): 1/2.20462, ("°C", "°F"): lambda c: c * 9/5 + 32, ("°F", "°C"): lambda f: (f - 32) * 5/9, ("L", "gal"): 0.264172, ("gal", "L"): 1/0.264172, } # 相同单位 if from_unit == to_unit: converted = value # 处理温度转换（非线性） elif (from_unit, to_unit) in [("°C", "°F"), ("°F", "°C")]: func = conversions[(from_unit, to_unit)] converted = func(value) # 处理其他单位转换 elif (from_unit, to_unit) in conversions: factor = conversions[(from_unit, to_unit)] converted = value * factor else: # 尝试通过中间单位（如米）进行转换 # 简化逻辑：假设所有长度单位可通过米转换，所有重量通过千克... # 实际项目需要更完善的转换图 raise ValueError(f"暂不支持从 {from_unit} 到 {to_unit} 的直接转换。") return [TextContent(type="text", text=f"{value} {from_unit} = {converted:.4f} {to_unit}")] else: raise ValueError(f"未知工具: {name}") except Exception as e: # 将异常信息返回给客户端 return [TextContent(type="text", text=f"工具调用出错: {str(e)}")] async def main(): stdin = sys.stdin.buffer stdout = sys.stdout.buffer await server.run(stdin=stdin, stdout=stdout, debug=False) # 生产环境建议关闭debug if __name__ == "__main__": asyncio.run(main())

关键改进点：

1. 多个工具：服务器现在提供了calculate和convert_units两个工具。
2. 详细的输入模式：convert_units工具使用了enum来限定可用的单位，这为 AI 提供了明确的选项，减少了调用错误。
3. 错误处理：try...except块捕获工具执行中的异常，并将错误信息以友好的方式返回给客户端，而不是让整个服务器崩溃。
4. 安全警告：代码中明确注释了eval的安全风险。在真实的、暴露给不受信任输入的服务器中，绝对不允许直接使用eval。应使用ast.literal_eval或专门的数学表达式解析库（如asteval）。

将这个服务器也配置到 Claude Desktop 的mcpServers中（可以配置多个），重启后，你就可以让 Claude 进行复杂的计算和单位转换了。例如：“请计算 sin(pi/4) + log10(100) 的值” 或 “请将 5 英里转换成公里”。

5. 进阶：连接真实服务与处理状态

无状态服务器并不意味着不能与有状态的后端服务交互。服务器的“无状态”是指其与 AI 客户端的会话无状态，但它自身可以维护连接池、缓存或连接到数据库。

5.1 示例：连接 SQLite 数据库的 MCP 服务器

这是一个更接近实际应用的例子。服务器将提供查询和操作 SQLite 数据库的工具。

创建文件sqlite_server.py：

#!/usr/env python3 import asyncio import sys import sqlite3 import json from pathlib import Path from typing import Optional from mcp import Server from mcp.types import Tool, TextContent server = Server() # 我们可以将数据库路径作为配置或上下文管理，这里简化为固定路径。 # 实际应用中，可以通过环境变量或客户端初始化参数传递。 DB_PATH = Path("./example.db") def init_database(): """初始化示例数据库""" if not DB_PATH.exists(): conn = sqlite3.connect(DB_PATH) cursor = conn.cursor() cursor.execute(""" CREATE TABLE IF NOT EXISTS tasks ( id INTEGER PRIMARY KEY AUTOINCREMENT, title TEXT NOT NULL, description TEXT, status TEXT DEFAULT 'pending', created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ) """) cursor.execute("INSERT INTO tasks (title, description) VALUES (?, ?)", ("学习 MCP", "阅读官方文档")) cursor.execute("INSERT INTO tasks (title, description, status) VALUES (?, ?, ?)", ("编写服务器", "完成 SQLite 示例", "in_progress")) conn.commit() conn.close() print(f"数据库已初始化于 {DB_PATH.absolute()}", file=sys.stderr) @server.list_tools() async def handle_list_tools(): tools = [ Tool( name="query_tasks", description="查询任务列表。可以按状态过滤。", inputSchema={ "type": "object", "properties": { "status": { "type": "string", "description": "过滤任务状态，可选值: 'all', 'pending', 'in_progress', 'done'。默认为 'all'。", "enum": ["all", "pending", "in_progress", "done"] }, "limit": { "type": "integer", "description": "返回结果的最大数量。默认为 10。" } }, "required": [] } ), Tool( name="add_task", description="添加一个新任务。", inputSchema={ "type": "object", "properties": { "title": { "type": "string", "description": "任务标题" }, "description": { "type": "string", "description": "任务详细描述" } }, "required": ["title"] } ), Tool( name="update_task_status", description="更新指定任务的状态。", inputSchema={ "type": "object", "properties": { "task_id": { "type": "integer", "description": "要更新的任务ID" }, "new_status": { "type": "string", "description": "新的状态", "enum": ["pending", "in_progress", "done"] } }, "required": ["task_id", "new_status"] } ) ] return tools @server.call_tool() async def handle_call_tool(name: str, arguments: dict): try: conn = sqlite3.connect(DB_PATH) conn.row_factory = sqlite3.Row # 以字典形式返回行 cursor = conn.cursor() if name == "query_tasks": status = arguments.get("status", "all") limit = arguments.get("limit", 10) query = "SELECT id, title, description, status, created_at FROM tasks" params = [] if status != "all": query += " WHERE status = ?" params.append(status) query += " ORDER BY created_at DESC LIMIT ?" params.append(limit) cursor.execute(query, params) rows = cursor.fetchall() if not rows: result_text = "未找到任务。" else: tasks = [dict(row) for row in rows] result_text = json.dumps(tasks, indent=2, ensure_ascii=False, default=str) return [TextContent(type="text", text=result_text)] elif name == "add_task": title = arguments["title"] description = arguments.get("description", "") cursor.execute( "INSERT INTO tasks (title, description) VALUES (?, ?)", (title, description) ) task_id = cursor.lastrowid conn.commit() return [TextContent(type="text", text=f"任务添加成功！ID: {task_id}")] elif name == "update_task_status": task_id = arguments["task_id"] new_status = arguments["new_status"] cursor.execute( "UPDATE tasks SET status = ? WHERE id = ?", (new_status, task_id) ) if cursor.rowcount == 0: return [TextContent(type="text", text=f"未找到 ID 为 {task_id} 的任务。")] conn.commit() return [TextContent(type="text", text=f"任务 {task_id} 状态已更新为 '{new_status}'。")] else: raise ValueError(f"未知工具: {name}") except sqlite3.Error as e: return [TextContent(type="text", text=f"数据库操作失败: {str(e)}")] except Exception as e: return [TextContent(type="text", text=f"工具调用出错: {str(e)}")] finally: conn.close() async def main(): # 确保数据库存在 init_database() stdin = sys.stdin.buffer stdout = sys.stdout.buffer await server.run(stdin=stdin, stdout=stdout) if __name__ == "__main__": asyncio.run(main())

这个示例展示了：

1. 外部资源连接：服务器在启动时初始化并连接到一个 SQLite 数据库文件。
2. 安全的参数化查询：使用?占位符进行参数化查询，有效防止 SQL 注入攻击。这是与 AI 交互时必须遵守的安全铁律，因为 AI 生成的输入可能不可预测。
3. 复杂的工具交互：提供了查询、插入、更新等多个工具，AI 可以组合使用它们来管理一个简单的任务列表。
4. 结构化输出：查询结果以 JSON 格式返回，便于 AI 客户端解析和呈现。

通过这个服务器，AI 智能体就获得了管理一个简易数据库的能力，而这一切都无需修改智能体本身的任何代码。

6. 常见问题与排查思路

在开发和集成 MCP 服务器时，你可能会遇到一些问题。以下是一些常见问题及其解决方法。

7. 最佳实践与工程建议

将 MCP 服务器用于生产环境或团队协作时，遵循以下最佳实践可以提升可靠性、安全性和可维护性。

7.1 设计与开发阶段

1. 单一职责：一个 MCP 服务器应专注于一个明确的领域（如“数据库操作”、“天气查询”、“代码仓库管理”）。这符合 Unix 哲学，也便于维护和权限控制。
2. 清晰的工具定义：
   • 名称：使用动词开头，如search_web,create_file,query_database。
   • 描述：详细说明工具做什么、输入是什么、输出是什么。好的描述是 AI 能否正确使用工具的关键。
   • 输入模式：尽可能严格。使用enum提供选项，使用pattern验证字符串格式，为数字设置minimum/maximum。
3. 防御性编程：
   • 验证所有输入：即使 Schema 已定义，服务器端代码也应再次验证关键参数。
   • 安全的错误处理：不要将内部异常堆栈信息直接返回给客户端。返回对用户（AI）友好的错误消息，同时将详细错误记录到服务器日志。
   • 资源管理：确保数据库连接、文件句柄、网络连接在使用后正确关闭（使用try...finally或上下文管理器）。

7.2 安全与权限

1. 最小权限原则：运行 MCP 服务器的操作系统用户应具有尽可能少的权限。例如，一个只读的数据查询服务器不应有写文件权限。
2. 输入消毒与参数化：这是最重要的安全规则。永远不要拼接字符串来生成 SQL、Shell 命令或文件路径。
3. 网络隔离：如果服务器需要访问内部网络服务，应将其部署在相应的网络区域，并配置严格的防火墙规则。
4. 审计与日志：记录所有工具调用的元数据（如工具名、调用时间、调用者标识（如果客户端提供）、关键参数（脱敏后））。这对于调试和审计至关重要。

7.3 部署与运维

1. 配置化：不要将数据库密码、API 密钥等硬编码在代码中。使用环境变量、配置文件或安全的密钥管理服务。
2. 进程管理：使用像systemd(Linux)、launchd(macOS) 或进程管理器（如pm2）来管理服务器进程，确保崩溃后能自动重启。
3. 版本化与发布：将你的 MCP 服务器代码纳入版本控制（如 Git）。可以考虑将其打包为 Docker 镜像，以实现环境一致性。
4. 监控与健康检查：为服务器实现一个简单的健康检查端点（例如，一个不依赖外部服务的简单工具），方便监控系统探测其存活状态。

7.4 与 AI 客户端的协作优化

1. 提供示例：在工具的description中或通过resources提供调用示例，可以显著提高 AI 首次调用的成功率。
2. 处理复杂输出：如果工具返回大量结构化数据，考虑提供分页、过滤或摘要工具，避免让 AI 一次性处理过多信息。
3. 无状态设计：牢记“无状态更新”原则。不要在服务器内存中存储与特定 AI 会话相关的上下文。所有必要的状态都应通过每次调用的参数传递，或持久化到外部存储（数据库、文件）。

通过 MCP 协议和“无状态更新”理念，我们为 AI 智能体构建了一套可插拔、可扩展、安全的基础设施。开发者可以像搭积木一样，为智能体组合所需的能力，而无需担心核心模型的改动。从简单的计算器到复杂的数据库操作，MCP 将智能体的“思考”与“行动”优雅地分离，这正是构建下一代可靠、强大 AI 应用的关键。现在，你可以尝试将搜索 API、绘图库、邮件服务甚至内部业务系统封装成 MCP 服务器，让你的 AI 助手真正成为全能的工作伙伴。