ReAct工作流程

ReAct是一种思考与行动相辅相成的范式，思考指导行动，而行动又来修正思考。因此，他的每一步都遵循一套固定的流程。思考-行动-观察

• Thought (思考)： 这是智能体的“内心独白”。它会分析当前情况、分解任务、制定下一步计划，或者反思上一步的结果。
• Action (行动)： 这是智能体决定采取的具体动作，通常是调用一个外部工具，例如 Search['苹果最新款手机']。
• Observation (观察)： 这是执行Action后从外部工具返回的结果，例如搜索结果的摘要或API的返回值。

经过上面不断的思考-行动-观察的循环，将新的观察加到思考中，形成一个不断增加的上下文，直到它在思考中认为本次的结果没有问题了，就输入最后的结果。

接下来就是对ReAct工作流程的编码实现

编码实现

环境准备

主要使用 Python 语言，建议使用 Python 3.10 或更高版本。首先，请确保你已经安装了 openai 库用于与大语言模型交互，以及 python-dotenv 库用于安全地管理我们的 API 密钥。

在你的终端中运行以下命令：

pip install openai python-dotenv

为了让我们的代码更通用，我们将模型服务的相关信息（模型ID、API密钥、服务地址）统一配置在环境变量中。

1. 在你的项目根目录下，创建一个名为 .env 的文件。
2. 在该文件中，添加以下内容。你可以根据自己的需要，将其指向 OpenAI 官方服务，或任何兼容 OpenAI 接口的本地/第三方服务。

# .env file
#使用deepseek
LLM_API_KEY="YOUR-API-KEY"
LLM_MODEL_ID="YOUR-MODEL"
LLM_BASE_URL="YOUR-URL"

为了让代码结构更清晰、更易于复用，我们来定义一个专属的LLM客户端类。这个类将封装所有与模型服务交互的细节，让我们的主逻辑可以更专注于智能体的构建。

import os
from openai import OpenAI
from dotenv import load_dotenv
from typing import List, Dict

# 加载 .env 文件中的环境变量
load_dotenv()

class HelloAgentsLLM:
    """
    为本书 "Hello Agents" 定制的LLM客户端。
    它用于调用任何兼容OpenAI接口的服务，并默认使用流式响应。
    """
    def __init__(self, model: str = None, apiKey: str = None, baseUrl: str = None, timeout: int = None):
        """
        初始化客户端。优先使用传入参数，如果未提供，则从环境变量加载。
        """
        self.model = model or os.getenv("LLM_MODEL_ID")
        apiKey = apiKey or os.getenv("LLM_API_KEY")
        baseUrl = baseUrl or os.getenv("LLM_BASE_URL")
        timeout = timeout or int(os.getenv("LLM_TIMEOUT", 60))
        
        if not all([self.model, apiKey, baseUrl]):
            raise ValueError("模型ID、API密钥和服务地址必须被提供或在.env文件中定义。")

        self.client = OpenAI(api_key=apiKey, base_url=baseUrl, timeout=timeout)

    def think(self, messages: List[Dict[str, str]], temperature: float = 0) -> str:
        """
        调用大语言模型进行思考，并返回其响应。
        """
        print(f"🧠 正在调用 {self.model} 模型...")
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=messages,
                temperature=temperature,
                stream=True,
            )
            
            # 处理流式响应
            print("✅ 大语言模型响应成功:")
            collected_content = []
            for chunk in response:
                content = chunk.choices[0].delta.content or ""
                print(content, end="", flush=True)
                collected_content.append(content)
            print()  # 在流式输出结束后换行
            return "".join(collected_content)

        except Exception as e:
            print(f"❌ 调用LLM API时发生错误: {e}")
            return None

# --- 客户端使用示例 ---
if __name__ == '__main__':
    try:
        llmClient = HelloAgentsLLM()
        
        exampleMessages = [
            {"role": "system", "content": "You are a helpful assistant that writes Python code."},
            {"role": "user", "content": "写一个快速排序算法"}
        ]
        
        print("--- 调用LLM ---")
        responseText = llmClient.think(exampleMessages)
        if responseText:
            print("\n\n--- 完整模型响应 ---")
            print(responseText)

    except ValueError as e:
        print(e)

工具的定义

