【无标题】

MCP（Model Context Protocol）是一种开放协议，为大型语言模型（如Claude、GPT）提供与外部服务交互的标准接口。它类似于USB接口标准，让大模型能够通过MCP服务访问实时信息、操作系统工具、查询数据库等，从而扩展其能力范围。MCP架构包含协议标准和服务实现两个核心部分，支持多种开发语言和平台，使大模型获得"眼睛、耳朵、手和脚"般的扩展功能。开发者可以

而非丶

893人浏览 · 2026-01-28 12:51:32

而非丶 · 2026-01-28 12:51:32 发布

MCP (Model Context Protocol) 完全指南万字精讲 - 什么是 MCP、怎么开发 MCP 服务、大模型如何整合 MCP 服务

MCP (Model Context Protocol) 完全指南万字精讲 - 什么是 MCP、怎么开发 MCP 服务、大模型如何整合 MCP 服务

原文链接：MCP (Model Context Protocol) 完全指南

一、什么是 MCP

1.1 MCP 简介

想象一下，大模型（如 Claude、GPT）就像一个超级聪明的大脑，它拥有海量的知识和强大的推理能力。但是，这个大脑被关在一个封闭的房间里，只能通过文字与你交流。

MCP 就像是给这个大脑装上了"眼睛、耳朵、手和脚"：

没有MCP时，大脑只能依靠训练时学到的知识回答问题，就像一个被困在房间里的天才，有才华但无法施展
有了MCP后，大脑可以通过各种服务"看"到实时信息、"听"到事件、"操作"文件和工具、"访问"各种数据源

MCP 的整体架构：

┌─────────────────────────────────────────────────────────┐
│                    大模型 (大脑)                          │
│                  (Claude/GPT 等)                         │
└────────────────────┬────────────────────────────────────┘
                     │
                     │  MCP 协议 (通用语言)
                     │  就像 USB 接口标准
                     │
┌────────────────────▼────────────────────────────────────┐
│              MCP 服务 (各种"器官")                       │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
│  │ 天气服务     │  │ 文件服务     │  │ 数据库服务   │ │
│  │ (眼睛)       │  │ (手)         │  │ (记忆)       │ │
│  └──────────────┘  └──────────────┘  └──────────────┘ │
└─────────────────────────────────────────────────────────┘
                     │
                     │
┌────────────────────▼────────────────────────────────────┐
│              外部世界 (各种数据源和服务)                  │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────┐ │
│  │ 天气 API │  │ 文件系统 │  │ 数据库   │  │ 云服务 │ │
│  └──────────┘  └──────────┘  └──────────┘  └────────┘ │
└─────────────────────────────────────────────────────────┘

MCP 的两个核心概念：

MCP 协议 - 通用语言
- 就像 USB 接口标准一样，定义了统一的通信规则
- 让大模型和各种服务能够"说同一种语言"
- 一次定义，所有服务都能遵循
MCP 服务 - 各种"器官"
- 基于协议开发的具体服务
- 每个服务提供特定的能力（天气、文件、数据库等）
- 可以独立开发、独立部署、独立维护

没有 MCP 的情况：

大脑只能依靠训练时学到的知识回答问题
无法访问实时信息（比如今天的天气、最新的新闻）
无法操作外部工具（比如运行代码、查询数据库、发送邮件）
无法读取你的文件或访问你的数据
就像一个被困在房间里的天才，有才华但无法施展

有了 MCP 之后：

通过 MCP 协议，大脑可以与各种 MCP 服务通信
MCP 服务就像给大脑装上了眼睛、耳朵、手和脚：
- 👁️ 眼睛（天气服务、网页服务）：可以查看实时信息
- 👂 耳朵（事件服务、消息服务）：可以接收实时数据
- ✋ 手（文件服务、代码服务）：可以操作文件和运行代码
- 🦵 脚（数据库服务、API 服务）：可以访问各种平台

📊 有 MCP vs 没有 MCP 的对比

场景	没有 MCP	有 MCP
查询天气	只能根据训练数据回答，可能不准确	调用天气 MCP 服务，获取实时准确的天气信息
分析数据	需要用户手动复制粘贴数据	调用数据库 MCP 服务，直接读取并分析数据
运行代码	只能提供代码，无法执行	调用代码 MCP 服务，直接运行代码并返回结果
发送邮件	只能写邮件内容，无法发送	调用邮件 MCP 服务，直接发送邮件
文件操作	无法访问用户文件	调用文件 MCP 服务，读取、写入、搜索文件
数据库查询	无法访问数据库	调用数据库 MCP 服务，执行 SQL 查询，获取数据

