1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

传统方式：Claude 只能看到你发给它的文本
MCP方式：Claude 可以主动调用工具获取信息

┌─────────────┐     MCP协议      ┌─────────────┐
│  Claude Code │ ◄────────────► │  外部服务    │
└─────────────┘                 └─────────────┘
                                    ├── 文件系统
                                    ├── 数据库
                                    ├── GitHub
                                    ├── Slack
                                    ├── Google Drive
                                    └── 自定义工具

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 添加文件系统访问
claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem ~/Documents ~/Projects

# 添加 GitHub 集成
claude mcp add github -e GITHUB_TOKEN=your_token -- npx -y @modelcontextprotocol/server-github

# 添加内存服务（持久化记忆）
claude mcp add memory -- npx -y @modelcontextprotocol/server-memory

# 查看已配置的服务器
claude mcp list

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/Projects"],
      "env": {}
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_xxxxxxxxxxxx"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

You: 帮我查一下最近7天注册的用户数量，按天分组

Claude: 我来查询数据库...
[调用 postgres MCP 服务器]

查询结果：
| 日期 | 新增用户数 |
|------|-----------|
| 12-20 | 156 |
| 12-21 | 189 |
| 12-22 | 203 |
| 12-23 | 178 |
| 12-24 | 245 |
| 12-25 | 312 |
| 12-26 | 198 |

总计：1,481 位新用户
可以看出 12-25（圣诞节）有明显的注册高峰。

1
2
3
4
5
6
7

用户输入 → [UserPromptSubmit Hook] → Claude 思考
                                          ↓
                              [PreToolUse Hook] → 工具执行
                                                      ↓
                                          [PostToolUse Hook] → 返回结果
                                                                   ↓
                                                          [Stop Hook] → 会话结束

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "echo '[AUDIT] Bash command: $TOOL_INPUT' >> ~/.claude/audit.log"
          }
        ]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command", 
            "command": "npx prettier --write $FILE_PATH 2>/dev/null || true"
          }
        ]
      }
    ],
    "UserPromptSubmit": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "/path/to/validate-prompt.sh"
          }
        ]
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint:fix -- $FILE_PATH"
          }
        ]
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit|MultiEdit",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$TOOL_INPUT\" 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

#!/bin/bash
# ~/.claude/scripts/validate-bash.sh

DANGEROUS_PATTERNS="rm -rf|DROP TABLE|DELETE FROM|format|mkfs"

if echo "$TOOL_INPUT" | grep -qE "$DANGEROUS_PATTERNS"; then
    echo "BLOCKED: 检测到危险命令"
    exit 1
fi

exit 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "~/.claude/scripts/validate-bash.sh"
          }
        ]
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

{
  "hooks": {
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "curl -X POST -H 'Content-type: application/json' --data '{\"text\":\"Claude Code 任务完成!\"}' $SLACK_WEBHOOK_URL"
          }
        ]
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

用户请求
    ↓
主 Agent (nO 函数)
    ↓
是否调用 Task 工具？
    ├── 否 → 直接处理 → 返回结果
    └── 是 → 创建 SubAgent
              ↓
         并发执行调度器 (UH1)
              ↓
         多个 SubAgent 并行执行
              ↓
         结果合成器 (KN5)
              ↓
         返回合成结果

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

You: 分析这个项目的代码质量，包括：
1. 代码结构是否合理
2. 是否有潜在的性能问题
3. 测试覆盖率如何
4. 安全漏洞检查

Claude: 这是一个复杂的分析任务，我会启动多个 SubAgent 并行处理：

[启动 SubAgent 1] 分析代码结构...
[启动 SubAgent 2] 检查性能问题...
[启动 SubAgent 3] 分析测试覆盖率...
[启动 SubAgent 4] 扫描安全漏洞...

[等待所有 SubAgent 完成...]

[合成结果] 综合所有 Agent 的分析：
...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

