ReAct设计模式深度解析：LangGraph实现AI智能体的完整指南（含完整案例，值得收藏）

这篇文章详细介绍了ReAct设计模式及其在LangGraph中的实现。文章对比了传统实现与LangGraph的差异，展示了如何构建状态管理、推理节点、行动节点和条件决策等核心组件，并通过实际案例展示了ReAct模式在多步骤推理任务中的应用，提供了最佳实践和对比，帮助开发者构建生产就绪的AI智能体系统。

bugyinyin

545人浏览 · 2026-02-05 14:56:26

bugyinyin · 2026-02-05 14:56:26 发布

什么是ReAct设计模式？

ReAct（Reasoning-Action）是一种经典的AI智能体设计模式，它模拟人类解决问题的方式：

Reasoning（推理）：分析当前情况，制定计划
Action（行动）：执行具体操作，如调用工具
循环：基于行动结果继续推理和行动

这种模式特别适合需要外部信息获取和多步骤推理的复杂任务。

为什么选择LangGraph？

传统ReAct实现的挑战

传统的ReAct实现通常使用手动while、for循环控制：

def run_react_agent(query):    state = initial_state    while not is_finished(state):        thought = generate_thought(state, query)        action = decide_action(thought)        if action:            observation = execute_action(action)            state = update_state(state, thought, action, observation)        else:            break    return generate_response(state)

这种方式存在以下问题：

手动状态管理容易出错
需要手动控制执行流程
状态累积和转换复杂
缺乏可视化和调试能力

LangGraph的优势

LangGraph通过声明式图结构解决了这些问题，只需定义三大元素：

定义节点Node：ResoningNode，ActingNode
定义状态Sate
定义边Edge，条件循环控制

核心组件实现

1. 状态定义

from typing_extensions import TypedDictfrom typing import Annotatedimport operatorfrom langchain.messages import AnyMessageclass AgentState(TypedDict):    messages: Annotated[list[AnyMessage], operator.add]    llm_calls: int    steps: int  # 记录ReAct循环步数

状态是LangGraph的核心概念，TypedDict提供了类型安全，operator.add实现了消息的自动累积。

2. 推理节点 (Reasoning Node)

from langchain.messages import SystemMessagefrom langchain.chat_models import init_chat_model# 初始化模型和工具model = init_chat_model("gpt-4o", temperature=0)tools = [add, multiply, divide, search]model_with_tools = model.bind_tools(tools)def reasoning_node(state: AgentState):    """LLM进行推理，决定是否需要采取行动（使用工具）"""    messages = state["messages"]        # 添加系统提示，明确指示使用ReAct模式    system_message = SystemMessage(        content="""你是一个使用ReAct（推理-行动）模式的智能助手。        1. 首先分析用户请求，进行推理        2. 如果需要外部信息，使用search工具进行网络搜索        3. 如果需要数学计算，使用add, multiply, divide等工具        4. 否则直接回复用户        5. 每次只做一件事，等待结果后再继续"""    )        response = model_with_tools.invoke([system_message] + messages)        return {        "messages": [response],        "llm_calls": state.get('llm_calls', 0) + 1,        "steps": state.get('steps', 0) + 1    }

推理节点负责：

接收当前状态和消息历史
使用系统提示指导LLM行为
生成可能包含工具调用的响应
更新执行统计信息

3. 行动节点 (Action Node)

from langchain.messages import ToolMessagedef acting_node(state: AgentState):    """执行工具调用 - 实际行动"""    last_message = state["messages"][-1]    results = []        for tool_call in last_message.tool_calls:        # 根据工具名称查找并执行对应工具        tool_map = {t.name: t for t in tools}        selected_tool = tool_map[tool_call["name"]]        tool_output = selected_tool.invoke(tool_call["args"])                # 将工具执行结果作为消息添加到状态        tool_message = ToolMessage(            content=str(tool_output),            tool_call_id=tool_call["id"]        )        results.append(tool_message)        return {"messages": results}

行动节点负责：

解析LLM生成的工具调用
执行相应的工具
将工具结果包装为消息返回

4. 条件决策函数

from typing import Literaldef should_continue(state: AgentState) -> Literal["acting_node", "FINISH"]:    """判断是否需要继续ReAct循环"""    last_message = state["messages"][-1]        # 如果LLM生成了工具调用，说明还需要行动    if hasattr(last_message, 'tool_calls') and last_message.tool_calls:        return "acting_node"  # 继续行动步骤        # 否则结束循环    return "FINISH"

图构建过程

