在这里插入图片描述

目录

  1. 从纯思考到思考加行动
  2. ReAct循环的结构:轨迹、观察与回灌
  3. 行动空间设计:给模型哪些可执行动作
  4. 观察结果的回灌格式与信息密度
  5. 循环的终止条件与防护
  6. ReAct的失效模式与对策
  7. 与思维链和工具调用的关系
  8. 实战:最小可用的ReAct执行引擎

摘要

ReAct 把程序性执行从"想完再做"升级为"想一步、做一步、看结果、再想":推理步与行动步在轨迹中交替,观察结果回灌后驱动下一步。本文拆解 ReAct 循环结构、行动空间设计、观察回灌格式、终止防护与失效模式,给出最小可用的 ReAct 执行引擎代码。

1. 从纯思考到思考加行动

1.1 纯思维链的盲区

思维链只能操作模型权重里已有的知识:不知道的 API、过时的配置、需要实时查询的状态,思维链编不出来。纯推理遇到"缺信息"的任务时只有两条路——凭幻觉补齐(危险)或承认失败(无用)。

图:纯推理与ReAct在缺信息任务上的分岔

任务需要外部信息

纯思维链

ReAct

凭权重硬编 幻觉风险

推理步:识别缺什么

行动步:调工具查询

观察步:拿到真实数据

基于事实继续推理

图下解读:ReAct 的本质改进是把"行动"作为程序性执行的原语:推理决定做什么,行动改变世界或获取信息,观察把真实结果带回轨迹。知识与事实从"回忆"变成"查询",幻觉的根子被釜底抽薪。

1.2 推理步与行动步的分工

步类型职责输出
思考(Thought)分析现状、规划下一步、解读观察一段推理文本
行动(Action)调用工具改变或查询工具调用
观察(Observation)执行结果工具输出回灌

三步构成一个循环单元:思考解释"为什么做",行动执行"做什么",观察提供"结果如何"。分工明确后,每一步都可单独审计(思考是否合理、行动是否得当、观察是否被正确解读)。

1.3 交替执行的收益

交替执行(而非先想完再做完)让模型在信息增量到达时修正路线:查询结果推翻预设时,下一个思考步立即调整计划。这与第 12 篇规划执行的"计划修正"同源,只是粒度更细——每一步行动后都有修正机会。

2. ReAct循环的结构:轨迹、观察与回灌

2.1 轨迹的构成

ReAct 的执行轨迹是"思考-行动-观察"三元组的序列。轨迹既是模型的输入(前几轮三元组进上下文),也是输出的格式约定(新三元组按同样格式续写)。

图:一轮ReAct循环的信息流

finish

当前轨迹

模型生成

Thought 分析现状

Action 调用工具

环境执行

Observation 结果

终止交付

图下解读:一轮循环的信息流闭合:轨迹喂给模型,模型产出思考与行动,行动改变环境,观察回到轨迹。循环的出口只有 finish(显式)与防护终止(强制),观察永远回到轨迹而不是直接进答案。

// 来源:自实现 / react_trace.txt(ReAct轨迹格式)
Thought 1: 任务是查某仓库最近的release版本。
           我需要先搜索仓库主页。
Action 1: web_search["repo-name latest release"]
Observation 1: 搜索结果显示 v2.4.1 于本月发布…
Thought 2: 搜索结果可信但需交叉验证,
           查看仓库的 releases 页面。
Action 2: web_fetch["https://github.com/repo/releases"]
Observation 2: 页面列出 v2.4.1 …
Thought 3: 两个来源一致,可以给出答案。
Action 3: finish["v2.4.1"]

轨迹格式的工程要点:编号连续(便于引用与审计)、每段有类型前缀(解析器可切分)、行动带参数(可重放)。格式在提示词里用示例锚定(第 1 篇的少样本杠杆)。

2.2 轨迹的增长与窗口预算

每轮循环轨迹加一段三元组,长任务的轨迹会吃满窗口。轨迹管理两层:近端原样保留(最近三五轮),远端摘要压缩(已完成子任务的轨迹折叠成一行结论)。

区域内容处理
近端最近几轮三元组原文保留完整
远端早期轮次折叠为结论行
系统任务描述与行动空间固定头部

折叠的单位是"已完成子任务":查询 A 的四轮轨迹压成"查询A:结果X"一行,细节按需重查。这与第 3 篇压缩策略的原则一致(过程可丢、结论必留)。