const SUBAGENT_ALLOWED_TOOLS = [
    'Read',       // 读取文件
    'Write',      // 写入文件
    'Edit',       // 编辑文件
    'MultiEdit',  // 多处编辑
    'Glob',       // 文件搜索
    'Grep',       // 内容搜索
    'Bash',       // 执行命令
    'WebFetch',   // 网页获取
    'WebSearch',  // 网络搜索
    'TodoRead',   // 读取任务
    'TodoWrite',  // 写入任务
];

// 被禁用的工具（防止递归）
const BLOCKED_TOOLS = ['Task'];

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

You: 帮我同时搜索项目中所有的 TODO 注释、FIXME 标记和废弃的 API 调用

Claude: 我会并行启动 3 个搜索任务：

[SubAgent 1] 搜索 TODO 注释...
[SubAgent 2] 搜索 FIXME 标记...
[SubAgent 3] 搜索废弃 API 调用...

--- 3 秒后 ---

[SubAgent 1 完成] 找到 23 个 TODO
[SubAgent 2 完成] 找到 8 个 FIXME
[SubAgent 3 完成] 找到 5 个废弃 API

[合成结果]
## 代码待办事项汇总

### TODO (23处)
- src/api/user.ts:45 - TODO: 添加缓存
- src/components/Table.tsx:123 - TODO: 优化渲染性能
...

### FIXME (8处)
- src/utils/date.ts:67 - FIXME: 时区处理有问题
...

### 废弃 API (5处)
- src/legacy/auth.ts:12 - 使用了已废弃的 crypto.createCipher
...

1
2

claude
> /init

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 项目配置

## 项目概述
这是一个 Next.js 14 电商平台，使用 TypeScript + Prisma + PostgreSQL。

## 技术栈
- 框架：Next.js 14 (App Router)
- 语言：TypeScript 5.x (严格模式)
- 数据库：PostgreSQL + Prisma ORM
- 样式：Tailwind CSS
- 状态管理：Zustand
- 测试：Vitest + Testing Library

## 代码规范
- 使用 ESLint + Prettier 格式化
- 组件使用函数式写法
- 所有函数必须有 JSDoc 注释
- 禁止使用 any 类型
- 错误处理使用自定义 Error 类

## 目录结构

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

## 常用命令
- `npm run dev` - 启动开发服务器
- `npm run build` - 构建生产版本
- `npm run test` - 运行测试
- `npm run lint` - 代码检查
- `npx prisma studio` - 打开数据库管理界面

## Git 提交规范
- feat: 新功能
- fix: 修复 Bug
- refactor: 重构
- docs: 文档
- test: 测试
- chore: 构建/工具

## 注意事项
- 数据库敏感操作需要人工确认
- 不要直接修改 prisma/migrations 目录
- API 路由必须有权限验证

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 本地配置

## 个人偏好
- 我喜欢详细的注释
- 代码示例要完整可运行
- 解释时使用中文

## 本地环境
- Node.js: v20.10.0
- 数据库：本地 Docker 容器
- 端口：3000 (开发), 5432 (PostgreSQL)

## 调试配置
- 使用 VS Code 调试
- 断点调试端口: 9229

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 全局配置

## 通用规范
- 使用 2 空格缩进
- 变量命名使用 camelCase
- 常量使用 UPPER_SNAKE_CASE
- 组件使用 PascalCase

## 默认工具
- 包管理器：pnpm
- 版本控制：Git
- 编辑器：VS Code

## 安全规则
- 不要在代码中硬编码密钥
- 敏感文件（.env）不要提交
- API 调用必须有超时设置

1
2
3
4
5

.claude/
└── commands/
    ├── review.md      # /review 命令
    ├── test.md        # /test 命令
    └── deploy.md      # /deploy 命令

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

请对当前项目进行代码审查：

1. 检查代码质量
   - 是否有重复代码
   - 函数是否过长
   - 命名是否清晰

2. 检查潜在问题
   - 是否有未处理的错误
   - 是否有性能问题
   - 是否有安全漏洞

3. 检查最佳实践
   - 是否遵循项目规范
   - 是否有充分的测试
   - 是否有必要的注释

