【用AI学Agent】ReAct框架（实现自主闭环，搞定复杂任务）

首先欢迎大家点进文章，其次

申明：本系列内容是作者通过AI学习 Agent得到的内容，如若有错误之处，欢迎批评指正

在前三篇博客中，我们已经逐一拆解了Agent的三大核心模块：大模型 （大脑）赋予Agent思考能力，Prompt工程 （灵魂）规范Agent的思考与输出，Function Calling（手脚）让Agent拥有执行能力。这三大模块就像Agent的"零件"，单独存在时各有价值，但只有将它们有机整合，才能搭建出一个完整、自主、能解决复杂任务的Agent。

开发Agent时，如果陷入"模块孤立"的误区：能写出规范的Prompt，能实现简单的工具调用，却无法让Agent自主完成"思考→行动→观察→再思考"的完整流程------比如调用工具获取数据后，不知道如何根据结果调整下一步行动；或者无法判断"是否需要继续调用工具"，会导致任务中断或输出无效结果。

而解决这一问题的核心，就是掌握Agent的完整架构------ReAct框架。ReAct框架就像Agent的"骨架"，将大模型、Prompt工程、Function Calling三大模块串联起来，明确Agent的运行逻辑，让Agent能够自主循环、持续推进任务，真正实现"能思考、能行动、能迭代"，从容应对复杂任务。

这篇博客，我们就聚焦ReAct框架，从"是什么""核心逻辑"，到"框架拆解""实操搭建步骤""避坑指南"，再到"完整案例演示"，全是能直接落地的实操干货，帮你把三大模块整合起来，搭建一个真正能自主完成复杂任务的Agent，彻底打通Agent开发的"最后一公里"。

一、ReAct框架到底是什么？

ReAct（全称：Reason + Act），是一种简单、高效且可落地的Agent架构，核心逻辑是**"思考（Reason）→ 行动（Act）→ 观察（Observe）→ 再思考（Reason）"的闭环循环**。

通俗来讲，ReAct框架就像一个"自主决策的执行者"：Agent通过"思考"拆解任务、判断下一步行动；通过"行动"调用工具、执行具体操作；通过"观察"获取行动结果、判断是否符合预期；再通过"再思考"调整策略，重复循环，直到完成任务。

结合前三篇的三大模块，我们可以这样理解ReAct框架的定位：

ReAct框架 = 大模型（思考核心） + Prompt工程（思考与行动规范） + Function Calling（行动执行） + 观察模块（结果反馈）。它不新增额外的复杂模块，而是将已有的三大模块进行逻辑串联，明确每个模块的分工和联动方式，让Agent从"零散执行"变成"闭环自主"。

举个直观的例子（衔接前文数据分析场景）：

用户需求："分析近3个月A产品的销量趋势，对比竞品B的销量，生成一份带结论建议的复盘报告。"

1. 思考（Reason）：大模型通过Prompt引导，拆解任务------需要先获取A产品近3个月销量数据、竞品B近3个月销量数据，再对比两者趋势，最后生成报告；判断需要调用"Excel分析工具"（查A产品数据）和"联网搜索工具"（查竞品B数据）。

2. 行动（Act）：通过Function Calling，先调用Excel分析工具，获取A产品销量数据；再调用联网搜索工具，获取竞品B销量数据。

3. 观察（Observe）：接收两个工具的返回结果，确认数据是否完整（如A产品数据有3个月完整数据，竞品B数据仅获取到2个月，存在缺失）。

4. 再思考（Reason）：基于观察结果，判断需要补充调用联网搜索工具，查询竞品B缺失的1个月销量数据；补充数据后，再调用Excel分析工具，对比两者销量趋势。

5. 再行动（Act）：调用联网搜索工具补充竞品B数据，再调用Excel分析工具完成趋势对比。

6. 再观察（Observe）：确认所有数据完整、对比结果有效。

7. 最终思考与行动：整理所有数据和对比结果，生成带结论建议的复盘报告，完成任务。

