Agent（智能体）是指能够自主感知环境、做出决策、执行行动的 AI 系统。

和传统 LLM 对话最大的区别在于：
• 传统 LLM：你问一句，它答一句（被动响应）
• Agent：你给一个目标，它自己拆解任务、调用工具、解决问题（主动执行）

用户："帮我整理一份 AI Agent 的研究报告，发到我的邮箱"

Agent 的工作流：
┌─────────────────────────────────────────────────────────┐
│  Step 1: 任务理解                                        │
│  "用户需要一份 AI Agent 的研究报告，要发到邮箱"            │
├─────────────────────────────────────────────────────────┤
│  Step 2: 任务拆解                                        │
│  ① 搜索 AI Agent 最新动态                                │
│  ② 搜索 MCP 协议最新进展                                 │
│  ③ 整理成报告格式                                       │
│  ④ 发送到邮箱                                           │
├─────────────────────────────────────────────────────────┤
│  Step 3: 工具调用（循环执行）                              │
│  → 调用 WebSearch（搜索最新文章）                        │
│  → 调用 WebFetch（抓取详细内容）                         │
│  → 调用 FileWrite（写入报告）                            │
│  → 调用 EmailSend（发送邮件）                            │
├─────────────────────────────────────────────────────────┤
│  Step 4: 结果整合                                        │
│  "已为您完成：报告已生成并发送到 example@email.com"        │
└─────────────────────────────────────────────────────────┘

Function Calling 是 Tool 调用的底层协议。当 LLM 觉得需要调用工具时，不是直接执行，而是返回一个结构化的"函数调用请求"。

// 开发者注册一个 Tool
{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "获取指定城市的天气",
    "parameters": {
      "type": "object",
      "properties": {
        "city": { "type": "string", "description": "城市名称" }
      },
      "required": ["city"]
    }
  }
}

// LLM 的响应（不是直接回答，而是返回调用请求）
{
  "tool_calls": [{
    "id": "call_xxx",
    "type": "function",
    "function": {
      "name": "get_weather",
      "arguments": "{\"city\":\"北京\"}"
    }
  }]
}

// Agent 框架收到后调用实际的 API
// 将结果传回给 LLM 继续处理

完整流程：

用户："北京今天天气怎么样？"
  ↓
LLM 发现需要查询天气 → 返回 tool_calls
  ↓
Agent 框架收到 tool_calls → 调用 get_weather("北京")
  ↓
返回结果给 LLM："北京今天 25°C，晴"
  ↓
LLM 格式化答案："北京今天天气晴朗，温度 25°C ☀️"

MCP 是 Anthropic 于 2024 年 11 月发布的开源协议，全称 Model Context Protocol。
可以理解为 "AI 界的 USB-C 标准"——统一了 AI 调用工具的方式。

之前：每个模型有自己的一套 Function Calling 格式，工具开发者需要为每个平台适配。
之后：只要实现了 MCP 协议，任何 MCP 客户端都可以使用同一套工具。

┌─────────────────────────────────────────────────────────┐
│                    MCP 架构图                            │
├─────────────────────────────────────────────────────────┤
│                                                         │
│   ┌───────────────────┐                                 │
│   │  MCP Host         │  ← 用户使用的 AI 应用           │
│   │  (Claude/Cursor)  │    （用 MCP 客户端库）           │
│   └────────┬──────────┘                                 │
│            │  JSON-RPC（标准协议）                        │
│            ▼                                             │
│   ┌───────────────────┐                                 │
│   │  MCP Server       │  ← 提供工具的服务               │
│   │  (各种 Tool 集合)  │    （可本地运行或远程）          │
│   └────────┬──────────┘                                 │
│            │                                             │
│   ┌────────┴──────────┬──────────┬──────────┐           │
│   ▼                   ▼          ▼          ▼           │
│ 本地文件             数据库     API服务   浏览器         │
│                                                         │
└─────────────────────────────────────────────────────────┘

一个最简单的 MCP Server（Python）：

from mcp.server import Server, NotificationOptions
from mcp.server.models import InitializationOptions
import mcp.server.stdio

# 创建 MCP Server
server = Server("weather-server")

# 注册一个 Tool
@server.list_tools()
async def handle_list_tools():
    return [
        {
            "name": "get_weather",
            "description": "获取天气",
            "inputSchema": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"}
                }
            }
        }
    ]

# 实现 Tool 逻辑
@server.call_tool()
async def handle_call_tool(name, arguments):
    if name == "get_weather":
        city = arguments["city"]
        # 调用实际的天气 API
        return {"temperature": 25, "condition": "晴"}

# 启动
async with mcp.server.stdio.stdio_server() as (read, write):
    await server.run(read, write, InitializationOptions(
        server_name="weather-server",
        server_version="1.0.0"
    ))

