从零构建AI Agent：基于MCP协议实现智能工具调用与自动化

最近在尝试将AI能力集成到自己的项目中，发现单纯调用大模型API往往不够用——想让AI真正“动手”操作文件、查询数据库、调用外部工具，需要一套标准化的连接协议。这正是MCP（Model Context Protocol）和Agent技术要解决的核心问题。本文将从零开始，带你构建一个能理解指令、调用工具、完成实际任务的智能Agent，并深入解析MCP协议如何成为连接AI大脑与外部世界的“神经系统”。无论你是想为现有项目添加AI自动化能力，还是探索下一代AI应用架构，这篇实战指南都能提供一条清晰的路径。

1. 背景与核心概念：为什么需要MCP与Agent？

在深入代码之前，我们有必要厘清几个关键概念，理解它们为何成为当前AI工程化的热点。

AI Agent（智能体）是什么？你可以把它想象成一个具备一定自主性的“数字员工”。它不仅仅是一个问答模型，而是一个能够感知环境（通过输入）、进行思考（规划与决策）、执行动作（调用工具）并达成目标的系统。一个典型的Agent工作流程是：接收用户指令 -> 分析指令并规划步骤 -> 调用合适的工具执行动作 -> 评估结果并决定下一步 -> 最终输出结果。

MCP（Model Context Protocol）又是什么？它是连接AI模型（尤其是大语言模型）与外部工具、数据源的一套开放协议。你可以把它理解为AI世界的“USB标准”或“插件协议”。在没有MCP之前，每个AI应用想要连接新工具（如搜索引擎、数据库、图形界面），都需要编写特定的、紧耦合的集成代码，过程繁琐且难以复用。MCP定义了一套标准的通信方式，让工具（称为MCP Server）可以以一种模型能理解的方式“自我介绍”（暴露工具列表和参数），而模型或Agent（作为MCP Client）则可以动态发现并调用这些工具。

核心关系：Agent是“大脑”和“执行者”，而MCP是“手”和“眼睛”的标准化连接方式。一个强大的Agent可以利用MCP协议，轻松接入海量工具，从而扩展其能力边界。

常见应用场景：

• 代码助手增强：让AI不仅能写代码，还能直接运行测试、查询文档、提交Git。
• 自动化工作流：自动处理邮件、整理文档、生成报表并发送。
• 智能数据分析：连接数据库，根据自然语言查询生成SQL并可视化结果。
• 跨软件操作：控制设计软件（如Blender）、办公软件，实现跨平台自动化。

接下来，我们将从环境搭建开始，一步步构建一个实战项目。

2. 环境准备与版本说明

本教程将以一个Python环境下的经典Agent框架为例进行构建，同时演示MCP Server的开发。请确保你的环境满足以下要求：

• 操作系统：Windows 10/11, macOS 10.15+, 或主流Linux发行版（如Ubuntu 20.04+）。本文命令以Linux/macOS的bash为例，Windows用户可在PowerShell或WSL中运行。
• Python：版本 3.8 - 3.11。推荐使用3.10以获得最佳兼容性。使用python --version或python3 --version检查。
• 包管理工具：pip最新版。
• 代码编辑器：VS Code（推荐，因其对AI工具有良好的扩展支持）或任何你熟悉的IDE。
• （可选）Node.js：部分MCP工具或前端示例可能需要，版本16+即可。

我们将使用两个核心Python库：

1. LangChain：一个广泛使用的Agent和LLM应用开发框架，提供了构建Agent所需的各种组件。
2. MCP SDK：用于快速开发MCP Server和Client。我们将使用mcp库。

首先，创建一个干净的虚拟环境并安装依赖：

# 创建项目目录并进入 mkdir ai-agent-tutorial && cd ai-agent-tutorial # 创建Python虚拟环境（可选但强烈推荐） python3 -m venv venv # 激活虚拟环境 # Linux/macOS: source venv/bin/activate # Windows: # venv\Scripts\activate # 安装核心依赖 pip install langchain langchain-openai mcp # 安装额外的工具库（用于后续示例） pip install requests python-dotenv duckduckgo-search