这个完整的循环过程，就是ReAct框架的核心------它让Agent不再是"被动执行单一指令"，而是"主动判断、持续迭代"，真正实现自主完成复杂任务。

二、ReAct框架的核心优势：为什么它是Agent开发的首选架构？

市面上有很多Agent架构（如LangChain、AutoGPT），但ReAct框架之所以成为新手入门的首选，核心在于它"简单、高效、可落地"，完美适配新手的开发节奏，同时能满足大部分复杂任务的需求。

核心优势有4点，结合Agent开发场景逐一拆解：

1. 逻辑清晰，降低开发难度

ReAct框架的核心就是"思考→行动→观察"的闭环，没有复杂的额外模块，所有逻辑都围绕"如何让Agent自主推进任务"展开。新手只需明确三大模块在框架中的分工，就能快速上手搭建，无需掌握复杂的架构设计知识。

对比其他复杂架构（如需要额外搭建记忆模块、规划模块），ReAct框架更适合新手入门，能快速实现"从0到1"的突破。

2. 贴合三大模块，实现无缝联动

ReAct框架天生就是为"大模型+Prompt工程+Function Calling"三大模块设计的：

• 思考（Reason）：由大模型主导，通过Prompt工程引导，完成任务拆解、行动判断；

• 行动（Act）：由Function Calling主导，执行工具调用，落地思考后的决策；

• 观察（Observe）：衔接行动与思考，将工具返回的结果反馈给大模型，为下一次思考提供依据。

这种联动方式，能让三大模块的价值最大化，避免"模块孤立"导致的任务中断、输出无效等问题。

3. 支持自主迭代，适配复杂任务

复杂任务的核心需求是"持续调整、逐步推进"------比如用户需求是"生成一份行业竞品分析报告"，需要先查竞品名单、再查各竞品数据、再对比分析、最后生成报告，中间可能出现数据缺失、分析偏差等问题。

ReAct框架的闭环特性，能让Agent自主发现问题、调整策略（如数据缺失时补充调用工具），无需用户手动干预，就能持续推进任务，直到完成目标。

4. 灵活可扩展，适配不同场景

ReAct框架的灵活性极强，既能适配简单任务（如查天气、计算数据），也能适配复杂任务（如竞品分析、报告生成、自动化办公）；同时，可根据需求扩展工具范围（如新增AI绘画工具、邮件发送工具），无需修改核心框架逻辑。

总结：对于新手而言，ReAct框架是"性价比最高"的Agent架构------无需复杂开发，就能将三大模块整合起来，实现Agent的自主闭环，搞定大部分复杂任务。

三、ReAct框架核心拆解（四大模块，分工明确）

ReAct框架看似简单，实则有明确的模块分工，四大模块相互联动，构成完整的闭环。结合前三篇的知识点，我们逐一拆解每个模块的核心职责、实现方式，帮你彻底吃透框架逻辑，为后续实操搭建打下基础。

模块1：思考模块（Reason）------Agent的"决策中心"

核心职责：接收用户需求、观察结果，拆解任务、判断下一步行动（是否调用工具、调用什么工具、如何调用），相当于Agent的"大脑中枢"。

实现方式：由大模型+Prompt工程共同实现，核心是通过Prompt引导大模型生成清晰的思考过程，明确决策依据。

关键要点：

• 思考过程要可追溯：通过Prompt要求大模型"分步呈现思考过程"，明确"为什么需要调用工具""为什么选择这个工具""参数如何设置"，方便后续调试和优化；

• 决策要贴合观察结果：思考时必须结合"观察模块"反馈的工具返回结果，不能脱离实际行动结果盲目决策（如工具返回数据缺失，需调整工具调用参数，补充数据）；

• 明确任务终止条件：通过Prompt引导大模型判断"什么时候任务完成"，避免无限循环（如"当所有数据获取完整、分析完成，生成最终报告后，停止调用工具，输出结果"）。

示例（思考模块Prompt片段）：

