1. 项目概述：从“执行”到“思考”的范式跃迁

如果你最近在关注AI领域，尤其是智能体（Agent）的发展，那么“ReAct循环”这个词一定不会陌生。它听起来有点学术，但本质上，它描述的是一个极其朴素却又强大的思想：让AI像人一样，在解决问题时，先“想一想”，再“动动手”，然后“看一看”结果，并基于观察决定下一步。这个“Think → Act → Observe”的循环，正在成为构建真正实用、可靠AI智能体的核心引擎。我最初接触这个概念时，觉得它不过是将人类解决问题的直觉过程形式化，但当我真正将其应用到几个具体的项目中——从自动化数据分析到复杂API编排——我才深刻体会到，正是这个简单的循环，解决了传统AI应用中最头疼的“黑箱执行”和“一步错步步错”的问题。

简单来说，ReAct循环为AI智能体注入了“思考”的能力。传统的AI模型，无论是完成一个指令还是回答一个问题，往往是一次性输出结果。这个过程就像一个熟练但盲目的工人，你给他指令，他立刻执行，但中间如果遇到意外情况（比如工具找不到、数据格式不对），他要么报错罢工，要么给出一个完全错误的答案。而ReAct循环则引入了一个关键的“思考”步骤，让智能体在执行动作前，先规划一下：我的目标是什么？我现在有什么信息？我应该用什么工具？第一步该做什么？这个短暂的“停顿”和“内省”，极大地提升了智能体行动的可靠性和适应性。它不再是一个只会反应的函数，而是一个具备初步规划和推理能力的“协作者”。

这个框架特别适合谁呢？我认为有三类人最应该深入了解：一是AI应用开发者，你正在构建需要与外部世界（数据库、API、文件系统）交互的智能体；二是业务分析师或数据科学家，你希望用AI自动化那些需要多步骤、条件判断的流程；三是任何对AI如何“像人一样思考”感兴趣的技术爱好者。掌握ReAct，你就能理解当前最前沿的AI智能体（如AutoGPT、BabyAGI等开源项目的底层逻辑）是如何工作的，并能亲手搭建属于自己的、更聪明的AI助手。接下来，我将结合我的实操经验，拆解ReAct循环的每一个环节，分享如何从零构建一个具备ReAct能力的智能体，并深入探讨其中的设计哲学、实现细节以及那些只有踩过坑才知道的注意事项。

2. 核心架构与设计哲学拆解

2.1 ReAct循环的本质：将推理与行动交织

ReAct循环的核心思想，是让语言模型（LLM）在解决任务时，交替进行 推理 （Reasoning）和 行动 （Acting）。这听起来简单，但其设计背后有深刻的考量。传统的“链式思维”（Chain-of-Thought）提示让模型“一步步想”，但它的输出止于文本，不涉及行动。而单纯的“工具调用”模式，模型直接选择动作，缺乏对“为什么选这个动作”的显式思考，容易导致动作序列不合理。

ReAct巧妙地将两者结合。 “思考” 步骤是模型的内省过程，它以文本形式生成。这个文本不是最终答案，而是对当前状况的分析、对下一步的规划、或对之前观察的总结。例如，智能体可能会输出：“ 用户想查询北京明天的天气。我需要一个能查询天气的API。我首先应该确定城市是‘北京’，然后调用天气查询工具。 ” 这个思考过程有两大作用：第一，它让模型的推理过程对开发者 可见、可调试 ，如果智能体犯了错，你可以通过它的“思考轨迹”快速定位问题出在规划阶段还是执行阶段。第二，它实质上为模型提供了一个“工作记忆区”，模型可以把之前的观察、自己的计划写下来，避免在长序列任务中遗忘上下文。

“行动” 步骤则是思考的具象化。模型根据思考的结论，生成一个结构化的动作指令，比如调用一个名为 get_weather 的函数，并传入参数 {“city”: “北京”} 。这个动作会被系统执行，并产生一个结果。 “观察” 步骤就是捕获这个结果，并将其作为文本信息反馈给模型，成为下一轮“思考”的输入。例如，天气API返回 {“city”: “北京”， “weather”: “晴”， “temperature”: “22°C”} ，观察就是：“ 调用天气API成功，返回结果：北京明天晴天，气温22摄氏度。 ”