版本说明：本文基于langchain==0.1.0以上版本（采用新式API），mcp库使用其官方Python SDK。请注意，AI领域库更新迅速，核心逻辑不变，但具体API可能微调。如果遇到问题，请查阅对应库的最新官方文档。

3. 核心原理与架构拆解

3.1 Agent的核心组件：ReAct模式

一个典型的Agent遵循ReAct (Reason + Act)模式，其思维过程可以简化为：

1. Thought（思考）：分析当前情况、用户目标和可用工具，决定下一步做什么。
2. Action（行动）：选择一个工具并传入合适的参数。
3. Observation（观察）：获取工具执行的结果。
4. 循环1-3步，直到得出最终答案。

在LangChain中，这通过AgentExecutor和Tool等组件来实现。

3.2 MCP协议的核心概念

MCP协议主要包含两类角色：

• MCP Server（服务器）：提供工具的一方。它向客户端宣告自己有哪些工具（tools/list），每个工具的名称、描述和参数格式。当客户端调用工具（tools/call）时，服务器执行具体逻辑并返回结果。
• MCP Client（客户端）：使用工具的一方。通常是AI模型或Agent。它向服务器请求工具列表，并根据需要调用它们。

通信通常通过标准输入输出(stdin/stdout)、HTTP或SSE (Server-Sent Events)进行，这使得MCP可以与任何语言、任何进程边界的组件集成。

4. 实战一：构建你的第一个简单Agent

我们先不涉及MCP，用LangChain内置工具构建一个能进行简单计算和网络搜索的Agent，熟悉基本流程。

4.1 设置API密钥

我们需要一个大语言模型作为Agent的“大脑”。这里使用OpenAI的GPT模型。请准备你的OPENAI_API_KEY。

创建一个.env文件来管理密钥（确保该文件在.gitignore中）：

# .env OPENAI_API_KEY=你的实际api密钥

然后在Python代码中加载：

# config.py 或直接在主文件中 import os from dotenv import load_dotenv load_dotenv() # 加载 .env 文件中的环境变量 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") if not OPENAI_API_KEY: raise ValueError("请在 .env 文件中设置 OPENAI_API_KEY")

4.2 创建工具（Tool）

工具是Agent能力的延伸。我们创建两个工具：一个计算器，一个网络搜索。

# tools.py from langchain.tools import Tool from langchain_community.tools import DuckDuckGoSearchRun import math def calculate(expression: str) -> str: """计算一个数学表达式。支持 +, -, *, /, **, sqrt等。""" try: # 安全警告：在生产环境中，应对expression做严格检查和沙箱执行，避免任意代码执行。 # 这里为演示简化处理。 result = eval(expression, {"__builtins__": None}, {"math": math}) return str(result) except Exception as e: return f"计算错误: {e}" # 将函数包装成LangChain Tool calculator_tool = Tool( name="Calculator", func=calculate, description="用于计算数学表达式。输入应为一个有效的Python数学表达式字符串，例如 '3 + 5*2' 或 'math.sqrt(16)'。" ) # 使用LangChain社区集成的搜索工具 search_tool = DuckDuckGoSearchRun() # 也可以包装成统一的Tool对象 search_tool = Tool( name="Web_Search", func=search_tool.run, description="用于在互联网上搜索最新信息。输入是一个搜索查询词。" )

4.3 构建Agent并运行

现在，我们将模型、工具组合成Agent。

# simple_agent.py import os from dotenv import load_dotenv from langchain_openai import ChatOpenAI from langchain.agents import initialize_agent, AgentType from langchain.memory import ConversationBufferMemory from tools import calculator_tool, search_tool load_dotenv() # 1. 初始化LLM llm = ChatOpenAI( model="gpt-3.5-turbo", # 或 "gpt-4" temperature=0, # 降低随机性，使Agent更稳定 openai_api_key=os.getenv("OPENAI_API_KEY") ) # 2. 初始化记忆（使Agent能记住对话上下文） memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) # 3. 定义工具列表 tools = [calculator_tool, search_tool] # 4. 初始化Agent # 使用ZERO_SHOT_REACT_DESCRIPTION，这是一个通用的ReAct模式Agent类型 agent = initialize_agent( tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, memory=memory, verbose=True, # 设为True可以看到Agent的思考过程（Thought/Action/Observation） handle_parsing_errors=True # 更好地处理解析错误 ) # 5. 运行Agent if __name__ == "__main__": queries = [ "珠穆朗玛峰的高度是多少米？", "把这个高度加上1000米，然后换算成英尺。", "刚才我们说的英尺数，它的平方根是多少？" ] for query in queries: print(f"\n用户: {query}") response = agent.run(query) print(f"Agent: {response}")

