06.6 阶段 5:Agent 架构与编排
所属:全栈开发面试题库 / 学习路径 / 06 AI Agent
本页目录
一、阶段定位
前面你做的是"单轮决策":模型决定调一个工具,拿到结果,回答。本阶段进入"多步自主任务":给 Agent 一个目标,它自己反复地"思考→行动→观察→再思考",直到完成任务。这就是 Agent 与普通工具调用的区别——任务可能需要 5 步、10 步,中间还要自己纠错、管理记忆、控制预算。
为什么这是阶段 5:RAG 解决了"查资料",工具调用解决了"做一步",Agent 解决"多步且自主"。真实任务("帮我调研一个竞品并出报告")需要:规划步骤、调用多个工具、根据中间结果调整、记住之前做了什么、最后汇总。这些都不是单轮调用能搞定的。
与前后阶段的衔接:往上接 阶段 4 RAG,检索器是 Agent 的一个工具;往下接 阶段 6 工程化框架与服务化,那时你会用 LangGraph 等框架把这里的手写循环变成状态图。跳过本阶段直接上框架,常见后果是:Agent 无限循环不设停止条件、上下文只做累加窗口爆满、记忆不分区跨用户串数据、长任务失败从头重跑没有断点。
本阶段的卡点(判断依据):
- Agent 无限循环不设停止条件:现象是模型反复调同一个工具,跑了几十步还不停。判断标准:你能否说出步数上限、token 预算、超时、目标达成判定四种停止条件。
- 上下文只做累加不做压缩,窗口爆满:现象是跑了 10 轮后
context_length_exceeded。判断标准:你能否说出摘要压缩、检索式记忆、旧消息裁剪三种上下文管理手段。 - 记忆不分区不隔离,跨用户串数据:现象是 A 用户的对话里出现了 B 用户的信息。判断标准:你能否说清短期记忆(会话内)与长期记忆(按用户隔离)的区别。
- 多智能体之间互相推诿或重复调用:现象是两个 subagent 各自查了同一份资料。判断标准:你能否说清角色划分、通信方式、共享状态。
- 长任务失败后从头重跑,没有断点:现象是跑到第 8 步崩了,下次从头开始。判断标准:你能否说出检查点(checkpoint)的作用。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能手写一个 ReAct 循环,跑通多步任务 | Agent 能连续调用工具直到任务完成 |
| 能实现步数与 token 预算上限 | 超过上限自动停止,不无限循环 |
| 能对上下文做摘要压缩 | 跑 10 轮后不超窗 |
| 能区分短期记忆与按用户隔离的长期记忆 | 不同用户记忆不串 |
| 能说出 ReAct/Plan-Execute/Reflection 适用场景 | 给一个任务能选对架构 |
| 能实现检查点,中断后从断点恢复 | 跑到第 5 步中断后从第 5 步继续 |
建议学时:
- 全职(每天 4–6 小时):2.5 周,约 60 小时。其中 ReAct 循环 16 小时、Plan-Execute/Reflection 12 小时、上下文与记忆 16 小时、多智能体 10 小时、预算与断点 6 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周,约 65 小时。手写 ReAct 循环是必须的,不要只看框架。
学时分配:ReAct 25%、Plan-Execute 与 Reflection 18%、上下文压缩与记忆 27%、多智能体 15%、预算与断点 15%。上下文与记忆是工程难点。
三、先修自检
| 先修项 | 合格标准 | 不合格时回到 |
|---|---|---|
| 工具调用循环 | 能跑通 tool_calls 消息流 | 06.4 阶段 3 |
| 上下文窗口 | 知道输入输出共享窗口会超窗 | 06.2 阶段 1 |
| RAG 检索 | 能把检索器当工具 | 06.5 阶段 4 |
| Python 循环与状态 | 能写 while 循环与状态字典 | 补 Python 基础 |
经验判断:写过传统工作流的人容易把 Agent 当"固定流程";Agent 的核心是模型自主决策,流程不可预知,所以停止条件和状态管理比固定编排更重要。
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| ReAct | 推理+行动循环、Thought/Action/Observation | 能讲清原理 | 10.4 Agent 架构 |
| Plan-Execute | 先规划再执行、计划调整 | 会用 | 10.4 Agent 架构 |
| Reflection | 自我评判与修正 | 会用 | 10.4 Agent 架构 |
| 上下文与记忆 | 摘要压缩、短期/长期记忆、按用户隔离 | 能讲清原理 | 10.4 Agent 架构 |
| 多智能体 | subagent、角色划分、通信、共享状态 | 会用 | 10.4 Agent 架构 |
| 预算与断点 | 步数/token/时间上限、检查点 | 会用 | 10.4 Agent 架构 |
进度管理建议:用一个多步任务(如"查资料→整理→出摘要")贯穿本阶段。《知识点全清单》给全量条目;术语查《术语表》;框架化实现在阶段 6。
五、分模块精讲
5.1 ReAct 循环
为什么需要它:ReAct(Reasoning + Acting)让模型在每一步先"想"(推理下一步该做什么),再"做"(调工具),然后观察结果,继续想。这是 Agent 最基础的自主循环。
核心机制:
- 循环结构:
while not done:- 把当前 messages 发给模型,要求它输出思考(Thought)与动作(Action/工具调用)。
- 执行工具,拿到观察(Observation),回填。
- 模型判断任务是否完成,完成则输出最终答案,否则继续。
- 与普通 Function Calling 的区别:普通是单轮(调一次工具就回答);ReAct 是多轮,模型自主决定还要调几次。
- 停止条件:模型输出"完成"、达到步数上限、或达到 token 预算。
最小可运行示例:
# react.py:手写 ReAct 循环,带步数上限
def run_agent(question: str, max_steps: int = 8) -> str:
messages = [
{"role": "system", "content":
"你是一个能调用工具的助手。每一步先思考该做什么,需要时调用工具。"
"任务完成时输出最终答案,不要继续调用工具。"},
{"role": "user", "content": question},
]
for step in range(max_steps):
r = httpx.post(f"{BASE_URL}/chat/completions", headers=auth_header(),
json={"model": MODEL, "messages": messages, "tools": TOOLS,
"temperature": 0}, timeout=60.0)
msg = r.json()["choices"][0]["message"]
messages.append(msg)
if r.json()["choices"][0]["finish_reason"] != "tool_calls":
return msg["content"] # 模型给了最终答案
for call in msg["tool_calls"]:
result = execute_tool(call) # 执行工具
messages.append({"role": "tool", "tool_call_id": call["id"], "content": result})
return "达到步数上限,任务未完成。"
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| Agent 无限调工具不停 | 没设步数上限 | max_steps 强制停止 |
| 模型反复调同一工具 | 工具结果没回填或模型卡住 | 检查回填;加"已完成 X"提示 |
| 循环几轮就超窗 | 上下文没压缩 | 摘要压缩(5.4) |
面试考法:问"ReAct 和单轮 Function Calling 有什么区别"。要点:单轮是调一次工具就回答;ReAct 是模型自主多轮决策,思考→行动→观察→再思考,直到任务完成,必须有停止条件。
5.2 Plan-Execute 架构
为什么需要它:ReAct 走一步看一步,对复杂任务容易迷路或反复。Plan-Execute 先让模型把任务拆成完整计划,再逐步执行,中途可调整计划。
核心机制:
- 两阶段:
- Plan:模型先输出一个步骤列表(如"1. 查竞品 A 2. 查竞品 B 3. 对比 4. 写报告")。
- Execute:逐步执行,每步完成后标记进度,必要时 replan(重新规划)。
- 与 ReAct 的取舍:Plan-Execute 适合步骤明确、需要全局规划的长任务;ReAct 适合探索性强、步骤不可预知的任务。
- 计划要可检查:每步有明确的完成标志,避免"做了但不知道做完没"。
最小可运行示例:
# plan_execute.py:先规划再执行
def plan(question: str) -> list[str]:
r = httpx.post(..., json={"model": MODEL, "messages": [
{"role": "system", "content": "把任务拆成 3-6 步计划,每行一步,不要执行。"},
{"role": "user", "content": question}]}, timeout=30.0)
return [s.strip() for s in r.json()["choices"][0]["message"]["content"].split("\n") if s.strip()]
def execute(question: str):
steps = plan(question)
for i, step in enumerate(steps):
print(f"执行第 {i+1}/{len(steps)} 步: {step}")
# 每步用 ReAct 小循环执行,必要时 replan
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 计划执行到一半发现走不通 | 计划没考虑依赖 | 中途 replan,允许修改剩余步骤 |
| 计划太粗 | 模型拆得不够具体 | 要求每步可执行、可验证 |
面试考法:问"ReAct 和 Plan-Execute 怎么选"。要点:探索性、步骤不可预知用 ReAct;步骤明确、需要全局规划的长任务用 Plan-Execute,并允许中途 replan。
5.3 Reflection 与自我修正
为什么需要它:Agent 一次做对概率不高。Reflection 让 Agent 做完一步后自己评判"这步做得对不对、要不要重来",提升最终质量。
核心机制:
- 在执行完一个关键步骤后,加一个"评判"调用:让模型或另一个模型看当前结果,指出问题。
- 如果评判发现错误,回到上一步修正;如果通过,继续。
- 代价:每步多一次模型调用,延迟和成本上升;只在关键步骤(最终答案、高风险动作)用,不要每步都反思。
- 可以用一个专门的 critic agent 做评判(多智能体的雏形)。
最小可运行示例:
# reflect.py:生成后自我评判
def generate_and_reflect(task: str, draft: str) -> str:
r = httpx.post(..., json={"model": MODEL, "messages": [
{"role": "system", "content":
"你是评审。检查草稿是否满足任务要求,指出问题。"
"如果没问题,回复'通过'。"},
{"role": "user", "content": f"任务: {task}\n草稿: {draft}"}]}, timeout=30.0)
review = r.json()["choices"][0]["message"]["content"]
if review.strip() == "通过":
return draft
# 把评审意见回填,让模型修改
...
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 成本翻倍 | 每步都反思 | 只在关键步骤反思 |
| 评审和生成是同一个模型 | 看不出自己的错 | 用更强模型或独立 critic |
面试考法:问"Reflection 什么时候用、代价是什么"。要点:在最终答案或高风险动作后自我评判提升质量;代价是多一次模型调用,延迟成本上升,所以只在关键步骤用。
5.4 上下文管理与记忆
为什么需要它:Agent 跑多轮后,messages 越积越多,很快撑爆上下文窗口。必须主动管理:压缩旧消息、区分短期与长期记忆。
核心机制:
- 上下文压缩:旧的工具结果与思考用模型摘要成一段,替换原始多条消息,保留 system 与最近消息。
- 短期记忆:当前会话内的 messages,随会话结束而消失。
- 长期记忆:跨会话保存,按用户隔离(user_id 分区),存进向量库或数据库,需要时检索相关片段放回上下文。
- 记忆隔离:不同用户的记忆用 user_id 严格分区,检索时带 user_id 过滤,杜绝串数据。
- 记忆不是越多越好:只放与当前任务相关的记忆,否则又是噪声。
最小可运行示例:
# memory.py:摘要压缩 + 按用户隔离的长期记忆
def summarize_old(messages: list[dict]) -> str:
# 把旧消息发给模型摘要
r = httpx.post(..., json={"model": MODEL, "messages": [
{"role": "system", "content": "把以下对话压缩成要点,保留关键事实。"},
{"role": "user", "content": str(messages)}]}, timeout=30.0)
return r.json()["choices"][0]["message"]["content"]
def long_term_retrieve(user_id: str, query: str) -> list[str]:
# 检索时按 user_id 过滤,杜绝跨用户串数据
return vector_search(query, filter={"user_id": user_id}, top_k=3)
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 跑几轮就 context_length_exceeded | 消息只累加 | 摘要压缩旧消息 |
| A 用户看到 B 用户的记忆 | 检索没按 user_id 过滤 | 加 user_id 元数据过滤 |
| 记忆太多反而干扰 | 全塞进来 | 只检索相关片段 |
面试考法:问"Agent 上下文怎么管理,为什么要按用户隔离记忆"。要点:旧消息摘要压缩,短期会话内、长期按 user_id 分区存储与检索;不隔离会导致跨用户串数据,是严重安全问题。
5.5 多智能体与 subagent 编排
为什么需要它:单个 Agent 工具列表过长、上下文过载。把任务按角色拆分(研究员、写作者、审核者),每个 subagent 有自己的工具与上下文,主 Agent 调度。
核心机制:
- 主 Agent(orchestrator)负责拆解任务、分派给 subagent、汇总结果。
- subagent 各司其职:研究员只查资料,写作者只写,审核者只评审;各自工具列表精简。
- 通信:主 Agent 把 subagent 的产出作为消息传递;共享状态放一个公共存储。
- 避免重复:不同 subagent 不要重复查同一资料;共享中间结果。
- 适用:任务链路复杂、角色清晰;简单任务不要为概念引入多智能体。
最小可运行示例:
# multi_agent.py:主 Agent 调度 subagent(概念示意)
def researcher(task: str) -> str:
# 只配检索工具
return run_agent(task, tools=RETRIEVAL_TOOLS)
def writer(task: str, material: str) -> str:
# 只配写作工具,输入是研究员的产出
return run_agent(task, tools=WRITING_TOOLS)
def orchestrator(goal: str):
material = researcher(f"为以下目标收集资料: {goal}")
report = writer(f"基于资料写报告: {goal}", material)
return report
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| subagent 互相推诿 | 职责边界不清 | 明确每个角色的输入输出 |
| 重复调用同一工具 | 没共享中间结果 | 主 Agent 传递产物 |
| 简单任务硬上多智能体 | 过度设计 | 单 Agent 加工具集足够就不要拆 |
面试考法:问"什么时候该用多智能体"。要点:任务复杂、角色清晰、单 Agent 工具/上下文过载时拆分;简单任务不要为概念引入,避免编排复杂度与重复调用。
5.6 停止条件、预算控制与断点续跑
为什么需要它:Agent 自主运行最容易失控——无限循环、成本爆炸。必须设硬性停止条件,并支持中断恢复。
核心机制:
- 停止条件四种:
- 步数上限(如 max_steps=10)。
- token 预算上限(累计 prompt+completion 超阈值即停)。
- 时间超时(如 5 分钟)。
- 目标达成判定(模型输出"完成"或回答通过校验)。
- 预算控制:每步累计 token,超预算即停并返回中间结果。
- 断点续跑:每完成一步把当前状态(messages、已完成步骤、中间结果)存为检查点;中断后从最近检查点恢复,不用从头重跑。
最小可运行示例:
# budget.py:带预算与检查点
def run_with_budget(question: str, max_steps: int = 10, token_budget: int = 50000):
state = load_checkpoint() or {"messages": [...], "step": 0, "used_tokens": 0}
while state["step"] < max_steps and state["used_tokens"] < token_budget:
# 执行一步
result = step_once(state)
state["step"] += 1
state["used_tokens"] += result["usage_total"]
save_checkpoint(state) # 每步存检查点
if result.get("done"):
return result["answer"]
return "达到预算上限,返回中间结果。"
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| Agent 跑了几十步还不停 | 没设步数/预算上限 | 加 max_steps 与 token_budget |
| 崩了从头开始 | 没检查点 | 每步存状态到检查点 |
| 成本失控 | 没累计 token | 每步累加 usage,超预算即停 |
面试考法:问"怎么防止 Agent 无限循环和成本失控"。要点:四种停止条件(步数、token 预算、时间、目标达成),每步累计用量;用检查点支持中断恢复。
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 手写 ReAct 循环 | 多步任务连续调工具直到完成 | 任务完成,不无限循环 | 4 小时 |
| 加步数上限 | 超过 max_steps 自动停 | 不会无限跑 | 1 小时 |
| 摘要压缩上下文 | 跑 10 轮后不超窗 | 不触发 context_length_exceeded | 3 小时 |
| 按用户隔离记忆 | 两个 user_id 记忆不串 | 检索带 user_id 过滤 | 2 小时 |
| 加检查点 | 中断后从断点恢复 | 不从头重跑 | 3 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 从 ReAct 改为 Plan-Execute | 给定 ReAct,加计划阶段 | 先出步骤列表再执行 | 3 小时 |
| 加 Reflection | 最终答案前加评审 | 评审不过则修改 | 3 小时 |
| 加 token 预算 | 每步累计 usage | 超预算自动停 | 2 小时 |
| 拆分 subagent | 研究员/写作者分开 | 各自工具列表精简 | 4 小时 |
| 压缩旧工具结果 | 旧 Observation 摘要化 | 上下文长度稳定 | 2.5 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 多步任务 Agent | 查资料→整理→出摘要 | 有步数与成本上限,中断可恢复 | 8 小时 |
| 三种架构对比 | 对同一任务跑 ReAct/Plan/Reflection | 给出适用场景与代价表 | 5 小时 |
| 记忆系统设计 | 短期+长期按用户隔离 | 跨用户不串,长期记忆可检索 | 6 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| Agent 无限调工具 | 没设停止条件 | 看步数日志 | 加 max_steps 与 token 预算 |
| 跑几轮就超窗 | 消息只累加 | 看 messages 长度 | 摘要压缩旧消息 |
| 跨用户记忆串数据 | 检索没按 user_id | 检查过滤条件 | 加 user_id 元数据过滤 |
| 成本爆炸 | 没累计用量 | 统计 usage | 每步累加,超预算即停 |
| 崩了从头重跑 | 没检查点 | 看是否存了状态 | 每步存检查点 |
| subagent 重复查资料 | 没共享中间结果 | 看调用日志 | 主 Agent 传递产物 |
| 计划执行一半走不通 | 计划没考虑依赖 | 看哪步失败 | 允许中途 replan |
| 评审看不出自己的错 | 生成与评审同模型 | 用更强模型或独立 critic | 换评审模型 |
八、出口条件
全部勾选后再进入 阶段 6 工程化框架与服务化。
- [ ] 能手写 ReAct 循环,跑通多步任务并带步数上限
- [ ] 能实现 token 预算控制,超预算自动停
- [ ] 能对上下文做摘要压缩,跑 10 轮不超窗
- [ ] 能区分短期记忆与按用户隔离的长期记忆
- [ ] 能对比 ReAct/Plan-Execute/Reflection 的适用场景与代价
- [ ] 能实现检查点,中断后从断点恢复
- [ ] 排障表随机抽三个现象能在 5 分钟内定位
自测题(先自己想,再看要点):
- ReAct 和单轮 Function Calling 的本质区别是什么?
- 要点:单轮调一次工具就回答;ReAct 是模型自主多轮"思考→行动→观察→再思考",直到完成,必须有停止条件。
- 防止 Agent 无限循环有哪几种停止条件?
- 要点:步数上限、token 预算、时间超时、目标达成判定;四种叠加。
- 为什么长期记忆必须按 user_id 隔离?
- 要点:不隔离会导致跨用户串数据,A 用户看到 B 用户的信息,是严重安全与隐私问题;检索时带 user_id 过滤。
- 上下文为什么要压缩?怎么压?
- 要点:多轮后 messages 撑爆窗口;旧消息用模型摘要成要点,保留 system 与最近消息。
- ReAct 和 Plan-Execute 怎么选?
- 要点:探索性、步骤不可预知用 ReAct;步骤明确、需全局规划的长任务用 Plan-Execute,并允许 replan。
- Reflection 的代价是什么?什么时候不该用?
- 要点:每步多一次模型调用,延迟成本上升;只在关键步骤用,简单步骤不要每步反思。
- 断点续跑(checkpoint)解决什么问题?
- 要点:长任务跑到第 N 步崩了不用从头重跑;每步存状态,中断后从最近检查点恢复。