💡 MCP 的定义

MCP 协议：

由 Anthropic 推出的开放标准协议
就像 USB 接口标准，定义了大模型与外部服务通信的统一规则
一次定义，所有服务都能遵循

MCP 服务：

基于 MCP 协议开发的具体服务
每个服务提供特定的能力和功能
可以独立开发、独立部署、独立维护

整体价值：

标准化接口：就像 USB 接口一样，一次开发，所有设备都能用
上下文增强：给大模型装上"眼睛"和"手"，让它能看到世界、能做事
可扩展性：像搭积木一样，可以轻松添加新的能力和工具
跨平台兼容：支持多种编程语言和平台，不限制技术栈

1.3 MCP 架构

┌─────────────────────────────────────────────────────────┐
│                    大模型 (LLM)                          │
│                  (Claude/GPT 等)                         │
└────────────────────┬────────────────────────────────────┘
                     │
                     │ MCP 协议
                     │
┌────────────────────▼────────────────────────────────────┐
│                  MCP Client                              │
│              (Claude Desktop 等)                        │
└────────────────────┬────────────────────────────────────┘
                     │
                     │ stdio / SSE
                     │
┌────────────────────▼────────────────────────────────────┐
│                  MCP Server                              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
│  │  工具 (Tools) │  │ 资源 (Resources) │  │ 提示词 (Prompts) │ │
│  └──────────────┘  └──────────────┘  └──────────────┘ │
└─────────────────────────────────────────────────────────┘
                     │
                     │
┌────────────────────▼────────────────────────────────────┐
│              外部数据源和服务                            │
│  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌────────┐ │
│  │ 数据库    │  │ API      │  │ 文件系统 │  │ 云服务 │ │
│  └──────────┘  └──────────┘  └──────────┘  └────────┘ │
└─────────────────────────────────────────────────────────┘

二、如何开发一个 MCP 服务

2.1 MCP 服务的整体开发逻辑

🎯 开发流程概览

开发一个 MCP 服务就像开发一个"插件"，让大模型能够调用你的功能。整体流程如下：

┌─────────────────────────────────────────────────────────┐
│              1. 设计服务能力                           │
│         确定要提供什么功能（工具/资源/提示词）            │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              2. 选择开发语言和 SDK                      │
│         TypeScript SDK 或 Python SDK等等                │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              3. 实现服务逻辑                           │
│    - 定义工具（可调用的函数）                           │
│    - 定义资源（可访问的数据）                           │
│    - 定义提示词（预定义的模板）                         │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              4. 测试和调试                             │
│         使用 MCP Inspector 或手动测试                    │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              5. 部署和配置                             │
│         部署服务，配置到 Claude Desktop 或其他应用       │
└─────────────────────────────────────────────────────────┘

📦 MCP 服务的三大核心组件

MCP 服务
├── 工具 (Tools)
│   ├── 可被大模型调用的函数
│   ├── 类似于 API 接口
│   └── 示例：天气查询、代码执行、邮件发送
│
├── 资源 (Resources)
│   ├── 可被大模型读取的数据
│   ├── 类似于文件系统或数据库
│   └── 示例：文件、数据库记录、API 响应
│
└── 提示词 (Prompts)
    ├── 预定义的提示词模板
    ├── 可以包含变量占位符
    └── 示例：代码审查模板、分析报告模板

🔑 核心概念

1. MCP 协议的作用

定义了大模型和 MCP 服务之间的通信规则
就像 HTTP 协议定义了浏览器和服务器之间的通信规则
开发者不需要关心协议细节，只需要使用 SDK

2. MCP SDK 的作用

封装了 MCP 协议的细节
提供了简单的 API 来定义工具、资源和提示词
让开发者专注于业务逻辑，而不是协议实现

3. 开发者的工作

选择编程语言（TypeScript 或 Python）
使用对应的 SDK
定义工具、资源和提示词
实现具体的业务逻辑

2.2 开发环境准备

选择开发语言

TypeScript SDK

适合前端/全栈开发者
生态完善，类型安全
适合复杂的项目

Python SDK

适合数据科学、后端开发者
语法简洁，易于上手
适合快速原型开发

