← 返回首页 📚 实战课程
📑 本篇章节导航 (共5章,点击直达)
本节目标核心知识面试模拟动手练习下一课预告

P3-05 - Agent设计模式

本节目标

1. Agent和ChatBot的本质区别是什么?

2. ReAct模式的推理-行动循环怎么实现?

3. Plan-Execute模式和ReAct模式各自的适用场景?

4. Multi-Agent系统怎么协调?任务怎么分配?

5. Agent的记忆(Memory)怎么设计?

核心知识

一、Agent vs ChatBot vs Prompt Chain


ChatBot(聊天机器人):
  用户问 → 模型答 → 结束
  特点:单轮交互,无工具调用,纯对话
  例子:ChatGPT基础对话

Prompt Chain(提示链):
  步骤1 → 步骤2 → 步骤3 → 最终输出
  特点:固定流程,每步输出是下步输入
  例子:文档翻译 → 摘要 → 格式化
  缺点:流程固定,不能根据中间结果调整

Agent(智能体):
  循环执行:观察 → 思考 → 行动 → 观察 → ...
  特点:动态决策,能根据中间结果选择下一步
  例子:自动定价Agent、代码调试Agent
  关键:有工具调用能力 + 有决策循环 + 有记忆

一句话区分:
  ChatBot = 被动回答
  Prompt Chain = 固定流水线
  Agent = 自主决策 + 工具使用 + 动态调整

二、ReAct模式 — 最经典的Agent模式


ReAct = Reasoning(推理) + Acting(行动)

循环:
  ┌─────────────────────────────────────────┐
  │                                          │
  │  ① Thought(思考)                       │
  │     "用户想知道深圳-北京明天的最低价,     │
  │      我需要先查库存,再查当前价格"         │
  │          │                               │
  │          ▼                               │
  │  ② Action(行动)                        │
  │     调用 queryInventory("SZX","PEK","明天")│
  │          │                               │
  │          ▼                               │
  │  ③ Observation(观察)                   │
  │     "SZX-PEK 明天库存: 35张"             │
  │          │                               │
  │          ▼                               │
  │  ④ Thought(再思考)                     │
  │     "有库存,现在查价格"                  │
  │          │                               │
  │          ▼                               │
  │  ⑤ Action(再行动)                      │
  │     调用 queryPrice("SZX","PEK","明天")   │
  │          │                               │
  │          ▼                               │
  │  ⑥ Observation(再观察)                 │
  │     "最低价580元"                        │
  │          │                               │
  │          ▼                               │
  │  ⑦ Final Answer(最终回答)              │
  │     "深圳-北京明天最低价580元,有35张票"   │
  │                                          │
  └─────────────────────────────────────────┘

关键:循环次数不固定,模型自己决定什么时候停止

手写ReAct Agent Loop(核心代码)


@Service
public class ReactAgent {

    private final ChatModel chatModel;
    private final Map<String, Function<String, String>> tools;

    public ReactAgent(ChatModel chatModel, List<AgentTool> toolList) {
        this.chatModel = chatModel;
        this.tools = toolList.stream()
            .collect(Collectors.toMap(AgentTool::getName, AgentTool::execute));
    }

    public String run(String userQuestion, int maxIterations) {
        List<Message> messages = new ArrayList<>();
        messages.add(new SystemMessage("""
            你是一个智能助手。你可以使用工具来完成任务。
            每一步你需要:
            1. 思考当前情况(Thought)
            2. 决定使用什么工具(Action)
            3. 观察工具返回结果(Observation)
            当你有了足够信息时,给出最终回答。

            可用工具:%s
            """.formatted(String.join(", ", tools.keySet()))));

        messages.add(new UserMessage(userQuestion));

        for (int i = 0; i < maxIterations; i++) {
            // 调用模型
            ChatResponse response = chatModel.call(new Prompt(messages));
            String content = response.getResult().getOutput().getText();

            // 检查是否是最终回答
            if (!content.contains("Action:")) {
                return content; // 模型给出了最终回答
            }

            // 解析工具调用
            String toolName = extractToolName(content);
            String toolArgs = extractToolArgs(content);

            if (tools.containsKey(toolName)) {
                // 执行工具
                String observation = tools.get(toolName).apply(toolArgs);

                // 把Thought+Action和Observation追加到对话历史
                messages.add(new AssistantMessage(content));
                messages.add(new UserMessage("Observation: " + observation));
            } else {
                messages.add(new AssistantMessage(content));
                messages.add(new UserMessage("Observation: 工具 " + toolName + " 不存在"));
            }
        }

        return "抱歉,任务过于复杂,超过最大迭代次数。";
    }
}