这个循环会一直持续，直到模型在“思考”步骤中判定任务已经完成，并输出最终答案。这种设计使得智能体具备了处理 动态环境 和 非确定性结果 的能力。比如，让智能体“帮我查一下某公司CEO的邮箱，如果找不到就找他的领英主页”。智能体可能会先思考：“我需要搜索公司信息和CEO姓名”，然后执行搜索动作。如果观察发现搜索不到邮箱，它会在下一轮思考中调整计划：“邮箱未找到，改为搜索该CEO的领英资料”，并执行新的动作。这种基于观察的动态调整能力，是传统单次调用模型完全不具备的。

2.2 关键组件与交互设计

要实现一个健壮的ReAct循环，你需要设计好几个核心组件，它们之间的数据流和职责划分至关重要。

  1. 智能体核心（Agent Core） ：通常由一个大型语言模型驱动。它的职责是接收当前的“任务描述”+“历史（思考、行动、观察）”+“可用工具列表”，然后生成下一步的输出。这个输出需要被 解析 ，以区分出“思考”文本和“行动”指令。一种常见的做法是要求模型严格按照特定格式输出，例如：

    思考：我需要先理解用户的问题。用户想了解ReAct。
行动：搜索_网络， 查询内容：“ReAct 循环 详解”

    解析器会识别“思考：”和“行动：”后面的内容。

  2. 工具集（Toolkit） ：这是智能体的“手”和“感官”。每个工具都是一个函数，有明确的名称、描述和参数格式。描述非常重要，它需要清晰告诉模型这个工具是干什么的、怎么用。例如， get_weather(city: str) 的工具描述可能是：“查询指定城市的当前天气。参数city：城市名称，如‘北京’。” 工具集可以包括：搜索引擎、计算器、数据库查询、文件读写、API调用等。工具的设计要追求“高内聚、低耦合”，每个工具只做一件明确的事。

  3. 执行器（Executor） ：它负责解析智能体输出的“行动”指令，找到对应的工具函数，传入参数并执行。执行器还需要捕获执行结果（成功或失败），并将其格式化为一个清晰的“观察”字符串。例如，如果工具执行出错，观察应该是：“ 行动‘搜索_网络’失败：网络连接超时。 ” 而不是一个原始的异常堆栈。这有助于模型理解错误并调整策略。

  4. 状态管理器（State Manager） ：它维护着整个对话或任务的历史记录，即一系列的（思考，行动，观察）元组。每一轮循环，它都将完整的历史上下文和当前任务提交给智能体核心。这里的一个关键设计点是 上下文窗口的管理 。随着循环进行，历史会越来越长，可能超出模型的上下文限制。因此，需要策略来压缩或总结历史。一个简单有效的方法是只保留最近N轮循环的完整记录，或者让模型在思考时主动对之前的长历史进行摘要。

实操心得：工具描述是灵魂 早期我低估了工具描述的重要性，只是简单写了函数名。结果发现模型经常用错工具或参数。后来我借鉴了LangChain等框架的做法，将描述写成：“工具名：用于做什么。输入参数1（类型）：参数1的详细说明和示例。返回：返回值的描述。” 经过这样细化后，模型的工具调用准确率提升了至少50%。记住，模型是通过你的描述来“理解”工具的，描述就是工具的“说明书”。

2.3 与相关模式的对比：为什么是ReAct？

在智能体架构中，除了ReAct，还有几种常见的模式，理解它们的区别能帮你更好地应用ReAct。

  • vs. 计划-执行（Plan-and-Execute） ：这种模式让模型先制定一个完整的、多步骤的计划（Plan），然后由一个简单的执行器按步骤执行。它的缺点是计划是静态的，无法应对执行中的意外。比如计划“1. 登录网站A，2. 爬取数据”，但如果第一步登录失败，整个计划就卡住了。而ReAct是动态的，每一步都根据上一步的观察重新“思考”，适应性更强。
  • vs. 自主智能体（AutoGPT风格） ：像AutoGPT这类项目，本质上是ReAct循环的一个复杂实现，它增加了长期/短期记忆管理、多目标分解等更高级的特性。你可以把基础的ReAct看作智能体的“最小可行产品”（MVP），而AutoGPT是它的“豪华版”。从ReAct入手，能更清晰地理解这些高级特性的底层机制。
  • vs. 纯链式调用（Sequential Chain） ：在LangChain中，你可以用SequentialChain把多个LLM调用串起来。但这通常是预定义好的、线性的流程。ReAct的循环是 非确定性的 ，下一步做什么取决于上一步的结果，流程是动态生成的，因此能处理更开放、更复杂的任务。