你是一个自主Agent，基于ReAct框架运行，核心职责是完成用户复杂任务。思考模块要求：1. 先接收用户需求和观察到的工具返回结果，分步拆解任务；2. 判断下一步是否需要调用工具，若需要，选择合适的工具并确定参数；3. 若工具返回结果不完整或有错误，调整策略重新调用；4. 当任务完成（所有需求均满足），停止行动，输出最终结果；5. 每一步思考都要清晰，说明决策依据。

模块2：行动模块（Act）------Agent的"执行中心"

核心职责：根据思考模块的决策，调用对应的工具，执行具体操作，获取工具返回结果，相当于Agent的"手脚"。

实现方式：由Function Calling实现，核心是规范工具调用参数，确保工具能正常运行、返回有效结果。

关键要点：

• 参数规范：严格按照思考模块生成的参数调用工具，确保参数名称、类型与工具定义一致，不遗漏必填参数；

• 工具适配：确保调用的工具能满足当前行动需求（如需要实时数据，调用联网搜索工具；需要数据计算，调用Excel分析工具）；

• 结果反馈：将工具返回的结果（结构化格式，如JSON）完整反馈给观察模块，不遗漏关键信息。

衔接前文：行动模块的核心逻辑，就是我们上一篇讲解的Function Calling实操内容，这里只需将其融入ReAct框架，作为"思考模块决策的执行者"即可。

模块3：观察模块（Observe）------Agent的"反馈中心"

核心职责：接收行动模块返回的工具结果，对结果进行解析、校验，判断结果是否完整、有效，再将解析后的结果反馈给思考模块，为下一次思考提供依据，相当于Agent的"眼睛"。

实现方式：由"简单的解析逻辑+Prompt引导"实现，无需新增复杂工具，核心是"校验结果、提取关键信息"。

关键要点：

• 结果校验：判断工具返回结果是否有效（如是否有错误信息、数据是否缺失、格式是否正确）；

• 信息提取：从工具返回结果中，提取思考模块需要的关键信息（如销量数据、竞品信息），剔除无关内容；

• 反馈清晰：将校验后的结果、提取的关键信息，以简洁、结构化的方式反馈给思考模块，方便思考模块快速决策。

示例（观察模块解析逻辑）：

观察模块功能：1. 接收行动模块返回的工具结果（JSON格式）；2. 校验结果：若存在error字段且非空，判定为工具调用失败；若data/result字段为空，判定为结果缺失；3. 提取关键信息：从data/result字段中，提取与当前任务相关的核心数据（如销量、增长率、竞品名称）；4. 将"校验结果+关键信息"反馈给思考模块。

模块4：记忆模块（Memory）------Agent的"存储中心"（简化版）

核心职责：存储用户需求、思考过程、行动记录、观察结果，方便思考模块在"再思考"时调用历史信息，避免重复思考、重复调用工具，相当于Agent的"记忆"。

实现方式：新手入门可采用"简化版记忆模块"------将历史信息（思考过程、行动记录、观察结果）拼接在Prompt中，传递给大模型，无需搭建复杂的数据库存储。

关键要点：

• 存储关键信息：无需存储所有细节，重点存储"用户需求、工具调用记录、核心观察结果"；

• 避免冗余：控制记忆信息的长度，不超出大模型的上下文窗口，防止大模型遗忘核心需求；

• 实时更新：每次思考、行动、观察后，及时更新记忆信息，确保思考模块能获取最新的历史数据。

示例（简化版记忆模块Prompt片段）：

【记忆信息】用户需求：分析近3个月A产品销量趋势，对比竞品B，生成复盘报告；历史行动1：调用Excel分析工具，获取A产品近3个月销量平均值1250.5件；历史观察1：A产品数据完整，无缺失；历史行动2：调用联网搜索工具，获取竞品B近2个月销量数据；历史观察2：竞品B缺失1个月数据，需补充调用工具。

四、ReAct框架实操搭建步骤（新手可直接落地）

理解了ReAct框架的四大模块后，我们结合具体的复杂任务场景，讲解实操搭建步骤------从"环境准备"到"四大模块实现"，再到"闭环测试"，每一步都配示例和代码片段，新手可直接复用，快速搭建一个完整的自主Agent。

