从7个实战项目看懂AI Agent开发：《动手做AI Agent》深度解读

2024年被称为"AI Agent元年"。OpenAI CEO奥特曼预测，未来每个人都将拥有一个AI Agent；比尔·盖茨预言AI Agent将彻底改变人机交互方式。但在这些宏大叙事背后，一个更务实的问题摆在开发者面前：

AI Agent到底是什么？怎么开发一个真正能用的Agent？

黄佳的《大模型应用开发：动手做AI Agent》（人民邮电出版社，2024年5月）给出了答案。这本书没有停留在概念层面，而是用7个完整的实战项目，把Agent开发从"听起来很酷"变成"跑起来很稳"。

这本书解决了什么问题？

市面上的AI书籍大多有两类问题：

要么太浅——讲一堆概念，看完只会说"Agent是能感知环境、做出决策、采取行动的智能体"，但真要写代码，无从下手。

要么太散——今天学LangChain，明天学AutoGPT，后天又听说MetaGPT很火，技术碎片化，缺乏系统性框架。

这本书的定位很清晰：从零到一构建Agent的系统性方法论。

作者黄佳是新加坡科技研究局AI研究员，笔名"咖哥"。他在NLP和大模型领域有丰富项目经验，之前写的《GPT图解》和《零基础学机器学习》发行量都超过13000册。这本书发行不到三周就印刷三次，累计发行超过8000册，连续18天位列京东人工智能图书榜第一名。

Agent的四大核心组件：一个不能少

书中的核心框架是Agent的四大组件：规划、记忆、工具、执行。

┌─────────────────────────────────────────┐
│              Agent 架构                  │
├─────────────────────────────────────────┤
│  ┌─────────┐  ┌─────────┐               │
│  │  规划   │  │  记忆   │               │
│  │ Planning│  │ Memory  │               │
│  └────┬────┘  └────┬────┘               │
│       │            │                     │
│       └─────┬──────┘                     │
│             ▼                            │
│       ┌──────────┐                       │
│       │  执行    │                       │
│       │ Execution│                       │
│       └────┬─────┘                       │
│            │                             │
│       ┌────▼─────┐                       │
│       │  工具    │                       │
│       │  Tools   │                       │
│       └──────────┘                       │
└─────────────────────────────────────────┘

规划（Planning）：大脑的思考过程

Agent需要把复杂任务拆解成可执行的步骤。书中重点介绍了ReAct框架（Reasoning + Acting），这是目前最主流的Agent认知框架。

ReAct的核心思想：先推理，再行动。

用户问题: "帮我找一家北京评分最高的意大利餐厅"

Agent思考过程:
1. [Thought] 我需要先搜索北京的意大利餐厅
2. [Action] 调用地图搜索API
3. [Observation] 返回10家餐厅，需要筛选评分
4. [Thought] 需要获取每家餐厅的评分信息
5. [Action] 调用评分查询API
6. [Observation] 找到评分最高的餐厅
7. [Thought] 可以给出答案了
8. [Answer] 推荐XXX餐厅，评分4.8...

这种"思考-行动-观察"的循环，让Agent的行为可解释、可调试。

记忆（Memory）：不只是存对话

Agent的记忆分三种类型：

短期记忆：当前对话的上下文，通过LLM的上下文窗口实现。

长期记忆：跨会话的知识存储，通常用向量数据库（如Chroma、Pinecone）。

工作记忆：任务执行过程中的中间状态，比如"我已经搜索了A，还需要搜索B"。

书中用LlamaIndex实现了RAG（检索增强生成），让Agent能够从海量文档中检索相关信息。

工具（Tools）：连接外部世界的桥梁

Agent的能力边界取决于它能调用哪些工具。书中介绍的工具类型：

搜索工具：Google Search、Wikipedia
代码执行工具：Python REPL、代码解释器
文件操作工具：读写文件、处理Excel/PDF
API调用工具：调用外部服务接口

工具的设计原则：单一职责、接口清晰、错误处理完善。

执行（Execution）：从计划到结果

执行是把规划落地的过程。书中强调了任务分解和异常处理：

def execute_task(task):
    try:
        # 分解任务
        subtasks = decompose(task)

        # 按顺序执行
        results = []
        for subtask in subtasks:
            result = execute_subtask(subtask)
            results.append(result)

        # 汇总结果
        return aggregate(results)
    except Exception as e:
        # 错误恢复
        return handle_error(e)

7个实战项目：从简单到复杂

项目1：Assistants API + DALL·E 3 创作PPT

场景：自动生成PPT，解放职场人的双手。

技术要点：

• OpenAI Assistants API的Code Interpreter功能
• DALL·E 3图像生成
• 多模态内容的组合输出

踩坑经验：
Assistants API是异步的，需要轮询状态。书中的处理方式：

