LangGraph 介绍

数据智能老司机
1,060 阅读22分钟

LangGraph 是由 LangChain 创建的一个流行开源框架，帮助开发者利用大型语言模型（LLMs）构建复杂的、有状态且多参与者的应用程序。这种能力对于打造能够保留上下文、从交互中学习并持续进化的高级智能体架构至关重要。

LangGraph 的一个关键区别在于它突破了许多 LLM 框架中常见的有向无环图（DAG）结构的限制。有向无环图是一种在计算机科学和数学中常用的概念模型。它由有限个顶点（或节点）通过有向边连接组成，且关键约束是结构中不存在环或循环。换句话说，从任一节点出发沿有向边前进，永远不会回到起始节点。DAG 广泛应用于任务调度、数据处理流水线和依赖关系解析中，适合需要明确、单向流程的操作或数据流。

虽然 DAG 对许多应用非常有用，但在构建真正动态且自适应的 AI 智能体时存在局限。LangGraph 的创新之处就在于允许工作流中出现循环结构，从而支持迭代过程、反馈回路和递归行为——这些都是实现真正智能体行为的核心组成部分。

LangGraph 的架构灵感来自成熟的框架如 Pregel 和 Apache Beam，其公共接口借鉴了 NetworkX 的概念。这种融合带来了一个强大且易用的 AI 开发工具。虽然 LangGraph 设计时考虑了与 LangChain 和 LangSmith 的无缝协作，但它仍保持独立使用的灵活性，满足不同开发者的工具链偏好。

无论如何，理解 LangChain 的基础知识依然十分重要。这将是本章上半部分的重点内容，之后我们将深入探讨 LangChain 的工作原理。

将 LangChain 与 LangGraph 结合的优势

LangChain 与 LangGraph 的集成代表了人工智能开发领域的一次重大进步，构建了一个强大的生态系统，为开发者带来了前所未有的能力。这种协同融合了 LangChain 在大型语言模型（LLM）交互方面的丰富工具集与 LangGraph 复杂的有状态框架，形成了一个构建先进 AI 应用的综合解决方案。

该集成的核心优势在于更轻松、高效地处理复杂性。开发者现在可以创建能够管理复杂多步骤流程的 AI 代理，这些流程以前难以实现。这些代理具备更强的上下文感知能力，能够在多次交互中保持状态，从经验中学习并随着时间演进。这种动态适应性使得 AI 系统更加智能和响应迅速，能够以更高的复杂度处理各种任务。

这一组合框架还提供了简化的开发体验，尤其对已经熟悉 LangChain 的开发者极为有利。两个系统之间共享的概念和模式降低了学习门槛，使开发者能迅速利用 LangGraph 的高级功能。这种连续性加速了开发流程，实现复杂 AI 代理的快速创建和部署。此外，集成带来了更大的灵活性，开发者在解决具体 AI 挑战时拥有更多工具和方法可供选择。

集成的一个关键优势是增强的工作流管理能力。LangGraph 的循环工作流与 LangChain 强大的语言模型工具相辅相成，使 AI 代理能够实现复杂的反馈回路和迭代行为。这一特性对于创建能够根据持续交互和结果优化响应及调整策略的 AI 系统至关重要。

该集成方式提供的可扩展性也是一大亮点。随着 AI 应用复杂度和数据量的增长，集成框架提供了有效扩展所需的工具和结构。配合改进的错误处理机制，整体提升了 AI 系统的可靠性和稳健性。其模块化特性也使维护和更新更加便捷，帮助开发者构建更具复用性的组件。

从资源角度来看，LangChain 与 LangGraph 的整合促进了计算资源的更高效利用。这种优化有助于降低 AI 应用部署成本，使先进 AI 解决方案更易被更多项目和组织采用。该框架还拓展了潜在应用场景，使开发者能够应对更广泛的 AI 挑战，从简单的聊天机器人到需要细腻理解和推理的复杂决策系统。

复杂 AI 系统的测试和调试因这一集成方法而更易管理。组合框架提供了增强的工具来观察 AI 代理行为和排查复杂工作流的问题。这种改进提升了开发和质量保证流程，推动更可靠、高性能的 AI 应用诞生。

最后，集成提升了互操作性，简化了 AI 代理与外部系统和数据源的连接。这种扩展的连接能力为 AI 应用开辟了更多可能，使其能更无缝地融入现有技术生态系统，并利用更广泛的数据和功能。

