1
问题现状：
2

3
Claude Desktop → 需要开发 Claude 专用工具
4
Cursor IDE → 需要开发 Cursor 专用工具
5
Windsurf → 需要开发 Windsurf 专用工具
6
自定义应用 → 需要开发自己的工具体系
7

8
结果：
9
• 开发者重复造轮子
10
• 用户在不同平台体验不一致
11
• 工具生态无法共享
12
• 维护成本高昂

1
┌─────────────────────────────────────────────────────────────┐
2
│                    MCP 核心价值                              │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  对开发者：                                                  │
6
│  一次开发，多处使用                                       │
7
│  统一的工具接口标准                                       │
8
│  减少维护成本                                            │
9
│  接入更多 AI 应用                                        │
10
│                                                             │
11
│  对用户：                                                    │
12
│  工具可在不同应用间共享                                   │
13
│  体验一致性                                              │
14
│  更丰富的工具生态                                         │
15
│                                                             │
16
│  对 AI 应用：                                                │
17
│  即插即用的工具生态                                       │
18
│  降低工具开发门槛                                         │
19
│  专注核心能力                                            │
20
│                                                             │
21
└─────────────────────────────────────────────────────────────┘

1
┌─────────────────────────────────────────────────────────────┐
2
│                    MCP 组件职责                              │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  MCP Host（宿主应用）                                        │
6
│  ├── 定义：集成 MCP 的 AI 应用                              │
7
│  ├── 职责：                                                 │
8
│  │   ├── 提供 AI 能力                                      │
9
│  │   ├── 管理 MCP Client                                   │
10
│  │   ├── 展示工具结果                                      │
11
│  │   └── 处理用户交互                                      │
12
│  └── 示例：Claude Desktop、Cursor、Windsurf                 │
13
│                                                             │
14
│  MCP Client（客户端）                                        │
15
│  ├── 定义：Host 内的 MCP 客户端组件                         │
16
│  ├── 职责：                                                 │
17
│  │   ├── 建立 Server 连接                                  │
18
│  │   ├── 发送请求和接收响应                                 │
19
│  │   ├── 能力协商                                          │
20
│  │   └── 消息路由                                          │
21
│  └── 每个 Host 可管理多个 Client                            │
22
│                                                             │
23
│  MCP Server（服务器）                                        │
24
│  ├── 定义：提供工具和资源的后端服务                         │
25
│  ├── 职责：                                                 │
26
│  │   ├── 暴露工具列表                                      │
27
│  │   ├── 提供资源访问                                      │
28
│  │   ├── 执行工具调用                                      │
29
│  │   └── 发送通知                                          │
30
│  └── 可以是本地进程或远程服务                                │
31
│                                                             │
32
└─────────────────────────────────────────────────────────────┘

1
# MCP 支持两种传输方式
2

3
# 1. Stdio（标准输入输出）
4
# 适用于本地工具，Server 作为子进程运行
5
{
6
    "transport": "stdio",
7
    "command": "python",
8
    "args": ["mcp_server.py"]
9
}
10

11
# 2. SSE（Server-Sent Events）
12
# 适用于远程服务，通过 HTTP 连接
13
{
14
    "transport": "sse",
15
    "url": "https://api.example.com/mcp"
16
}

1
// 请求格式
2
{
3
    "jsonrpc": "2.0",
4
    "id": 1,
5
    "method": "tools/list",
6
    "params": {}
7
}
8

9
// 成功响应格式
10
{
11
    "jsonrpc": "2.0",
12
    "id": 1,
13
    "result": {
14
        "tools": [...]
15
    }
16
}
17

18
// 错误响应格式
19
{
20
    "jsonrpc": "2.0",
21
    "id": 1,
22
    "error": {
23
        "code": -32600,
24
        "message": "Invalid Request"
25
    }
26
}