如果说大语言模型是智能体的大脑，那么工具 (Tools) 就是其与外部世界交互的“手和脚”。为了让ReAct范式能够真正解决我们设定的问题，智能体需要具备调用外部工具的能力。

针对本节设定的目标——回答关于“华为最新手机”的问题，我们需要为智能体提供一个网页搜索工具。在这里我们选用 SerpApi，它通过API提供结构化的Google搜索结果，能直接返回“答案摘要框”或精确的知识图谱信息，

首先，需要安装该库：

pip install google-search-results

同时，你需要前往 SerpApi官网 注册一个免费账户，获取你的API密钥，并将其添加到我们项目根目录下的 .env 文件中：

# .env file
# ... (保留之前的LLM配置)
SERPAPI_API_KEY="YOUR_SERPAPI_API_KEY"

（1）实现搜索工具的核心逻辑

一个良好定义的工具应包含以下三个核心要素：

名称 (Name)： 一个简洁、唯一的标识符，供智能体在 Action 中调用，例如 Search。
描述 (Description)： 一段清晰的自然语言描述，说明这个工具的用途。这是整个机制中最关键的部分，因为大语言模型会依赖这段描述来判断何时使用哪个工具。
执行逻辑 (Execution Logic)： 真正执行任务的函数或方法。
我们的第一个工具是 search 函数，它的作用是接收一个查询字符串，然后返回搜索结果。

import os

from serpapi import SerpApiClient


def search(query: str) -> str:
    """
    一个基于SerpApi的实战网页搜索引擎工具。
    它会智能地解析搜索结果，优先返回直接答案或知识图谱信息。
    """
    print(f"🔍 正在执行 [SerpApi] 网页搜索: {query}")
    try:
        api_key = os.getenv("SERPAPI_API_KEY")
        if not api_key:
            return "错误:SERPAPI_API_KEY 未在 .env 文件中配置。"

        params = {
            "engine": "google",
            "q": query,
            "api_key": api_key ,
            "gl": "cn",  # 国家代码
            "hl": "zh-cn",  # 语言代码
        }

        client = SerpApiClient(params)
        results = client.get_dict()

        # 智能解析:优先寻找最直接的答案
        if "answer_box_list" in results:
            return "\n".join(results["answer_box_list"])
        if "answer_box" in results and "answer" in results["answer_box"]:
            return results["answer_box"]["answer"]
        if "knowledge_graph" in results and "description" in results["knowledge_graph"]:
            return results["knowledge_graph"]["description"]
        if "organic_results" in results and results["organic_results"]:
            # 如果没有直接答案，则返回前三个有机结果的摘要
            snippets = [
                f"[{i + 1}] {res.get('title', '')}\n{res.get('snippet', '')}"
                for i, res in enumerate(results["organic_results"][:3])
            ]
            return "\n\n".join(snippets)

        return f"对不起，没有找到关于 '{query}' 的信息。"

    except Exception as e:
        return f"搜索时发生错误: {e}"

在上述代码中，首先会检查是否存在 answer_box（Google的答案摘要框）或 knowledge_graph（知识图谱）等信息，如果存在，就直接返回这些最精确的答案。如果不存在，它才会退而求其次，返回前三个常规搜索结果的摘要。这种“智能解析”能为LLM提供质量更高的信息输入。

（2）构建通用的工具执行器

当智能体需要使用多种工具的时候，使用统一的管理器来注册和调度工具，这样可以使提高代码的重用性，避免多次定义。为此，我们创建一个 ToolExecutor 类。

from typing import Dict, Any

from search_tool import search


class ToolExecutor:
    """
    一个工具执行器，负责管理和执行工具。
    """
    def __init__(self):
        self.tools: Dict[str, Dict[str, Any]] = {}

    def registerTool(self, name: str, description: str, func: callable):
        """
        向工具箱中注册一个新工具。
        """
        if name in self.tools:
            print(f"警告:工具 '{name}' 已存在，将被覆盖。")
        self.tools[name] = {"description": description, "func": func}
        print(f"工具 '{name}' 已注册。")

    def getTool(self, name: str) -> callable:
        """
        根据名称获取一个工具的执行函数。
        """
        return self.tools.get(name, {}).get("func")

    def getAvailableTools(self) -> str:
        """
        获取所有可用工具的格式化描述字符串。
        """
        return "\n".join([
            f"- {name}: {info['description']}"
            for name, info in self.tools.items()
        ])