运行这个脚本 (python simple_agent.py)，你将看到类似以下的输出，清晰地展示了Agent的思考链：

用户: 珠穆朗玛峰的高度是多少米？ > Entering new AgentExecutor chain... Thought: 我需要搜索珠穆朗玛峰的当前公认高度。 Action: Web_Search Action Input: 珠穆朗玛峰 高度 米 Observation: 珠穆朗玛峰的最新测量高度为8848.86米（2020年公布）。 Thought: 我已经得到了高度信息，可以回答用户了。 Action: Final Answer Action Input: 珠穆朗玛峰的高度是8848.86米。 > Finished chain. Agent: 珠穆朗玛峰的高度是8848.86米。

这个Agent已经能够自主决定何时搜索、何时计算，并利用记忆关联多个问题。

5. 实战二：开发一个自定义MCP Server

现在，我们进入MCP部分。我们将把一个本地功能（例如：读写特定目录下的文件）封装成MCP Server，这样任何兼容MCP的客户端（如Claude Desktop、Cursor IDE或我们自己的Agent）都可以调用它。

5.1 理解MCP Server的基本结构

一个MCP Server需要：

1. 实现特定的协议接口（列出工具、调用工具）。
2. 通过标准IO与客户端通信。
3. 定义清晰的工具（名称、描述、输入模式）。

我们将使用官方mcpPython库来简化开发。

5.2 创建文件操作MCP Server

# mcp_file_server.py import json import sys import os from typing import Any, List from mcp import Server, types # 导入MCP SDK # 初始化MCP Server，使用标准输入输出进行通信 server = Server() # 定义Server提供的工具列表 @server.list_tools() async def handle_list_tools() -> List[types.Tool]: """返回此Server提供的所有工具的描述。""" return [ types.Tool( name="read_file", description="读取指定路径的文本文件内容。", inputSchema={ "type": "object", "properties": { "filepath": { "type": "string", "description": "要读取的文件的绝对路径或相对于当前工作目录的路径。" } }, "required": ["filepath"] } ), types.Tool( name="write_file", description="向指定路径的文本文件写入内容。如果文件不存在则创建，存在则覆盖。", inputSchema={ "type": "object", "properties": { "filepath": { "type": "string", "description": "要写入的文件的绝对路径或相对于当前工作目录的路径。" }, "content": { "type": "string", "description": "要写入文件的文本内容。" } }, "required": ["filepath", "content"] } ), types.Tool( name="list_directory", description="列出指定目录下的文件和文件夹。", inputSchema={ "type": "object", "properties": { "dir_path": { "type": "string", "description": "要列出的目录的路径。默认为当前目录。", "default": "." } }, "required": [] } ) ] # 实现工具调用逻辑 @server.call_tool() async def handle_call_tool(name: str, arguments: dict) -> List[types.TextContent]: """根据工具名和参数执行具体的工具逻辑。""" try: if name == "read_file": filepath = arguments["filepath"] if not os.path.exists(filepath): return [types.TextContent(type="text", text=f"错误：文件 '{filepath}' 不存在。")] with open(filepath, 'r', encoding='utf-8') as f: content = f.read() return [types.TextContent(type="text", text=content)] elif name == "write_file": filepath = arguments["filepath"] content = arguments["content"] # 简单安全检查：防止写入系统关键目录（示例） # 实际生产环境需要更严格的路径校验和权限控制 os.makedirs(os.path.dirname(os.path.abspath(filepath)), exist_ok=True) with open(filepath, 'w', encoding='utf-8') as f: f.write(content) return [types.TextContent(type="text", text=f"成功写入文件：{filepath}")] elif name == "list_directory": dir_path = arguments.get("dir_path", ".") if not os.path.isdir(dir_path): return [types.TextContent(type="text", text=f"错误：'{dir_path}' 不是一个有效目录。")] items = os.listdir(dir_path) # 简单区分文件和文件夹 result = [] for item in items: full_path = os.path.join(dir_path, item) if os.path.isdir(full_path): result.append(f"[目录] {item}") else: result.append(f"[文件] {item}") return [types.TextContent(type="text", text="\n".join(result))] else: return [types.TextContent(type="text", text=f"错误：未知工具 '{name}'。")] except Exception as e: return [types.TextContent(type="text", text=f"工具执行出错：{str(e)}")] # 主函数：启动Server，监听标准输入 async def main(): await server.run() if __name__ == "__main__": import asyncio asyncio.run(main())

