面向客户端开发者

开始构建您自己的客户端，以便与所有 MCP 服务器集成。

在本教程中，您将学习如何构建一个由 LLM 驱动的聊天机器人客户端，并将其连接到 MCP 服务器。在此之前，建议您先阅读 服务器快速入门，该指南将帮助您完成搭建第一个服务器的基础知识。

支持的语言：

  • Python
  • Node
  • Java

本教程的完整代码可在此找到。

系统要求

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

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

设置开发环境

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

  1. # 创建项目目录
  2. uv init mcp-client
  3. cd mcp-client
  5. # 创建虚拟环境
  6. uv venv
  8. # 激活虚拟环境
  9. # 在 Windows 上：
  10. .venv\Scripts\activate
  11. # 在 Unix 或 macOS 上：
  12. source .venv/bin/activate
  14. # 安装所需的依赖包
  15. uv add mcp anthropic python-dotenv
  17. # 移除默认生成的示例文件
  18. rm hello.py
  20. # 创建我们的主文件
  21. touch client.py

配置 API 密钥

您需要从 Anthropic 控制台 获取一个 API 密钥。

创建 .env 文件以存储密钥：

  1. # 创建 .env 文件
  2. touch .env

在 .env 文件中添加您的密钥：

  1. ANTHROPIC_API_KEY=<your key here>

然后将 .env 文件添加到 .gitignore，避免泄露密钥：

  1. echo ".env" >> .gitignore

请确保您的 ANTHROPIC_API_KEY 处于安全状态！

创建客户端

基本的客户端结构

首先，设置必要的导入，并创建基本的客户端类：

  1. import asyncio
  2. from typing import Optional
  3. from contextlib import AsyncExitStack
  5. from mcp import ClientSession, StdioServerParameters
  6. from mcp.client.stdio import stdio_client
  8. from anthropic import Anthropic
  9. from dotenv import load_dotenv
  11. load_dotenv()  # 从 .env 文件加载环境变量
  13. class MCPClient:
  14.     def __init__(self):
  15.         # 初始化会话和客户端对象
  16.         self.session: Optional[ClientSession] = None
  17.         self.exit_stack = AsyncExitStack()
  18.         self.anthropic = Anthropic()
  19.     # 方法将在这里定义

管理服务器连接

接下来，我们实现连接 MCP 服务器的方法：

  1. async def connect_to_server(self, server_script_path: str):
  2.     """连接到 MCP 服务器
  4.     参数:
  5.         server_script_path: 服务器脚本文件的路径 (.py 或 .js)
  6.     """
  7.     is_python = server_script_path.endswith('.py')
  8.     is_js = server_script_path.endswith('.js')
  9.     if not (is_python or is_js):
  10.         raise ValueError("服务器脚本必须是 .py 或 .js 文件")
  12.     command = "python" if is_python else "node"
  13.     server_params = StdioServerParameters(
  14.         command=command,
  15.         args=[server_script_path],
  16.         env=None
  17.     )
  19.     stdio_transport = await self.exit_stack.enter_async_context(stdio_client(server_params))
  20.     self.stdio, self.write = stdio_transport
  21.     self.session = await self.exit_stack.enter_async_context(ClientSession(self.stdio, self.write))
  23.     await self.session.initialize()
  25.     # 列出可用工具
  26.     response = await self.session.list_tools()
  27.     tools = response.tools
  28.     print("\n成功连接服务器，以下是可用工具:", [tool.name for tool in tools])

处理查询请求

现在，添加核心功能，用于处理用户查询并调用服务器提供的工具：

  1. async def process_query(self, query: str) -> str:
  2.     """使用 Claude 和可用工具处理查询"""
  3.     messages = [
  4.         {
  5.             "role": "user",
  6.             "content": query
  7.         }
  8.     ]
  10.     response = await self.session.list_tools()
  11.     available_tools = [{
  12.         "name": tool.name,
  13.         "description": tool.description,
  14.         "input_schema": tool.inputSchema
  15.     } for tool in response.tools]
  17.     # 调用 Claude API 处理初始查询
  18.     response = self.anthropic.messages.create(
  19.         model="claude-3-5-sonnet-20241022",
  20.         max_tokens=1000,
  21.         messages=messages,
  22.         tools=available_tools
  23.     )
  25.     # 处理响应，并执行工具调用
  26.     final_text = []
  27.     assistant_message_content = []
  29.     for content in response.content:
  30.         if content.type == 'text':
  31.             final_text.append(content.text)
  32.             assistant_message_content.append(content)
  33.         elif content.type == 'tool_use':
  34.             tool_name = content.name
  35.             tool_args = content.input
  37.             # 执行工具调用
  38.             result = await self.session.call_tool(tool_name, tool_args)
  39.             final_text.append(f"[调用工具 {tool_name} 参数: {tool_args}]")
  41.             assistant_message_content.append(content)
  42.             messages.append({
  43.                 "role": "assistant",
  44.                 "content": assistant_message_content
  45.             })
  46.             messages.append({
  47.                 "role": "user",
  48.                 "content": [
  49.                     {
  50.                         "type": "tool_result",
  51.                         "tool_use_id": content.id,
  52.                         "content": result.content
  53.                     }
  54.                 ]
  55.             })
  57.             # 获取 Claude 的后续响应
  58.             response = self.anthropic.messages.create(
  59.                 model="claude-3-5-sonnet-20241022",
  60.                 max_tokens=1000,
  61.                 messages=messages,
  62.                 tools=available_tools
  63.             )
  65.             final_text.append(response.content[0].text)
  67.     return "\n".join(final_text)

交互式聊天界面

  1. async def chat_loop(self):
  2.     """运行交互式聊天"""
  3.     print("\nMCP 客户端已启动!")
  4.     print("请输入查询，或输入 'quit' 退出。")
  6.     while True:
  7.         try:
  8.             query = input("\n输入查询: ").strip()
  10.             if query.lower() == 'quit':
  11.                 break
  13.             response = await self.process_query(query)
  14.             print("\n" + response)
  16.         except Exception as e:
  17.             print(f"\n错误: {str(e)}")

运行客户端

要运行您的客户端，并连接到 MCP 服务器：

  1. uv run client.py path/to/server.py # 连接 Python 服务器
  2. uv run client.py path/to/build/index.js # 连接 Node 服务器

如果您正在继续服务器快速入门教程（例如天气查询服务器），命令可能如下：

  1. python client.py .../weather/src/weather/server.py

客户端将会：

  1. 连接到指定服务器
  2. 列出可用工具
  3. 启动交互式聊天，支持：
    • 发送查询
    • 执行工具调用
    • 获取 Claude 生成的回复

常见问题排查

服务器路径问题

  • 确保服务器脚本路径正确
  • 如果相对路径无效，请使用绝对路径
  • Windows 用户请使用 / 或 \\ 作为路径分隔符

示例：

  1. # 相对路径
  2. uv run client.py ./server/weather.py
  4. # 绝对路径
  5. uv run client.py /Users/username/projects/mcp-server/weather.py
  7. # Windows 路径
  8. uv run client.py C:/projects/mcp-server/weather.py
  9. uv run client.py C:\\projects\\mcp-server\\weather.py

响应延迟

  • 首次查询可能需要 30 秒返回（服务器初始化、Claude 处理查询）
  • 后续查询通常更快
  • 避免在初始加载期间中断进程

这样，您就可以使用 MCP 搭建自己的 LLM 驱动的聊天机器人客户端了！ 🚀