AI Agent（智能体）深度学习教程

版本: v1.0 | 日期: 2026-06-03 | 作者: 实战笔记系列

从零到一掌握 AI Agent 核心原理与实践，覆盖 LLM 大脑、规划推理、工具调用、记忆系统、多智能体协作等完整知识体系。

---

目录

1. 一、AI Agent 简介

• 1.1 什么是 AI Agent？
• 1.2 谁适合学习本教程？
• 1.3 思维转变：从对话到任务执行

2. 二、AI Agent 核心概念

• 2.1 结构组成四要素
• 2.2 运行方式详解
• 2.3 与普通大模型的区别
• 2.4 类比理解
• 2.5 实例场景：北京三日游

3. 三、AI Agent 工作原理

• 3.1 架构总览
• 3.2 Python 代码示例：天气穿衣助手
• 3.3 Agent 运行循环（ReAct 模式）
• 3.4 工具调用（Tool Calling）机制
• 3.5 记忆系统设计

4. 四、AI Agent 完整课程体系

• 4.1 理论基础路线
• 4.2 实践操作路线
• 4.3 Vibe Coding 新范式
• 4.4 Python 实现智能体路线

5. 五、核心工具与平台实战

• 5.1 Claude Code 入门
• 5.2 Skills 系统教程
• 5.3 LangChain / LangGraph 实战
• 5.4 CrewAI 多智能体协作
• 5.5 OpenClaw (Clawdbot) 教程

6. 六、学习资源推荐
7. 七、快速体验：无代码构建 Agent
8. 八、实战项目：构建一个智能助手
9. 附录：术语表与参考

---

一、AI Agent 简介

1.1 什么是 AI Agent？

AI Agent（人工智能智能体 / Artificial Intelligence Agent） 是一种能够感知环境、自主决策并执行行动以达成目标的智能软件实体。

与传统的"一问一答"聊天机器人不同，AI Agent 不仅仅是"回答问题"，而是能够"动手做事"。

┌──────────────────────────────────────────────────────────────────────┐
│                     AI Agent 核心公式                                  │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│   Agent = LLM (大脑) + Planning (规划) + Tool Use (执行) + Memory (记忆) │
│                                                                       │
│   ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐       │
│   │  🧠 LLM  │    │  📋 规划  │    │  🔧 工具  │    │  🗄️  记忆  │       │
│   │ 大语言模型│    │ Planning │    │ Tool Use │    │  Memory  │       │
│   │          │    │          │    │          │    │          │       │
│   │  理解意图 │───→│  拆解任务 │───→│  执行操作 │───→│  存储上下文│       │
│   │  生成方案 │    │  编排步骤 │    │  调用 API │    │  积累经验 │       │
│   └──────────┘    └──────────┘    └──────────┘    └──────────┘       │
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

与传统聊天机器人的对比：

维度	传统 Chatbot	AI Agent
输入	自然语言问题	目标/任务描述
处理	单轮 NLU → NLG	多轮推理 + 工具调用
输出	文本回复	文本回复 + 实际行动
状态	无状态（每次独立）	有状态（记忆上下文）
能力边界	受限训练数据	可通过工具扩展
典型场景	客服问答、闲聊	自动化工作流、数据分析、代码生成

1.2 谁适合学习本教程？

目标人群	学习方向	预期收获
想用 AI 自动化日常任务的人	了解 Agent 能做什么、如何接入	用 Agent 替代重复工作
编程新手	基础概念 → Vibe Coding → 实践	零代码或低代码构建 Agent
零基础但会电脑操作	无代码平台体验 → 理解原理	从"聊天"升级到"干活"
有编程基础的学习者	Python Agent 开发 → 多智能体系统	从零构建生产级 Agent
DevOps / 运维工程师	Agent + 工具集成 → 自动化运维	智能告警、自动修复

1.3 思维转变：从对话到任务执行

旧思维：人 → 「帮我查天气」 → AI → 「北京今天晴，22°C」 → 人自己决定穿什么
─────────────────────────────────────────────────────────────────────
新思维：人 → 「明天去北京出差，行程怎么安排？」 → Agent ─┐
                                                        ├→ 查天气
                                                        ├→ 查航班
                                                        ├→ 订酒店
                                                        ├→ 排日程
                                                        └→ 返回完整方案

核心思维转变：从"对话框问答"（Dialog-based Q&A）升级为"目标驱动的任务执行"（Goal-driven Task Execution）。Agent 不再是被动的信息提供者，而是主动的任务完成者。

---

二、AI Agent 核心概念

2.1 结构组成四要素