这个Server提供了三个工具：读文件、写文件、列目录。它通过异步方式运行，并通过stdin/stdout与客户端通信。

5.3 测试MCP Server

我们可以写一个简单的客户端脚本来测试Server是否工作正常。但更简单的方式是使用MCP CLI工具（如果已安装）或像claude这样的客户端。这里我们用一个简单的Python测试脚本：

# test_mcp_client.py import subprocess import json import time # 启动MCP Server进程 server_process = subprocess.Popen( ['python', 'mcp_file_server.py'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True ) def send_request(request): """向Server进程发送一个JSON-RPC请求并获取响应。""" request_str = json.dumps(request) + '\n' server_process.stdin.write(request_str) server_process.stdin.flush() # 读取响应行 response_line = server_process.stdout.readline() return json.loads(response_line) # 1. 初始化请求（必需） init_request = { "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": { "protocolVersion": "0.1.0", "capabilities": {}, "clientInfo": {"name": "TestClient", "version": "1.0"} } } print("发送初始化请求...") init_response = send_request(init_request) print(f"初始化响应: {init_response}\n") # 2. 列出工具 list_tools_request = { "jsonrpc": "2.0", "id": 2, "method": "tools/list", } print("请求工具列表...") list_response = send_request(list_tools_request) print(f"工具列表: {json.dumps(list_response, indent=2)}\n") # 3. 调用一个工具（例如，列目录） call_tool_request = { "jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": { "name": "list_directory", "arguments": {"dir_path": "."} } } print("调用 list_directory 工具...") call_response = send_request(call_tool_request) print(f"调用结果: {json.dumps(call_response, indent=2)}\n") # 关闭Server server_process.terminate() server_process.wait()

运行python test_mcp_client.py，你应该能看到Server返回的工具列表和当前目录的文件列表。这证明我们的MCP Server工作正常。

6. 实战三：让Agent与MCP Server协同工作

最后，也是最激动人心的部分：让我们之前构建的Agent能够动态发现并使用这个MCP Server提供的文件操作工具。我们将把MCP Client集成到LangChain Agent中。

6.1 创建MCP Client工具适配器

我们需要一个桥接层，将MCP Server的工具“翻译”成LangChain Agent能识别的Tool对象。