请提供详细的改进建议。

1

> /review

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "~/Projects"],
      "env": {}
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  },
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npx prettier --write \"$FILE_PATH\" 2>/dev/null || true"
          }
        ]
      }
    ],
    "Stop": [
      {
        "hooks": [
          {
            "type": "command",
            "command": "echo \"[$(date)] Task completed\" >> ~/.claude/activity.log"
          }
        ]
      }
    ]
  },
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git *)",
      "Bash(npx prettier *)"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(sudo *)"
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

1. 启动项目
   > claude
   > /init  # 生成 CLAUDE.md

2. 查看项目状态
   > /review  # 运行自定义代码审查命令

3. 开发新功能
   > 帮我实现用户头像上传功能，要支持裁剪和压缩
   
   [Claude 自动]:
   - 分析项目结构
   - 创建组件文件（自动格式化）
   - 编写测试用例
   - 更新文档

4. 提交代码
   > 提交这些改动，写一个清晰的 commit message
   
   [Claude 使用 GitHub MCP]:
   - 生成 commit message
   - 创建 commit
   - 可选：创建 PR

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 反例
{
  "name": "db_query",
  "description": "对主库执行 SQL 查询"
}

# 正例
{
  "name": "search_orders",
  "description": "按用户 ID、时间范围或订单状态查询订单。
                  用于回答'用户买过什么''某笔订单到哪了'这类问题。
                  不要用它查商品库存——那是 search_inventory 的活。"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 反例:status 是 str,模型自由发挥
def search_orders(user_id: str, status: str): ...

# 正例:枚举,模型只能在合法值里选
from enum import Enum
class OrderStatus(str, Enum):
    PENDING = "pending"
    SHIPPED = "shipped"
    DELIVERED = "delivered"
    CANCELLED = "cancelled"

def search_orders(user_id: str, status: OrderStatus | None = None): ...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

{
  "data": [{
    "order_id": "ord_8f3a2b1c-9d4e-4f5a-8b6c-1d2e3f4a5b6c",
    "tenant_uuid": "tn_a1b2c3d4",
    "created_at_unix": 1747300800,
    "updated_at_unix": 1747387200,
    "row_version": 7,
    "status_code": 2,
    "_internal_flags": { "is_migrated": true, "shard": 3 }
  }]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

{
  "orders": [{
    "id": "ord_8f3a2b1c",
    "status": "shipped",
    "created_at": "2026-05-15 14:00",
    "total": "¥299.00",
    "items_summary": "无线耳机 x1"
  }],
  "total_count": 47,
  "showing": "1-10",
  "hint": "还有 37 条,加 status 或更窄的时间范围可缩小结果"
}

1
2
3

raise ValueError("Invalid input")          # 模型:啥 input?哪儿错了?
return {"error": "ERR_4012"}                 # 模型:4012 是什么我怎么知道
raise Exception(traceback...)                # 模型:吞掉半屏 token,然后还是不知道咋办

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 正例:说清错在哪 + 给出可执行的下一步
return {
  "error": "参数 status 的值 '发货中' 不合法",
  "valid_values": ["pending", "shipped", "delivered", "cancelled"],
  "hint": "你可能想用 'shipped'"
}

return {
  "error": "未找到 user_id 'u_999' 对应的用户",
  "hint": "确认 ID 是否正确,或先用 search_users 按用户名查到 ID"
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 开发者A的实现
class ClaudeWithDatabase:
    def query_db(self, sql):
        # 自己写数据库连接逻辑
        conn = psycopg2.connect(...)
        # 自己写SQL执行逻辑
        cursor.execute(sql)
        # 自己写结果格式化
        return format_results(...)

# 开发者B的实现（完全不同）
class GPTWithDatabase:
    def db_query(self, query):
        # 又要重新实现一遍
        engine = create_engine(...)
        # 完全不同的接口
        return engine.execute(query)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 任何AI都可以使用同一个MCP服务器
from mcp import Client

# 连接到数据库MCP服务器
client = Client("postgresql://localhost:5432/mydb")

# Claude使用
claude_response = claude.chat(
    "查询上月销售数据",
    tools=[client]  # 直接传入MCP客户端
)

# GPT使用（完全相同的方式）
gpt_response = gpt.chat(
    "查询上月销售数据",
    tools=[client]  # 同一个工具！
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 完整的MCP通信示例
class MCPCommunicationFlow:
    def demonstrate(self):
        # Step 1: AI发现可用工具
        tools = mcp_client.list_tools()
        # 返回: [
        #   {"name": "query_database", "description": "查询PostgreSQL数据库"},
        #   {"name": "read_file", "description": "读取本地文件"},
        # ]
        
        # Step 2: AI选择并调用工具
        result = mcp_client.call_tool(
            name="query_database",
            arguments={
                "sql": "SELECT * FROM sales WHERE month = '2025-11'"
            }
        )
        
        # Step 3: MCP服务器执行并返回结果
        # result = {
        #   "content": [
        #     {"type": "text", "text": "找到123条记录"},
        #     {"type": "resource", "uri": "db://sales/2025-11"}
        #   ]
        # }
        
        # Step 4: AI处理结果并回复用户
        return ai_model.generate_response(result)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// 请求示例
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "query_database",
    "arguments": {
      "sql": "SELECT COUNT(*) FROM users"
    }
  }
}

// 响应示例
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "总用户数: 1,234,567"
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

# file_server.py
from mcp.server import Server
from mcp.types import Tool, TextContent
import os

# 创建MCP服务器
app = Server("file-reader")

# 定义工具
@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="read_file",
            description="读取本地文件内容",
            inputSchema={
                "type": "object",
                "properties": {
                    "path": {
                        "type": "string",
                        "description": "文件路径"
                    }
                },
                "required": ["path"]
            }
        )
    ]