总之，LangChain 与 LangGraph 的结合为开发者提供了一套全面的工具包，推动了 AI 开发的边界。它使得构建更复杂、适应性更强且具备上下文感知能力的 AI 应用成为可能，树立了智能系统的新标杆。随着这一集成方案的不断发展，它有望推动 AI 创新，开启机器智能及其在各领域实际应用的新篇章。

LangGraph 的优缺点

LangGraph 的一个突出特点是其对可控性的高度重视。作为一个底层框架，它为开发者提供了对操作流程和应用状态的细粒度控制。这种控制能力对于创建可靠且可预测的 AI 代理尤为重要，特别是在对精度和一致性有极高要求的场景中。开发者可以定义复杂的决策树，实施条件逻辑，并精确编排多步骤流程。

持久性是 LangGraph 的另一个关键优势。框架内置了在图的每一步之后自动保存状态的机制。这一功能为高级应用打开了无限可能，比如实现人机交互（human-in-the-loop）工作流，使人工操作员能够在关键节点介入、提供反馈或做出决策。持久性还便于错误恢复，开发者可以在任意时刻暂停并恢复图的执行，这对长时间运行的流程或对可靠性和容错性要求极高的场景尤为重要。

LangGraph 的设计理念借鉴了成熟框架如 Pregel 和 Apache Beam，其公共接口则采用了 NetworkX 的概念。这种多元融合造就了一个既强大又易用的 AI 开发工具。虽然 LangGraph 设计上能够无缝集成 LangChain 和 LangSmith，但它同样可以独立使用，给予不同工具链偏好的开发者更大灵活性。

该框架在流式输出支持方面表现尤为出色。图中每个节点生成结果时，都能实现实时流式传输，包括语言模型的逐令牌（token）流式输出。这一功能对打造响应迅速、交互性强的 AI 代理至关重要，使其能即时反馈并参与动态对话。

在更广泛的 AI 开发领域，LangGraph 代表了构建更复杂、有状态 AI 代理的重要进步。它通过提供实现循环结构、保障状态持久以及细粒度控制的工具，赋能开发者打造能处理复杂多步骤任务、维持长时间交互上下文、并适应变化环境的 AI 系统。这使其特别适合于会话式 AI、任务规划与执行以及多代理仿真等应用场景。

随着 AI 技术不断发展，并在各行业找到新的应用，像 LangGraph 这样的框架在连接大型语言模型原始能力与现实复杂需求之间发挥着关键作用。通过为构建有状态、自适应 AI 代理提供坚实基础，LangGraph 有望加速人工智能领域的创新，推动更强大、更可靠、更复杂的 AI 应用诞生。

图结构

LangGraph 将代理工作流建模为图（Graphs），其中代理的行为由三个核心组成部分定义。首先是 State（状态），表示应用的当前快照，可以是任何 Python 类型，但通常采用 TypedDict 或 Pydantic BaseModel 的形式。其次是 Nodes（节点），即 Python 函数，编码代理的逻辑，接受当前的 State 作为输入，执行计算或动作，并返回更新后的 State。最后是 Edges（边），也是 Python 函数，根据当前的 State 决定下一个要执行的节点，指导操作流程，通过条件分支或固定的转换进行跳转。

通过结合 Nodes 和 Edges，你可以创建复杂的循环工作流，使 State 随时间演进。LangGraph 的真正优势在于它如何管理这个 State，Nodes 和 Edges 都是以 Python 代码的形式运行——无论是集成大型语言模型（LLM）还是使用标准 Python 逻辑。

本质上，Nodes 执行具体任务，而 Edges 决定下一步操作。LangGraph 的底层图算法采用消息传递机制定义通用程序结构。当一个节点完成操作后，会沿其边发送消息给后续节点，后续节点接收消息并执行对应函数，再将结果消息传递出去。这个过程遵循类似谷歌 Pregel 系统的模式，以离散的“超级步”推进。每个超级步对应对图中所有节点的单次迭代，属于同一超级步的操作可并行执行，而顺序操作分布在不同超级步中。

图执行开始时，所有节点处于非活跃状态，只有当通过入边或通道接收到新消息（State）时才激活。激活的节点运行其函数并发送更新响应。超级步结束后，没有入消息的节点将标记为非活跃。图的执行在所有节点均非活跃且无消息在传递时结束。

