1. Agent和ChatBot的本质区别是什么?
2. ReAct模式的推理-行动循环怎么实现?
3. Plan-Execute模式和ReAct模式各自的适用场景?
4. Multi-Agent系统怎么协调?任务怎么分配?
5. Agent的记忆(Memory)怎么设计?
ChatBot(聊天机器人):
用户问 → 模型答 → 结束
特点:单轮交互,无工具调用,纯对话
例子:ChatGPT基础对话
Prompt Chain(提示链):
步骤1 → 步骤2 → 步骤3 → 最终输出
特点:固定流程,每步输出是下步输入
例子:文档翻译 → 摘要 → 格式化
缺点:流程固定,不能根据中间结果调整
Agent(智能体):
循环执行:观察 → 思考 → 行动 → 观察 → ...
特点:动态决策,能根据中间结果选择下一步
例子:自动定价Agent、代码调试Agent
关键:有工具调用能力 + 有决策循环 + 有记忆
一句话区分:
ChatBot = 被动回答
Prompt Chain = 固定流水线
Agent = 自主决策 + 工具使用 + 动态调整
ReAct = Reasoning(推理) + Acting(行动)
循环:
┌─────────────────────────────────────────┐
│ │
│ ① Thought(思考) │
│ "用户想知道深圳-北京明天的最低价, │
│ 我需要先查库存,再查当前价格" │
│ │ │
│ ▼ │
│ ② Action(行动) │
│ 调用 queryInventory("SZX","PEK","明天")│
│ │ │
│ ▼ │
│ ③ Observation(观察) │
│ "SZX-PEK 明天库存: 35张" │
│ │ │
│ ▼ │
│ ④ Thought(再思考) │
│ "有库存,现在查价格" │
│ │ │
│ ▼ │
│ ⑤ Action(再行动) │
│ 调用 queryPrice("SZX","PEK","明天") │
│ │ │
│ ▼ │
│ ⑥ Observation(再观察) │
│ "最低价580元" │
│ │ │
│ ▼ │
│ ⑦ Final Answer(最终回答) │
│ "深圳-北京明天最低价580元,有35张票" │
│ │
└─────────────────────────────────────────┘
关键:循环次数不固定,模型自己决定什么时候停止
@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 "抱歉,任务过于复杂,超过最大迭代次数。";
}
}
适用场景:任务步骤多、步骤之间有依赖关系
ReAct的问题:每一步都是临场决策,没有全局规划
Plan-Execute的优势:先制定完整计划,再按计划执行
流程:
┌──────────────────────────────────────────────────┐
│ │
│ ① Planner(规划器) │
│ 输入:用户任务 │
│ 输出:步骤列表 │
│ 例:["查库存", "查价格", "查竞品价格", "计算建议价"]│
│ │ │
│ ▼ │
│ ② Executor(执行器) │
│ 按步骤依次执行,每步可以调用工具 │
│ │ │
│ ▼ │
│ ③ Replanner(重规划器,可选) │
│ 如果某步执行失败或结果不符预期,重新调整计划 │
│ │ │
│ ▼ │
│ ④ Finalizer(总结器) │
│ 整合所有步骤的结果,生成最终回答 │
│ │
└──────────────────────────────────────────────────┘
什么时候用Plan-Execute:
- 任务需要5步以上
- 步骤之间有严格顺序(B依赖A的结果)
- 需要"如果A成功就做B,如果A失败就做C"的条件分支
什么时候用ReAct:
- 任务简单(2-3步)
- 不需要全局规划
- 每步独立
短期记忆(对话内):
- 当前对话的上下文(最近N轮)
- 当前任务的中间结果
- 存储:内存 or Redis(带TTL)
- 生命周期:对话结束即清理
长期记忆(跨对话):
- 用户偏好("我偏好上午航班")
- 历史决策("上次定价580元效果不好")
- 知识积累("深圳-北京航线周末需求高")
- 存储:向量数据库 or 关系数据库
- 生命周期:永久,按需检索
设计模式:
┌──────────────────────────────────────┐
│ Memory Manager │
│ │
│ ┌──────────┐ ┌──────────────────┐ │
│ │ 短期记忆 │ │ 长期记忆 │ │
│ │ (Redis) │ │ (VectorStore) │ │
│ │ │ │ │ │
│ │ 最近10轮 │ │ 用户偏好 │ │
│ │ 中间结果 │ │ 历史决策 │ │
│ │ 当前状态 │ │ 领域知识 │ │
│ └──────────┘ └──────────────────┘ │
│ │
│ 查询时: │
│ 1. 先查短期记忆(当前对话上下文) │
│ 2. 再查长期记忆(相关历史和偏好) │
│ 3. 合并后注入Prompt │
└──────────────────────────────────────┘
"ChatBot是被动回答——用户问什么答什么,只能用模型自己学到的知识。
>
Agent有三个核心区别:
1. 有工具——可以调用外部系统(查数据库、调API、执行操作)
2. 有循环——不是一问一答,而是思考→行动→观察→再思考的循环
3. 有记忆——能记住上下文和历史决策,做出更连贯的判断
>
比如我们的定价Agent:用户说'深圳到北京的票要不要调价',
Agent会先查库存→查当前价格→查竞品价格→查历史调价效果→综合判断→给出建议。
这是一个5步的ReAct循环,ChatBot做不到。"
"设了最大10轮迭代,防止无限循环(模型可能一直调用工具不停下来)。
>
超过10轮后直接返回当前已知信息,附带说明'信息收集未完成'。
>
实际运行中95%的查询在3轮内完成,超过5轮的基本都是工具调用失败导致的重试。
所以还有一个优化:如果同一轮工具连续失败3次,提前终止并走降级。"
1. 定义3个Tool(查询数据库、查询API、计算)
2. 实现Agent Loop
3. 测试一个需要2-3轮循环的任务
1. 用同样的任务分别用ReAct和固定Pipeline实现
2. 对比执行效率、准确性、灵活性
P3-06将深入MCP协议实战,实现一个MCP Server并集成到Spring AI中。