2.3 观察回灌的实现

# 来源:自实现 / react_trace_mgr.py(轨迹管理与回灌)
import json

class TraceManager:
    """ReAct轨迹的追加、折叠与渲染"""

    def __init__(self, max_recent: int = 5):
        self.rounds: list[dict] = []
        self.max_recent = max_recent

    def add_round(self, thought: str, action: str,
                  observation: str):
        self.rounds.append({"n": len(self.rounds) + 1,
                            "thought": thought,
                            "action": action,
                            "observation": observation})

    def _fold(self, r: dict) -> str:
        """远端轮次折叠为一行结论"""
        obs_head = r["observation"][:60].replace("\n", " ")
        return (f"轮{r['n']}(已完成):{r['action'][:40]}"
                f" → {obs_head}")

    def render(self) -> str:
        if len(self.rounds) <= self.max_recent:
            parts = [f"Thought {r['n']}: {r['thought']}\n"
                     f"Action {r['n']}: {r['action']}\n"
                     f"Observation {r['n']}: {r['observation']}"
                     for r in self.rounds]
            return "\n\n".join(parts)
        cut = len(self.rounds) - self.max_recent
        folded = "\n".join(self._fold(r)
                           for r in self.rounds[:cut])
        recent = "\n\n".join(
            f"Thought {r['n']}: {r['thought']}\n"
            f"Action {r['n']}: {r['action']}\n"
            f"Observation {r['n']}: {r['observation']}"
            for r in self.rounds[cut:])
        return f"[早期轨迹(已折叠)]\n{folded}\n\n{recent}"

if __name__ == "__main__":
    tm = TraceManager(max_recent=2)
    for i in range(4):
        tm.add_round(f"思考{i+1}", f"search[{i+1}]",
                     f"结果{i+1}")
    print(tm.render()[:300])

源码说明:TraceManager 用"近端原文加远端折叠"管理轨迹增长:折叠行保留动作与观察头部(结论必留),近端轮次完整原文。渲染输出直接作为下一轮生成的上下文,轨迹增长有界。

3. 行动空间设计:给模型哪些可执行动作

3.1 行动空间的三条设计原则

图:行动空间三原则与反例

行动空间设计

覆盖闭环

粒度适中

描述带边界

缺动作导致模型硬编

太细太粗都难用

描述缺失则动作间摇摆

原则共同服务于行动有效率

图下解读:三条原则各防一类失败:覆盖闭环防"没有工具只好编",粒度适中防单步太碎或太粗,描述带边界防相似动作选择混乱。与第 8 篇工具协议的工具集设计同构,质量标准一致。

原则内容反例
覆盖闭环常用子任务都有对应动作缺动作导致模型硬编
粒度适中动作对应一个可验证单元太细(点按钮级)或太粗(完成项目级)
描述带边界每个动作写清何时用何时不用相似动作间摇摆

行动空间与第 8 篇(工具协议)的工具集设计同构:ReAct 的 Action 就是工具调用,行动空间即工具集,质量标准一致。

3.2 行动的注册与描述

# 来源:自实现 / action_space.py(行动空间注册)
from dataclasses import dataclass

@dataclass
class Action:
    name: str
    description: str      # 何时用、何时不用
    params: dict          # 参数schema简表
    fn: object            # 执行函数

class ActionSpace:
    """行动空间的注册、渲染与查找"""

    def __init__(self):
        self._actions: dict[str, Action] = {}

    def register(self, action: Action):
        self._actions[action.name] = action

    def get(self, name: str) -> Action | None:
        return self._actions.get(name)

    def render(self) -> str:
        lines = []
        for a in self._actions.values():
            p = ", ".join(f"{k}:{v}" for k, v in a.params.items())
            lines.append(f"- {a.name}({p}): {a.description}")
        return "\n".join(lines)

if __name__ == "__main__":
    space = ActionSpace()
    space.register(Action(
        "search", "检索文档。用于查事实;已知路径时改用read。",
        {"query": "str"}, lambda query: f"结果:{query}"))
    space.register(Action(
        "finish", "提交最终答案。确认信息充分后使用。",
        {"answer": "str"}, lambda answer: answer))
    print(space.render())

源码说明:ActionSpace 的 render 把行动清单渲染进提示词,description 写"何时用、何时不用"(与第 8 篇 schema 说明书同一标准)。finish 动作显式存在——终止也是一种行动,模型通过调用 finish 表达"信息已充分",比依赖隐式停止更可控。