1
┌─────────────────────────────────────────────────────────────┐
2
│                    MCP 核心消息                              │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  初始化阶段                                                  │
6
│  ├── initialize：Client 发送能力列表，Server 返回自身能力    │
7
│  └── notifications/initialized：确认初始化完成              │
8
│                                                             │
9
│  工具操作                                                    │
10
│  ├── tools/list：获取可用工具列表                           │
11
│  ├── tools/call：调用指定工具                               │
12
│  └── notifications/tools/list_changed：工具列表变更通知      │
13
│                                                             │
14
│  资源操作                                                    │
15
│  ├── resources/list：获取可用资源列表                       │
16
│  ├── resources/read：读取指定资源                           │
17
│  ├── resources/templates/list：获取资源模板                 │
18
│  └── notifications/resources/updated：资源更新通知           │
19
│                                                             │
20
│  提示词操作                                                  │
21
│  ├── prompts/list：获取可用提示词模板                       │
22
│  └── prompts/get：获取指定提示词                            │
23
│                                                             │
24
│  日志与采样                                                  │
25
│  ├── logging/setLevel：设置日志级别                         │
26
│  └── sampling/createMessage：请求 AI 生成消息               │
27
│                                                             │
28
└─────────────────────────────────────────────────────────────┘

1
// 初始化请求
2
{
3
    "jsonrpc": "2.0",
4
    "id": 1,
5
    "method": "initialize",
6
    "params": {
7
        "protocolVersion": "2024-11-05",
8
        "capabilities": {
9
            "tools": {},
10
            "resources": {"subscribe": true},
11
            "prompts": {}
12
        },
13
        "clientInfo": {
14
            "name": "my-client",
15
            "version": "1.0.0"
16
        }
17
    }
18
}
19

20
// 初始化响应
21
{
22
    "jsonrpc": "2.0",
23
    "id": 1,
24
    "result": {
25
        "protocolVersion": "2024-11-05",
26
        "capabilities": {
27
            "tools": {"listChanged": true},
28
            "resources": {"subscribe": true, "listChanged": true}
29
        },
30
        "serverInfo": {
31
            "name": "my-server",
32
            "version": "1.0.0"
33
        }
34
    }
35
}

1
{
2
  "jsonrpc": "2.0",
3
  "id": 2,
4
  "result": {
5
    "tools": [
6
      {
7
        "name": "get_weather",
8
        "description": "获取指定城市的天气信息",
9
        "inputSchema": {
10
          "type": "object",
11
          "properties": {
12
            "city": {
13
              "type": "string",
14
              "description": "城市名称"
15
            },
16
            "unit": {
17
              "type": "string",
18
              "enum": ["celsius", "fahrenheit"],
19
              "default": "celsius"
20
            }
21
          },
22
          "required": ["city"]
23
        }
24
      },
25
      {
26
        "name": "search_web",
27
        "description": "搜索网络获取信息",
28
        "inputSchema": {
29
          "type": "object",
30
          "properties": {
31
            "query": {
32
              "type": "string",
33
              "description": "搜索关键词"
34
            },
35
            "limit": {
36
              "type": "integer",
37
              "description": "返回结果数量",
38
              "default": 5
39
            }
40
          },
41
          "required": ["query"]
42
        }
43
      }
44
    ]
45
  }
46
}

1
// 工具调用请求
2
{
3
    "jsonrpc": "2.0",
4
    "id": 3,
5
    "method": "tools/call",
6
    "params": {
7
        "name": "get_weather",
8
        "arguments": {
9
            "city": "北京",
10
            "unit": "celsius"
11
        }
12
    }
13
}
14

15
// 工具调用响应（成功）
16
{
17
    "jsonrpc": "2.0",
18
    "id": 3,
19
    "result": {
20
        "content": [
21
            {
22
                "type": "text",
23
                "text": "北京今天晴，温度 15-25°C，空气质量良好"
24
            }
25
        ],
26
        "isError": false
27
    }
28
}
29

30
// 工具调用响应（错误）
31
{
32
    "jsonrpc": "2.0",
33
    "id": 3,
34
    "result": {
35
        "content": [
36
            {
37
                "type": "text",
38
                "text": "错误：无法获取城市天气信息"
39
            }
40
        ],
41
        "isError": true
42
    }
43
}