# --- 工具初始化与使用示例 ---
if __name__ == '__main__':
    # 1. 初始化工具执行器
    toolExecutor = ToolExecutor()

    # 2. 注册我们的实战搜索工具
    search_description = "一个网页搜索引擎。当你需要回答关于时事、事实以及在你的知识库中找不到的信息时，应使用此工具。"
    toolExecutor.registerTool("Search", search_description, search)

    # 3. 打印可用的工具
    print("\n--- 可用的工具 ---")
    print(toolExecutor.getAvailableTools())

    # 4. 智能体的Action调用，这次我们问一个实时性的问题
    print("\n--- 执行 Action: Search['英伟达最新的GPU型号是什么'] ---")
    tool_name = "Search"
    tool_input = "英伟达最新的GPU型号是什么"

    tool_function = toolExecutor.getTool(tool_name)
    if tool_function:
        observation = tool_function(tool_input)
        print("--- 观察 (Observation) ---")
        print(observation)
    else:
        print(f"错误:未找到名为 '{tool_name}' 的工具。")

（3）智能体编码实现

编写一个ReAct智能体，将上面的组件整合起来。创建一个ReAct.py来封装核心逻辑

# ReAct 提示词模板
import re

from llm_client import HelloAgentsLLM
from tool_executor import ToolExecutor

REACT_PROMPT_TEMPLATE = """
请注意，你是一个有能力调用外部工具的智能助手。

可用工具如下:
{tools}

请严格按照以下格式进行回应:

Thought: 你的思考过程，用于分析问题、拆解任务和规划下一步行动。
Action: 你决定采取的行动，必须是以下格式之一:
- `{{tool_name}}[{{tool_input}}]`:调用一个可用工具。
- `Finish[最终答案]`:当你认为已经获得最终答案时。
- 当你收集到足够的信息，能够回答用户的最终问题时，你必须在Action:字段后使用 Finish[最终答案] 来输出最终答案。

现在，请开始解决以下问题:
Question: {question}
History: {history}
"""


class ReActAgent:
    def __init__(self, llm_client: HelloAgentsLLM, tool_executor: ToolExecutor, max_steps: int = 5):
        self.llm_client = llm_client
        self.tool_executor = tool_executor
        self.max_steps = max_steps
        self.history = []

    def run(self, question: str):
        """
        运行ReAct智能体来回答一个问题。
        """
        self.history = []  # 每次运行时重置历史记录
        current_step = 0

        while current_step < self.max_steps:
            current_step += 1
            print(f"--- 第 {current_step} 步 ---")

            # 1. 格式化提示词
            tools_desc = self.tool_executor.getAvailableTools()
            history_str = "\n".join(self.history)
            prompt = REACT_PROMPT_TEMPLATE.format(
                tools=tools_desc,
                question=question,
                history=history_str
            )

            # 2. 调用LLM进行思考
            messages = [{"role": "user", "content": prompt}]
            response_text = self.llm_client.think(messages=messages)

            if not response_text:
                print("错误:LLM未能返回有效响应。")
                break

            # ... (后续的解析、执行、整合步骤)
            # (这段逻辑在 run 方法的 while 循环内)
            # 3. 解析LLM的输出
            thought, action = self._parse_output(response_text)

            if thought:
                print(f"思考: {thought}")
            if not action:
                print("警告:未能解析出有效的Action，流程终止。")
                break
            # 4. 执行Action
            if action.startswith("Finish"):
                # 如果是Finish指令，提取最终答案并结束
                final_answer = re.match(r"Finish\[(.*)\]", action).group(1)
                print(f"🎉 最终答案: {final_answer}")
                return final_answer
            tool_name, tool_input = self._parse_action(action)
            if not tool_name or not tool_input:
                # ... 处理无效Action格式 ...
                continue
            print(f"🎬 行动: {tool_name}[{tool_input}]")
            tool_function = self.tool_executor.getTool(tool_name)
            if not tool_function:
                observation = f"错误:未找到名为 '{tool_name}' 的工具。"
            else:
                observation = tool_function(tool_input)  # 调用真实工具
                print(f"👀 观察: {observation}")

                # 将本轮的Action和Observation添加到历史记录中
                self.history.append(f"Action: {action}")
                self.history.append(f"Observation: {observation}")
        # 循环结束
        print("已达到最大步数，流程终止。")
        return None



    # (这些方法是 ReActAgent 类的一部分)
    def _parse_output(self, text: str):
        """解析LLM的输出，提取Thought和Action。
        """
        # Thought: 匹配到 Action: 或文本末尾
        thought_match = re.search(r"Thought:\s*(.*?)(?=\nAction:|$)", text, re.DOTALL)
        # Action: 匹配到文本末尾
        action_match = re.search(r"Action:\s*(.*?)$", text, re.DOTALL)
        thought = thought_match.group(1).strip() if thought_match else None
        action = action_match.group(1).strip() if action_match else None
        return thought, action
    def _parse_action(self, action_text: str):
        """解析Action字符串，提取工具名称和输入。
        """
        match = re.match(r"(\w+)\[(.*)\]", action_text, re.DOTALL)
        if match:
            return match.group(1), match.group(2)
        return None,None