3.3 行动空间的规模控制

行动空间超过十五个后,模型在相似动作间的选择错误率上升(第 8 篇的工具集规模规律同样适用)。压缩手段:合并语义重叠动作、按任务类型动态裁剪(数据任务只挂数据类动作)、低频动作收进"高级"分组按需展示。

4. 观察结果的回灌格式与信息密度

4.1 观察的清洗与截断

工具输出可能是几万行的网页或日志,直接回灌会淹没轨迹。观察回灌走三步:清洗(去噪声)、压缩(保关键段)、标注(附元信息)。

图:观察回灌的三步压缩管线

原始工具输出

清洗 去噪声

压缩 按类型保关键段

标注 附元信息

回灌进轨迹

轨迹不因单次观察撑爆

图下解读:三步管线的目标是在"信息保真"与"轨迹预算"之间取平衡:清洗去掉的、压缩省下的都是噪声,标注保留的是判定所需的元信息(成功与否、数据来源)。

输出类型回灌策略
搜索结果Top-3 条目加摘要
网页文本正文抽取加头尾截断
命令输出退出码加尾部N行
API响应结构化字段抽取

4.2 观察回灌的实现

# 来源:自实现 / observation_feeder.py(观察回灌的清洗与压缩)
import re

def feed_observation(raw: str, kind: str,
                     budget: int = 800) -> str:
    """按输出类型把工具结果压缩为观察文本"""
    if kind == "search":
        lines = [l for l in raw.splitlines() if l.strip()]
        return "\n".join(lines[:3])[:budget]
    if kind == "command":
        ok = "退出码0" if raw.endswith("\n0") or "成功" in raw \
            else "退出码非0"
        tail = "\n".join(raw.splitlines()[-10:])
        return f"[{ok}]\n{tail}"[:budget]
    if kind == "web":
        text = re.sub(r"<[^>]+>", "", raw)      # 剥标签
        text = re.sub(r"\s+", " ", text).strip()
        return text[:budget] + ("…" if len(text) > budget else "")
    return raw[:budget]

if __name__ == "__main__":
    web = "<html><body>" + "正文内容" * 200 + "</body></html>"
    print(feed_observation(web, "web", budget=50))
    cmd = "running tests...\n3 passed\n0"
    print(feed_observation(cmd, "command"))

源码说明:feed_observation 按类型分派压缩策略:搜索保 Top-3、命令保退出码与尾部(错误在尾部)、网页剥标签取正文。预算参数控制观察的最大信息密度,保证轨迹不被单次观察撑爆。

4.3 观察失败的表达

工具执行失败时,观察必须如实回灌失败信息而不是静默或编造:"查询超时,未获得结果"比空字符串好,比假装成功好得多。失败观察驱动下一个思考步调整路线(换工具、改参数、放弃该路径),这是 ReAct 容错性的来源。

5. 循环的终止条件与防护

5.1 终止的三条路径

图:ReAct循环的三条终止路径

显式

防护

外部

循环运行中

终止判定

finish动作 信息充分

步数或token超限

用户中断

正常交付答案

软着陆:总结现状

保留轨迹 可续跑

图下解读:显式终止(finish)是理想路径,防护终止(步数、token 上限)是工程必需,外部终止保留轨迹供续跑。防护触发时走软着陆:注入"总结已获得的信息并给出当前最佳答案"的指令,让循环带着产出退出而不是空手而归。

5.2 循环防护的实现

# 来源:自实现 / react_guard.py(循环步数与重复防护)
from collections import Counter

class ReactGuard:
    """步数上限与重复行动防护"""

    def __init__(self, max_steps: int = 12,
                 repeat_threshold: int = 3):
        self.max_steps = max_steps
        self.repeat_threshold = repeat_threshold
        self.action_log: list[str] = []

    def check(self, action_sig: str) -> tuple[bool, str]:
        if len(self.action_log) >= self.max_steps:
            return False, "步数超限,请总结现有信息"
        self.action_log.append(action_sig)
        top = Counter(self.action_log).most_common(1)[0]
        if top[1] >= self.repeat_threshold:
            return False, (f"动作{action_sig}已重复{top[1]}次,"
                           "请更换策略或finish")
        return True, ""

if __name__ == "__main__":
    g = ReactGuard(repeat_threshold=3)
    for i in range(4):
        ok, msg = g.check("search[同一个词]")
        print(f"第{i+1}次:{'放行' if ok else msg}")