┌──────────────────────────────────────────────────────────────────────┐
│                      Agent 结构四要素详解                              │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │  🎯 目标 (Goal)                                               │   │
│  │  ─────────────────────────────────────────────────────────── │   │
│  │  明确任务意图：用户想达成什么结果？                            │   │
│  │  示例："规划三天北京行程，预算 5000 元"                        │   │
│  │  好的目标 = 可量化、有边界、可验证                             │   │
│  └──────────────────────────────────────────────────────────────┘   │
│                              │                                        │
│                              ▼                                        │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │  📋 逻辑/推理 (Reasoning / Planning)                           │   │
│  │  ─────────────────────────────────────────────────────────── │   │
│  │  按规则拆解为可执行步骤：                                      │   │
│  │    步骤1: 查询北京未来三天天气                                 │   │
│  │    步骤2: 搜索北京热门景点                                     │   │
│  │    步骤3: 查询机票/高铁价格                                    │   │
│  │    步骤4: 按预算筛选酒店                                       │   │
│  │    步骤5: 编排生成最终行程表                                   │   │
│  │  常用方法: ReAct, Chain-of-Thought, Tree-of-Thoughts          │   │
│  └──────────────────────────────────────────────────────────────┘   │
│                              │                                        │
│                              ▼                                        │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │  🔧 工具 (Tools)                                              │   │
│  │  ─────────────────────────────────────────────────────────── │   │
│  │  通过代码或 API 落地执行：                                     │   │
│  │    search_web(query)     → 搜索引擎 API                       │   │
│  │    get_weather(city)     → 天气 API                           │   │
│  │    query_flights(from,to)→ 机票 API                           │   │
│  │    book_hotel(...)       → 酒店预订 API                       │   │
│  │    send_email(...)       → 邮件 API                           │   │
│  │  工具 = Agent 的"手脚"，将意图转化为现实世界的行动             │   │
│  └──────────────────────────────────────────────────────────────┘   │
│                              │                                        │
│                              ▼                                        │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │  🗄️   记忆 (Memory)                                           │   │
│  │  ─────────────────────────────────────────────────────────── │   │
│  │  短时记忆 (Short-term)：当前对话上下文、中间结果               │   │
│  │  长时记忆 (Long-term)：用户偏好、历史经验、知识库              │   │
│  │  工作记忆 (Working)：当前任务执行中的临时状态                  │   │
│  │  示例：记住用户"不吃辣"的偏好，后续推荐餐厅时自动过滤          │   │
│  └──────────────────────────────────────────────────────────────┘   │
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

2.2 运行方式详解

Agent 的完整运行闭环：

                       ┌──────────────────────────────────┐
                       │         Agent 运行闭环            │
                       └──────────────────────────────────┘

   ① 接收输入           ② 理解+判断           ③ 拆解任务
   User: "帮我订        LLM 理解意图：         ReAct 规划：
   明天去上海的          出差订票需求            1) 查航班
   机票"        ──────→ 紧急程度：高     ──────→ 2) 比较价格
                                                3) 选择下单

        │                                            │
        │           ┌────────────────────┐           │
        │           │   ⑦ 调整策略        │           │
        │           │   遇到错误/阻塞     │           │
        │           │   重新规划路线      │←──────────┤
        │           └────────────────────┘           │
        │                    ▲                       │
        ▼                    │                       ▼
   ⑥ 返回结果               │               ④ 调用工具
   "已为您预订                │               search_flights(
    MU5101 航班               │                from=上海,
    8:00-10:30                │                to=北京,
    ¥680"       ──────────────┘                date=2026-06-04
                                               )
        │                                            │
        └────────────── ⑤ 解析结果 ◄────────────────┘
                       提取航班号、时间、价格
                       存入短时记忆

关键能力说明：

阶段	能力	说明
① 接收输入	意图理解（Intent Understanding）	支持自然语言、图像、语音等多模态输入
② 理解判断	语义解析 + 实体提取	从"明天去上海"中提取 date=2026-06-04、dest=上海
③ 拆解任务	任务分解（Task Decomposition）	将一个复杂目标分解为有序的子任务链
④ 调用工具	工具选择与参数填充	根据任务类型自动选择合适的工具并填入参数
⑤ 解析结果	结构化数据提取	将 API 返回的 JSON 转为人类可读信息
⑥ 返回结果	多模态输出	文字 + 表格 + 链接 + 操作确认
⑦ 调整策略	错误恢复与重规划	遇阻时自动寻找替代方案

2.3 与普通大模型的区别