# 实现工具逻辑
@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "read_file":
        path = arguments["path"]
        
        # 安全检查
        if not os.path.exists(path):
            return [TextContent(
                type="text",
                text=f"错误：文件 {path} 不存在"
            )]
        
        # 读取文件
        with open(path, 'r', encoding='utf-8') as f:
            content = f.read()
        
        return [TextContent(
            type="text",
            text=f"文件内容：\n{content}"
        )]

# 启动服务器
if __name__ == "__main__":
    app.run()

1
2

python file_server.py
# MCP服务器启动在 stdio://

1
2
3
4
5
6
7
8
9

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "file-reader": {
      "command": "python",
      "args": ["/path/to/file_server.py"]
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

# database_server.py
from mcp.server import Server
from mcp.types import Tool, TextContent, Resource
import psycopg2
import pandas as pd

app = Server("postgres-query")

# 数据库连接配置
DB_CONFIG = {
    "host": "localhost",
    "database": "myapp",
    "user": "postgres",
    "password": "secret"
}

@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="query_database",
            description="执行SQL查询并返回结果",
            inputSchema={
                "type": "object",
                "properties": {
                    "sql": {
                        "type": "string",
                        "description": "SQL查询语句"
                    },
                    "format": {
                        "type": "string",
                        "enum": ["table", "json", "markdown"],
                        "description": "返回格式",
                        "default": "markdown"
                    }
                },
                "required": ["sql"]
            }
        ),
        Tool(
            name="list_tables",
            description="列出数据库中的所有表",
            inputSchema={"type": "object", "properties": {}}
        )
    ]

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    conn = psycopg2.connect(**DB_CONFIG)
    
    try:
        if name == "list_tables":
            # 查询所有表
            df = pd.read_sql("""
                SELECT table_name 
                FROM information_schema.tables 
                WHERE table_schema = 'public'
            """, conn)
            
            tables = df['table_name'].tolist()
            return [TextContent(
                type="text",
                text=f"数据库表：\n" + "\n".join(f"- {t}" for t in tables)
            )]
        
        elif name == "query_database":
            sql = arguments["sql"]
            format_type = arguments.get("format", "markdown")
            
            # 执行查询
            df = pd.read_sql(sql, conn)
            
            # 格式化输出
            if format_type == "markdown":
                result = df.to_markdown(index=False)
            elif format_type == "json":
                result = df.to_json(orient="records", indent=2)
            else:
                result = str(df)
            
            return [TextContent(
                type="text",
                text=f"查询结果（{len(df)}行）：\n{result}"
            )]
    
    finally:
        conn.close()