本次实操场景：搭建一个"竞品分析Agent"，完成用户需求------"分析近3个月A产品与竞品B的销量趋势，计算两者的增长率，生成带结论建议的复盘报告"。

步骤1：环境准备（基础前提）

搭建ReAct框架Agent，需准备以下基础环境和工具，确保后续步骤能正常运行：

1. 编程语言：Python 3.9+（兼容性最好，避免版本过低导致的库报错）；

2. 核心库：pandas（Excel数据处理）、requests（联网请求）、openai（大模型调用，可替换为其他大模型，如字节跳动Seed大模型）；

3. 工具准备：提前定义2个工具（excel_analysis、search），复用上一篇的工具定义（直接复制即可）；

4. 大模型准备：获取大模型API密钥（如OpenAI API、字节跳动API），确保能正常调用大模型生成思考过程和工具调用参数。

环境安装命令（直接复制运行）：

pip install pandas requests openai

步骤2：实现四大模块（核心步骤）

我们逐一实现ReAct框架的四大模块，每个模块都提供可直接复用的代码，新手只需替换对应的参数（如API密钥、文件路径），即可快速运行。

1. 工具定义

先定义excel_analysis和search两个工具，作为行动模块的核心，确保参数和返回格式一致：

import json
import pandas as pd
import requests
from openai import OpenAI

# 初始化大模型客户端（替换为你的API密钥和基础URL）
client = OpenAI(
    api_key="你的API密钥",
    base_url="你的大模型基础URL"
)

# 工具1：excel_analysis（Excel分析工具）
def excel_analysis(file_path, target_column, analysis_type):
    try:
        df = pd.read_excel(file_path)
        if not all(col in df.columns for col in target_column):
            return json.dumps({"result": None, "description": "目标列不存在，请检查列名", "error": "column_error"})
        if analysis_type == "average":
            result = df[target_column[0]].mean()
            description = f"A产品近3个月销量平均值为{result:.1f}件"
        elif analysis_type == "growth_rate":
            # 简化版增长率计算（实际可根据真实数据优化）
            df_sorted = df.sort_values(by="日期")
            first_month = df_sorted[target_column[0]].iloc[0]
            last_month = df_sorted[target_column[0]].iloc[-1]
            result = (last_month - first_month) / first_month
            description = f"A产品近3个月销量增长率为{result*100:.1f}%"
        else:
            return json.dumps({"result": None, "description": "分析类型错误，仅支持average/growth_rate", "error": "type_error"})
        return json.dumps({"result": result, "description": description, "error": ""})
    except Exception as e:
        return json.dumps({"result": None, "description": str(e), "error": "runtime_error"})

# 工具2：search（联网搜索工具，模拟真实接口）
def search(keyword, time_range=None):
    try:
        query = keyword
        if time_range:
            query += f" {time_range}"
        # 模拟联网返回结果（实际可替换为真实搜索API）
        if "竞品B" in query and "销量" in query:
            response_data = {
                "data": f"{query} 查询结果：2024年4月销量1000件，5月销量1100件，6月销量1320件",
                "source": "行业统计平台",
                "error": ""
            }
        else:
            response_data = {
                "data": "未查询到相关数据",
                "source": "",
                "error": "data_not_found"
            }
        return json.dumps(response_data)
    except Exception as e:
        return json.dumps({"data": None, "source": None, "error": str(e)})

2. 记忆模块（简化版，拼接历史信息）

实现简化版记忆模块，用列表存储历史信息（用户需求、思考过程、行动记录、观察结果），每次循环后更新记忆：

# 初始化记忆模块（存储历史信息）
memory = []

def update_memory(content):
    """更新记忆模块，添加新的历史信息"""
    memory.append(content)
    # 控制记忆长度，避免超出大模型上下文窗口（保留最近10条信息）
    if len(memory) > 10:
        memory.pop(0)

def get_memory():
    """获取记忆信息，拼接为字符串，传递给大模型"""
    if not memory:
        return "无历史信息"
    return "\n".join([f"【历史{idx+1}】{content}" for idx, content in enumerate(memory)])