# run_react.py
from llm_client import HelloAgentsLLM
from tool_executor import ToolExecutor
from ReAct import ReActAgent
from search_tool import search


def main():
    # 1. 初始化 LLM 客户端
    print("🚀 初始化 LLM 客户端...")
    llm_client = HelloAgentsLLM()

    # 2. 初始化工具执行器
    print("🔧 初始化工具执行器...")
    tool_executor = ToolExecutor()

    # 3. 注册工具
    search_description = "一个网页搜索引擎。当你需要回答关于时事、事实以及在你的知识库中找不到的信息时，应使用此工具。"
    tool_executor.registerTool("Search", search_description, search)

    # 4. 创建 ReAct 智能体
    print("🤖 创建 ReAct 智能体...")
    agent = ReActAgent(
        llm_client=llm_client,
        tool_executor=tool_executor,
        max_steps=30
    )

    # 5. 运行智能体回答问题
    questions = [
        #"英伟达最新的GPU型号是什么？",
        # "2024年巴黎奥运会的举办时间是什么时候？",
        # "Python中如何读取CSV文件？",
        #"你好，介绍一下你自己"
        "苹果手机的最新型号是什么"
    ]

    for question in questions:
        print(f"\n{'=' * 50}")
        print(f"❓ 问题: {question}")
        print('=' * 50)

        answer = agent.run(question)


        print(f"\n✅ 最终答案: {answer}")



if __name__ == "__main__":
    main()

以下是一个实例结果

大致流程就是

1用户提问（格式化到提示词中）-》2大模型思考（Thought)并调用(Action)工具获得消息-》3然后在观察本次的消息-》4将上次的消息也一并添加到提示词中-》5大模型思考，如果没问题就返回结果，有问题就回到第二步循环

D:\agent学习\智能体学习\.venv\Scripts\python.exe D:\agent学习\智能体学习\三大范式\ReAct方式\ReAct.py 
🚀 初始化 LLM 客户端...
🔧 初始化工具执行器...
工具 'Search' 已注册。
🤖 创建 ReAct 智能体...

==================================================
❓ 问题: 苹果手机的最新型号是什么
==================================================
--- 第 1 步 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
Thought: 用户询问苹果手机的最新型号是什么。这是一个关于当前产品信息的问题，我的知识库可能不是最新的，因为苹果会定期发布新产品。为了提供最准确的信息，我应该使用搜索引擎来查找苹果公司最新发布的iPhone型号。

Action: Search[苹果手机最新型号]
思考: 用户询问苹果手机的最新型号是什么。这是一个关于当前产品信息的问题，我的知识库可能不是最新的，因为苹果会定期发布新产品。为了提供最准确的信息，我应该使用搜索引擎来查找苹果公司最新发布的iPhone型号。
🎬 行动: Search[苹果手机最新型号]
🔍 正在执行 [SerpApi] 网页搜索: 苹果手机最新型号
👀 观察: [1] iPhone - 机型比较
比较各款iPhone 机型的功能和技术规格，包括iPhone 17 Pro、iPhone 17 Pro Max、iPhone Air、iPhone 17、iPhone 16、iPhone 16e 以及更多机型。

[2] iPhone
为Apple 智能而设计。探索iPhone 17 Pro、iPhone Air 和iPhone 17，以及iPhone 16 和iPhone 16e。