选择ReAct，意味着你选择将 控制权更多地交给模型 ，让它来动态决策。这牺牲了一点可预测性，但换来了巨大的灵活性和处理未知情况的能力。对于流程固定、边界清晰的任务，可能用预定义的链更高效；对于探索性、决策性的任务，ReAct是更优解。

3. 从零构建一个ReAct智能体：实战演练

理论说了这么多，现在我们动手搭建一个简单的ReAct智能体。我将使用Python和OpenAI的API（你也可以替换为其他兼容的LLM，如通义千问、DeepSeek等）来演示，并实现两个核心工具：一个用于计算，一个用于搜索网络（这里我们用模拟搜索）。

3.1 环境准备与基础框架搭建

首先，确保你的环境已安装必要的库。我们将使用 openai 库来调用模型，并用 langchain 社区版的部分工具概念来辅助设计（但核心循环我们自己实现，以加深理解）。

pip install openai

接下来，我们定义最基础的类结构。这个智能体将能够进行多轮对话，记住历史，并调用工具。

import openai
import json
import re

class ReActAgent:
    def __init__(self, model="gpt-3.5-turbo", api_key=None):
        self.model = model
        self.client = openai.OpenAI(api_key=api_key)
        self.conversation_history = [] # 存储完整的（思考，行动，观察）历史
        self.tools = self._define_tools() # 定义可用的工具集

    def _define_tools(self):
        """定义智能体可以使用的工具。每个工具是一个字典，包含名称、描述和函数。"""
        tools = [
            {
                "name": "计算器",
                "description": "执行数学计算。输入一个包含数字和运算符（+， -， *， /， **）的数学表达式字符串。例如：'3 + 5 * 2'。",
                "function": self._tool_calculator
            },
            {
                "name": "搜索网络",
                "description": "模拟搜索网络信息。输入一个查询字符串。此工具将返回模拟的搜索结果。",
                "function": self._tool_search_web
            },
            {
                "name": "结束任务",
                "description": "当任务完成，需要给出最终答案时使用此工具。输入最终答案文本。调用此工具后循环将终止。",
                "function": self._tool_final_answer
            }
        ]
        return tools

    def _tool_calculator(self, expression: str) -> str:
        """计算器工具的实现。警告：直接使用eval有安全风险，仅用于演示。"""
        try:
            # 严重安全提示：在生产环境中，绝对不要用eval直接执行用户或模型提供的字符串。
            # 这里仅为演示，应使用ast.literal_eval或专用数学库（如numexpr）。
            result = eval(expression, {"__builtins__": None}, {})
            return f"计算成功：{expression} = {result}"
        except Exception as e:
            return f"计算失败：表达式‘{expression}’有误。错误信息：{e}"

    def _tool_search_web(self, query: str) -> str:
        """模拟网络搜索工具。在实际应用中，这里应接入真正的搜索API。"""
        # 这是一个简单的模拟，根据查询返回预设结果
        knowledge_base = {
            "ReAct循环的作者": "ReAct框架由Princeton大学的Shunyu Yao等人在2022年的论文《ReAct: Synergizing Reasoning and Acting in Language Models》中提出。",
            "北京明天的天气": "模拟结果：北京，2023年10月27日，晴天，气温10-20摄氏度，西北风3-4级。",
            "Python的最新版本": "模拟结果：截至2023年10月，Python的最新稳定版本是3.11。"
        }
        for key, value in knowledge_base.items():
            if key.lower() in query.lower():
                return f“搜索到信息：{value}”
        return f“未找到与‘{query}’直接相关的信息。建议尝试其他关键词。”

    def _tool_final_answer(self, answer: str) -> str:
        """此工具被调用时，意味着智能体决定结束任务。我们返回一个特殊信号。"""
        # 这里我们抛出一个特殊异常，在外部循环中捕获以结束任务。
        raise FinalAnswerException(answer)

我们定义了一个 FinalAnswerException 来优雅地结束循环。

class FinalAnswerException(Exception):
    def __init__(self, answer):
        self.answer = answer
        super().__init__(f"任务完成，最终答案：{answer}")

3.2 核心循环引擎的实现

现在，我们实现ReAct循环中最关键的部分：生成、解析、执行。

