用 MCP 协议构建你的 AI Agent 工作流：从概念到实践

摘要：深入讲解 MCP（Model Context Protocol）协议的原理与架构，展示如何用 MCP 构建具备工具调用能力的 AI Agent 自动化工作流，附完整代码示例。

为什么 AI Agent 需要 MCP

2024 年以来，AI Agent 从概念走向落地。但一个核心问题始终困扰着开发者：大模型怎么和外部工具交互？

早期的做法是硬编码——为每个工具写一个函数调用，模型输出特定格式的字符串，程序解析后执行。这种方式在工具少的时候能用，但一旦工具数量增加、调用链变长，代码就变得难以维护。

更根本的问题是：每个 AI 应用都在重复造轮子。你为自己的 Agent 写了一套工具调用协议，我也写了一套，大家的接口格式、错误处理、权限管理都不一样。

MCP（Model Context Protocol）就是为了解决这个问题而生的。

MCP 是什么

MCP 是 Anthropic 在 2024 年底发布的一个开放协议，全称 Model Context Protocol。它的核心思想是：定义一个标准化的接口，让 AI 模型能够以统一的方式访问外部工具和数据源。

用一个类比：USB 接口统一了电脑和外设的连接方式。在 USB 之前，键盘用 PS/2、鼠标用串口、打印机用并口——每种设备都要专门的接口。USB 出现后，所有设备都用同一个接口，即插即用。

MCP 做的事情类似——它定义了 AI 模型和外部工具之间的"USB 接口"。

核心架构：Host、Client、Server 三端模型

┌─────────────────────────────────────────────────────┐
│                     Host（宿主）                     │
│  AI 应用的运行环境，如 Claude Desktop、IDE 插件等      │
├─────────────────────────────────────────────────────┤
│                     Client（客户端）                  │
│  负责与 Server 建立连接、发送请求、接收响应            │
├─────────────────────────────────────────────────────┤
│                     Server（服务端）                  │
│  提供具体的工具和数据源，如文件系统、数据库、API 等    │
└─────────────────────────────────────────────────────┘

Host：AI 应用的宿主环境。比如 Claude Desktop 就是一个 Host，它管理多个 Client 实例，每个 Client 对接一个 Server。

Client：协议客户端，负责与 Server 建立 1:1 的连接。它处理协议握手、消息路由、错误恢复等底层逻辑。

Server：工具和数据的提供方。一个 Server 可以暴露多个工具（Tools）、资源（Resources）和提示模板（Prompts）。

三者的交互流程：

用户提问 → Host 接收 → Client 发送给 LLM → LLM 决定调用工具
    → Client 转发请求到 Server → Server 执行并返回结果
    → Client 传回 Host → LLM 基于结果生成回答 → 返回用户

MCP 的三个核心概念

1. Tools（工具）

工具是 MCP 最核心的能力。每个工具就是一个函数，有名称、描述、输入参数和输出格式。

{
  "name": "search_web",
  "description": "搜索互联网获取信息",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "搜索关键词"
      },
      "count": {
        "type": "integer",
        "description": "返回结果数量",
        "default": 5
      }
    },
    "required": ["query"]
  }
}

LLM 看到这个工具定义后，就知道在什么场景下可以调用它、需要传什么参数。

2. Resources（资源）

资源是 Server 暴露的数据源，类似于 REST API 中的 GET 端点。资源是只读的，LLM 可以读取但不能修改。

{
  "uri": "file:///project/README.md",
  "name": "项目 README",
  "mimeType": "text/markdown"
}

3. Prompts（提示模板）

Server 可以提供预定义的提示模板，帮助 LLM 更好地使用工具。

{
  "name": "code_review",
  "description": "代码审查模板",
  "arguments": [
    {
      "name": "code",
      "description": "待审查的代码",
      "required": true
    }
  ]
}

用 Python 实现一个 MCP Server

下面是一个完整的 MCP Server 示例——一个文件系统操作工具：

# server.py - 一个简单的文件系统 MCP Server
import os
import json
from mcp.server import Server
from mcp.types import Tool, TextContent

server = Server("filesystem")

