AI - MCP 模型上下文协议详解

Published:

MCP (Model Context Protocol) 详解

什么是 MCP？

MCP 是 Anthropic 开发的开放标准，让 AI 模型安全访问外部数据和系统。

传统 AI 只能处理对话中的文本信息，无法读取文件、查询数据库或调用 API。MCP 解决了这个限制，让 AI 能够：

这相当于为 AI 提供了”手”和”眼”，让它能真正与现实世界交互。

MCP 数据流详解

完整的交互流程

想象你问 AI：“帮我分析一下今天的销售数据”，整个流程是这样的：

1. 用户提问
   ↓
2. AI 理解需求：需要访问销售数据库
   ↓  
3. AI 通过 MCP 向数据库服务器发送请求
   ↓
4. MCP 服务器验证权限和参数
   ↓
5. 执行数据库查询
   ↓
6. 将查询结果返回给 AI
   ↓
7. AI 分析数据并生成报告
   ↓
8. 向用户展示分析结果

具体数据流示例

场景: AI 需要读取一个配置文件

第1步 - AI 发起请求:

{
  "jsonrpc": "2.0",
  "id": "req_001",
  "method": "tools/call",
  "params": {
    "name": "read_file",
    "arguments": {
      "path": "/app/config/database.json"
    }
  }
}

第2步 - MCP 服务器验证和处理:

- 检查文件路径是否在允许范围内 ✓
- 验证文件是否存在 ✓  
- 检查读取权限 ✓
- 读取文件内容

第3步 - 返回结果:

{
  "jsonrpc": "2.0",
  "id": "req_001",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{\n  \"host\": \"localhost\",\n  \"port\": 5432\n}"
      }
    ]
  }
}

第4步 - AI 处理数据: AI 获得配置信息后，可以继续执行后续操作，比如连接数据库。

MCP 的核心价值

没有 MCP 的情况:

有了 MCP 的情况:

关键差异:

  1. 实时性: 获取最新数据而非过时信息
  2. 自动化: AI 主动获取数据而非被动等待
  3. 准确性: 直接访问源数据而非依赖转述
  4. 效率: 一次对话解决问题而非多次交互

核心概念

1. 协议架构

MCP 采用客户端-服务器架构，通过标准化协议连接AI和外部系统：

┌─────────────┐    MCP Protocol    ┌─────────────┐    Direct Access    ┌─────────────┐
│   Claude    │ ←──────────────→   │ MCP Server  │ ←────────────────→  │  Database   │
│  (Client)   │   JSON-RPC 2.0     │   (Proxy)   │    Native Calls     │   Files     │
│             │                    │             │                     │   APIs      │
└─────────────┘                    └─────────────┘                     └─────────────┘

各组件职责:

数据流向:

  1. AI 需要外部数据时，向 MCP Server 发送请求
  2. MCP Server 验证请求合法性和安全性
  3. MCP Server 访问实际数据源获取数据
  4. 数据经过处理后返回给 AI
  5. AI 基于获得的数据生成回答

这种架构的好处：

2. 主要组件

Resources（资源）

可读取的数据，如文件内容、数据库记录、网页内容等。

Tools（工具）

可执行的操作，如读写文件、查询数据库、调用API等。

Prompts（提示词）

预定义的对话模板，可重复使用并传入参数。

技术实现原理

消息格式（JSON-RPC 2.0）

MCP 基于 JSON-RPC 2.0 协议，这是一种轻量级的远程过程调用协议：

为什么选择 JSON-RPC？

消息结构:

{
  "jsonrpc": "2.0",        // 协议版本
  "id": 1,                 // 请求唯一标识
  "method": "tools/call",  // 调用的方法
  "params": {              // 方法参数
    "name": "read_file",
    "arguments": {"path": "/tmp/data.txt"}
  }
}

TypeScript 实现示例

下面是一个简洁的MCP客户端和服务端实现示例：

/**
 * MCP 核心类型定义
 */
interface JsonRpcRequest {
  /** JSON-RPC 协议版本 */
  jsonrpc: "2.0";
  /** 请求唯一标识符 */
  id: string | number;
  /** 调用方法名 */
  method: string;
  /** 方法参数 */
  params?: Record<string, unknown>;
}

/**
 * MCP 工具定义
 */
interface McpTool {
  /** 工具名称 */
  name: string;
  /** 工具描述 */
  description: string;
  /** 参数结构定义 */
  inputSchema: {
    type: "object";
    properties: Record<string, { type: string; description: string }>;
    required?: string[];
  };
}

/**
 * MCP 客户端
 */
class McpClient {
  /** 请求ID计数器 */
  private requestId = 0;

  /**
   * 发送请求到服务器
   * @param method - 方法名
   * @param params - 参数
   * @returns 响应结果
   */
  async request(method: string, params?: Record<string, unknown>): Promise<any> {
    const request: JsonRpcRequest = {
      jsonrpc: "2.0",
      id: ++this.requestId,
      method,
      params
    };
    
    // 实际实现中这里会发送HTTP/WebSocket请求
    console.log('发送请求:', request);
    return this.mockResponse(request);
  }