安装 Python SDK

pip install mcp

2.3 完整示例：天气查询 MCP 服务

下面是一个完整的 Python 示例，实现一个简单的天气查询服务：

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
import asyncio

# 创建 MCP 服务器实例
app = Server("weather-mcp-server")

# 定义工具列表
@app.list_tools()
async def list_tools() -> list[Tool]:
    """告诉大模型这个服务提供了哪些工具"""
    return [
        Tool(
            name="get_weather",
            description="获取指定城市的天气信息",
            inputSchema={
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，例如：北京、上海"
                    }
                },
                "required": ["city"]
            }
        )
    ]

# 实现工具调用逻辑
@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    """当大模型调用工具时，执行这个函数"""
    if name == "get_weather":
        city = arguments["city"]
        
        # 这里可以调用真实的天气 API
        weather_data = await fetch_weather(city)
        
        return [TextContent(
            type="text",
            text=f"{city}的天气：{weather_data['condition']}，温度：{weather_data['temperature']}°C"
        )]
    
    raise ValueError(f"未知的工具: {name}")

# 模拟天气 API 调用
async def fetch_weather(city: str) -> dict:
    """实际项目中，这里会调用真实的天气 API"""
    # 模拟数据
    weather_db = {
        "北京": {"condition": "晴朗", "temperature": 25},
        "上海": {"condition": "多云", "temperature": 28},
        "广州": {"condition": "小雨", "temperature": 30},
    }
    
    return weather_db.get(city, {"condition": "未知", "temperature": 20})

# 启动服务器
async def main():
    async with stdio_server() as (read_stream, write_stream):
        await app.run(
            read_stream,
            write_stream,
            app.create_initialization_options()
        )

if __name__ == "__main__":
    asyncio.run(main())

2.4 代码解析

关键部分说明

1. 创建服务器实例

app = Server("weather-mcp-server")

给服务起个名字，方便识别
这个名字会在配置文件中使用

2. 定义工具列表

@app.list_tools()
async def list_tools() -> list[Tool]:

告诉大模型这个服务提供了哪些工具
每个工具都有名称、描述和输入参数定义
大模型会根据这些信息决定是否调用工具

3. 实现工具调用

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:

当大模型决定调用工具时，会执行这个函数
name 是工具名称
arguments 是大模型传入的参数
返回结果给大模型

4. 启动服务器

async with stdio_server() as (read_stream, write_stream):
    await app.run(read_stream, write_stream, app.create_initialization_options())

使用 stdio 传输方式
大模型通过标准输入输出与这个服务通信

2.5 扩展服务功能

添加更多工具

@app.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="get_weather",
            description="获取指定城市的天气信息",
            inputSchema={
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "城市名称"}
                },
                "required": ["city"]
            }
        ),
        Tool(
            name="get_forecast",
            description="获取未来几天的天气预报",
            inputSchema={
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "城市名称"},
                    "days": {"type": "number", "description": "预报天数"}
                },
                "required": ["city", "days"]
            }
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "get_weather":
        # 获取当前天气
        pass
    elif name == "get_forecast":
        # 获取天气预报
        pass

添加资源

from mcp.types import Resource, ResourceContents

@app.list_resources()
async def list_resources() -> list[Resource]:
    """告诉大模型这个服务提供了哪些资源"""
    return [
        Resource(
            uri="weather://beijing",
            name="北京天气数据",
            description="北京的实时天气数据",
            mimeType="application/json"
        )
    ]

@app.read_resource()
async def read_resource(uri: str) -> ResourceContents:
    """当大模型读取资源时，执行这个函数"""
    if uri == "weather://beijing":
        data = await fetch_weather("北京")
        return ResourceContents(
            contents=[
                {
                    "uri": uri,
                    "mimeType": "application/json",
                    "text": json.dumps(data)
                }
            ]
        )

2.6 测试和调试

使用 MCP Inspector

# 安装 Inspector
pip install mcp-inspector

# 启动 Inspector
mcp-inspector python weather_server.py

Inspector 会提供一个 Web 界面，让你：

查看服务提供的工具和资源
手动调用工具测试功能
查看请求和响应的详细信息

手动测试

# 启动服务
python weather_server.py

# 在另一个终端发送测试请求
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | python weather_server.py

2.7 部署和配置

部署到 Claude Desktop