@server.list_tools()
async def list_tools():
    """列出所有可用工具"""
    return [
        Tool(
            name="read_file",
            description="读取文件内容",
            inputSchema={
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "文件路径"
                    }
                },
                "required": ["path"]
            }
        ),
        Tool(
            name="list_directory",
            description="列出目录中的文件",
            inputSchema={
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "目录路径"
                    }
                },
                "required": ["path"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    """执行工具调用"""
    if name == "read_file":
        path = arguments["path"]
        with open(path, "r", encoding="utf-8") as f:
            content = f.read()
        return [TextContent(type="text", text=content)]
    
    elif name == "list_directory":
        path = arguments["path"]
        files = os.listdir(path)
        return [TextContent(type="text", text=json.dumps(files, ensure_ascii=False))]

# 启动 Server（stdio 传输）
if __name__ == "__main__":
    import asyncio
    from mcp.server.stdio import stdio_server
    
    async def main():
        async with stdio_server() as (read_stream, write_stream):
            await server.run(read_stream, write_stream)
    
    asyncio.run(main())

构建一个内容自动化 Agent 工作流

有了 MCP，构建一个完整的 AI Agent 工作流变得清晰。下面展示一个"内容自动化 Agent"的架构：

架构设计

┌──────────────────────────────────────────────────────┐
│                   AI Agent（LLM）                    │
│                                                      │
│  用户: "帮我写一篇关于 AI 的文章并发到 CSDN"          │
│                                                      │
│  Agent 思考:                                         │
│  1. 调用 search_web 搜索 AI 热点                      │
│  2. 调用 generate_content 生成文章                    │
│  3. 调用 publish_to_platform 发布                     │
│  4. 返回结果给用户                                    │
└───────┬──────────────┬──────────────┬────────────────┘
        │              │              │
   ┌────▼────┐   ┌─────▼─────┐   ┌────▼────┐
   │ 搜索工具 │   │ 内容生成   │   │ 发布工具 │
   │ Server  │   │ Server    │   │ Server  │
   └─────────┘   └───────────┘   └─────────┘

实现代码

# agent.py - 基于 MCP 的内容自动化 Agent
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from anthropic import Anthropic

# 连接到 MCP Server
server_params = StdioServerParameters(
    command="python",
    args=["server.py"]
)

async def run_agent(user_request: str):
    """运行 Agent"""
    # 连接 MCP Server
    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            # 初始化连接
            await session.initialize()
            
            # 获取可用工具列表
            tools = await session.list_tools()
            
            # 调用 LLM
            client = Anthropic()
            response = client.messages.create(
                model="claude-sonnet-4-20250514",
                max_tokens=4096,
                messages=[{"role": "user", "content": user_request}],
                tools=[{
                    "name": tool.name,
                    "description": tool.description,
                    "input_schema": tool.inputSchema
                } for tool in tools.tools]
            )
            
            # 处理工具调用
            for content in response.content:
                if content.type == "tool_use":
                    # 执行工具
                    result = await session.call_tool(
                        content.name,
                        content.input
                    )
                    print(f"工具 {content.name} 执行结果: {result}")
            
            return response

# 运行
asyncio.run(run_agent("帮我搜索最近的 AI 热点"))

运行效果

$ python agent.py

Agent 调用工具: search_web
参数: {"query": "AI 热点 2026"}
返回结果: [...搜索结果...]

Agent 基于搜索结果生成回答:
"最近 AI 领域的热点包括: ..."

MCP 相比传统方案的优势

1. 标准化

传统方案中，每个 AI 应用都要自己定义工具调用格式。MCP 提供了统一标准，工具只需要实现一次，就能被任何 MCP 兼容的 Host 使用。

2. 可组合性

多个 MCP Server 可以同时连接到一个 Host，Agent 可以自由组合不同 Server 的能力。比如同时连接文件系统 Server、数据库 Server、API Server，构建复杂的工作流。

3. 安全性

MCP 协议内置了权限管理机制。Server 可以声明自己的能力范围，Host 可以控制哪些工具对 LLM 可见。这比直接把 API Key 传给 LLM 安全得多。

4. 生态复用

随着 MCP Server 生态的发展，开发者可以直接复用社区提供的 Server，而不需要从零实现。比如文件系统操作、数据库查询、邮件发送等常见功能，都有现成的 MCP Server。

实际应用场景

场景 1：自动化内容运营

连接搜索 Server、内容生成 Server、多平台发布 Server，让 Agent 自动完成选题→写作→发布的全流程。

场景 2：智能数据分析

连接数据库 Server、图表生成 Server、报告 Server，让 Agent 自动查询数据、生成可视化图表、输出分析报告。

场景 3：开发辅助

连接代码仓库 Server、CI/CD Server、文档 Server，让 Agent 自动执行代码审查、运行测试、更新文档。

总结

MCP 协议的核心价值是标准化——它让 AI Agent 和外部工具的交互有了统一的语言。这带来的好处是：

1. 开发效率提升：工具实现一次，处处可用
2. 生态可复用：社区 Server 可以直接拿来用
3. 安全可控：权限管理内置在协议中
4. 架构清晰：Host-Client-Server 三端分离，职责明确

对于想构建 AI Agent 的开发者来说，MCP 是一个值得关注的技术方向。它不是万能的，但它解决了 Agent 工具调用中最核心的"标准化"问题。

---

本文为技术分享，不构成任何产品推荐。文中代码示例基于 MCP 协议规范，仅供学习参考。