3. 观察模块（解析工具结果，反馈给思考模块）

实现观察模块，解析行动模块返回的工具结果，校验有效性、提取关键信息，反馈给思考模块：

def observe(tool_result, tool_name):
    """
    观察模块：解析工具返回结果，校验有效性，提取关键信息
    :param tool_result: 工具返回的JSON字符串
    :param tool_name: 调用的工具名称
    :return: 结构化的观察结果，用于反馈给思考模块
    """
    result_dict = json.loads(tool_result)
    # 校验结果是否有效
    if result_dict.get("error") and result_dict["error"] != "":
        observation = f"工具{tool_name}调用失败，错误信息：{result_dict['error']}，请调整参数重新调用"
    else:
        # 提取关键信息（根据工具类型区分）
        if tool_name == "excel_analysis":
            observation = f"工具{tool_name}调用成功，{result_dict['description']}，核心结果：{result_dict['result']}"
        elif tool_name == "search":
            observation = f"工具{tool_name}调用成功，查询结果：{result_dict['data']}，数据来源：{result_dict['source']}"
        else:
            observation = f"工具{tool_name}调用成功，返回结果：{result_dict}"
    # 更新记忆模块
    update_memory(f"行动：调用{tool_name}工具；观察：{observation}")
    return observation

4. 思考模块（大模型+Prompt，生成决策）

实现思考模块，通过Prompt引导大模型，结合用户需求、记忆信息、观察结果，生成思考过程和行动决策（是否调用工具、调用什么工具、参数是什么）：

def reason(user_query, observation=None):
    """
    思考模块：结合用户需求、记忆、观察结果，生成思考过程和行动决策
    :param user_query: 用户需求
    :param observation: 观察模块反馈的结果（首次调用时为None）
    :return: 思考过程、行动决策（tool_params）、任务是否完成（is_finished）
    """
    # 拼接Prompt，引导大模型生成规范的思考和决策
    prompt = f"""
你是一个基于ReAct框架的竞品分析Agent，核心职责是完成用户的竞品分析需求，遵循"思考→行动→观察→再思考"的闭环。
【用户需求】{user_query}
【记忆信息】{get_memory()}
【最新观察结果】{observation if observation else "无观察结果（首次执行）"}

请按照以下要求输出：
1. 思考过程：分步拆解任务，结合记忆和观察结果，说明下一步决策依据（是否需要调用工具、调用什么工具、为什么）；
2. 行动决策：若需要调用工具，输出JSON格式的工具调用参数（包含tool和parameters，参数需符合工具定义）；若不需要调用工具，输出"无需调用工具"；
3. 任务状态：判断任务是否完成，输出"完成"或"未完成"。

注意：
- 工具仅支持excel_analysis和search，参数需符合工具定义（excel_analysis需包含file_path、target_column、analysis_type；search需包含keyword，time_range可选）；
- 若观察到工具调用失败或数据缺失，需调整参数重新调用；
- 当所有数据获取完整、分析完成，生成最终报告后，任务状态设为"完成"，无需再调用工具；
- 思考过程要详细，行动决策格式要规范，不要添加多余解释。
    """
    
    # 调用大模型，获取返回结果
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",  # 可替换为其他大模型
        messages=[{"role": "user", "content": prompt}],
        temperature=0.3  # 降低随机性，确保决策稳定
    )
    
    response_content = response.choices[0].message.content
    # 更新记忆模块（存储思考过程）
    update_memory(f"思考过程：{response_content.split('行动决策：')[0].strip()}")
    
    # 解析大模型返回结果，提取行动决策和任务状态
    if "行动决策：无需调用工具" in response_content:
        tool_params = None
    else:
        # 提取JSON格式的工具调用参数
        import re
        json_match = re.search(r"\{.*?\}", response_content, re.DOTALL)
        tool_params = json.loads(json_match.group()) if json_match else None
    
    is_finished = "任务状态：完成" in response_content
    return response_content, tool_params, is_finished

5. 行动模块（调用工具，执行决策）

实现行动模块，根据思考模块生成的tool_params，调用对应的工具，获取返回结果，传递给观察模块：