保存服务代码：将代码保存为 weather_server.py
配置 Claude Desktop：
- Windows: %APPDATA%\Claude\claude_desktop_config.json
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
- Linux: ~/.config/Claude/claude_desktop_config.json
添加配置：

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["path/to/weather_server.py"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

重启 Claude Desktop
开始使用：在 Claude 中询问天气问题，它会自动调用你的服务

2.8 开发最佳实践

设计原则

单一职责：每个工具只做一件事
清晰的描述：工具的描述要准确，让大模型知道何时调用
参数验证：验证输入参数，避免错误
错误处理：提供友好的错误信息
性能优化：避免长时间阻塞，使用异步操作

安全考虑

输入验证：严格验证所有输入参数
权限控制：限制工具的访问范围
敏感信息：不要在日志中记录敏感信息
速率限制：防止滥用和攻击

三、大模型如何整合 MCP 服务

3.1 整体集成流程

🎯 集成概览

将第二部分开发的天气查询 MCP 服务整合到大模型中，整体流程如下：

┌─────────────────────────────────────────────────────────┐
│              1. 开发 MCP 服务                          │
│         (第二部分：天气查询服务)                         │
│         - 定义工具：get_weather                        │
│         - 实现逻辑：查询天气数据                        │
│         - 启动服务：weather_server.py                  │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              2. 配置大模型应用                          │
│         - Claude Desktop 配置文件                      │
│         - 指定服务启动命令和参数                        │
│         - 设置环境变量（API Key 等）                    │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              3. 启动和连接                             │
│         - 大模型应用启动时自动加载 MCP 服务               │
│         - 建立与 MCP 服务的通信连接                      │
│         - 获取服务提供的工具列表                        │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│              4. 用户交互                               │
│         用户: "今天北京的天气怎么样？"                     │
│         ↓                                              │
│         大模型分析问题，决定调用 get_weather 工具          │
│         ↓                                              │
│         调用天气 MCP 服务                              │
│         ↓                                              │
│         返回天气数据                                   │
│         ↓                                              │
│         大模型生成最终回答                               │
└─────────────────────────────────────────────────────────┘

🔑 核心概念

MCP Client 的作用

MCP Client 是大模型应用（如 Claude Desktop）的一部分
负责与 MCP 服务建立连接
负责转发大模型的工具调用请求
负责将服务返回的结果传回给大模型

集成方式

配置文件集成：通过配置文件指定 MCP 服务（最常用）
代码集成：在应用代码中使用 MCP Client SDK（自定义应用）

3.2 配置 Claude Desktop

配置文件位置

Windows: %APPDATA%\Claude\claude_desktop_config.json
macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Linux: ~/.config/Claude/claude_desktop_config.json

配置天气查询服务

使用第二部分开发的天气查询服务，配置如下：

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["path/to/weather_server.py"],
      "env": {
        "API_KEY": "your-weather-api-key",
        "DEBUG": "true"
      }
    }
  }
}

配置说明：

weather: 服务的唯一标识符，可以自定义
command: 启动服务的命令（Python 解释器）
args: 传递给服务的参数（服务脚本路径）
env: 环境变量（API Key、调试开关等）

配置多个服务

如果需要同时使用多个 MCP 服务：

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["path/to/weather_server.py"],
      "env": {
        "API_KEY": "your-weather-api-key"
      }
    },
    "leetcode": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@jinzcdev/leetcode-mcp-server",
        "--site",
        "cn",
        "--session",
        "your-session-token"
      ]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]
    }
  }
}

3.3 启动和测试

启动 Claude Desktop

保存配置文件到正确的位置
重启 Claude Desktop
Claude Desktop 会自动加载所有配置的 MCP 服务
在 Claude 的聊天界面，可以看到可用的工具

测试天气查询服务

在 Claude 中输入：

用户: 今天北京的天气怎么样？

Claude 的处理流程：

分析用户问题，识别需要查询天气
查看可用的工具，找到 get_weather 工具
调用 get_weather 工具，传入参数 city: "北京"
天气 MCP 服务接收请求，查询天气数据
服务返回结果："北京的天气：晴朗，温度：25°C"
Claude 基于结果生成最终回答

Claude 的回答示例：

根据查询结果，今天北京的天气是晴朗，温度为 25°C。天气不错，适合外出活动！

3.4 MCP 与大模型的交互流程

