罗罗编程学习记录
本页内容 展开查看

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:
    1. 把当前 messages 发给模型,要求它输出思考(Thought)与动作(Action/工具调用)。
    2. 执行工具,拿到观察(Observation),回填。
    3. 模型判断任务是否完成,完成则输出最终答案,否则继续。
  • 与普通 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 先让模型把任务拆成完整计划,再逐步执行,中途可调整计划。

核心机制:

  • 两阶段:
    1. Plan:模型先输出一个步骤列表(如"1. 查竞品 A 2. 查竞品 B 3. 对比 4. 写报告")。
    2. 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 自主运行最容易失控——无限循环、成本爆炸。必须设硬性停止条件,并支持中断恢复。

核心机制:

  • 停止条件四种:
    1. 步数上限(如 max_steps=10)。
    2. token 预算上限(累计 prompt+completion 超阈值即停)。
    3. 时间超时(如 5 分钟)。
    4. 目标达成判定(模型输出"完成"或回答通过校验)。
  • 预算控制:每步累计 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 分钟内定位

自测题(先自己想,再看要点):

  1. ReAct 和单轮 Function Calling 的本质区别是什么?
    • 要点:单轮调一次工具就回答;ReAct 是模型自主多轮"思考→行动→观察→再思考",直到完成,必须有停止条件。
  2. 防止 Agent 无限循环有哪几种停止条件?
    • 要点:步数上限、token 预算、时间超时、目标达成判定;四种叠加。
  3. 为什么长期记忆必须按 user_id 隔离?
    • 要点:不隔离会导致跨用户串数据,A 用户看到 B 用户的信息,是严重安全与隐私问题;检索时带 user_id 过滤。
  4. 上下文为什么要压缩?怎么压?
    • 要点:多轮后 messages 撑爆窗口;旧消息用模型摘要成要点,保留 system 与最近消息。
  5. ReAct 和 Plan-Execute 怎么选?
    • 要点:探索性、步骤不可预知用 ReAct;步骤明确、需全局规划的长任务用 Plan-Execute,并允许 replan。
  6. Reflection 的代价是什么?什么时候不该用?
    • 要点:每步多一次模型调用,延迟成本上升;只在关键步骤用,简单步骤不要每步反思。
  7. 断点续跑(checkpoint)解决什么问题?
    • 要点:长任务跑到第 N 步崩了不用从头重跑;每步存状态,中断后从最近检查点恢复。