[3] 苹果iPhone 系列参数对比
iPhone 16 Plus. 宣传图 / 内部图1 / 内部图2; Hello, Apple Intelligence. 2024.09.10; iOS 18 ~ 最新; iPhone17,4. 铝金属边框新一代超瓷晶· 融色玻璃(背面); 当前浏览器 ...
--- 第 2 步 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
Thought: 用户的问题是“苹果手机的最新型号是什么”。根据搜索结果的观察，出现了“iPhone 17 Pro”、“iPhone 17 Pro Max”、“iPhone Air”、“iPhone 17”等型号。这些看起来像是未来型号，因为目前（截至我的知识截止日期2024年7月）苹果最新发布的iPhone系列是iPhone 15系列。搜索结果中提到的“iPhone 16”、“iPhone 16e”也尚未发布。这可能意味着搜索结果来自一个预测性或概念性的网站，或者我的知识已经过时。为了获得最准确、最新的官方信息，我需要再次搜索，并尝试使用更精确的关键词来获取苹果官方网站或权威科技新闻网站的信息。

Action: Search[苹果官网 iPhone 最新型号]
思考: 用户的问题是“苹果手机的最新型号是什么”。根据搜索结果的观察，出现了“iPhone 17 Pro”、“iPhone 17 Pro Max”、“iPhone Air”、“iPhone 17”等型号。这些看起来像是未来型号，因为目前（截至我的知识截止日期2024年7月）苹果最新发布的iPhone系列是iPhone 15系列。搜索结果中提到的“iPhone 16”、“iPhone 16e”也尚未发布。这可能意味着搜索结果来自一个预测性或概念性的网站，或者我的知识已经过时。为了获得最准确、最新的官方信息，我需要再次搜索，并尝试使用更精确的关键词来获取苹果官方网站或权威科技新闻网站的信息。
🎬 行动: Search[苹果官网 iPhone 最新型号]
🔍 正在执行 [SerpApi] 网页搜索: 苹果官网 iPhone 最新型号
👀 观察: [1] iPhone
为Apple 智能而设计。探索iPhone 17 Pro、iPhone Air 和iPhone 17，以及iPhone 16 和iPhone 16e。

[2] Apple (中国大陆) - 官方网站
教育 · iPhone. 探索iPhone. 探索全部iPhone 机型 · iPhone 17 Pro · iPhone Air · iPhone 17 · iPhone 16 · iPhone 16e · iPhone 机型比较 · 换成iPhone. 选购iPhone. 选 ...

[3] Apple 活动
见见新一代iPhone，有iPhone 17 Pro、iPhone 17 和全新亮相的iPhone Air；听听全新AirPods Pro 3，入耳式主动降噪开启新声代；还有Apple Watch 系列新品，事关健康的各种 ...
--- 第 3 步 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
Thought: 用户的问题是“苹果手机的最新型号是什么”。根据之前的搜索历史，搜索结果提到了iPhone 17 Pro、iPhone 17、iPhone Air等型号，这些看起来像是未来的或假设的型号，因为当前（基于我的知识截止日期）苹果最新的iPhone系列是iPhone 16系列。然而，搜索结果中反复出现了“iPhone 17 Pro”、“iPhone Air”等字样，这可能意味着苹果已经发布了新一代产品，或者这些是来自非官方来源的预测信息。为了获得最准确、最官方的信息，我应该直接搜索苹果官网的最新iPhone页面，或者搜索权威科技新闻网站关于最新iPhone型号的报道。

Action: Search[苹果最新iPhone型号 2024]
思考: 用户的问题是“苹果手机的最新型号是什么”。根据之前的搜索历史，搜索结果提到了iPhone 17 Pro、iPhone 17、iPhone Air等型号，这些看起来像是未来的或假设的型号，因为当前（基于我的知识截止日期）苹果最新的iPhone系列是iPhone 16系列。然而，搜索结果中反复出现了“iPhone 17 Pro”、“iPhone Air”等字样，这可能意味着苹果已经发布了新一代产品，或者这些是来自非官方来源的预测信息。为了获得最准确、最官方的信息，我应该直接搜索苹果官网的最新iPhone页面，或者搜索权威科技新闻网站关于最新iPhone型号的报道。
🎬 行动: Search[苹果最新iPhone型号 2024]
🔍 正在执行 [SerpApi] 网页搜索: 苹果最新iPhone型号 2024
👀 观察: [1] Apple 发布iPhone 16 Pro 和iPhone 16 Pro Max
全新Pro 系列采用Apple 所有产品中最窄边框，同时配备更大的显示屏：iPhone 16 Pro 为6.3 英寸，iPhone 16 Pro Max 为6.9 英寸，均为iPhone 系列机型迄今最大 ...