class ReActAgent(ReActAgent): # 接上面的类
    def run(self, user_query: str, max_steps: int = 10):
        """运行ReAct循环处理用户查询。"""
        print(f“用户: {user_query}”)
        print("-" * 50)

        # 初始化任务上下文
        task_context = f“用户的任务是：{user_query}”
        steps = 0

        while steps < max_steps:
            steps += 1
            print(f“\n[步骤 {steps}]”)

            # 1. 生成提示，包含历史、工具描述和当前任务
            prompt = self._build_prompt(task_context)
            # print(“调试 - 发送给模型的提示：\n”, prompt) # 调试时可打开

            # 2. 调用LLM，获取响应
            llm_response = self._call_llm(prompt)
            # print(“调试 - 模型原始响应：\n”, llm_response) # 调试时可打开

            # 3. 解析响应，分离出“思考”和“行动”
            thought, action_str = self._parse_response(llm_response)
            print(f“思考: {thought}”)

            # 4. 解析行动字符串，得到工具名和输入
            tool_name, tool_input = self._parse_action(action_str)
            print(f“行动: 调用工具‘{tool_name}’， 输入：{tool_input}”)

            # 5. 查找并执行工具
            observation = self._execute_tool(tool_name, tool_input)
            print(f“观察: {observation}”)

            # 6. 将本轮（思考，行动，观察）加入历史
            self.conversation_history.append({
                “thought”: thought,
                “action”: f“{tool_name}({tool_input})”,
                “observation”: observation
            })

            # 检查是否因“结束任务”工具而终止
            if tool_name == “结束任务”:
                print(“\n” + “=”*50)
                print(f“任务完成！最终答案：{tool_input}”)
                return tool_input

        print(f“\n达到最大步数（{max_steps}）仍未完成任务。”)
        return “任务未能在限制步数内完成。”

    def _build_prompt(self, task_context: str) -> str:
        """构建给LLM的提示词。这是ReAct性能的关键。"""
        # 工具描述部分
        tools_text = “你可以使用以下工具：\n”
        for tool in self.tools:
            tools_text += f“- {tool[‘name’]}: {tool[‘description’]}\n”

        # 历史记录部分
        history_text = “”
        if self.conversation_history:
            history_text = “\n以下是已经发生的历史：\n”
            for i, step in enumerate(self.conversation_history, 1):
                history_text += f“步骤{i}:\n”
                history_text += f“  思考: {step[‘thought’]}\n”
                history_text += f“  行动: {step[‘action’]}\n”
                history_text += f“  观察: {step[‘observation’]}\n”

        # 系统指令，严格要求输出格式
        system_instruction = “”“你是一个ReAct智能体，必须严格按照以下格式输出：
思考：[你的推理过程，分析当前情况，决定下一步做什么]
行动：[工具名]， [工具输入]

例如：
思考：用户需要计算一个表达式。我应该使用计算器工具。
行动：计算器， 3 + 5 * 2

或者，当你认为任务已经完成，需要给出最终答案时：
思考：我已经获得了所有需要的信息，可以给出答案了。
行动：结束任务， [你的最终答案文本]

请确保‘思考：’和‘行动：’这两个关键词准确出现。行动部分，工具名必须是上述工具列表中的一个，工具输入是一个字符串。
”“”

        # 最终组合提示
        prompt = f“{system_instruction}\n\n{tools_text}{history_text}\n当前任务上下文：{task_context}\n\n请开始你的下一步：”
        return prompt

    def _call_llm(self, prompt: str) -> str:
        """调用OpenAI API。"""
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=[{“role”: “user”， “content”: prompt}],
                temperature=0.1, # 低温度保证输出格式稳定
                max_tokens=500
            )
            return response.choices[0].message.content.strip()
        except Exception as e:
            return f“调用语言模型失败：{e}”

    def _parse_response(self, response: str):
        """解析模型响应，提取思考和行动部分。"""
        thought_match = re.search(r“思考：?(.+?)(?=行动：|$)”， response, re.DOTALL)
        action_match = re.search(r“行动：?(.+?)$”， response, re.DOTALL)

        thought = thought_match.group(1).strip() if thought_match else “未提供思考。”
        action = action_match.group(1).strip() if action_match else “”

        return thought, action

    def _parse_action(self, action_str: str):
        """解析行动字符串，提取工具名和输入。"""
        if “，” in action_str:
            tool_name, tool_input = action_str.split(“，”， 1)
        else:
            # 如果没有逗号，尝试按第一个空格分割
            parts = action_str.split(“ ”， 1)
            tool_name = parts[0]
            tool_input = parts[1] if len(parts) > 1 else “”
        return tool_name.strip(), tool_input.strip()

    def _execute_tool(self, tool_name: str, tool_input: str) -> str:
        """根据工具名找到对应的工具函数并执行。"""
        for tool in self.tools:
            if tool[“name”] == tool_name:
                try:
                    return tool[“function”](tool_input)
                except FinalAnswerException as e:
                    # 如果工具抛出了最终答案异常，我们在这里重新抛出，由run函数捕获
                    raise e
                except Exception as e:
                    return f“执行工具‘{tool_name}’时出错：{e}”
        return f“错误：未知的工具名称‘{tool_name}’。请从可用工具列表中选择。”