StateGraph 类是主要的图类，以用户定义的 State 对象作为参数。相比之下，MessageGraph 是一种专门的图类型，其 State 仅为消息列表，使用场景较少，主要用于聊天机器人等对状态复杂度要求较低的应用。

构建图时，首先定义 State，然后添加节点和边，最后进行编译。编译是一个简单的过程，主要进行图的基础结构检查（如是否存在孤立节点等）。同时允许指定运行时参数，如检查点和断点。编译通过调用图对象的 .compile 方法完成。

接下来的章节中，我们将深入探讨 State、Nodes 和 Edges 三个核心概念。

状态（State）

状态包含定义如何应用更新的架构（schema）和归约器函数（reducers）。架构作为所有节点（Nodes）和边（Edges）的输入，可以是 TypedDict 或 Pydantic 模型。节点发出对状态的更新，然后使用指定的归约器函数处理这些更新。
架构通常用 TypedDict 定义，但也可以使用 Pydantic BaseModel 来支持默认值和额外的数据校验。默认情况下，图的输入和输出架构相同，但如果需要，尤其是在处理大量不同角色的键时，可以自定义。
归约器在应用状态更新时发挥关键作用。状态中的每个键都有一个独立的归约器函数，默认行为是用新更新覆盖原有键。例如，可以使用 Annotated 类型指定自定义归约器，如 operator.add，用于追加更新而非覆盖。
上下文通道允许管理共享资源，如数据库连接，这些资源在节点外部维护且不参与检查点保存。它们在图执行开始时初始化，结束时清理，确保执行过程中的资源高效管理。
在涉及聊天模型的应用中，状态中存储消息时，建议将对话历史存储为 Message 对象列表。通过在状态中添加消息键并用 operator.add 归约器，可以高效管理消息更新。或者，使用 add_messages 函数可以准确跟踪消息 ID，处理新增和更新消息，避免手动更新时重复添加。
add_messages 还支持将消息反序列化为 LangChain Message 对象，方便状态更新。你可以用点号访问消息，如 state["messages"][-1].content。

节点（Nodes）

节点通常是 Python 函数（同步或异步），第一个参数是状态，第二个可选参数是包含可配置参数（如 session_id）的“配置”对象。通过 add_node 方法将节点添加到图中。
示例：定义一个 process_data 函数，打印日志并返回修改后的状态：

from langchain_core.runnables import RunnableConfig
from langgraph.graph import StateGraph

builder = StateGraph(dict)

def process_data(state: dict, config: RunnableConfig):
    print("Processing data for session:", config["configurable"]["session_id"])
    state["output"] = f"Processed: {state['input']}"
    return state

def finalize_data(state: dict):
    state["status"] = "complete"
    return state

builder.add_node("process_data", process_data)
builder.add_node("finalize_data", finalize_data)

添加到图中的函数会自动转换为 RunnableLambda 对象，支持批处理、异步执行和内置跟踪调试。若不指定节点名，默认使用函数名作为节点名。
特殊节点 START 和 END 用于控制图内流程。START 指定用户输入入口点：

from langgraph.graph import START
builder.add_edge(START, "process_data")

END 是终止点，执行到该节点后不再有后续操作：

from langgraph.graph import END
builder.add_edge("finalize_data", END)

这些特殊节点帮助定义图结构，确保数据流有明确的起止。

边（Edges）

边有几种关键类型：

  • 普通边（Normal Edges）：直接连接两个节点。
  • 条件边（Conditional Edges）：通过函数根据当前状态决定下一执行节点。
  • 入口边（Entry Point）：指定接收用户输入时第一个执行的节点。
  • 条件入口边（Conditional Entry Point）：根据自定义逻辑函数选择初始执行节点。

一个节点可以有多条出边，表示所有目标节点将在下一超级步并行执行。

普通边添加示例：

graph.add_edge("step_one", "step_two")

条件边示例：

def routing_logic(state):
    return "step_two" if state["condition"] else "step_three"

graph.add_conditional_edges("step_one", routing_logic)
# 或映射函数输出
graph.add_conditional_edges("step_one", routing_logic, {True: "step_two", False: "step_three"})

入口边示例（连接虚拟 START 节点）：

from langgraph.graph import START
graph.add_edge(START, "initial_step")

条件入口边示例（根据状态动态选择起始节点）：