Tool  = 单个原子操作
         → 搜索、查天气、写文件、执行代码

Skill = 多个 Tool 的组合 + 专有 Prompt + 使用流程
         → "市场研究技能"（搜索 + 总结 + 写报告）
         → "代码审查技能"（读代码 + 分析 + 写评论）
         → "客服技能"（查订单 + 退款 + 回复客户）

Agent = LLM + 多个 Skill + 记忆 + 规划能力

┌─────────────────────────────────────────────────────────┐
│                      Agent                              │
│  ┌─────────────────────────────────────────────────────┐│
│  │  🧠 LLM（大脑）                                     ││
│  │  • 理解任务、推理、决策                               ││
│  │  • 决定"下一步该用什么"                              ││
│  └────────────┬────────────────────────────────────────┘│
│               │                                         │
│  ┌────────────▼────────────────────────────────────────┐│
│  │  📋 Skill 1: 市场研究技能                           ││
│  │  ├── Tool: WebSearch（搜索）                        ││
│  │  ├── Tool: WebFetch（抓取内容）                     ││
│  │  ├── Tool: FileWrite（写文件）                      ││
│  │  └── Prompt: "你是一个市场研究分析师..."            ││
│  │                                                     ││
│  │  📋 Skill 2: 代码开发技能                           ││
│  │  ├── Tool: ReadFile（读代码）                       ││
│  │  ├── Tool: EditFile（改代码）                       ││
│  │  ├── Tool: Bash（运行测试）                         ││
│  │  └── Prompt: "你是一个资深软件工程师..."            ││
│  └─────────────────────────────────────────────────────┘│
│                                                         │
│  ┌─────────────────────────────────────────────────────┐│
│  │  🔌 MCP 协议层（标准化 Tool 调用）                  ││
│  │  ├── MCP Server: filesystem（文件操作）              ││
│  │  ├── MCP Server: github（GitHub 操作）               ││
│  │  ├── MCP Server: wecom（企业微信）                   ││
│  │  └── MCP Server: ...（更多）                         ││
│  └─────────────────────────────────────────────────────┘│
└─────────────────────────────────────────────────────────┘

层次的粒度：
MCP → 定义"怎么调"（协议标准）
Tool → 定义"调什么"（单个原子能力）
Skill → 定义"怎么用"（组合成完整任务）
Agent → 定义"什么时候用"（自主决策）

以本项目使用的 OpenClaw 为例，它的 Skill 系统是 Agent 能力的实际体现：

1. 部署 Dify（docker compose 一键启动）
2. 接入大模型 API（OpenAI / DeepSeek / 百炼）
3. 创建 Agent → 填入 System Prompt
4. 添加工具（内置搜索、代码执行等）
5. 发布 → 获得 API 或 Web 界面

# 创建一个带工具的 Assistant
from openai import OpenAI
client = OpenAI()

assistant = client.beta.assistants.create(
    name="市场研究 Agent",
    instructions="你是专业市场研究分析师",
    model="gpt-4o",
    tools=[
        {"type": "code_interpreter"},           # 代码执行
        {"type": "file_search"},                 # 文件搜索
        {
            "type": "function",                  # 自定义函数
            "function": {
                "name": "search_web",
                "description": "搜索互联网",
                "parameters": {...}
            }
        }
    ]
)

# 创建对话线程
thread = client.beta.threads.create()
client.beta.threads.messages.create(
    thread_id=thread.id,
    role="user",
    content="请研究 AI Agent 市场趋势并出报告"
)

# 运行（自动调用工具！）
run = client.beta.threads.runs.create(
    thread_id=thread.id,
    assistant_id=assistant.id
)

配置 Claude Desktop 的 MCP Server（在 claude_desktop_config.json 中）：

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "你的 Token" }
    },
    "custom-search": {
      "command": "python",
      "args": ["/path/to/your/mcp_server.py"]
    }
  }
}

配置完成后，Claude Desktop 就能调用你的文件系统和 GitHub 了——零代码，纯配置。

📌 核心要点

✅ Agent = LLM + Tools + Memory + Planning，缺一不可
✅ Tool 是 Agent 改造世界的手，本质是 Function Calling
✅ MCP 是 Tool 的标准化协议（AI 界的 USB-C），让工具可以跨平台复用
✅ Skill 是 Tool 的组合 + 使用指南，是更高维度的能力抽象
✅ MCP → Tool → Skill → Agent 是从底层到上层的层层封装
✅ 当下已经不需要重复造轮子，Dify / Coze / OpenAI Assistants 开箱即用

🔮 未来趋势

一句话总结 Agent 时代

"过去我们是 AI 的用户，我们提问，AI 回答。
现在我们是 AI 的管理者，我们给目标，AI 执行。" 🤖