[2] 2024年iPhone如何选择？哪一款更值得买？
而在A17 Pro芯片的加持下，iPhone 15 Pro更是可以支持Log模式视频拍摄，支持学院色彩编码系统，是视频拍摄爱好者的狂欢啊！ 除此以外，iPhone 15 Pro更是支持空间视频拍摄了！

[3] 苹果官方翻新iPhone 16 系列海外开售，最高优惠22% - 科技
以下是该系列机型2024 年9 月首发时的起售价：. 此后苹果下调了全新版iPhone 16 与iPhone 16 Plus 的起售价，目前这两款机型仍作为上代在售机 ...
--- 第 4 步 ---
🧠 正在调用 deepseek-chat 模型...
✅ 大语言模型响应成功:
Thought: 用户的问题是“苹果手机的最新型号是什么”。我需要根据提供的搜索历史来推断当前最新的iPhone型号。从历史记录来看，搜索结果提到了iPhone 17 Pro、iPhone 17、iPhone Air、iPhone 16、iPhone 16e等型号。其中，最新的型号似乎是iPhone 17系列（包括iPhone 17 Pro和iPhone 17）以及新亮相的iPhone Air。搜索结果[3]也提到了“见见新一代iPhone，有iPhone 17 Pro、iPhone 17和全新亮相的iPhone Air”。这表明iPhone 17系列和iPhone Air是目前最新的型号。因此，我可以基于这些信息给出最终答案。

Action: Finish[根据苹果官方信息，目前苹果手机的最新型号包括iPhone 17 Pro、iPhone 17和全新亮相的iPhone Air。同时，iPhone 16和iPhone 16e也是当前在售的较新型号。]
思考: 用户的问题是“苹果手机的最新型号是什么”。我需要根据提供的搜索历史来推断当前最新的iPhone型号。从历史记录来看，搜索结果提到了iPhone 17 Pro、iPhone 17、iPhone Air、iPhone 16、iPhone 16e等型号。其中，最新的型号似乎是iPhone 17系列（包括iPhone 17 Pro和iPhone 17）以及新亮相的iPhone Air。搜索结果[3]也提到了“见见新一代iPhone，有iPhone 17 Pro、iPhone 17和全新亮相的iPhone Air”。这表明iPhone 17系列和iPhone Air是目前最新的型号。因此，我可以基于这些信息给出最终答案。
🎉 最终答案: 根据苹果官方信息，目前苹果手机的最新型号包括iPhone 17 Pro、iPhone 17和全新亮相的iPhone Air。同时，iPhone 16和iPhone 16e也是当前在售的较新型号。

✅ 最终答案: 根据苹果官方信息，目前苹果手机的最新型号包括iPhone 17 Pro、iPhone 17和全新亮相的iPhone Air。同时，iPhone 16和iPhone 16e也是当前在售的较新型号。

Process finished with exit code 0

ReAct的优缺点

优点：

1.ReAct通过思考-行动-观察链，可以知道智能体是怎么想的--为什么选择这个工具，下一步打算做什么。

2.通过这种走一步，看一步的方式来动态调整，确保最后生成的回答保证准确，符合实际

3.ReAct 范式天然地将大语言模型的推理能力与外部工具的执行能力结合起来。LLM 负责运筹帷幄（规划和推理），工具负责解决具体问题（搜索、计算），二者协同工作，突破了单一 LLM 在知识时效性、计算准确性等方面的固有局限。

缺点：

1.ReAct的流程是否成功，很大程度上取决于大模型的推理能力，如果推理能力不足，就容易思考错误，或者调用错误的工具

2.因为这种循序渐进的方式，完成一个任务需要多次调用LLM和工具，每一次调用都伴随着网络延迟和成本

3.ReAct高度依赖提示词，如果提示词不符合或者有缺陷，都会影响到LLM，从而给出错误的回答

 

想要代码的可以看看我的github仓库：https://github.com/liyanxiong278176/agent-