┌─────────────────────────────────────────────────────────┐
│  1. 用户提问                                        │
│     "今天北京的天气怎么样？"                           │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  2. 大模型分析问题                                    │
│     - 识别用户意图：查询天气                           │
│     - 确定需要调用工具：get_weather                   │
│     - 提取参数：city = "北京"                        │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  3. 大模型生成工具调用请求                             │
│     {                                               │
│       "name": "get_weather",                         │
│       "arguments": {"city": "北京"}                   │
│     }                                               │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  4. MCP Client 接收请求，转发给 MCP Server            │
│     - Claude Desktop 的 MCP Client                    │
│     - 通过 stdio 发送到 weather_server.py              │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  5. MCP Server 执行工具，返回结果                     │
│     - weather_server.py 接收请求                      │
│     - 执行 fetch_weather("北京")                      │
│     - 返回天气数据                                   │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  6. MCP Client 将结果返回给大模型                     │
│     - 接收天气数据                                   │
│     - 转发给大模型                                   │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  7. 大模型基于结果生成最终回答                         │
│     "根据查询结果，今天北京的天气是晴朗，温度为 25°C..." │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  8. 用户获得回答                                      │
│     看到完整的天气信息和建议                            │
└─────────────────────────────────────────────────────────┘

3.5 实际应用场景

场景 1：智能助手

需求：开发一个智能助手，能够回答天气、新闻、日程等问题

实现方案：

开发天气 MCP 服务（已完成）
开发新闻 MCP 服务
开发日程 MCP 服务
配置到 Claude Desktop

用户体验：

用户: 今天北京天气怎么样？有什么重要新闻？
     ↓
Claude: 调用天气服务和新闻服务
     ↓
Claude: 今天北京天气晴朗，温度 25°C。
        重要新闻：...

场景 2：数据分析助手

需求：让大模型能够分析数据库中的数据

实现方案：

开发数据库 MCP 服务
- 工具：query_database - 执行 SQL 查询
- 资源：database://table_name - 表数据
配置到 Claude Desktop

用户体验：

用户: 分析上个月的销售数据，找出销售额最高的产品
     ↓
Claude: 调用 query_database 查询数据
     ↓
Claude: 分析数据，生成报告
     ↓
Claude: 根据分析结果，销售额最高的产品是...

场景 3：代码开发助手

需求：让大模型能够读取、修改、运行代码

实现方案：

开发文件系统 MCP 服务
- 工具：read_file, write_file, run_code
- 资源：file://path/to/file
配置到 Claude Desktop

用户体验：

用户: 帮我优化这个函数，并运行测试验证
     ↓
Claude: 调用 read_file 读取代码
     ↓
Claude: 分析代码，生成优化版本
     ↓
Claude: 调用 write_file 保存优化后的代码
     ↓
Claude: 调用 run_code 运行测试
     ↓
Claude: 返回优化结果和测试报告

3.6 自定义应用集成

使用 MCP Client SDK

如果需要在自定义应用中集成 MCP 服务，可以使用 MCP Client SDK：

# 简化的 Python 示例
from mcp.client import Client
from mcp.client.stdio import stdio_client
import asyncio

async def main():
    # 创建客户端
    client = Client("my-app")
    
    # 连接到天气服务
    async with stdio_client("python", ["path/to/weather_server.py"]) as (read, write):
        await client.start(read, write)
        
        # 调用工具
        result = await client.call_tool("get_weather", {"city": "北京"})
        print(result)

asyncio.run(main())

适用场景：

开发自定义的大模型应用
需要更细粒度的控制
需要自定义用户界面

3.7 故障排查

常见问题

1. 服务无法启动

检查 Python 路径是否正确
检查服务脚本路径是否正确
查看错误日志

2. 工具无法调用

检查配置文件格式是否正确
检查环境变量是否设置
重启 Claude Desktop

3. 连接超时

检查服务是否正常运行
检查防火墙设置
增加超时时间

调试方法

启用调试日志：

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["path/to/weather_server.py"],
      "env": {
        "DEBUG": "true"
      }
    }
  }
}

手动测试服务：

# 启动服务
python weather_server.py

# 在另一个终端发送测试请求
echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | python weather_server.py

四、最佳实践

4.1 工具设计原则

单一职责：每个工具只做一件事
清晰的输入输出：明确定义参数和返回值
错误处理：提供详细的错误信息
幂等性：相同输入产生相同输出
文档完善：提供详细的描述和示例