# mcp_client_tool.py import asyncio import json import subprocess from typing import Optional, Dict, Any from langchain.tools import BaseTool from pydantic import BaseModel, Field class MCPClientTool(BaseTool): name: str description: str server_process: subprocess.Popen args_schema: Optional[type[BaseModel]] = None def _run(self, **kwargs: Any) -> str: """同步调用MCP工具。内部使用异步转同步。""" return asyncio.run(self._arun(**kwargs)) async def _arun(self, **kwargs: Any) -> str: """异步调用MCP工具。""" request_id = hash(str(kwargs)) % 10000 # 简单的请求ID生成 call_request = { "jsonrpc": "2.0", "id": request_id, "method": "tools/call", "params": { "name": self.name, "arguments": kwargs } } request_str = json.dumps(call_request) + '\n' # 发送请求到Server的stdin self.server_process.stdin.write(request_str) self.server_process.stdin.flush() # 从Server的stdout读取响应 response_line = await asyncio.to_thread(self.server_process.stdout.readline) try: response = json.loads(response_line) if "result" in response: # 提取文本内容 contents = response["result"].get("content", []) text_parts = [c.get("text", "") for c in contents if c.get("type") == "text"] return "\n".join(text_parts) elif "error" in response: return f"MCP Server错误: {response['error']}" else: return f"未知响应格式: {response}" except json.JSONDecodeError as e: return f"解析响应失败: {e}, 原始行: {response_line}" def create_mcp_tools(server_script_path: str): """启动MCP Server并创建对应的LangChain Tool列表。""" # 启动Server进程 server_process = subprocess.Popen( ['python', server_script_path], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, bufsize=1 # 行缓冲 ) # 发送初始化请求（简化版，实际生产需要完整握手） init_request = json.dumps({ "jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "0.1.0", "capabilities": {}} }) + '\n' server_process.stdin.write(init_request) server_process.stdin.flush() server_process.stdout.readline() # 消费初始化响应 # 请求工具列表 list_request = json.dumps({ "jsonrpc": "2.0", "id": 2, "method": "tools/list", }) + '\n' server_process.stdin.write(list_request) server_process.stdin.flush() list_response_line = server_process.stdout.readline() tools = [] try: list_response = json.loads(list_response_line) if "result" in list_response: for tool_info in list_response["result"].get("tools", []): # 为每个MCP工具创建一个LangChain Tool包装器 tool = MCPClientTool( name=tool_info["name"], description=tool_info.get("description", "No description"), server_process=server_process, # 可以根据inputSchema动态生成args_schema，这里简化处理 ) tools.append(tool) except Exception as e: print(f"获取MCP工具列表失败: {e}") # 确保进程被终止 server_process.terminate() raise return tools, server_process

6.2 构建集成MCP的超级Agent

现在，我们将计算工具、搜索工具和MCP文件工具整合到一个Agent中。

# super_agent_with_mcp.py import os from dotenv import load_dotenv from langchain_openai import ChatOpenAI from langchain.agents import initialize_agent, AgentType from langchain.memory import ConversationBufferMemory from tools import calculator_tool, search_tool from mcp_client_tool import create_mcp_tools import signal import sys load_dotenv() def cleanup(server_process): """清理MCP Server进程。""" if server_process: server_process.terminate() server_process.wait() print("\nMCP Server进程已终止。") def main(): # 1. 初始化LLM llm = ChatOpenAI( model="gpt-3.5-turbo", temperature=0, openai_api_key=os.getenv("OPENAI_API_KEY") ) # 2. 创建记忆 memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True) # 3. 创建基础工具列表 all_tools = [calculator_tool, search_tool] # 4. 动态加载MCP工具 mcp_tools, mcp_server_process = None, None try: print("正在启动MCP文件服务器并加载工具...") mcp_tools, mcp_server_process = create_mcp_tools("mcp_file_server.py") all_tools.extend(mcp_tools) print(f"成功加载 {len(mcp_tools)} 个MCP工具。") # 设置信号处理，确保程序退出时清理Server进程 def signal_handler(sig, frame): cleanup(mcp_server_process) sys.exit(0) signal.signal(signal.SIGINT, signal_handler) except Exception as e: print(f"加载MCP工具失败，将继续使用基础工具。错误: {e}") mcp_server_process = None # 5. 初始化Agent agent = initialize_agent( all_tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, memory=memory, verbose=True, handle_parsing_errors=True, max_iterations=6 # 防止Agent陷入无限循环 ) # 6. 交互式对话 print("\n" + "="*50) print("超级Agent已就绪！") print("我可以：1. 计算 2. 网络搜索 3. 读写本地文件") print("输入 'quit' 或 'exit' 退出。") print("="*50) while True: try: user_input = input("\n你: ").strip() if user_input.lower() in ['quit', 'exit', 'q']: break if not user_input: continue print("\nAgent思考中...") response = agent.run(user_input) print(f"\nAgent: {response}") except KeyboardInterrupt: print("\n接收到中断信号。") break except Exception as e: print(f"\n处理请求时出错: {e}") # 7. 清理 cleanup(mcp_server_process) print("程序退出。") if __name__ == "__main__": main()

运行这个脚本 (python super_agent_with_mcp.py)，你现在可以尝试以下指令，观察Agent如何自主选择工具：