if __name__ == "__main__":
    app.run()

1
2
3
4
5
6
7
8
9

# 用户只需要说话，AI自动完成整个分析流程
用户: "分析一下我们Q4的销售趋势"

# AI的工作流程（全自动）：
1. [调用list_tables] 发现有sales表
2. [调用query_database] 查询Q4数据
3. [调用python_executor] 用pandas分析趋势
4. [调用chart_generator] 生成可视化图表
5. [返回分析报告] "Q4销售呈上升趋势，环比增长23%..."

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# analytics_server.py
@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "analyze_sales":
        # Step 1: 查询数据
        df = query_sales_data(arguments["period"])
        
        # Step 2: 自动分析
        insights = {
            "total": df['amount'].sum(),
            "growth": calculate_growth(df),
            "top_products": df.groupby('product')['amount'].sum().nlargest(5),
            "trend": detect_trend(df)
        }
        
        # Step 3: 生成图表
        chart_url = generate_chart(df)
        
        # Step 4: 返回结果
        return [
            TextContent(type="text", text=format_insights(insights)),
            Resource(type="image", uri=chart_url)
        ]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 开发者的梦想：AI能直接操作代码库
用户: "帮我重构auth模块，添加OAuth支持"

# AI的操作：
1. [调用git_server] 创建新分支 feature/oauth
2. [调用file_server] 读取现有auth代码
3. [调用code_generator] 生成OAuth实现
4. [调用file_server] 写入新代码
5. [调用test_runner] 运行测试
6. [调用git_server] 提交并推送
7. [返回] "重构完成，所有测试通过，PR已创建"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

{
  "mcpServers": {
    "git": {
      "command": "mcp-git-server"
    },
    "filesystem": {
      "command": "mcp-file-server",
      "args": ["--root", "/Users/dev/myproject"]
    },
    "test-runner": {
      "command": "mcp-pytest-server"
    }
  }
}

1
2
3
4
5
6
7
8
9

# 连接公司所有数据源
用户: "上季度客户投诉最多的问题是什么？"

# AI自动整合多个数据源：
1. [调用jira_server] 查询工单系统
2. [调用slack_server] 搜索客服频道
3. [调用database_server] 查询CRM数据
4. [调用confluence_server] 检索知识库
5. [综合分析] "最多的投诉是配送延迟（占37%），主要原因是..."

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 安装官方服务器
npm install -g @modelcontextprotocol/server-github