3.3 运行你的第一个ReAct智能体

现在，让我们初始化智能体并运行一个任务。你需要将自己的OpenAI API密钥填入。

# 初始化智能体
agent = ReActAgent(model=“gpt-3.5-turbo”， api_key=“你的-OpenAI-API-密钥”)

# 运行一个复合任务
result = agent.run(“请先计算 (15 + 7) * 3 等于多少，然后告诉我ReAct循环的作者是谁？”)

预期输出示例： 

用户: 请先计算 (15 + 7) * 3 等于多少，然后告诉我ReAct循环的作者是谁？
--------------------------------------------------
[步骤 1]
思考: 用户提出了一个复合任务。首先需要计算数学表达式 (15 + 7) * 3，然后查询“ReAct循环的作者”信息。我应该按顺序进行。第一步是计算。
行动: 计算器， (15 + 7) * 3
观察: 计算成功：(15 + 7) * 3 = 66

[步骤 2]
思考: 第一步计算完成，结果是66。现在需要执行第二步：查询ReAct循环的作者信息。我应该使用“搜索网络”工具。
行动: 搜索网络， ReAct循环的作者
观察: 搜索到信息：ReAct框架由Princeton大学的Shunyu Yao等人在2022年的论文《ReAct: Synergizing Reasoning and Acting in Language Models》中提出。

[步骤 3]
思考: 我已经完成了用户要求的两个子任务。计算结果是66，ReAct循环的作者是Shunyu Yao等人。现在可以给出最终答案了。
行动: 结束任务， 计算结果：(15 + 7) * 3 = 66。ReAct循环的作者是Princeton大学的Shunyu Yao等人，他们在2022年的论文中提出了该框架。
==================================================
任务完成！最终答案：计算结果：(15 + 7) * 3 = 66。ReAct循环的作者是Princeton大学的Shunyu Yao等人，他们在2022年的论文中提出了该框架。

看，智能体成功地进行了多步推理和行动！它先识别出复合任务，然后按顺序执行计算和搜索，最后整合信息给出答案。整个过程清晰可见。

注意事项：提示工程是成败关键 上面 _build_prompt 方法中的系统指令（ system_instruction ）是核心。你必须明确要求模型按“思考：...行动：...”的格式输出。模型（尤其是GPT-3.5）有时会“偷懒”，不输出“思考”部分，或者行动格式不对。我的经验是：

  1. 明确分隔符 ：使用“思考：”和“行动：”这样独特的、不易在正常文本中出现的词作为分隔符。
  2. 提供多个示例 ：在系统指令中，提供2-3个不同任务类型的输出示例，能极大提高模型遵循格式的稳定性。
  3. 降低温度（Temperature） ：在推理和行动步骤，将温度设为较低值（如0.1-0.3），可以减少输出的随机性，让格式更稳定。
  4. 后处理校验 ：在 _parse_response 函数中，要有健壮的容错逻辑。如果解析失败，可以尝试让模型重试，或者给出一个默认的“错误”观察，引导模型在下一步纠正。

4. 高级技巧与生产级考量

一个能跑通的Demo只是起点。要让ReAct智能体真正可靠地用于生产环境，还需要解决一系列工程挑战。

4.1 处理复杂工具与参数验证

我们的示例工具参数很简单。但现实中的工具可能接受复杂的JSON对象。这时，我们需要更强大的解析和验证。

改进方案：使用JSON格式的行动指令 我们可以要求模型将行动输出为JSON，这样更容易解析复杂参数。