4.2 性能优化

缓存机制：对频繁访问的数据进行缓存
批量操作：支持批量处理减少请求次数
异步处理：使用异步操作避免阻塞
连接池：复用数据库连接等资源

4.3 安全考虑

输入验证：严格验证所有输入参数
权限控制：实现细粒度的权限管理
敏感信息：不要在日志中记录敏感信息
速率限制：防止滥用和 DDoS 攻击

4.4 监控和日志

请求追踪：记录所有请求和响应
性能监控：监控响应时间和资源使用
错误告警：及时通知异常情况
日志分析：定期分析日志发现问题

五、常见问题

Q1: 什么是 Function Calling？

🧠 Function Calling 的概念

Function Calling（函数调用）是大模型的一个核心功能特性，让大模型能够调用外部函数并获取结构化的输出。

🎯 Function Calling 的工作原理

┌─────────────────────────────────────────────────────────┐
│  1. 用户提问                                        │
│     "今天北京的天气怎么样？"                           │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  2. 大模型分析问题                                    │
│     - 识别用户意图：需要查询天气                       │
│     - 决定调用函数：get_weather                       │
│     - 提取参数：city = "北京"                        │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  3. 大模型生成函数调用请求                           │
│     {                                               │
│       "function": "get_weather",                      │
│       "arguments": {"city": "北京"}                  │
│     }                                               │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  4. 外部系统执行函数                                 │
│     - 调用天气 API                                 │
│     - 获取天气数据                                   │
│     - 返回结果：{temperature: 25, condition: "晴朗"}   │
└────────────────────┬────────────────────────────────────┘
                     │
                     ▼
┌─────────────────────────────────────────────────────────┐
│  5. 大模型基于函数结果生成最终回答                     │
│     "根据天气数据，今天北京晴朗，温度 25°C..."       │
└─────────────────────────────────────────────────────────┘

🔑 Function Calling vs 传统 API 调用

特性	Function Calling	传统 API 调用
决策方式	大模型自动判断	程序硬编码
参数提取	自动从自然语言提取	需要手动解析
灵活性	高，适应各种表达	低，固定格式
错误处理	大模型理解并纠正	需要额外逻辑
用户体验	自然对话	表单或命令行

🎯 Function Calling 的优势

自然交互：用户可以用自然语言描述需求
智能理解：大模型理解意图和上下文
灵活适应：适应不同的表达方式
减少开发：不需要编写复杂的参数解析逻辑
提升体验：更友好的用户界面

⚠️ Function Calling 的局限性

依赖模型：需要支持 Function Calling 的大模型
标准化不足：每个大模型的实现方式不同
扩展性有限：难以支持复杂的工具链
协议不统一：没有统一的通信标准
生态分散：每个应用需要单独集成

Q2: MCP 和 Function Calling 有什么区别？

🔄 MCP vs Function Calling 对比

维度	Function Calling	MCP
本质	大模型的功能特性	开放标准协议
范围	单一大模型内部	跨平台、跨模型
标准化	各大模型实现不同	统一的通信协议
扩展性	有限	强大，支持工具、资源、提示词
生态	分散	统一的生态系统
开发成本	每个应用单独开发	一次开发，多处使用
维护成本	高	低

🎯 MCP 是 Function Calling 的升级版

Function Calling 的痛点：

❌ 每个大模型的实现方式不同
❌ 需要为每个应用单独开发
❌ 缺乏统一的工具管理
❌ 难以支持复杂的工具链
❌ 生态分散，难以复用

MCP 的解决方案：

✅ 统一的协议标准
✅ 跨平台、跨模型支持
✅ 标准化的工具、资源、提示词
✅ 可扩展的架构
✅ 统一的生态系统

Function Calling 就像是：

每个品牌都有自己的充电器
iPhone 用 Lightning，Android 用 USB-C
每次换手机都要换充电器
充电器之间不能通用

**MCP 就像是：

USB 接口标准
所有设备都用 USB
一次开发，所有设备都能用
充电器可以跨品牌使用

Q3: 如何选择传输方式？

🔄 传输方式的作用

传输方式是指 MCP Client 和 MCP Server 之间的通信方式，就像两个人之间用什么方式交流（面对面、打电话、发短信等）。