维度	普通大模型（LLM）	AI Agent
核心能力	文本生成	文本生成 + 行动执行
交互模式	单轮/多轮对话	目标驱动的多步任务链
工具调用	❌ 不支持	✅ 支持（API、代码、函数）
记忆系统	仅会话上下文	短期 + 长期 + 工作记忆
自主性	被动响应	主动规划、自主决策
行动边界	仅输出文本	操作文件、访问网络、调用服务
错误处理	无	自动重试、降级策略
典型输出	“建议你穿外套”	“已发邮件给你的助理，附上穿衣建议”

普通 LLM：
  你: "帮我分析这份 Excel 销售数据"
  LLM: "请上传文件，我无法直接访问你的电脑"

AI Agent：
  你: "帮我分析这份 Excel 销售数据"
  Agent: 
    ① 读取 D:/reports/sales.xlsx
    ② 按月份汇总销售额
    ③ 生成趋势图
    ④ 输出分析报告到 D:/reports/analysis.md
    ⑤ "分析完成！已生成报告到 analysis.md，要点：本月环比+15%"

2.4 类比理解

┌──────────────────────────────────────────────────────────────────────┐
│                        两种"程序"的对比                               │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│   传统程序 = 自动售货机                     AI Agent = 私人助理        │
│   ────────────────                         ────────────────           │
│                                                                       │
│   ┌──────────────┐                         ┌──────────────┐          │
│   │  🥤 投币 →   │                          │  👤 "帮我安排  │          │
│   │  选按钮 →   │                          │  明天行程"    │          │
│   │  出货       │                          │               │          │
│   └──────────────┘                          │  ① 查日历    │          │
│                                              │  ② 预约会议  │          │
│   ✅ 固定流程（if-else）                    │  ③ 订餐厅    │          │
│   ✅ 可预测、可靠                           │  ④ 发邮件    │          │
│   ❌ 无法处理未知场景                       │               │          │
│   ❌ 无自主决策                             │  ⑤ 回复你    │          │
│                                              └──────────────┘          │
│                                              ✅ 自主规划              │
│                                              ✅ 灵活应变              │
│                                              ⚠️  结果需验证          │
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

2.5 实例场景：北京三日游

以"规划三天北京行程，预算 5000 元"为例，演示 Agent 的完整工作流程：

┌──────────────────────────────────────────────────────────────────────┐
│  🎯 目标: 规划三天北京行程，预算 ¥5000                                │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│  Step 1 — 信息收集                                                    │
│  ┌────────────────────────────────────────────────────────────────┐  │
│  │ 🔧 search_flights("深圳→北京", "2026-06-10")                    │  │
│  │    → 共 15 班航班，最低 ¥650，最高 ¥2100                        │  │
│  │ 🔧 get_weather("北京", "2026-06-10..2026-06-12")               │  │
│  │    → 晴 28°C / 多云 25°C / 小雨 22°C                            │  │
│  │ 🔧 search_hotels("北京", budget="<300/晚")                      │  │
│  │    → 3 家可选酒店，均价 ¥220-280/晚                             │  │
│  │ 🔧 search_attractions("北京", "热门")                           │  │
│  │    → 故宫 ¥60, 长城 ¥40, 颐和园 ¥30, 天坛 ¥15                  │  │
│  └────────────────────────────────────────────────────────────────┘  │
│                                    │                                   │
│                                    ▼                                   │
│  Step 2 — 预算规划                                                    │
│  ┌────────────────────────────────────────────────────────────────┐  │
│  │  机票往返:     ¥650 × 2 = ¥1300                                 │  │
│  │  酒店(2晚):    ¥250 × 2 = ¥500                                  │  │
│  │  景点门票:     故宫+长城+颐和园+天坛 = ¥145                     │  │
│  │  餐饮预算:     ¥120 × 3天 = ¥360                                │  │
│  │  交通(市内):   ¥50 × 3天 = ¥150                                 │  │
│  │  ─────────────────────────────────────                          │  │
│  │  合计: ¥2455 ✅ 在 ¥5000 预算内                                  │  │
│  └────────────────────────────────────────────────────────────────┘  │
│                                    │                                   │
│                                    ▼                                   │
│  Step 3 — 生成行程                                                    │
│  ┌────────────────────────────────────────────────────────────────┐  │
│  │  📅 Day 1 (6/10 晴 28°C)                                       │  │
│  │   08:00 抵达北京首都机场                                         │  │
│  │   10:00 入住酒店（如家·王府井店 ¥240/晚）                       │  │
│  │   12:00 午餐：护国寺小吃 ¥35                                    │  │
│  │   14:00 故宫博物院 ¥60（需提前预约）                            │  │
│  │   18:00 晚餐：全聚德烤鸭 ¥120                                   │  │
│  │                                                                  │  │
│  │  📅 Day 2 (6/11 多云 25°C)                                     │  │
│  │   07:00 出发 → 八达岭长城 ¥40                                   │  │
│  │   12:00 午餐：长城脚下农家菜 ¥50                                │  │
│  │   15:00 返回市区 → 颐和园 ¥30                                   │  │
│  │   19:00 晚餐：簋街 ¥100                                         │  │
│  │                                                                  │  │
│  │  📅 Day 3 (6/12 小雨 22°C)                                     │  │
│  │   09:00 天坛公园 ¥15                                            │  │
│  │   11:00 前门大街逛街                                             │  │
│  │   14:00 前往机场 → 16:00 航班返回                               │  │
│  └────────────────────────────────────────────────────────────────┘  │
│                                                                       │
│  💰 预算使用率: 49.1% | 剩余 ¥2545                                   │
│  ⚠️  提示: Day 3 有雨，建议携带雨具                                  │
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