三、Plan-Execute模式 — 先规划再执行


适用场景:任务步骤多、步骤之间有依赖关系

ReAct的问题:每一步都是临场决策,没有全局规划
Plan-Execute的优势:先制定完整计划,再按计划执行

流程:
  ┌──────────────────────────────────────────────────┐
  │                                                    │
  │  ① Planner(规划器)                                │
  │     输入:用户任务                                   │
  │     输出:步骤列表                                   │
  │     例:["查库存", "查价格", "查竞品价格", "计算建议价"]│
  │          │                                         │
  │          ▼                                         │
  │  ② Executor(执行器)                               │
  │     按步骤依次执行,每步可以调用工具                    │
  │          │                                         │
  │          ▼                                         │
  │  ③ Replanner(重规划器,可选)                       │
  │     如果某步执行失败或结果不符预期,重新调整计划         │
  │          │                                         │
  │          ▼                                         │
  │  ④ Finalizer(总结器)                              │
  │     整合所有步骤的结果,生成最终回答                    │
  │                                                    │
  └──────────────────────────────────────────────────┘

什么时候用Plan-Execute:
  - 任务需要5步以上
  - 步骤之间有严格顺序(B依赖A的结果)
  - 需要"如果A成功就做B,如果A失败就做C"的条件分支

什么时候用ReAct:
  - 任务简单(2-3步)
  - 不需要全局规划
  - 每步独立

四、Memory设计 — Agent的短期和长期记忆


短期记忆(对话内):
  - 当前对话的上下文(最近N轮)
  - 当前任务的中间结果
  - 存储:内存 or Redis(带TTL)
  - 生命周期:对话结束即清理

长期记忆(跨对话):
  - 用户偏好("我偏好上午航班")
  - 历史决策("上次定价580元效果不好")
  - 知识积累("深圳-北京航线周末需求高")
  - 存储:向量数据库 or 关系数据库
  - 生命周期:永久,按需检索

设计模式:
  ┌──────────────────────────────────────┐
  │            Memory Manager            │
  │                                      │
  │  ┌──────────┐  ┌──────────────────┐ │
  │  │ 短期记忆  │  │ 长期记忆          │ │
  │  │ (Redis)  │  │ (VectorStore)    │ │
  │  │          │  │                  │ │
  │  │ 最近10轮 │  │ 用户偏好         │ │
  │  │ 中间结果 │  │ 历史决策         │ │
  │  │ 当前状态 │  │ 领域知识         │ │
  │  └──────────┘  └──────────────────┘ │
  │                                      │
  │  查询时:                             │
  │  1. 先查短期记忆(当前对话上下文)      │
  │  2. 再查长期记忆(相关历史和偏好)      │
  │  3. 合并后注入Prompt                  │
  └──────────────────────────────────────┘

面试模拟

Q1: "Agent和普通ChatBot有什么区别?"

"ChatBot是被动回答——用户问什么答什么,只能用模型自己学到的知识。

>

Agent有三个核心区别:
1. 有工具——可以调用外部系统(查数据库、调API、执行操作)
2. 有循环——不是一问一答,而是思考→行动→观察→再思考的循环
3. 有记忆——能记住上下文和历史决策,做出更连贯的判断

>

比如我们的定价Agent:用户说'深圳到北京的票要不要调价',
Agent会先查库存→查当前价格→查竞品价格→查历史调价效果→综合判断→给出建议。
这是一个5步的ReAct循环,ChatBot做不到。"

Q2: "你们Agent的循环最多跑几轮?超了怎么办?"

"设了最大10轮迭代,防止无限循环(模型可能一直调用工具不停下来)。

>

超过10轮后直接返回当前已知信息,附带说明'信息收集未完成'。

>

实际运行中95%的查询在3轮内完成,超过5轮的基本都是工具调用失败导致的重试。
所以还有一个优化:如果同一轮工具连续失败3次,提前终止并走降级。"

动手练习

练习1:手写一个ReAct Agent

1. 定义3个Tool(查询数据库、查询API、计算)

2. 实现Agent Loop

3. 测试一个需要2-3轮循环的任务

练习2:对比ReAct和固定Pipeline

1. 用同样的任务分别用ReAct和固定Pipeline实现

2. 对比执行效率、准确性、灵活性

下一课预告

P3-06将深入MCP协议实战,实现一个MCP Server并集成到Spring AI中。