┌─────────────────────────────────────────────────────────┐
│                    大模型 (LLM)                          │
│                  (Claude/GPT 等)                         │
└────────────────────┬────────────────────────────────────┘
                     │
                     │ MCP 协议
                     │
┌────────────────────▼────────────────────────────────────┐
│                  MCP Client                              │
│              (Claude Desktop 等)                        │
└────────────────────┬────────────────────────────────────┘
                     │
                     │ 传输方式 ⬅️ 这里！
                     │  stdio / SSE / WebSocket
                     │
┌────────────────────▼────────────────────────────────────┐
│                  MCP Server                              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐ │
│  │  工具 (Tools) │  │ 资源 (Resources) │  │ 提示词 (Prompts) │ │
│  └──────────────┘  └──────────────┘  └──────────────┘ │
└─────────────────────────────────────────────────────────┘

📦 三种主要传输方式

1. stdio (标准输入输出）

MCP Client ── stdin ──> MCP Server
   ↑                    ↓
   └── stdout ────────────┘

特点：

适合本地开发
简单易用，无需额外配置
性能较好，延迟低
通过标准输入输出通信

适用场景：

Claude Desktop 本地集成
本地开发和测试
服务运行在同一台机器上

配置示例：

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["path/to/weather_server.py"]
    }
  }
}

2. SSE (Server-Sent Events)

MCP Client <─── HTTP/SSE ───> MCP Server
   ↑                          ↓
   └──────────────────────────┘

特点：

适合 Web 应用
支持实时推送
需要服务器部署
基于 HTTP 协议

适用场景：

Web 应用集成
远程服务部署
需要实时更新

配置示例：

const transport = new SSEClientTransport(new URL('http://localhost:3000/sse'));
await client.connect(transport);

3. WebSocket

MCP Client <─── WebSocket ───> MCP Server
   ↑                           ↓
   └───────────────────────────┘

特点：

双向通信
低延迟
复杂度较高
实时性强

适用场景：

需要频繁双向通信
实时协作应用
复杂的交互场景

📊 传输方式对比

特性	stdio	SSE	WebSocket
适用场景	本地开发	Web 应用	实时协作
部署难度	简单	中等	较复杂
性能	最好	良好	优秀
延迟	低	中	很低
双向通信	否	否	是
实时推送	否	是	是
防火墙	无影响	需要开放端口	需要开放端口
跨网络	否	是	是

🎯 选择建议

选择 stdio：

✅ Claude Desktop 本地集成
✅ 服务和客户端在同一台机器
✅ 简单快速部署
✅ 不需要网络访问

选择 SSE：

✅ Web 应用集成
✅ 服务部署在远程服务器
✅ 需要实时更新
✅ 基于标准 HTTP 协议

选择 WebSocket：

✅ 需要频繁双向通信
✅ 实时协作应用
✅ 低延迟要求高
✅ 复杂的交互场景

💡 实际应用示例

场景 1：Claude Desktop 本地集成

{
  "mcpServers": {
    "weather": {
      "command": "python",
      "args": ["path/to/weather_server.py"]
    }
  }
}

使用 stdio 传输方式

场景 2：Web 应用集成

const transport = new SSEClientTransport(new URL('http://localhost:3000/sse'));
await client.connect(transport);

使用 SSE 传输方式

场景 3：实时协作应用

const transport = new WebSocketClientTransport(new URL('ws://localhost:3000/ws'));
await client.connect(transport);

使用 WebSocket 传输方式

Q4: MCP Server 可以部署在云端吗？

可以！MCP Server 可以部署在任何地方：

本地机器
云服务器（AWS、GCP、Azure）
容器（Docker、Kubernetes）
Serverless 平台（AWS Lambda、Cloud Functions）

Q4: 如何调试 MCP Server？

启用调试日志：

const logger = new Logger('my-server', { level: 'debug' });

使用 MCP Inspector：

npx @modelcontextprotocol/inspector node server/index.js

手动测试：

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' | node server/index.js

Q5: MCP 支持哪些编程语言？

官方支持：

TypeScript/JavaScript
Python

社区支持：

Go
Rust
Java
C#
Ruby

六、资源链接

官方资源

社区资源

mcp 广场

学习资源

七、总结

MCP (Model Context Protocol) 是一个强大的开放标准，让应用能够以标准化方式为大语言模型提供上下文和数据。通过 MCP，我们可以：