---

三、AI Agent 工作原理

3.1 架构总览

┌──────────────────────────────────────────────────────────────────────┐
│                     AI Agent 通用架构                                  │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│   ┌─────────────────────────────────────────────────────────────┐    │
│   │                      用户界面层 (UI)                          │    │
│   │               Chat / Voice / CLI / API Gateway               │    │
│   └──────────────────────────┬──────────────────────────────────┘    │
│                              │                                        │
│                              ▼                                        │
│   ┌─────────────────────────────────────────────────────────────┐    │
│   │                     Agent 核心 (Core)                         │    │
│   │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐     │    │
│   │  │ 规划器    │  │ 执行器    │  │ 记忆管理  │  │ 安全守卫  │     │    │
│   │  │ Planner  │  │ Executor │  │  Memory  │  │  Guard   │     │    │
│   │  └──────────┘  └──────────┘  └──────────┘  └──────────┘     │    │
│   └──────────────────────────┬──────────────────────────────────┘    │
│                              │                                        │
│                              ▼                                        │
│   ┌─────────────────────────────────────────────────────────────┐    │
│   │                       LLM 层 (Brain)                          │    │
│   │  GPT-4 / Claude / Gemini / DeepSeek / Qwen / LLaMA           │    │
│   └──────────────────────────┬──────────────────────────────────┘    │
│                              │                                        │
│                              ▼                                        │
│   ┌─────────────────────────────────────────────────────────────┐    │
│   │                    工具层 (Tools)                              │    │
│   │  ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐    │    │
│   │  │ 搜索   │ │ 代码   │ │ 文件   │ │ API    │ │ 浏览器  │    │    │
│   │  │ Search │ │ Code   │ │ File   │ │ Call   │ │Browser │    │    │
│   │  └────────┘ └────────┘ └────────┘ └────────┘ └────────┘    │    │
│   └─────────────────────────────────────────────────────────────┘    │
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

3.2 Python 代码示例：天气穿衣助手

下面是一个完整的 AI Agent 最小实现，无需任何框架依赖，仅用 Python + OpenAI API：

"""
天气穿衣助手 Agent — 最小可运行示例
依赖: pip install openai requests
"""

import json
import requests
from openai import OpenAI

# ─── 1. 定义工具 (Tools) ───
def get_weather(city: str) -> dict:
    """获取城市天气（模拟数据）"""
    # 实际项目中替换为天气 API（和风/OpenWeather/中国气象局）
    weather_data = {
        "北京": {"temp": 22, "humidity": 45, "condition": "晴"},
        "上海": {"temp": 28, "humidity": 80, "condition": "多云转小雨"},
        "深圳": {"temp": 32, "humidity": 90, "condition": "雷阵雨"},
    }
    return weather_data.get(city, {"temp": 20, "humidity": 60, "condition": "未知"})

def suggest_clothing(temp: int, humidity: int, condition: str) -> str:
    """根据天气生成穿衣建议"""
    suggestion = ""

    # 温度判断
    if temp < 10:
        suggestion += "❄️ 寒冷 | 建议羽绒服 + 围巾 + 手套\n"
    elif temp < 20:
        suggestion += "🍂 微凉 | 建议薄外套 + 长裤\n"
    elif temp < 28:
        suggestion += "☀️ 温暖 | 建议短袖 + 薄长裤\n"
    else:
        suggestion += "🔥 炎热 | 建议短袖短裤 + 防晒\n"

    # 湿度判断
    if humidity > 70:
        suggestion += "💧 潮湿 | 携带雨具，注意防潮\n"
    elif humidity < 30:
        suggestion += "🏜️ 干燥 | 注意补水保湿\n"

    # 天气判断
    if "雨" in condition:
        suggestion += "🌧️ 有雨 | 务必带伞！\n"
    elif "雪" in condition:
        suggestion += "🌨️ 有雪 | 穿防滑鞋\n"

    return suggestion