def act(tool_params):
    """
    行动模块：根据思考模块的决策，调用对应的工具
    :param tool_params: 工具调用参数（JSON格式，包含tool和parameters）
    :return: 工具返回的结果、工具名称
    """
    if not tool_params or "tool" not in tool_params:
        return "无效的工具调用参数", None
    tool_name = tool_params["tool"]
    params = tool_params["parameters"]
    
    # 调用对应的工具
    if tool_name == "excel_analysis":
        tool_result = excel_analysis(
            file_path=params["file_path"],
            target_column=params["target_column"],
            analysis_type=params["analysis_type"]
        )
    elif tool_name == "search":
        tool_result = search(
            keyword=params["keyword"],
            time_range=params.get("time_range")
        )
    else:
        tool_result = json.dumps({"error": "不支持的工具名称"})
    
    # 更新记忆模块（存储行动记录）
    update_memory(f"行动：调用{tool_name}工具，参数：{params}")
    return tool_result, tool_name

步骤3：搭建闭环循环，运行Agent

将四大模块串联起来，实现"思考→行动→观察→再思考"的闭环循环，直到任务完成，输出最终结果：

def run_react_agent(user_query):
    """
    运行ReAct框架Agent，实现闭环循环
    :param user_query: 用户需求
    :return: 最终任务结果
    """
    # 初始化记忆模块
    global memory
    memory = []
    update_memory(f"用户需求：{user_query}")
    
    observation = None
    is_finished = False
    final_result = ""
    
    # 闭环循环：思考→行动→观察→再思考
    while not is_finished:
        # 1. 思考模块：生成决策
        thinking, tool_params, is_finished = reason(user_query, observation)
        print("="*50)
        print("思考过程：")
        print(thinking.split("行动决策：")[0].strip())
        print("="*50)
        
        if is_finished:
            # 任务完成，提取最终结果
            final_result = thinking.split("任务状态：完成")[-1].strip()
            break
        
        # 2. 行动模块：调用工具
        tool_result, tool_name = act(tool_params)
        print(f"行动：调用{tool_name}工具，返回结果：{tool_result}")
        print("="*50)
        
        # 3. 观察模块：解析结果，反馈给思考模块
        observation = observe(tool_result, tool_name)
        print(f"观察结果：{observation}")
        print("="*50)
    
    # 输出最终结果
    print("\n" + "="*80)
    print("任务完成，最终结果：")
    print(final_result)
    return final_result

# 测试Agent：运行竞品分析任务
if __name__ == "__main__":
    user_query = "分析近3个月A产品与竞品B的销量趋势，计算两者的增长率，生成带结论建议的复盘报告。"
    run_react_agent(user_query)

步骤4：测试与优化（关键环节）

运行上述代码后，需根据测试结果进行优化，确保Agent能正常完成闭环：

1. 测试要点：检查Agent是否能自主调用工具、是否能根据观察结果调整策略、是否能完成任务并输出最终报告；

2. 常见优化方向：

   1. Prompt优化：若大模型决策偏差，调整思考模块的Prompt，明确决策规则和工具调用要求；

   2. 工具优化：若工具调用失败，检查工具函数的参数和逻辑，确保工具能正常返回有效结果；

   3. 记忆优化：若记忆信息冗余，调整update_memory函数，精简存储的信息，避免超出大模型上下文窗口。

五、ReAct框架避坑指南

新手搭建ReAct框架时，很容易出现"闭环断裂""决策偏差""工具调用失败"等问题，核心是踩了一些高频坑。下面整理了5个高频踩坑点，帮你避坑，提升Agent的稳定性和自主性。

坑1：思考模块Prompt引导不足，导致决策偏差

常见错误：Prompt中没有明确"任务终止条件""工具调用规则"，导致大模型无限循环调用工具，或任务完成后仍继续调用；或决策与用户需求偏离（如用户要竞品对比，却只调用了A产品的工具）。

解决方案：在思考模块的Prompt中，明确"任务完成的条件""可调用的工具范围""决策需贴合用户需求"，并给出思考过程的示例，引导大模型规范决策。