# 修改系统指令部分
system_instruction_json = “”“...
行动必须是一个有效的JSON对象，格式如下：
{"tool_name": "工具名"， "tool_input": "工具输入字符串或JSON对象"}
例如：{"tool_name": "计算器"， "tool_input": "3 + 5"}
”“”

# 在_call_llm中，可以使用Function Calling或JSON Mode来约束输出格式（如果模型支持）。
# 例如，OpenAI的gpt-3.5-turbo-1106和gpt-4-turbo支持JSON模式。
response = self.client.chat.completions.create(
    model=self.model,
    messages=[{“role”: “user”， “content”: prompt}],
    temperature=0.1,
    response_format={“type”: “json_object”}， # 强制返回JSON
    max_tokens=500
)
# 然后直接解析返回的JSON。

参数验证 ：在执行工具前，应该验证输入参数的类型和范围。例如，对于计算器，可以先用一个安全的表达式解析库（如 numexpr ）检查语法，或者白名单过滤危险字符。

4.2 长上下文管理与历史压缩

随着循环步数增加，历史记录会迅速膨胀，可能超出模型的上下文窗口。有几种策略：

  1. 滑动窗口 ：只保留最近N轮（比如5轮）的完整历史。这是最简单的方法，但可能导致智能体遗忘早期的关键信息。
  2. 智能摘要 ：在历史达到一定长度后，让模型自己（或用一个专门的总结模型）对之前的历史进行摘要。例如，在每第K步后，将“步骤1到M”的历史替换为一段总结性文字：“智能体首先计算了...，然后搜索了...，发现...”。这需要额外的LLM调用，增加成本和延迟。
  3. 向量记忆 ：将每一轮的“观察”中的重要事实提取出来，存入一个向量数据库。在每一轮开始时，根据当前“思考”查询相关记忆，作为补充上下文。这是AutoGPT等高级智能体采用的方法，更复杂但更强大。

一个折中的实践是 混合策略 ：保持最近3-5轮的完整历史，同时维护一个不断更新的“任务摘要”字符串。在每一轮提示中，既包含完整近期历史，也包含这个摘要。

4.3 错误处理与循环停滞

智能体可能会陷入死循环，或者反复犯同一个错误。必须设置安全阀。

  • 最大步数限制 ：如我们代码中的 max_steps ，这是最基本的。
  • 重复动作检测 ：记录最近几次的行动，如果发现完全相同的（思考，行动）组合重复出现，可以中断循环，并给模型一个强观察：“检测到重复动作循环，请重新评估你的计划。”
  • 超时处理 ：为每个工具调用设置超时，防止某个外部API挂起导致整个智能体卡住。
  • 后备计划（Fallback） ：当连续失败多次后，可以触发一个后备策略，比如将问题简化、请求人工干预、或者直接调用一个更强大的模型（如从GPT-3.5切换到GPT-4）来尝试破局。

4.4 评估与调试：如何知道你的智能体好不好？

构建智能体不是一蹴而就的，需要持续评估和迭代。

  1. 定性评估 ：手动测试一系列边界案例和复杂任务，观察其思考轨迹是否合理，动作序列是否高效，最终答案是否正确。这是最直接的方法。
  2. 定量评估 ：构建一个测试集（Benchmark），包含一系列任务和预期答案。自动化运行智能体，计算任务完成率、平均步数、正确率等指标。对于ReAct，评估指标可以细化为：
    • 任务成功率 ：最终答案是否正确。
    • 路径效率 ：完成任务的步数。步数越少，通常说明规划越高效。
    • 工具调用准确率 ：调用正确工具且参数正确的比例。
  3. 日志与可观测性 ：将每一轮的思考、行动、观察以及完整的提示词都记录下来。这是调试的黄金资料。当智能体出错时，通过日志你可以清晰地看到是提示词没引导好，还是模型“胡思乱想”，或者是工具执行出了问题。

5. 常见问题与实战避坑指南

在实际项目中应用ReAct，我遇到了不少坑。这里总结几个最常见的问题和解决方案。

5.1 模型不遵循输出格式