# ─── 2. 定义工具调用协议 ───
TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的实时天气，返回温度(°C)、湿度和天气状况",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，如: 北京、上海、深圳"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

# 工具名 → 函数映射
TOOL_MAP = {
    "get_weather": get_weather,
}


# ─── 3. Agent 主类 ───
class WeatherAgent:
    """
    AI Agent — 天气穿衣助手

    核心组件:
      - tools: 可调用的工具函数
      - memory: 存储中间结果和上下文
      - run:   解析指令 → 规划 → 执行 → 输出
    """

    def __init__(self, api_key: str, model: str = "gpt-4o-mini"):
        self.client = OpenAI(api_key=api_key, base_url="https://api.openai.com/v1")
        self.model = model
        self.memory: list[dict] = []  # 对话历史

    def run(self, user_input: str) -> str:
        """主运行方法"""
        print(f"👤 用户: {user_input}")
        print("🤖 Agent 工作中...")

        # Step 1: 添加用户消息到记忆
        self.memory.append({"role": "user", "content": user_input})

        # Step 2: 调用 LLM 获取响应（可能包含工具调用请求）
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": (
                    "你是一个穿衣助手 Agent。用户会询问某个城市的天气并寻求穿衣建议。"
                    "请先调用 get_weather 工具获取天气数据，\
然后根据温度、湿度、天气状况给出穿衣建议。"
                    "回复风格：简洁、实用、友好。"
                )},
                *self.memory
            ],
            tools=TOOLS,
            tool_choice="auto",  # 让 LLM 自动决定是否需要调用工具
        )

        assistant_msg = response.choices[0].message

        # Step 3: 处理工具调用请求
        if assistant_msg.tool_calls:
            print(f"  🔧 调用工具: {assistant_msg.tool_calls[0].function.name}")

            for tool_call in assistant_msg.tool_calls:
                func_name = tool_call.function.name
                func_args = json.loads(tool_call.function.arguments)

                # 执行工具
                func = TOOL_MAP[func_name]
                weather = func(**func_args)  # 获取天气数据

                # 生成穿衣建议
                clothing_advice = suggest_clothing(
                    weather["temp"], weather["humidity"], weather["condition"]
                )

                # Step 4: 将工具结果返回给 LLM 生成最终回复
                self.memory.append(assistant_msg.model_dump())
                self.memory.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": json.dumps(weather, ensure_ascii=False)
                })

            # 调用 LLM 生成最终自然语言回复
            final_response = self.client.chat.completions.create(
                model=self.model,
                messages=self.memory
            )
            reply = final_response.choices[0].message.content
        else:
            # LLM 直接回复（无需工具）
            reply = assistant_msg.content

        # Step 5: 保存回复到记忆
        self.memory.append({"role": "assistant", "content": reply})

        print(f"🤖 Agent: {reply}\n")
        return reply


# ─── 4. 运行示例 ───
if __name__ == "__main__":
    import os

    # 初始化 Agent（请替换为你的 API Key）
    agent = WeatherAgent(
        api_key=os.getenv("OPENAI_API_KEY", "sk-your-key-here"),
        model="gpt-4o-mini"
    )

    # 测试用例
    test_cases = [
        "我想知道北京的天气，该怎么穿衣服？",
        "明天去上海出差，需要带伞吗？",
        "深圳今天的天气适合跑步吗？",
    ]

    for question in test_cases:
        agent.run(question)
        print("-" * 50)

代码执行流程解析：

用户输入: "我想知道北京的天气，该怎么穿衣服？"
    │
    ▼
┌──────────────────────────────────────────┐
│ ① LLM 分析意图                            │
│    → 需要调用 get_weather 工具            │
│    → 从输入中提取 city=北京               │
│    → 生成 tool_calls:                     │
│      [{function: "get_weather",           │
│        args: {city: "北京"}}]             │
└──────────────────┬───────────────────────┘
                   ▼
┌──────────────────────────────────────────┐
│ ② Agent 执行工具                          │
│   get_weather("北京") = {                 │
│     temp: 22, 湿度: 45%, 天气: 晴        │
│   }                                       │
│   suggest_clothing(...) =                 │
│     "温暖 | 短袖 + 薄长裤"                │
└──────────────────┬───────────────────────┘
                   ▼
┌──────────────────────────────────────────┐
│ ③ 将工具结果返回 LLM                     │
│   LLM 整理为自然语言:                     │
│   "北京今天晴，22°C，湿度45%。建议穿     │
│    短袖+薄长裤，天气干燥注意补水！"       │
└──────────────────┬───────────────────────┘
                   ▼