坑2：观察模块未做结果校验，导致无效数据进入思考

常见错误：观察模块仅提取结果，不校验有效性（如工具返回错误信息、数据缺失，仍将其反馈给思考模块），导致思考模块基于无效数据决策，任务中断。

解决方案：观察模块必须加入结果校验逻辑，判断工具返回结果是否有错误、数据是否完整，若有问题，明确反馈给思考模块，引导其调整策略。

坑3：记忆模块信息冗余，超出大模型上下文窗口

常见错误：记忆模块存储所有细节信息（如完整的工具返回结果、冗长的思考过程），导致记忆信息过长，超出大模型的上下文窗口，大模型遗忘用户需求和核心决策。

解决方案：记忆模块仅存储关键信息（用户需求、工具调用记录、核心观察结果），控制记忆长度，超出限制时删除最早的信息，确保大模型能完整读取记忆。

坑4：行动模块未适配工具定义，导致调用失败

常见错误：行动模块调用工具时，参数名称、类型与工具定义不一致（如工具要求"file_path"，行动模块传递"filePath"），或遗漏必填参数，导致工具调用失败。

解决方案：行动模块调用工具时，严格按照工具定义的参数要求传递参数，可在调用前加入参数校验逻辑，确保参数正确无误。

坑5：未处理异常场景，导致闭环断裂

常见错误：未考虑"工具调用失败""数据查询不到""大模型返回无效决策"等异常场景，导致Agent无法处理，闭环断裂，任务中断。

解决方案：在每个模块中加入异常处理逻辑，如：工具调用失败时，引导思考模块调整参数重新调用；大模型返回无效决策时，重新调用大模型生成决策；数据查询不到时，提示用户补充信息。

六、核心总结：ReAct框架与Agent的完整闭环

结合前四篇的知识点，我们用一张"闭环图"，帮你串联起Agent开发的所有核心逻辑，彻底理解ReAct框架的价值：

1. 用户需求 → 记忆模块：存储用户需求，为思考模块提供基础；

2. 记忆模块 → 思考模块：大模型通过Prompt引导，结合记忆和观察结果，拆解任务、生成行动决策；

3. 思考模块 → 行动模块：根据决策，调用对应的工具，执行具体操作；

4. 行动模块 → 观察模块：接收工具返回结果，校验有效性、提取关键信息；

5. 观察模块 → 记忆模块+思考模块：更新记忆，同时将观察结果反馈给思考模块，触发"再思考"；

6. 循环迭代：重复"思考→行动→观察"，直到任务完成，输出最终结果。

一句话总结：ReAct框架的核心，是让大模型、Prompt工程、Function Calling三大模块"各司其职、无缝联动"，通过"思考→行动→观察"的闭环，让Agent从"零散执行"变成"自主闭环"，真正实现能思考、能行动、能迭代，搞定复杂任务。

写在最后

这篇博客，我们详细讲解了ReAct框架的核心逻辑、四大模块的实现方式，以及完整的实操搭建步骤------到这里，Agent开发的核心知识点（大模型、Prompt工程、Function Calling、ReAct框架），我们已经全部讲解完毕。

从"大脑"（大模型）到"灵魂"（Prompt工程），再到"手脚"（Function Calling），最后到"骨架"（ReAct框架），你已经掌握了搭建一个完整自主Agent的所有核心技能。很多新手觉得Agent开发很复杂，其实只要抓住"闭环"这个核心------让Agent能自主思考、自主行动、自主迭代，再一步步实践，就能快速上手。

运行本次实操的代码，替换自己的API密钥和工具参数，测试Agent的运行效果；然后尝试修改用户需求（如"生成一份天气周报，包含实时天气、出行建议"），优化四大模块，锻炼自己的实操能力。

下一篇，我们将进入Agent开发的进阶环节------讲解Agent的记忆模块优化（从简化版到进阶版）和复杂场景适配，教你如何让Agent拥有更长的记忆、更精准的决策，适配更多实际业务场景，真正实现Agent的落地应用。