你: 帮我创建一个名为“hello.txt”的文件，内容写上“Hello from MCP Agent!” （Agent会调用write_file工具） 你: 再读一下这个文件的内容。 （Agent会调用read_file工具） 你: 列出当前目录看看还有什么。 （Agent会调用list_directory工具） 你: 计算一下 345 除以 23 的结果。 （Agent会调用Calculator工具） 你: 搜索一下今天北京天气。 （Agent会调用Web_Search工具）

你会看到Agent在同一个会话中，根据你的指令，动态地在计算器、搜索引擎和本地文件系统操作之间切换，这正是MCP带来的强大可扩展性。

7. 常见问题与排查思路

在开发和使用MCP与Agent过程中，你可能会遇到以下典型问题：

8. 最佳实践与工程建议

将MCP与Agent投入生产环境或复杂项目时，请遵循以下建议：

1. 安全性是第一要务

   • 工具权限隔离：为不同的MCP Server分配不同的系统用户和权限，遵循最小权限原则。文件操作Server不应有执行任意命令的能力。
   • 输入验证与沙箱：对所有工具输入进行严格的验证和清理。特别是涉及文件路径、系统命令、数据库查询时，防止路径遍历、注入等攻击。考虑使用沙箱环境执行不可信代码。
   • 审计日志：记录所有工具的调用请求和结果，包括用户、时间、工具名、参数（敏感参数可脱敏）和结果状态，便于事后审计和问题追踪。

2. 设计清晰的工具契约

   • 准确的描述：工具的name和description至关重要，它们是模型选择工具的主要依据。描述应清晰说明功能、输入格式和预期输出。
   • 结构化的参数：充分利用MCP的inputSchema，定义强类型的参数（字符串、数字、枚举等），这能极大提高模型调用工具的准确率。
   • 错误处理：工具函数应返回结构化的错误信息，而不是抛出未捕获的异常，以便客户端能理解并可能进行恢复。

3. 提升Agent的可靠性与效率

   • 设置迭代限制：始终为AgentExecutor设置max_iterations，防止因逻辑错误或工具不可用导致无限循环。
   • 超时机制：为工具调用设置超时，避免单个工具挂起导致整个Agent僵死。
   • 结构化输出：鼓励Agent以JSON、Markdown等结构化格式输出最终答案，便于下游系统处理。
   • 验证关键操作：对于文件删除、数据库写入等高风险操作，可以让Agent生成一个摘要，并要求用户二次确认（“是的，请执行”）后再真正调用工具。

4. MCP Server的开发与部署

   • 单一职责：一个MCP Server最好只提供一组相关功能（如所有文件操作、所有数据库操作）。这有利于维护和权限管理。
   • 资源管理：确保Server能妥善管理数据库连接、网络会话等资源，避免泄漏。
   • 标准化部署：考虑将Server容器化（Docker），并配以健康检查。可以使用进程管理器（如 systemd, supervisord）来保证其持续运行。

5. 面向生产的学习路线

   1. 基础巩固：熟练掌握一个主流Agent框架（如LangChain, LlamaIndex, Semantic Kernel）的核心概念。
   2. 协议深入：精读 MCP官方协议文档 （这是一个安全链接），理解其所有消息类型和生命周期。
   3. 生态集成：学习如何将你的MCP Server接入Claude Desktop、Cursor、Windmill等流行客户端，扩大其使用场景。
   4. 高级模式：探索多Agent协作、分层规划（HAL）、工具学习（Tool Learning）等进阶主题。
   5. 性能监控：为你的AI应用添加监控指标（工具调用延迟、成功率、Token消耗等），持续优化。

从构建一个简单的计算Agent，到开发出自定义的MCP文件服务器，再到最终将它们无缝集成，我们完成了一个完整的MCP+Agent开发闭环。这套技术栈的核心价值在于“标准化”和“解耦”——MCP协议标准化了AI与工具的交互方式，而Agent框架提供了组织AI决策与执行的蓝图。当你需要为AI增加新能力时，不再需要修改核心Agent代码，只需开发或接入一个符合MCP协议的Server即可。这种架构使得构建复杂、可扩展的AI应用变得前所未有的清晰和高效。下一步，你可以尝试将数据库查询、调用内部API、发送邮件等更多实际业务功能封装成MCP工具，打造真正属于你自己的AI助手。