┌──────────────────────────────────────────┐
│ ④ 回复用户 + 存入记忆                    │
│   memory.append(assistant_reply)          │
│   下次用户问"那上海呢？"时 Agent 可      │
│   利用记忆直接关联上下文                  │
└──────────────────────────────────────────┘

3.3 Agent 运行循环（ReAct 模式）

ReAct（Reasoning + Acting） 是当前最主流的 Agent 推理模式：

┌──────────────────────────────────────────────────────────────────────┐
│                    ReAct 循环 (Reasoning + Acting)                     │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│   ┌──────────┐     ┌──────────┐     ┌──────────┐     ┌──────────┐   │
│   │ Thought  │────→│  Action  │────→│Observation│────→│ Thought  │   │
│   │  思考    │     │  行动    │     │  观察    │     │  思考    │   │
│   └──────────┘     └──────────┘     └──────────┘     └──────────┘   │
│        ▲                                                    │        │
│        │     ┌──────────────────────────────────────┐      │        │
│        └─────│         循环直到任务完成               │◄─────┘        │
│              │  最终 Answer: "任务完成，结果是..."     │              │
│              └──────────────────────────────────────┘              │
│                                                                       │
│   示例流程（订机票）：                                                │
│   Thought 1: "我需要先查询航班"                                      │
│   Action 1:  search_flights("北京→上海", "明天")                     │
│   Observe 1: {flights: [{MU5101, ¥680}, {CA1234, ¥920}]}            │
│   Thought 2: "MU5101 价格合适，但需要确认时间"                       │
│   Action 2:  get_flight_detail("MU5101")                            │
│   Observe 2: {dep: "08:00", arr: "10:30", seats: 23}                │
│   Thought 3: "时间合适，座位充足，可以下单"                           │
│   Action 3:  book_flight("MU5101", passenger="用户")               │
│   Observe 3: {status: "success", order_id: "FL20260603001"}         │
│   Thought 4: "预订成功"                                               │
│   Answer:    "已为您预订 MU5101 航班，8:00-10:30，订单号 FL20260603..."│
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

3.4 工具调用（Tool Calling）机制

工具调用是 Agent "动手能力"的核心，分为函数调用（Function Calling）和MCP 协议两种主流方式：

方式	原理	适用场景	代表实现
Function Calling	LLM 输出 JSON 描述要调用的函数名和参数	简单工具、API 调用	OpenAI / Claude API
MCP (Model Context Protocol)	标准化的工具连接协议	复杂工具集成、多服务协作	Anthropic MCP
Code Execution	LLM 直接生成可执行代码	数据分析、文件操作	Code Interpreter
Browser Control	LLM 控制浏览器操作	Web 自动化、信息采集	Playwright / Selenium

# Function Calling 的 JSON Schema 定义示例
TOOL_SCHEMA = {
    "name": "send_email",
    "description": "发送邮件",
    "parameters": {
        "type": "object",
        "properties": {
            "to":       {"type": "string", "description": "收件人邮箱"},
            "subject":  {"type": "string", "description": "邮件主题"},
            "body":     {"type": "string", "description": "邮件正文"},
            "cc":       {"type": "string", "description": "抄送邮箱（可选）"},
        },
        "required": ["to", "subject", "body"]
    }
}

3.5 记忆系统设计

┌──────────────────────────────────────────────────────────────────────┐
│                     Agent 三级记忆系统                                 │
├──────────────────────────────────────────────────────────────────────┤
│                                                                       │
│   ┌─────────────────────────────────────────────────────────────┐    │
│   │ 🗄️   工作记忆 (Working Memory)    生命周期: 当前任务          │    │
│   │ ─────────────────────────────────────────────────────────── │    │
│   │ 存放: 当前执行的中间步骤、工具调用结果、临时变量              │    │
│   │ 实现: Python 变量 / Redis / memcached                       │    │
│   │ 容量: 小（单次任务上下文）                                    │    │
│   └─────────────────────────────────────────────────────────────┘    │
│                              │                                        │
│                              ▼                                        │
│   ┌─────────────────────────────────────────────────────────────┐    │
│   │ 🗄️   短期记忆 (Short-term Memory)  生命周期: 当前会话          │    │
│   │ ─────────────────────────────────────────────────────────── │    │
│   │ 存放: 对话历史、用户偏好、上下文关联                          │    │
│   │ 实现: LLM 上下文窗口 / 会话缓存                              │    │
│   │ 容量: 中等（受 LLM Context Window 限制）                     │    │
│   └─────────────────────────────────────────────────────────────┘    │
│                              │                                        │
│                              ▼                                        │
│   ┌─────────────────────────────────────────────────────────────┐    │
│   │ 🗄️   长期记忆 (Long-term Memory)   生命周期: 跨会话持久化      │    │
│   │ ─────────────────────────────────────────────────────────── │    │
│   │ 存放: 用户档案、知识库、历史经验、项目文档                    │    │
│   │ 实现: 向量数据库 (Milvus/Pinecone) / PostgreSQL / 文件系统  │    │
│   │ 容量: 大（无上限）                                            │    │
│   └─────────────────────────────────────────────────────────────┘    │
│                                                                       │
└──────────────────────────────────────────────────────────────────────┘