from langgraph.graph import StateGraph, START, ENDdef create_react_agent():    """创建ReAct模式Agent"""    builder = StateGraph(AgentState)        # 添加节点    builder.add_node("reasoning_node", reasoning_node)    builder.add_node("acting_node", acting_node)        # 设置起始点    builder.add_edge(START, "reasoning_node")        # 添加条件边 - 根据决策函数决定下一步    builder.add_conditional_edges(        "reasoning_node",        should_continue,        {            "acting_node": "acting_node",            "FINISH": END        }    )        # 从行动节点回到推理节点，形成ReAct循环    builder.add_edge("acting_node", "reasoning_node")        return builder.compile()

工具集成实现

搜索工具

from langchain.tools import toolfrom tavily import TavilyClientimport ostavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))@tooldef search(query: str) -> str:    """Search the web for information using Tavily."""    try:        response = tavily_client.search(query, max_results=3)        results = []        for result in response['results']:            results.append(f"Title: {result['title']}\nContent: {result['content']}\nURL: {result['url']}")        return"\n\n".join(results)    except Exception as e:        returnf"Search failed: {str(e)}"

数学计算工具

@tooldef multiply(a: int, b: int) -> int:    """Multiply `a` and `b`."""    return a * b@tooldef add(a: int, b: int) -> int:    """Adds `a` and `b`."""    return a + b@tooldef divide(a: int, b: int) -> float:    """Divide `a` and `b`."""    if b == 0:        raise ValueError("Cannot divide by zero")    return a / b

实际执行案例

用户请求

“请先搜索白砂糖现在的市场零售价，再根据这个价格，计算买5斤白砂糖需要花多少钱”

核心依赖关系

计算总价的任务完全依赖搜索到的单价数据，无单价则无法完成计算，是日常购物中典型的任务依赖场景。

执行流程完整记录

推理阶段：LLM分析用户请求，拆分出两个强依赖的子任务

① 搜索白砂糖当前市场零售价（前置必要任务，需明确单位为元/斤）；

② 根据单价计算5斤白砂糖的总价（后置任务）。判定需优先完成搜索任务，再执行计算。
行动阶段：调用search工具，执行搜索查询词：白砂糖市场零售价 2025年12月元/斤
观察阶段：搜索工具返回实时市场数据

据2025年12月全国主流商超、生鲜电商平台的报价数据，白砂糖的市场零售价区间为 3.5-4.2元/斤，取市场交易中间均价约为 3.8元/斤。
推理阶段：确认已获取有效单价数据，确定计算逻辑为 总价 = 单价 × 数量，其中数量为5斤，分别按均价、最低价、最高价三档计算。
行动阶段：调用calculate_total_price工具，传入三组参数：

第一组：单价=3.8，数量=5
第二组：单价=3.5，数量=5
第三组：单价=4.2，数量=5

观察阶段：计算工具返回三档结果

均价计算：3.8元/斤 × 5斤 = 19元最低价计算：3.5元/斤 × 5斤 = 17.5元最高价计算：4.2元/斤 × 5斤 = 21元
推理阶段：两个任务均完成，整合单价信息与三档总价计算结果，生成符合日常购物需求的最终回复。

最终输出结果

一、白砂糖当前市场零售价

根据2025年12月全国主流商超、生鲜电商平台的实时报价，白砂糖的市场零售价区间为 3.5-4.2元/斤，市场交易中间均价约为 3.8元/斤。

二、5斤白砂糖总价计算结果

计算逻辑

总价单价购买数量总价=单价×购买数量

已知条件：购买数量 = 5 斤

分档计算结果

按市场均价计算：3.8元/斤 × 5斤 = 19元
按区间最低价计算：3.5元/斤 × 5斤 = 17.5元
按区间最高价计算：4.2元/斤 × 5斤 = 21元

最终结论

购买5斤白砂糖，预计总花费在 17.5-21元 区间内，按市场中间均价计算需花费 19元。

执行时序分析

这些案例清晰地展示了ReAct模式如何在LangGraph中工作：智能体在推理和行动之间循环，直到完成用户请求。每次LLM调用都基于完整的历史上下文，确保了对话的连贯性和任务的完整性。

最佳实践

1. 清晰的状态定义

使用TypedDict定义状态结构，确保类型安全和代码可读性。operator.add自动处理消息累积。

2. 模块化的节点设计

每个节点应该有明确的职责，便于测试和维护。推理节点只处理推理，行动节点只处理工具执行。

3. 适当的系统提示

系统提示应该清晰指导LLM的行为模式，明确ReAct循环的规则。

4. 错误处理

在工具调用中添加适当的错误处理机制，确保系统的健壮性。

5. 状态追踪

维护执行指标（LLM调用次数、循环步数），便于调试和性能分析。

与其他实现方式的对比

传统ReAct vs LangGraph ReAct

传统实现	LangGraph实现
手动状态管理	自动状态管理
需要手动控制流	声明式流程定义
容易出错的状态累积	operator.add自动累积
无内置验证	StateGraph.validate()验证
有限的可视化	内置图可视化能力
基础错误处理	增强的错误处理机制