源码说明:ReactGuard 双闸:步数上限(绝对兜底)加重复行动检测(同签名连续三次即打转)。防护触发不硬中断,返回"建议语"进提示词让模型自我纠正——防护的形态是引导而非掐断(与第 7 篇循环防护同构)。

5.3 防护触发的软着陆

触发软着陆动作
步数超限注入总结指令,产出现有结论
重复行动注入换路指令,附已试路径清单
观察连续失败注入降级指令,改用保守答案

软着陆的产出(部分结论加未决事项)比空手终止有价值得多——用户至少拿到"查到哪一步、还差什么"。

6. ReAct的失效模式与对策

6.1 四类典型失效

失效表现对策
行动依赖幻觉调用不存在的API或参数行动空间显式列举加校验拒绝
观察忽视无视观察继续原计划思考步强制引用上一观察
循环打转同类行动反复无进展重复检测加换路指令(第 5 节)
过早终止信息不足就 finishfinish 前强制自检清单

图:四类失效的检测信号与拦截位置

失效检测

行动校验层

轨迹审计层

未知行动或参数 拦截

观察忽视:思考未引用观察

打转:签名重复

过早终止:finish时信息不足

回灌错误信息 重选行动

图下解读:失效检测分两层:行动校验层拦"结构性错误"(未知行动、非法参数,程序判定零成本),轨迹审计层拦"行为性错误"(忽视观察、打转、过早终止)。两层都走回灌纠正而不是终止循环。

6.2 观察忽视的强制纠正

“思考步必须引用上一轮观察"是低成本的强制约束:解析思考文本,若未包含上一观察的关键词(实体、数值),回灌提示"请基于上一步观察结果继续”。这一招把"凭记忆推理"拉回"凭事实推理"。

6.3 过早终止的自检清单

finish 前的自检清单(写进行动描述或提示词):答案的每个要素都有观察支撑吗?有没有更权威的来源未查?不确定性是否已声明?清单把"何时算查完了"从模型感觉变成可核对标准。

7. 与思维链和工具调用的关系

7.1 ReAct 是思维链的行动扩展

图:三种执行形态的光谱关系

执行形态光谱

纯思维链 封闭推理

ReAct 推理加行动

纯工具调用 结构化操作流

信息全凭权重记忆

思考接上实时观察

行动为主 思考极简

按任务信息需求选择

图下解读:三种形态是任务光谱上的选择而非竞争:封闭知识推理用纯思维链,开放信息任务用 ReAct,结构化操作流用纯工具调用。选择的标准只有一个——任务需要多少外部信息。

维度纯思维链(第 1 篇)ReAct纯工具调用(第 8 篇)
步骤内容推理推理加行动行动
信息来源权重记忆权重加实时观察实时观察
适用任务封闭知识推理开放信息任务结构化操作流

ReAct 是思维链的"接世界"版本:思考步就是思维链,行动步把思维链接上工具。三者不是竞争关系而是任务光谱上的不同选择。

7.2 与现代工具调用协议的融合

现代 API 的原生函数调用(第 8 篇)承担了 ReAct 的 Action 层:模型输出结构化 tool_calls 而非文本格式的 Action 行。融合后的形态是"结构化 ReAct":思考仍是自由文本(或专用推理通道),行动走函数调用协议,观察走结果回灌。工程收益:行动解析零成本、格式漂移风险归零。

7.3 何时退回纯思维链

不需要外部信息的封闭推理任务,ReAct 的行动步是纯开销(每次调用的时间与token)。任务路由的标准:问题能否仅凭权重内知识作答?能则纯思维链,不能则 ReAct。路由器可以是简单规则(问题类型分类)也可以是模型自判(提示词里授权模型直接作答)。

8. 实战:最小可用的ReAct执行引擎

8.1 引擎的组装

图:ReAct执行引擎的组件串联

放行

超限

finish

任务

TraceManager 轨迹管理

模型生成 思考加行动

ActionSpace 解析执行

feed_observation 回灌

ReactGuard 防护检查

软着陆总结

交付答案

图下解读:五个组件串成完整引擎:轨迹管理、模型生成、行动执行、观察回灌、防护检查。全部组件来自本篇实现,总装约八十行即得可运行的 ReAct 引擎。

# 来源:自实现 / react_engine.py(最小ReAct执行引擎)
import json
from react_trace_mgr import TraceManager
from action_space import ActionSpace, Action
from observation_feeder import feed_observation
from react_guard import ReactGuard