from langgraph.graph import START
def start_logic(state):
    return "initial_step" if state["start_here"] else "alternative_step"

graph.add_conditional_edges(START, start_logic, {True: "initial_step", False: "alternative_step"})

这种方式可根据传入数据动态控制流程，确保图的启动点最适合当前情境。

反思代理（Reflection Agent）

LangGraph中的反思代理是一种专门设计用来分析和评估自身决策与行为的代理，使其能够随着时间提升性能。不同于仅对输入做直接响应的反应型代理，反思代理增加了自我评估层，能够从过去的交互和结果中学习。这种自我反思能力对于需要持续优化的任务尤为关键，例如内容创作或策略开发。通过不断迭代决策，反思代理能够改进输出，随着时间推移达到更高质量的结果。

为了演示这一点，我们将创建一个改进推文的程序。

首先，安装所需库：

pip install --upgrade -q openai langchain langchain-openai langchain-community langgraph

然后导入相关模块：

from typing import TypedDict, Annotated, Sequence
from langgraph.graph import Graph, StateGraph
from langchain_openai import ChatOpenAI
from langchain_core.prompts import PromptTemplate
from langchain_core.output_parsers import StrOutputParser
  • TypedDict 用于创建预定义结构的字典，保证数据格式一致；
  • Annotated 用于给类型提示添加元数据或约束，增强工具或框架对类型的理解；
  • Sequence 表示有序集合（如列表或元组）。

Graph 和 StateGraph 是 LangGraph 的核心组件。

ChatOpenAI 用于集成 OpenAI 聊天模型，PromptTemplate 用于管理结构化提示，StrOutputParser 用于解析字符串输出。

接着初始化语言模型（LLM）：

llm = ChatOpenAI(model="gpt-4o-mini")

定义反思提示模板：

reflection_template = PromptTemplate.from_template(
    """
    Analyze the following tweet and provide a reflection on how it can be improved:
    Tweet: {tweet}
    Consider aspects such as clarity, engagement, and brevity. Provide specific suggestions.
    """
)

该模板用于分析推文并提出改进建议，重点关注清晰度、吸引力和简洁性。模板使用 {tweet} 作为动态占位符，便于运行时替换具体内容。

定义推文改进模板：

improve_tweet_template = PromptTemplate.from_template(
    """
    Given the original tweet and the reflection, provide an improved version of the tweet:
    Original tweet: {tweet}
    Reflection: {reflection}
    Improved tweet:
    """
)

该模板根据原始推文和反思内容生成改进后的推文，同样通过占位符动态填充。

定义节点函数：

def reflect(state: AgentState) -> AgentState:
    chain = reflection_template | llm | StrOutputParser()
    reflection = chain.invoke({"tweet": state['tweet']})
    state['reflection'] = reflection
    return state

此函数接收当前状态（包含待分析推文），通过提示链生成反思结果，并存储回状态中。

改进推文的节点函数：

def improve_tweet(state: AgentState) -> AgentState:
    chain = improve_tweet_template | llm | StrOutputParser()
    improved_tweet = chain.invoke({"tweet": state['tweet'], "reflection": state['reflection']})
    state['improved_tweet'] = improved_tweet
    return state

同样基于状态内容，生成改进后的推文并更新状态。

构建图工作流：

workflow = StateGraph(AgentState)
workflow.add_node("reflect", reflect)
workflow.add_node("improve_tweet", improve_tweet)
workflow.add_edge("reflect", "improve_tweet")
workflow.set_entry_point("reflect")
graph = workflow.compile()

添加反思与改进节点，并设置边连接，指定入口节点为反思节点。

创建执行函数：

def improve_tweet_with_reflection(tweet: str) -> str:
    result = graph.invoke({"tweet": tweet})
    return result['improved_tweet']

该函数执行图，输入原始推文，输出改进推文。

示例调用：

if __name__ == "__main__":
    original_tweet = "I think AI is cool and will change everything."
    improved_tweet = improve_tweet_with_reflection(original_tweet)
    print(f"Original tweet: {original_tweet}")
    print(f"Improved tweet: {improved_tweet}")

打印原始和改进后推文，观察优化效果。

此外，可以生成图形化工作流展示（依赖可选库）：

from IPython.display import Image, display
try:
    display(Image(graph.get_graph().draw_mermaid_png()))
except Exception:
    pass