标准化集成：使用统一的协议连接各种应用和大模型
扩展能力：让大模型能够访问外部数据源和工具
提高效率：自动化复杂的工作流程
降低成本：减少重复开发工作

开发 MCP Server 的关键步骤：

选择合适的编程语言和 SDK
定义工具、资源和提示词
实现业务逻辑
配置和部署
测试和优化

大模型整合 MCP 的方式：

通过 Claude Desktop 配置
使用 MCP Client SDK
在应用中集成
实现自动化工作流

随着 MCP 生态的不断发展，越来越多的应用和服务将会支持 MCP，为大模型应用带来更多可能性。

2048 AI社区

有“AI”的1024 = 2048，欢迎大家加入2048 AI社区

更多推荐

让“小爱音箱PRO”智能起来：接入豆包AI

下面提供，包含豆包 API 申请、MiGPT 部署、配置与使用，确保你能顺利让小爱音箱 Pro 用上豆包的强大能力。

2048 AI社区

TRAE Rules 高效使用指南：让 AI 更听话的秘密

随着项目复杂度的提升和任务难度的增加，单条 Rule 的局限性逐渐显现。本文将深入解析 TRAE Rules 的最新升级，从问题分析到解决方案，从最佳实践到实际应用，帮助你掌握让 AI 更"听话"的秘诀。

2048 AI社区

TRAE AI 编程助手生态系统深度解析：智能体、MCP 与 SOLO Coder 的协同之道

本文将深入解析 TRAE 的三大核心功能：**自定义智能体（Custom Agents）**、**MCP（Model Context Protocol）协议** 以及 **SOLO Coder 多智能体协作模式**，帮助开发者全面了解如何通过这些工具提升编程效率。

2048 AI社区

所有评论(0)

查看更多评论

而非丶

@weixin_45980775

已为社区贡献1条内容

【无标题】

而非丶

MCP (Model Context Protocol) 完全指南 万字精讲 - 什么是 MCP、怎么开发 MCP 服务、大模型如何整合 MCP 服务

一、什么是 MCP

1.1 MCP 简介

📊 有 MCP vs 没有 MCP 的对比

💡 MCP 的定义

1.3 MCP 架构

二、如何开发一个 MCP 服务

2.1 MCP 服务的整体开发逻辑

🎯 开发流程概览

📦 MCP 服务的三大核心组件

🔑 核心概念

2.2 开发环境准备

选择开发语言

安装 Python SDK

2.3 完整示例：天气查询 MCP 服务

2.4 代码解析

关键部分说明

2.5 扩展服务功能

添加更多工具

添加资源

2.6 测试和调试

使用 MCP Inspector

手动测试

2.7 部署和配置

部署到 Claude Desktop

2.8 开发最佳实践

设计原则

安全考虑

三、大模型如何整合 MCP 服务

3.1 整体集成流程

🎯 集成概览

🔑 核心概念

3.2 配置 Claude Desktop

配置文件位置

配置天气查询服务

配置多个服务

3.3 启动和测试

启动 Claude Desktop

测试天气查询服务

3.4 MCP 与大模型的交互流程

3.5 实际应用场景

场景 1：智能助手

场景 2：数据分析助手

场景 3：代码开发助手

3.6 自定义应用集成

使用 MCP Client SDK

3.7 故障排查

常见问题

调试方法

四、最佳实践

4.1 工具设计原则

4.2 性能优化

4.3 安全考虑

4.4 监控和日志

五、常见问题

Q1: 什么是 Function Calling？

🧠 Function Calling 的概念

🎯 Function Calling 的工作原理

🔑 Function Calling vs 传统 API 调用

🎯 Function Calling 的优势

⚠️ Function Calling 的局限性

Q2: MCP 和 Function Calling 有什么区别？

🔄 MCP vs Function Calling 对比

🎯 MCP 是 Function Calling 的升级版

Q3: 如何选择传输方式？

🔄 传输方式的作用

📦 三种主要传输方式

📊 传输方式对比

🎯 选择建议

💡 实际应用示例

Q4: MCP Server 可以部署在云端吗？

Q4: 如何调试 MCP Server？

Q5: MCP 支持哪些编程语言？

六、资源链接

官方资源

社区资源

mcp 广场

学习资源

MCP (Model Context Protocol) 完全指南万字精讲 - 什么是 MCP、怎么开发 MCP 服务、大模型如何整合 MCP 服务