1
┌─────────────────────────────────────────────────────────────┐
2
│                    MCP 资源类型                              │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  静态资源                                                    │
6
│  ├── 文件资源：https://github.com/modelcontextprotocol/servers/blob/main/src/filesystem/README.md                         │
7
│  ├── 文档资源：document:///project/README.md                │
8
│  └── 配置资源：config:///settings.json                      │
9
│                                                             │
10
│  动态资源                                                    │
11
│  ├── 数据库记录：db:///users/123                            │
12
│  ├── API 响应：api:///weather/beijing                       │
13
│  └── 实时数据：stream:///logs/app                           │
14
│                                                             │
15
│  资源模板                                                    │
16
│  ├── 参数化路径：https://github.com/{org}/{repo}/blob/{branch}/{path}                             │
17
│  ├── 查询参数：db:///users?id={user_id}                     │
18
│  └── 模式匹配：log:///{app}/{date}                          │
19
│                                                             │
20
└─────────────────────────────────────────────────────────────┘

1
// 资源列表请求
2
{
3
    "jsonrpc": "2.0",
4
    "id": 4,
5
    "method": "resources/list"
6
}
7

8
// 资源列表响应
9
{
10
    "jsonrpc": "2.0",
11
    "id": 4,
12
    "result": {
13
        "resources": [
14
            {
15
                "uri": "https://github.com/modelcontextprotocol/python-sdk/blob/main/src/mcp/__init__.py",
16
                "name": "__init__.py",
17
                "description": "MCP SDK 主模块",
18
                "mimeType": "text/x-python"
19
            },
20
            {
21
                "uri": "https://github.com/modelcontextprotocol/python-sdk/blob/main/pyproject.toml",
22
                "name": "pyproject.toml",
23
                "description": "项目配置文件",
24
                "mimeType": "application/json"
25
            }
26
        ]
27
    }
28
}
29

30
// 资源读取请求
31
{
32
    "jsonrpc": "2.0",
33
    "id": 5,
34
    "method": "resources/read",
35
    "params": {
36
        "uri": "https://github.com/modelcontextprotocol/python-sdk/blob/main/src/mcp/__init__.py"
37
    }
38
}
39

40
// 资源读取响应
41
{
42
    "jsonrpc": "2.0",
43
    "id": 5,
44
    "result": {
45
        "contents": [
46
            {
47
                "uri": "https://github.com/modelcontextprotocol/python-sdk/blob/main/src/mcp/__init__.py",
48
                "mimeType": "text/x-python",
49
                "text": "def main():\n    print('Hello, World!')\n"
50
            }
51
        ]
52
    }
53
}

1
┌─────────────────────────────────────────────────────────────┐
2
│                    三种方案对比                              │
3
├───────────────┬─────────────┬────────────────┬──────────────┤
4
│ 维度          │ MCP         │ Function Call  │ OpenAPI      │
5
├───────────────┼─────────────┼────────────────┼──────────────┤
6
│ 设计目标      │ AI 工具标准 │ 模型能力扩展   │ API 文档标准 │
7
│ 发起方        │ Anthropic   │ OpenAI         │ Linux 基金会 │
8
│ 适用范围      │ 跨平台通用  │ 特定模型       │ REST API     │
9
│ 协议层        │ 应用层协议  │ 模型接口       │ 描述规范     │
10
│ 双向通信      │ 支持        │ 不支持         │ 不适用       │
11
│ 资源订阅      │ 支持        │ 不支持         │ 不适用       │
12
│ 发现机制      │ 内置        │ 需手动配置     │ Swagger UI   │
13
│ 状态管理      │ 支持        │ 不支持         │ 不适用       │
14
│ 安全模型      │ 权限控制    │ 依赖应用       │ OAuth 等     │
15
└───────────────┴─────────────┴────────────────┴──────────────┘

1
MCP 适合：
2
• 需要跨多个 AI 平台使用的工具
3
• 需要资源订阅和实时更新
4
• 需要统一的工具发现机制
5
• 构建可复用的工具生态
6