该代码用 Mermaid 图表形式直观展示工作流结构。

图 9-1 展示了该图形界面效果。

image.png

持久化（Persistence）

持久化是AI工作流中的关键特性，尤其适用于需要跨多次交互保持上下文的应用。在LangGraph中，持久化指的是能够在图中各节点执行完毕后存储和恢复图的状态。这意味着AI代理能够“记住”之前的操作，使其在中断后或不同会话之间能够从上次中断的地方继续。这对需要频繁用户输入的应用尤为重要，因为代理的状态可以被保存并恢复，确保不会丢失任何进度。

LangGraph通过一种称为checkpointer的功能，提供了将状态数据存储到多种持久化存储系统（如SQLite、Postgres或MongoDB）的简便方法。当代理暂停时（无论是等待用户输入还是其他事件），其状态会被保存，以便后续恢复处理。持久化不仅提升了调试和历史追踪的能力，还支持多用户会话，是打造健壮生产级AI应用的必备特性。借助LangGraph的checkpointers，无论交互发生何种情况，应用都能无缝高效地续接之前的进度。

以下是一个演示持久化功能的示例程序，场景为旅游预订助手。

环境准备：

from langgraph.graph.message import add_messages

add_messages用于将消息合并追加，以状态化方式处理聊天消息，确保图处理交互时消息串联正确。

定义工具函数：

from langchain_core.tools import tool

@tool
def book_flight(destination: str):
    """预订指定目的地的航班。"""
    return {"confirmation": "FL12345", "destination": destination}

@tool
def book_hotel(location: str):
    """预订指定地点的酒店。"""
    return {"confirmation": "HT98765", "location": location}

@tool
def book_car_rental(location: str):
    """预订指定地点的租车服务。"""
    return {"confirmation": "CR56789", "location": location}

tools = [book_flight, book_hotel, book_car_rental]

@tool装饰器将普通Python函数转为可被AI代理调用的“工具”，使其能在LangChain或LangGraph环境中执行。这里定义了三个旅行相关的工具：航班预订、酒店预订和租车预订。

设置OpenAI模型：

from langchain_openai import ChatOpenAI
model = ChatOpenAI(temperature=0, streaming=True)
bound_model = model.bind_tools(tools)

创建工作流相关函数：

from typing import Literal

def should_continue(state: TravelState) -> Literal["action", "__end__"]:
    last_message = state["messages"][-1]
    if not last_message.tool_calls:
        return "__end__"
    return "action"

def call_model(state: TravelState):
    response = model.invoke(state["messages"])
    return {"messages": response}
  • should_continue函数判断是否继续执行，若最后消息无工具调用则结束，否则继续。
  • call_model函数调用模型生成回复。

构建工作流及节点：

from langgraph.graph import StateGraph, START
from langgraph.prebuilt import ToolNode

tool_node = ToolNode(tools)
workflow = StateGraph(TravelState)

workflow.add_node("agent", call_model)
workflow.add_node("action", tool_node)

workflow.add_edge(START, "agent")
workflow.add_conditional_edges("agent", should_continue)
workflow.add_edge("action", "agent")
  • ToolNode负责执行旅行预订工具。
  • 图从START节点开始，经agent节点决定动作，再到action节点执行工具，然后循环往复。

设置持久化内存：

from langgraph.checkpoint.memory import MemorySaver

memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

MemorySaver提供内存中状态存储，保证状态跨交互持久保存。

模拟用户与AI的对话：

from langchain_core.messages import HumanMessage

config = {"configurable": {"thread_id": "2"}}

input_message = HumanMessage(content="Hello, I want to book a flight to New York?")
for event in app.stream({"messages": [input_message]}, config, stream_mode="values"):
    event["messages"][-1].pretty_print()

input_message = HumanMessage(content="I also want to book a hotel room.")
for event in app.stream({"messages": [input_message]}, config, stream_mode="values"):
    event["messages"][-1].pretty_print()
  • HumanMessage表示用户输入。
  • 通过thread_id维护会话上下文，确保对话连贯。

输出示例：

Human: Hello, I want to book a flight to New York?
AI: Great! When would you like to travel to New York and from which city would you be departing?
Human: I also want to book a hotel room.
AI: Of course! Would you like assistance in finding a hotel in New York as well? If so, what are your preferences for the hotel such as budget, location, amenities, etc.?