---

四、AI Agent 完整课程体系

4.1 理论基础路线

                    AI Agent 理论知识栈（由底向上）

  Layer 6  Agent 架构设计  → 单智能体 → 多智能体协作
  Layer 5  Agent 上下文工程 & Harness Engineering
  Layer 4  RAG & 向量数据库
  Layer 3  推理与规划 (CoT/ToT/ReAct/Plan-and-Solve)
  Layer 2  提示词工程 & Token 概念
  Layer 1  大语言模型基础 (Transformer/预训练/微调/RLHF)

层级	主题	核心知识点
Layer 1	LLM 基础	Transformer、自注意力、预训练vs微调、RLHF、模型量化
Layer 2	提示词工程	System Prompt、Few-shot、CoT、角色扮演
Layer 3	Token	BPE分词、Token计数、成本计算、上下文窗口
Layer 4	推理与规划	ReAct、Chain-of-Thought、Tree-of-Thoughts
Layer 5	向量数据库	Embedding、相似度搜索、Milvus/Pinecone/ChromaDB
Layer 6	RAG	文档加载→切分→向量化→检索→增强生成
Layer 7	上下文工程	上下文窗口管理、动态提示词组装
Layer 8	Agent架构	单Agent vs 多Agent、Orchestrator/Worker模式
Layer 9	Harness	安全护栏、输入验证、输出过滤
Layer 10	Hermes Agent	推理型Agent模式、自我纠错、元认知

4.2 实践操作路线

  新手入门(1-3天)   → Miaoda无代码 + Claude Code安装
       ↓
  基础进阶(1-2周)   → Claude Code深度 + Vibe Coding + Skills
       ↓
  框架实战(2-4周)   → LangChain + LangGraph + CrewAI + OpenClaw
       ↓
  Python原生(4-8周) → Python完整Agent + RAG + 多Agent + 部署

4.3 Vibe Coding 新范式

工具	定位	特点
Claude Code	最强AI编程助手	Skills系统、MCP支持、全栈开发
OpenCode	开源AI编程Agent	Coding Plan、CC Switch
Qoder	开发平台	Quest模式(任务驱动)、CLI
Trae	字节跳动出品	Solo模式、中文友好
AI MonkeyCode	AI开发平台	可视化编程、一键部署

4.4 Python 实现 Agent 完整路线

阶段	内容	核心技术
① 环境配置	Python 3.10+、Poetry/venv	开发环境搭建
② 第一个Agent	工具调用+LLM循环	OpenAI Function Calling
③ 记忆系统	短期/长期/工作记忆	Redis/ChromaDB/SQLite
④ 推理规划	ReAct/CoT实现	提示词工程+循环控制
⑤ RAG集成	知识检索增强	Embedding+向量搜索
⑥ 多智能体	多Agent协作	CrewAI/AutoGen
⑦ 多模态	图像/语音处理	GPT-4V/Whisper
⑧ 安全对齐	输入验证/输出过滤	Guardrails
⑨ 生产部署	Docker/K8s/监控	FastAPI/Prometheus

---

五、核心工具与平台实战

5.1 Claude Code 入门

npm install -g @anthropic-ai/claude-code
claude                      # 交互模式
claude -p "write a server" # 单次任务
claude --resume             # 恢复会话

Claude Code 核心能力：自动读项目结构→自主选工具→多步任务编排→MCP连接外部服务。

5.2 Skills 系统

Skills = Agent的"能力包"，三级存储：

级别	存储	示例
User-level	~/.workbuddy/skills/	PDF处理、Excel、Git
Project-level	{project}/.workbuddy/skills/	API调用、部署脚本
Built-in	应用内置	多模态生成、云部署

5.3 LangChain / LangGraph

特性	LangChain	LangGraph
定位	Agent开发框架	有状态Agent编排
核心概念	Chain/Tool/Memory	Graph/Node/Edge/State
适用场景	线性工作流	复杂多步、条件分支、循环

# LangGraph 最小示例
from langgraph.graph import StateGraph, END
class State(TypedDict):
    query: str; result: str | None