7
Function Calling 适合：
8
• 单一平台深度集成
9
• 快速原型开发
10
• 简单的工具调用场景
11
• 与特定模型深度优化
12

13
OpenAPI 适合：
14
• 已有 REST API 的 AI 化
15
• API 文档自动生成
16
• 与现有系统集成
17
• 企业内部 API 管理

1
┌─────────────────────────────────────────────────────────────┐
2
│                    官方 MCP Server                           │
3
├─────────────────────────────────────────────────────────────┤
4
│                                                             │
5
│  @modelcontextprotocol/server-filesystem                    │
6
│  ├── 功能：文件系统操作                                     │
7
│  ├── 支持：读写文件、目录遍历、文件搜索                      │
8
│  └── 用法：npx @modelcontextprotocol/server-filesystem      │
9
│                                                             │
10
│  @modelcontextprotocol/server-github                        │
11
│  ├── 功能：GitHub 操作                                      │
12
│  ├── 支持：仓库管理、Issue、PR、搜索                         │
13
│  └── 用法：需要 GitHub Token                                │
14
│                                                             │
15
│  @modelcontextprotocol/server-postgres                      │
16
│  ├── 功能：PostgreSQL 数据库                                │
17
│  ├── 支持：查询、Schema 发现                                │
18
│  └── 用法：配置数据库连接                                   │
19
│                                                             │
20
│  @modelcontextprotocol/server-sqlite                        │
21
│  ├── 功能：SQLite 数据库                                    │
22
│  ├── 支持：查询、Schema 发现                                │
23
│  └── 用法：指定数据库文件路径                                │
24
│                                                             │
25
│  @modelcontextprotocol/server-brave-search                  │
26
│  ├── 功能：Brave 搜索                                       │
27
│  ├── 支持：网页搜索                                         │
28
│  └── 用法：需要 Brave API Key                               │
29
│                                                             │
30
└─────────────────────────────────────────────────────────────┘

1
流行社区 MCP Server：
2

3
• mcp-server-puppeteer - 浏览器自动化
4
• mcp-server-docker - Docker 容器管理
5
• mcp-server-kubernetes - K8s 集群管理
6
• mcp-server-aws - AWS 服务集成
7
• mcp-server-linear - 项目管理
8
• mcp-server-notion - Notion 笔记
9
• mcp-server-slack - Slack 集成

1
from mcp.server import Server
2
from mcp.types import Tool, TextContent
3
import asyncio
4

5
# 创建 Server 实例
6
server = Server("my-custom-server")
7

8
# 定义工具列表
9
@server.list_tools()
10
async def list_tools():
11
    return [
12
        Tool(
13
            name="calculate",
14
            description="执行数学计算",
15
            inputSchema={
16
                "type": "object",
17
                "properties": {
18
                    "expression": {
19
                        "type": "string",
20
                        "description": "数学表达式，如：2 + 3 * 4"
21
                    }
22
                },
23
                "required": ["expression"]
24
            }
25
        ),
26
        Tool(
27
            name="get_time",
28
            description="获取当前时间",
29
            inputSchema={
30
                "type": "object",
31
                "properties": {},
32
                "required": []
33
            }
34
        )
35
    ]
36

37
# 实现工具调用
38
@server.call_tool()
39
async def call_tool(name: str, arguments: dict):
40
    if name == "calculate":
41
        try:
42
            result = eval(arguments["expression"])
43
            return [TextContent(type="text", text=str(result))]
44
        except Exception as e:
45
            return [TextContent(type="text", text=f"计算错误：{e}")]
46

47
    elif name == "get_time":
48
        from datetime import datetime
49
        now = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
50
        return [TextContent(type="text", text=f"当前时间：{now}")]
51

52
    return [TextContent(type="text", text=f"未知工具：{name}")]
53

54
# 运行 Server
55
async def main():
56
    from mcp.server.stdio import stdio_server
57

58
    async with stdio_server() as (read_stream, write_stream):
59
        await server.run(
60
            read_stream,
61
            write_stream,
62
            server.create_initialization_options()
63
        )
64

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