# 配置到Claude Desktop
{
  "mcpServers": {
    "github": {
      "command": "mcp-server-github",
      "env": {
        "GITHUB_TOKEN": "your_token_here"
      }
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 一些有趣的社区服务器
awesome_mcp_servers = [
    "mcp-server-notion",      # Notion笔记集成
    "mcp-server-gmail",       # Gmail邮件管理
    "mcp-server-calendar",    # Google Calendar
    "mcp-server-docker",      # Docker容器管理
    "mcp-server-kubernetes",  # K8s集群操作
    "mcp-server-aws",         # AWS云服务
    "mcp-server-stripe",      # 支付处理
    "mcp-server-openai",      # OpenAI API封装
]

1
2
3
4
5

pip install mcp
mcp create my-server
cd my-server
# 编辑 server.py
python server.py

1
2
3
4
5

npm create @modelcontextprotocol/server my-server
cd my-server
# 编辑 src/index.ts
npm run build
npm start

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# ❌ 危险：直接执行用户SQL
@app.call_tool()
async def call_tool(name: str, arguments: dict):
    sql = arguments["sql"]
    return execute_sql(sql)  # SQL注入风险！

# ✅ 安全：参数化查询 + 权限控制
@app.call_tool()
async def call_tool(name: str, arguments: dict):
    # 1. 验证用户权限
    if not user.has_permission("query_database"):
        return [TextContent(type="text", text="权限不足")]
    
    # 2. 白名单检查
    allowed_tables = ["users", "orders", "products"]
    if not all(table in allowed_tables for table in extract_tables(sql)):
        return [TextContent(type="text", text="不允许查询该表")]
    
    # 3. 参数化查询
    sql = arguments["sql"]
    params = arguments.get("params", [])
    return execute_safe_sql(sql, params)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    try:
        # 执行操作
        result = perform_operation(arguments)
        return [TextContent(type="text", text=result)]
    
    except FileNotFoundError as e:
        # 友好的错误提示
        return [TextContent(
            type="text",
            text=f"❌ 文件不存在：{e.filename}\n建议：检查文件路径是否正确"
        )]
    
    except PermissionError:
        return [TextContent(
            type="text",
            text="❌ 权限不足\n建议：使用sudo或检查文件权限"
        )]
    
    except Exception as e:
        # 记录详细错误日志
        logger.error(f"MCP tool error: {e}", exc_info=True)
        # 返回用户友好的错误
        return [TextContent(
            type="text",
            text=f"❌ 操作失败：{str(e)}"
        )]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# 使用缓存减少重复查询
from functools import lru_cache

@lru_cache(maxsize=100)
def query_database(sql: str):
    # 相同的SQL查询会被缓存
    return execute_sql(sql)

# 异步处理提高并发
import asyncio

@app.call_tool()
async def call_tool(name: str, arguments: dict):
    # 并行执行多个操作
    results = await asyncio.gather(
        query_database(sql1),
        query_database(sql2),
        read_file(path)
    )
    return combine_results(results)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 2025年：基础工具集成
current_capabilities = [
    "文件系统访问",
    "数据库查询",
    "API调用",
    "Git操作"
]

# 2026年预测：更智能的工具
future_capabilities = [
    "自动工具组合（AI自己决定调用哪些工具）",
    "工具学习（根据使用反馈优化工具行为）",
    "跨服务器协作（多个MCP服务器协同工作）",
    "实时数据流（WebSocket支持）",
    "工具市场（一键安装社区工具）"
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

用户: "网站响应变慢了"

AI自动执行：
1. [调用monitoring_server] 检查服务器指标
2. [调用log_server] 分析错误日志
3. [调用database_server] 检查慢查询
4. [调用docker_server] 重启有问题的容器
5. [调用slack_server] 通知团队

结果: "已自动修复，原因是数据库连接池耗尽"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

客户: "我的订单怎么还没发货？"

AI自动处理：
1. [调用crm_server] 查询客户信息
2. [调用order_server] 查询订单状态
3. [调用logistics_server] 查询物流信息
4. [调用email_server] 发送更新邮件
5. [调用ticket_server] 创建跟进工单

回复: "您的订单已在配送中，预计明天送达"

1

人类 → 使用AI → 获得答案

1

人类 → 告诉AI目标 → AI使用工具 → 完成任务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 以前：开发AI应用很难
def build_ai_app():
    学习LLM API ✅
    + 实现工具集成 ❌ (难)
    + 处理错误和边界情况 ❌ (难)
    + 维护和更新 ❌ (难)
    = 放弃 😭

# 现在：使用MCP很简单
def build_ai_app_with_mcp():
    学习LLM API ✅
    + 安装MCP服务器 ✅ (简单)
    + 配置JSON文件 ✅ (简单)
    = 成功 🎉

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 1. 安装MCP SDK
pip install mcp

# 2. 创建你的第一个服务器
mcp create my-first-server

# 3. 在Claude Desktop中配置
# 编辑 ~/Library/Application Support/Claude/claude_desktop_config.json

# 4. 开始使用！