这是新手遇到最多的问题。模型可能会输出“好的，我先来思考一下...”，然后直接给出答案，完全忽略“思考：”和“行动：”的格式要求。

  • 解决方案 ：
    • 强化系统指令 ：在提示词开头就用非常强硬、清晰的语言要求格式。例如：“你必须，注意是必须，按照以下精确格式输出，不要有任何额外的解释或问候语。”
    • 使用更强大的模型 ：GPT-4在遵循复杂指令方面远强于GPT-3.5。如果成本允许，在关键任务上使用GPT-4作为智能体核心。
    • 采用Function Calling ：OpenAI的API提供了原生的函数调用（Function Calling）功能。你可以将工具定义为“函数”，让模型以结构化JSON格式返回调用哪个函数以及参数。这比让模型输出自由文本再解析要稳定得多。LangChain、LlamaIndex等框架都内置了对Function Calling的支持。
    • 输出后处理与重试 ：如果解析失败，不要直接崩溃。可以将解析失败的原始响应连同一条错误信息（如“你的输出格式不正确，请严格按照‘思考：...行动：...’的格式重新输出”）作为新的观察，让模型再试一次。通常最多重试1-2次就能成功。

5.2 智能体陷入“思考怪圈”或无效行动

有时智能体会不停思考，却不采取有效行动，或者反复执行一个无效动作。

  • 解决方案 ：
    • 在思考中鼓励决策 ：在系统指令中明确要求“思考要简洁，旨在规划下一步行动，而不是泛泛而谈”。
    • 提供更具体的工具描述 ：如果工具描述模糊，模型可能不知道用它来干什么。确保描述包含清晰的使用场景和输入输出示例。
    • 引入反思机制 ：在历史中，如果连续几步的观察都是负面的（如“未找到”），可以在提示词中加入一句：“请注意，之前的几次尝试都未能取得进展，请尝试不同的策略或工具。”
    • 设置多样性惩罚 ：在代码层面，可以记录最近使用的工具，如果模型试图重复使用一个已经失败的工具，可以强行在观察中提醒它：“此工具在上一步已使用并失败，请尝试其他方法。”

5.3 工具执行的安全性与可靠性

我们的示例计算器用了 eval ，这在实际中是 极其危险 的，因为模型或用户可能提供恶意代码。

  • 解决方案 ：
    • 绝对不要使用eval ：对于计算，使用 ast.literal_eval （只能评估字面量）或专门的库如 numexpr 、 sympy 。
    • 输入净化与白名单 ：对所有工具输入进行严格的验证和过滤。例如，对于文件操作工具，检查路径是否在允许的目录内；对于网络请求工具，限制可访问的域名。
    • 沙箱环境 ：对于执行不确定代码的工具，考虑在Docker容器或沙箱环境中运行。
    • 权限最小化 ：为智能体分配执行任务所需的最小权限。不要给它root或管理员权限。

5.4 成本与延迟优化

ReAct循环意味着多次调用LLM，成本和时间开销都比单次调用高。

  • 解决方案 ：
    • 选择合适的模型 ：对于简单的规划步骤，可能不需要最强大的模型。可以尝试用较小、较快的模型（如GPT-3.5-Turbo）作为智能体核心，只在需要复杂推理或生成最终答案时使用大模型。
    • 缓存 ：对于常见的、确定性的子任务（如某些搜索或查询），可以缓存结果，避免重复调用昂贵的外部API或LLM。
    • 异步执行 ：如果多个工具调用之间没有依赖关系，可以考虑让它们并行执行，而不是串行等待。
    • 设置预算 ：监控每个会话的LLM调用次数和token消耗，设置硬性上限，防止失控循环产生天价账单。

构建一个成熟的ReAct智能体，就像训练一个实习生。你需要给它清晰的指令（提示词）、合适的工具（工具集）、明确的行为规范（输出格式），并在它犯错时及时纠正（错误处理与调试）。这个过程需要耐心和迭代，但一旦调教好，它就能自动化处理大量复杂、动态的任务，成为你手中无比强大的AI杠杆。从我自己的项目经验来看，从简单的问答机器人升级到具备ReAct能力的智能体，其处理复杂任务的成功率和用户体验的提升是质的飞跃。

# AI智能体
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

DeepSeek API涨价500%！Agent框架同步开源

avatar 亚马逊云科技技术品牌专区
cover

DeepSeek 又放大招！开源 AI Agent 框架 Harness：一切皆插件

avatar 亚马逊云科技技术品牌专区
cover

Agent Run 的状态机：别把智能体交给 LLM 自己管

avatar 亚马逊云科技技术品牌专区