import time

def wait_for_run(client, thread_id, run_id, timeout=300):
    """等待Assistant完成运行"""
    start_time = time.time()
    while time.time() - start_time < timeout:
        run = client.beta.threads.runs.retrieve(
            thread_id=thread_id,
            run_id=run_id
        )
        if run.status == 'completed':
            return run
        elif run.status == 'failed':
            raise Exception(f"Run failed: {run.last_error}")
        time.sleep(1)
    raise TimeoutError("Run timed out")

项目2：Function Calling 多功能引擎

场景：根据用户意图，调用不同的函数。

技术要点：

• OpenAI Function Calling机制
• 函数描述的写法（让LLM理解函数用途）
• 多函数选择的逻辑

核心代码：

functions = [
    {
        "name": "get_weather",
        "description": "获取指定城市的天气信息",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {
                    "type": "string",
                    "description": "城市名称，如：北京、上海"
                }
            },
            "required": ["city"]
        }
    },
    {
        "name": "search_web",
        "description": "搜索互联网信息",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {
                    "type": "string",
                    "description": "搜索关键词"
                }
            },
            "required": ["query"]
        }
    }
]

# 调用模型
response = client.chat.completions.create(
    model="gpt-4",
    messages=[{"role": "user", "content": "北京今天天气怎么样？"}],
    functions=functions
)

# 根据模型选择的函数执行
if response.choices[0].message.function_call:
    function_name = response.choices[0].message.function_call.name
    arguments = json.loads(response.choices[0].message.function_call.arguments)
    result = execute_function(function_name, arguments)

踩坑经验：
函数描述要具体。比如"description": "搜索信息"不如"description": "搜索互联网信息，当用户询问实时新闻、最新动态时使用"。

项目3：LangChain ReAct 自动定价

场景：智能定价系统，根据市场数据自动调整价格。

技术要点：

• LangChain的Agent模块
• ReAct框架的实现
• 自定义工具的开发

ReAct Agent的核心逻辑：

from langchain.agents import initialize_agent, Tool
from langchain.llms import OpenAI

# 定义工具
tools = [
    Tool(
        name="SearchPrice",
        func=search_price,
        description="搜索竞品价格信息"
    ),
    Tool(
        name="CalculateMargin",
        func=calculate_margin,
        description="计算利润率"
    ),
    Tool(
        name="AdjustPrice",
        func=adjust_price,
        description="调整价格"
    )
]

# 初始化Agent
agent = initialize_agent(
    tools=tools,
    llm=OpenAI(temperature=0),
    agent="zero-shot-react-description",
    verbose=True  # 打印思考过程
)

# 执行
agent.run("我们的产品成本是100元，竞品价格在150-180元之间，建议定价多少？")

踩坑经验：
ReAct Agent有时会陷入循环。书中建议设置max_iterations参数，并在Agent停止时检查原因：

from langchain.agents import AgentExecutor

agent_executor = AgentExecutor.from_agent_and_tools(
    agent=agent,
    tools=tools,
    max_iterations=5,  # 限制迭代次数
    early_stopping_method="generate"  # 超过限制时生成最终答案
)

项目4：Plan-and-Execute 智能调度库存

场景：复杂的库存管理，需要多步骤规划。

技术要点：

• Plan-and-Execute模式（先制定完整计划，再逐步执行）
• LangChain的PlanAndExecute Agent
• 复杂任务的分解策略

Plan-and-Execute vs ReAct：

特性	ReAct	Plan-and-Execute
执行方式	边想边做	先规划后执行
适用场景	简单任务、快速反馈	复杂任务、需要全局规划
调试难度	较难（思维链较长）	较易（计划可检查）
灵活性	高（可根据观察调整）	低（按计划执行）

核心代码：

from langchain_experimental.plan_and_execute import (
    PlanAndExecute,
    load_agent_executor,
    load_chat_planner
)

model = ChatOpenAI(temperature=0)
planner = load_chat_planner(model)
executor = load_agent_executor(model, tools, verbose=True)

agent = PlanAndExecute(planner=planner, executor=executor)

agent.run("分析当前库存，预测下月需求，生成采购建议")

项目5：LlamaIndex RAG Agent

场景：知识库问答，从海量文档中检索答案。

技术要点：

• LlamaIndex的索引构建
• 向量检索的原理
• RAG Pipeline的设计

RAG的核心流程：

用户问题
    ↓
[Embedding] 向量化
    ↓
[Retrieval] 从向量库检索相关文档
    ↓
[Augmentation] 构建Prompt（问题 + 相关文档）
    ↓
[Generation] LLM生成答案

核心代码：

from llama_index import VectorStoreIndex, SimpleDirectoryReader

# 加载文档
documents = SimpleDirectoryReader('./docs').load_data()