  /**
   * 调用MCP工具
   * @param toolName - 工具名称
   * @param args - 工具参数
   */
  async callTool(toolName: string, args: Record<string, unknown>) {
    return this.request('tools/call', { name: toolName, arguments: args });
  }

  /**
   * 获取工具列表
   */
  async listTools() {
    return this.request('tools/list');
  }

  /**
   * 模拟服务器响应
   */
  private async mockResponse(request: JsonRpcRequest) {
    await new Promise(resolve => setTimeout(resolve, 100));
    return { jsonrpc: "2.0", id: request.id, result: "模拟响应" };
  }
}

/**
 * MCP 服务器
 */
class McpServer {
  /** 工具注册表 */
  private tools = new Map<string, { 
    /** 工具定义 */
    definition: McpTool; 
    /** 处理函数 */
    handler: Function 
  }>();

  /**
   * 注册工具
   * @param definition - 工具定义
   * @param handler - 处理函数
   */
  registerTool(definition: McpTool, handler: Function) {
    this.tools.set(definition.name, { definition, handler });
  }

  /**
   * 处理客户端请求
   * @param request - JSON-RPC请求
   */
  async handleRequest(request: JsonRpcRequest) {
    try {
      switch (request.method) {
        case 'tools/list':
          const tools = Array.from(this.tools.values()).map(t => t.definition);
          return { jsonrpc: "2.0", id: request.id, result: { tools } };
          
        case 'tools/call':
          const { name, arguments: args } = request.params as any;
          const tool = this.tools.get(name);
          if (!tool) throw new Error(`工具不存在: ${name}`);
          
          const result = await tool.handler(args);
          return { jsonrpc: "2.0", id: request.id, result };
          
        default:
          throw new Error(`未知方法: ${request.method}`);
      }
    } catch (error: any) {
      return {
        jsonrpc: "2.0",
        id: request.id,
        error: { code: -32000, message: error.message }
      };
    }
  }
}

/**
 * 使用示例
 */
async function example() {
  // 创建服务器并注册工具
  const server = new McpServer();
  
  server.registerTool({
    name: 'calculate',
    description: '数学计算工具',
    inputSchema: {
      type: 'object',
      properties: {
        expression: { type: 'string', description: '数学表达式' }
      },
      required: ['expression']
    }
  }, async (args: any) => {
    const result = eval(args.expression); // 生产环境请使用安全的计算库
    return { content: [{ type: 'text', text: `结果: ${result}` }] };
  });

  // 创建客户端并调用
  const client = new McpClient();
  
  // 获取工具列表
  const tools = await client.listTools();
  console.log('可用工具:', tools);
  
  // 调用计算工具
  const result = await client.callTool('calculate', { expression: '2 + 3 * 4' });
  console.log('计算结果:', result);
}

// 运行示例
example().catch(console.error);

这个简化版本演示了MCP的核心概念：

  1. JSON-RPC协议：标准化的请求响应格式
  2. 工具系统：可注册和调用的功能模块
  3. 类型安全：完整的TypeScript类型定义
  4. 错误处理：统一的异常处理机制

主要方法说明

客户端方法：

服务端方法：

传输层选择

MCP 支持多种通信方式，适应不同的部署场景：

stdio（标准输入输出）

HTTP

WebSocket

应用场景详解

文件系统操作

功能: 让 AI 能够读写本地文件系统 场景举例:

数据库查询

功能: 让 AI 直接查询各种数据库 场景举例:

外部API调用

功能: 让 AI 调用第三方服务获取实时信息 场景举例:

安全机制详解

MCP 内置多层安全机制，确保 AI 访问外部系统的安全性：

权限控制（沙箱机制）

原理: 使用白名单机制限制访问范围 实现:

示例: AI 只能读取 /home/user/documents/ 目录，无法访问 /etc/passwd

输入验证（防注入攻击）

原理: 严格验证所有输入参数 实现:

示例: SELECT * FROM users WHERE id='; DROP TABLE users; -- 会被直接拒绝

速率限制（防滥用）

原理: 限制请求频率和资源使用 实现:

示例: 超过限制时返回 429 Too Many Requests 错误

技术对比

特性MCPOpenAI Function CallingLangChain Tools
标准化开放协议OpenAI 专有框架特定
传输方式stdio/HTTP/WSHTTP APIPython 内存
安全性内置机制API 密钥自实现
扩展性高度可扩展受限于 API框架内扩展

MCP 的优势与未来

核心优势

标准化带来的好处:

安全性优势:

开发效率:

总结

MCP 为 AI 模型与外部系统集成提供了标准化、安全的解决方案。它不仅解决了AI访问外部数据的技术问题，更为构建可信、可扩展的AI应用生态奠定了基础。

通过本文你可以：

MCP 正在成为 AI 应用开发的重要基础设施，值得开发者深入学习和实践。

评论