class ReactEngine:
    """思考-行动-观察交替的最小执行引擎"""

    def __init__(self, model_fn, space: ActionSpace,
                 max_steps: int = 12):
        self.model = model_fn
        self.space = space
        self.trace = TraceManager(max_recent=4)
        self.guard = ReactGuard(max_steps=max_steps)

    def _prompt(self, task: str) -> str:
        return (f"任务:{task}\n\n可用行动:\n"
                f"{self.space.render()}\n\n执行轨迹:\n"
                f"{self.trace.render()}\n\n"
                "请输出下一步:先Thought,再Action(JSON:"
                '{"name":..., "params":...})。'
                "信息充分时调用finish。")

    def run(self, task: str) -> str:
        while True:
            reply = self.model(self._prompt(task))
            thought, action = self._parse(reply)
            if action["name"] == "finish":
                return action["params"].get("answer", "")
            act = self.space.get(action["name"])
            if act is None:
                self.trace.add_round(
                    thought, json.dumps(action, ensure_ascii=False),
                    "[错误] 未知行动,请从可用行动中选择")
                continue
            ok, advice = self.guard.check(action["name"])
            if not ok:
                self.trace.add_round(
                    thought, action["name"],
                    f"[防护] {advice}")
                continue
            raw = act.fn(**action.get("params", {}))
            obs = feed_observation(str(raw), kind="search")
            self.trace.add_round(thought, action["name"], obs)

    @staticmethod
    def _parse(reply: str) -> tuple[str, dict]:
        import re
        thought = ""
        m = re.search(r"Thought\s*\d*[::](.+?)(?=Action|$)",
                      reply, re.S)
        if m:
            thought = m.group(1).strip()
        m = re.search(r"\{.*\}", reply, re.S)
        action = json.loads(m.group()) if m else \
            {"name": "finish", "params": {"answer": reply[-200:]}}
        return thought, action

if __name__ == "__main__":
    space = ActionSpace()
    space.register(Action("search", "查询资料",
                          {"query": "str"},
                          lambda query: f"{query}的结果: 42"))
    space.register(Action("finish", "提交答案",
                          {"answer": "str"},
                          lambda answer: answer))
    script = [
        'Thought 1: 需要查询。\nAction 1: {"name": "search", "params": {"query": "答案"}}',
        'Thought 2: 拿到42。\nAction 2: {"name": "finish", "params": {"answer": "42"}}',
    ]
    it = iter(script)
    engine = ReactEngine(lambda p: next(it), space)
    print("最终答案:", engine.run("查询某问题的答案"))

源码说明:ReactEngine 串起完整循环:模型输出解析出思考与行动(未知行动回灌错误重选),防护层守步数与重复,观察经压缩回灌,finish 显式终止。脚本化模型便于测试——真实部署时换 API 客户端即可。

8.2 指标与监控

指标定义健康值
平均循环轮数每任务的三元组轮数与任务复杂度匹配
行动有效率行动被防护或校验拒绝的占比低于一成
观察利用率思考步引用观察的比例高于九成
软着陆占比防护终止而非finish的占比低于一成

8.3 与后续篇目的衔接

衔接点说明所属篇
自我修正失败观察升级为修复回路第 3 篇
技能库成功轨迹沉淀为程序片段第 6 篇
经验沉淀轨迹反思为可复用经验第 7 篇
验证器finish 答案过验证器再交付第 9 篇

总结

ReAct 把程序性执行从"想完再做"升级为"想一步做一步看结果":思考步规划、行动步执行、观察步回灌,交替循环让模型在信息增量到达时修正路线,缺信息任务从"凭记忆硬编"变成"实时查询"。行动空间三原则(覆盖闭环、粒度适中、描述带边界)与工具协议设计同构,finish 显式化让终止可控。观察回灌按类型分派压缩策略(搜索保Top-3、命令保尾部、网页剥标签),失败观察如实回灌是容错的来源。防护双闸(步数上限加重复行动检测)配软着陆(总结现有信息退出),防护的形态是引导而非掐断。四类失效各有拦截层:未知行动走校验、忽视观察走强制引用、打转走换路指令、过早终止走自检清单。引擎约八十行总装,行动有效率高于九成、软着陆占比低于一成是健康线。

外部引用

Logo

有“AI”的1024 = 2048,欢迎大家加入2048 AI社区

更多推荐