# 构建索引
index = VectorStoreIndex.from_documents(documents)

# 创建查询引擎
query_engine = index.as_query_engine()

# 查询
response = query_engine.query("什么是ReAct框架？")
print(response)

踩坑经验：
文档分块大小影响检索质量。书中建议：

from llama_index.node_parser import SimpleNodeParser

parser = SimpleNodeParser.from_defaults(
    chunk_size=1024,  # 分块大小
    chunk_overlap=200  # 重叠部分，避免截断语义
)
nodes = parser.get_nodes_from_documents(documents)

项目6：AutoGPT、BabyAGI、CAMEL

场景：自主Agent，无需人类干预完成任务。

技术要点：

• AutoGPT的自我反思机制
• BabyAGI的任务队列管理
• CAMEL的角色扮演协作

AutoGPT的工作原理：

目标: "写一篇关于AI Agent的文章"

循环:
1. 思考下一步要做什么
2. 执行行动（搜索、写入文件等）
3. 评估结果
4. 决定是否完成或继续

BabyAGI的任务管理：

class BabyAGI:
    def __init__(self):
        self.task_list = []
        self.task_memory = VectorStore()  # 存储已完成任务的结果

    def run(self, objective):
        # 初始任务
        self.task_list = [{"task_id": 1, "task": f"完成目标: {objective}"}]

        while self.task_list:
            # 1. 任务执行
            task = self.task_list.pop(0)
            result = self.execute_task(task)

            # 2. 存储结果
            self.task_memory.add(task, result)

            # 3. 生成新任务
            new_tasks = self.create_tasks(objective, result)
            self.task_list.extend(new_tasks)

            # 4. 优先级排序
            self.prioritize_tasks()

踩坑经验：
自主Agent容易陷入无限循环。书中建议：

• 设置最大迭代次数
• 定期检查是否偏离目标
• 保留人类干预接口

项目7：AutoGen和MetaGPT

场景：多Agent协作，模拟团队工作。

技术要点：

• AutoGen的对话模式
• MetaGPT的角色定义
• 多Agent的通信协议

AutoGen的多Agent示例：

from autogen import AssistantAgent, UserProxyAgent

# 创建助手Agent
assistant = AssistantAgent(
    name="assistant",
    llm_config={"model": "gpt-4"}
)

# 创建用户代理
user_proxy = UserProxyAgent(
    name="user_proxy",
    human_input_mode="NEVER",  # 自动运行
    max_consecutive_auto_reply=10
)

# 开始对话
user_proxy.initiate_chat(
    assistant,
    message="帮我写一个Python爬虫"
)

MetaGPT的角色协作：

from metagpt.roles import ProductManager, Architect, Engineer

# 创建团队
team = Team()

# 添加角色
team.hire([
    ProductManager(),
    Architect(),
    Engineer()
])

# 启动项目
team.run_project("开发一个待办事项应用")

踩坑经验：
多Agent系统的调试是噩梦。书中建议：

• 每个Agent有明确的职责边界
• 记录完整的对话历史
• 使用可视化工具查看Agent交互

这本书的局限性

读完这本书，我也看到了一些不足：

1. 技术栈偏OpenAI

书中的示例主要基于OpenAI的API和模型。对于国内开发者，可能需要适配到国内大模型（如DeepSeek、通义千问、文心一言）。好消息是LangChain和LlamaIndex都支持自定义LLM，迁移成本可控。

2. 代码是教学用，非生产级

书中的代码清晰易懂，但缺少生产环境的关键要素：错误重试、日志监控、性能优化、安全防护。实际部署时需要补课。

3. Agent评测方法较少

如何评估一个Agent的好坏？书中涉及较少。实际项目中，Agent评测是重要环节，需要建立评测数据集和指标体系。

谁适合读这本书？

适合：

• 有Python基础，想入门AI Agent开发的程序员
• 需要系统性学习LangChain/LlamaIndex的开发者
• 想了解Agent前沿技术（AutoGPT、MetaGPT）的技术管理者

不适合：

• 完全零基础的初学者（需要先补Python和大模型基础）
• 只想了解概念、不打算写代码的人

结语

AI Agent正在从"玩具"变成"工具"。这本书的价值在于，它不是给你画饼，而是给你一把锤子——7个实战项目就是7个可运行的锤子，你可以拿着它们去敲钉子。

书中有一句话我印象深刻：

“Agent不仅是内容生成工具，更是连接复杂任务的关键纽带。”

这大概是AI Agent最准确的定义。

---

书籍信息

• 书名：《大模型应用开发：动手做AI Agent》
• 作者：黄佳
• 出版社：人民邮电出版社
• 出版时间：2024年5月
• 页数：449页
• 定价：89.80元
• QQ阅读：可在线阅读