如你所见，AI能够识别上下文中的城市信息，实现了跨节点和LLM调用的状态持久化。

LangSmith

LangSmith 是一个强大的平台，旨在帮助构建可用于生产环境的大型语言模型（LLM）应用。它简化了开发者对复杂系统的管理，使你能够密切监控应用的性能和进展，从而更自信、更快速地完成部署。LangSmith 能无缝集成 LangChain 和 LangGraph，同时也支持独立运行，提供了灵活且可靠的框架来处理 LLM 解决方案。

由于 LLM 本身具有概率性，响应结果往往不可预测，且基于自然语言提示可能产生不一致的输出，这给开发带来了挑战。

LangSmith 的核心功能包括追踪和调试，提供详细的应用运行日志，帮助开发者全面理解操作流程并迅速定位问题。平台还提供强大的评估和测试工具，支持构建输入与预期输出的数据集，以实现自动化和手动评测。在生产环境中，LangSmith 可实时监控关键指标，如延迟、成本和用户反馈，确保问题被及时发现和处理。

协作功能也是其重点之一，LangSmith 支持注释和反馈，方便团队共享见解，提升调试和评估效果。此外，平台提供版本管理与对比工具，用户可以并排分析不同应用版本，追踪变更历史。

LangSmith 提供三种定价方案，满足不同用户需求：

  • Developer 计划：免费，支持单用户，每月提供 5000 次免费追踪，超出部分每次收费 0.05 美元。
  • Plus 计划：每用户每月 39 美元，提供 10000 次免费追踪，超出部分同样收费。
  • Enterprise 企业方案：定制价格，包含单点登录（SSO）、多种部署选项及专属支持。

所有方案均支持调试、测试和监控等核心功能，团队版还额外提供协作与安全性增强。

你可以访问以下网址注册 LangSmith 服务：smith.langchain.com。图 9-2 展示了平台的仪表盘界面。

image.png

它被划分为不同的部分，如项目（Projects）、数据集与测试（Datasets & Testing）、标注队列（Annotation Queues）和提示（Prompts）。
要获取 API 密钥，请在仪表盘左侧选择“设置”图标，然后选择“创建 API 密钥”。你有两个选项：一个是个人访问令牌（Personal Access Token），适用于单个用户；另一个是服务密钥（Service Key），适用于更高级的功能。
对于我们的用途，选择个人访问令牌即可。
接下来，在终端执行以下命令：

export LANGCHAIN_TRACING_V2=true
export LANGCHAIN_API_KEY=<your-api-key>

这样就能连接到 LangSmith。返回仪表盘后，你可以使用各种功能来追踪、调试和监控代理。

Assistant-UI

Assistant-UI（www.assistant-ui.com/docs）是一个基于React 的组件库，用于构建类似聊天机器人的用户界面。它支持与 LangGraph Cloud 集成。你可以用它创建新项目，也可以将其集成到已有的 React 项目中，利用各种组件。

实现很简单。首先，创建一个新项目的方法是：

npx assistant-ui@latest create my-app
cd my-app

然后，为了添加用于访问 OpenAI 的 API 密钥，在项目中新建一个 .env 文件，内容如下：

OPENAI_API_KEY="sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

运行应用程序，使用以下命令（和普通 React 应用相同）：

npm run dev

这会显示一个聊天代理界面的骨架，正如图 9-3 所示。

image.png

LangGraph Studio

LangGraph Studio（github.com/langchain-ai/langgraph-studio）是一款用于原型设计和调试 LangGraph 应用的桌面应用程序。它提供了可视化的方式来交互、编辑和调试代理工作流，还支持逐步执行和人机交互（human-in-the-loop），并与 LangSmith 集成。目前该应用支持 macOS 和 Windows（即将支持 Linux），安装时需要使用 Docker。此应用目前处于测试阶段，免费提供。图 9-4 展示了该应用的仪表盘界面。

image.png

结论

LangGraph 是构建具备状态感知和自适应能力的代理的有效工具，能够处理复杂的工作流程。它在创建循环结构、实现持久化以及提供细粒度控制方面展现出高度灵活性，使开发者能够突破传统有向无环图（DAG）框架的限制。将 LangGraph 与 LangChain 结合使用，开发者将获得一个全面的生态系统，从而简化高级 AI 系统的构建，这些系统能够实现持续学习和动态交互。

avatar
文章
阅读
粉丝