graph = StateGraph(State)
graph.add_node('fetch', lambda s: s.update({'result': 'done'}) or s)
graph.add_edge('fetch', END)
graph.set_entry_point('fetch')
app = graph.compile()

5.4 CrewAI 多智能体

三个角色协作完成任务：研究员(收集数据)→撰写员(写报告)→审核员(质量把关)

5.5 OpenClaw / Clawdbot

开源多平台Agent机器人框架，支持Telegram/Discord/Slack/WhatsApp，多LLM后端，插件系统。

---

六、学习资源推荐

类别	资源	适合人群
课程	Google 5天智能体课程	入门
课程	微软 AI Agents for Beginners	入门→进阶
课程	Hugging Face 智能体课程	进阶
开源	Hello-Agents	最简Agent实现
开源	500个智能体案例	实战参考
平台	Miaoda	无代码体验
平台	Dify / Coze / n8n	低代码Agent构建

推荐学习时间线：第1周理解概念→第2周动手实践→第3周深入开发→第4周生产部署。

---

七、快速体验：无代码构建 Agent

Miaoda（一句话生成应用）

输入	Agent自动完成
“做一个待办事项应用”	增删改查+分类+状态标记
“生成数据看板”	图表+筛选+导出+实时刷新
“帮我写博客系统”	文章编辑+分类+评论+RSS

其他平台

平台	特点
Dify	可视化工作流、RAG Pipeline
Coze(扣子)	中文友好、插件市场
n8n	开源、200+集成
Flowise	LangChain可视化拖拽
LobeChat	插件系统、多模型

---

八、实战项目：构建个人工作助理

功能架构：输入层(自然语言/定时触发) → Agent核心(日程管理/邮件处理/文件管理/信息检索) → 工具层(日历API/邮件API/文件系统/搜索API/通知推送)

MVP代码

from openai import OpenAI; import json, os
client = OpenAI(api_key=os.getenv("API_KEY"))

def add_todo(task, due=""): return f"已添加待办: {task}"
def search_files(kw, path="."): 
    import subprocess
    r = subprocess.run(["find",path,"-name",f"*{kw}*","-maxdepth","3"],capture_output=True,text=True)
    return r.stdout.strip() or "未找到"

TOOLS = [...]  # 工具定义(省略schema)
TOOL_MAP = {"add_todo":add_todo, "search_files":search_files}

def run(user_input, memory):
    memory.append({"role":"user","content":user_input})
    resp = client.chat.completions.create(model="gpt-4o-mini",messages=memory,tools=TOOLS)
    msg = resp.choices[0].message
    if msg.tool_calls:
        memory.append(msg.model_dump())
        for tc in msg.tool_calls:
            r = TOOL_MAP[tc.function.name](**json.loads(tc.function.arguments))
            memory.append({"role":"tool","tool_call_id":tc.id,"content":r})
        final = client.chat.completions.create(model="gpt-4o-mini",messages=memory)
        reply = final.choices[0].message.content
    else:
        reply = msg.content
    memory.append({"role":"assistant","content":reply})
    return reply

---

附录：术语表

术语	解释
AI Agent	能自主感知、决策、执行任务的AI系统
LLM	大语言模型，Agent的推理引擎
Tool Calling	LLM调用外部函数/API的能力
ReAct	Reasoning+Acting，主流Agent推理模式
RAG	检索增强生成，结合外部知识检索
Embedding	向量嵌入，将文本转为向量
Vector Database	向量数据库(Milvus/Pinecone/ChromaDB)
MCP	Model Context Protocol，工具连接协议
Prompt Engineering	提示词工程
CoT	Chain-of-Thought，思维链推理
Vibe Coding	用自然语言驱动代码生成
Multi-Agent	多智能体协同
Guardrails	安全护栏
Context Window	上下文窗口，LLM单次处理上限
Fine-tuning	微调
Orchestrator	多Agent任务编排器

---

版本: v1.1 | 日期: 2026-06-03 | 更新: 实验环境部署完成
服务器集群: ecs-7175 系列 4 台 c6.large.2 已配置 (2026-06-03 21:18)

节点	IP	部署
agent-01	119.13.78.66	Docker 29.5.2 + Python 3.12 + OpenAI 2.40.0 + 天气Agent + 个人助理MVP
agent-02	159.138.6.170	Docker 29.5.2 + LangChain 1.3.4 + LangGraph 1.2.4
agent-03	27.106.123.111	Docker 29.5.2 + CrewAI 1.14.6
agent-04	119.13.90.229	Docker 29.5.2 + Node.js 22.22.3 + Flask 3.1.3
后续计划: LangChain/LangGraph/CrewAI完整实战代码、多Agent协作深入、生产级部署(Docker+K8s+Prometheus)