【Agent】LangGraph入门教程：基础理论（1）

转载 已于 2025-04-23 21:33:43 修改 · 839 阅读 · 3 ·
CC 4.0 BY-SA版权
原文链接：https://www.cnblogs.com/ssyfj/p/18308248
文章标签：

#大模型 #人工智能

于 2025-04-22 17:02:55 首次发布
该文章已生成可运行项目，

文章目录

本文内容主要转载自：

一、LangGraph入门

LangGraph 是基于 LangChain 构建的多智能体协作框架，专为构建复杂、动态的智能体工作流而设计。它采用图结构（Graph）建模任务流程，将多个智能体（Agent）作为节点，通过有向边定义交互逻辑，支持循环、分支、异步等控制模式。

（1）主要功能

  • 循环和分支: 在应用程序中实现循环和条件语句。
  • 持久性: 在图中的每个步骤之后自动保存状态，支持暂停和恢复执行，适用于错误恢复、“人机交互”工作流、时间旅行等场景。
  • 人机交互: 中断执行以批准或编辑代理计划的下一个动作。
  • 流支持: 在每个节点产生输出时流式传输输出（包括令牌流式传输）。
  • 与 LangChain 集成: LangGraph 与 LangChain 和 LangSmith 无缝集成（但不需要它们）。

（2）核心特性

  • 可视化编排，允许开发者通过API或UI拖拽编排智能体协作链路；
  • 状态管理，内置持久化上下文存储，支持智能体间的增量式信息传递；
  • 弹性扩展，可集成LLM、工具、人类反馈等异构节点。

（3）应用场景
典型应用场景包括自动化决策系统、多角色模拟仿真、复杂任务分解执行等，显著提升智能体系统的可解释性和任务处理上限。

1.1 Chain：线性执行的顺序链

LangChain的核心优势在于其能够轻松构建自定义链，这些链通常是线性的，类似于有向无环图（DAG），每个步骤都严格按顺序执行，每个任务只有一个输出和一个后续任务，形成一个没有循环的线性流程。
在遇到复杂任务时，比如第一次搜索没有找到想要的内容，我们可能需要进行第二次、第三次搜索，甚至可能需要调用网络搜索来完成。在这种情况下，顺序执行的任务（DAG）显然无法满足需求。
请求方和搜索方之间需要经历多次来回沟通，请求方可能会要求搜索方根据反馈调整搜索策略，这种多次的循环沟通才能逐步逼近最终答案。

1.2 LangChain代理：循环图，但是无法控制

这种情况下，我们需要的不再是DAG，而是一个循环图，它能够描述多个参与者之间的多轮对话和互动，以确认最终的答案。这种循环图能够处理更模糊、更复杂的用例，因为它允许系统根据反馈进行调整和迭代。那么，在循环图的运行模式就是智能代理，也就是AI Agent。

在这里插入图片描述

1.3 LangGraph，可以对智能代理进行更多的控制

在实际应用过程中，我们发现需要对智能代理进行更多的控制。例如，我们可能希望智能代理始终首先调用特定工具，或者我们可能希望对工具的调用方式有更多的控制，甚至可能希望根据智能代理的状态使用不同的提示。为了解决这些问题，LangGraph提出了 “状态机” 的概念。通过状态机为图创建对应的状态机，这种方法可以更好地控制智能代理的行动流程，使其更加灵活和有效地处理复杂任务。

补充：LangChain代理和LangGraph对比
在这里插入图片描述

二、LangGraph概念

2.1 StateGraph（状态图）

StateGraph是一个类，它负责表示整个图的结构；需要通过传入一个状态定义来初始化这个类（图状态），这个图状态代表了一个中心状态对象，它会在执行过程中不断更新。这个图状态对象由图中的节点更新，节点会以键值对的形式，返回对状态属性的操作。
状态对象的属性可以通过两种方式更新，在定义图状态的时候，需要指定属性的更新方式：（可以有多个属性，每个属性需要单独指定一种更新方式）

  • 覆盖更新：如果一个属性需要被新的值替换，我们可以让节点返回这个新值进行替换。
  • 增量更新：如果一个属性是一个动作列表（或类似的操作），我们可以在原有的列表上添加新的动作。

下面以旅行为例，具体步骤如下：

  1. 输入目的地（Edges里面的起始边）
  2. 任务规划，包括预定航班、预订酒店（Nodes里面的各个节点）
  3. 任务规划之间是有关联关系的，比如航班夜晚，我们就不要酒店了，航班改中间位置就要修改酒店地址，之间有因果关系（Edges里面的边，分为普通边和条件边，普通边就是任务有序执行，条件边就是可能根据情况不一样）
  4. StateGraph类就是这样的旅行计划，而节点就像是规划旅行的不同步骤，比如确定目的地、预定航班和预定酒店。每个步骤都会更新你的旅行计划，可能是完全替换旧的计划，也可能是添加新的信息到现有的计划中

2.2 Nodes（节点）

创建了StateGraph之后，需要向其中添加节点；每个节点都代表一个任务，它们执行的结果会影响StateGraph的状态。这些节点通过边相互连接，形成了一个有向无环图（DAG），确保了任务的正确执行顺序。

在 LangGraph 中，节点通常是 Python 函数（同步或 async），其中第一个位置参数是状态。（可选地），第二个位置参数是"配置"，包含可选的可配置参数（例如 thread_id）。

类似于 NetworkX，您可以使用 add_node 方法将这些节点添加到图形中。

在上面旅行计划的例子中：

  • Nodes（节点）就好像旅行计划中需要完成的任务，例如：预定航班、预订酒店。
  • Nodes（节点）接受旅行计划（图状态对象）作为输入，并输出一个更新后的任务状态，例如：完成酒店的预订

2.2.1 START节点

START 节点是一个特殊节点，它代表将用户输入发送到图形的节点。引用此节点的主要目的是确定哪些节点应该首先被调用。

from langgraph.graph import START

graph.add_edge(START, "my_node")
graph.add_edge("my_node", "other_node")

注意：使用 add_edge 函数添加 START节点，即 入口节点。

2.2.2 END节点

END 节点是一个特殊节点，它代表一个终端节点。当您想要指定哪些边在完成操作后没有动作时，会引用此节点。

from langgraph.graph import END

graph.add_edge("other_node", END)

2.3 Edges（边）

Edges（边）是连接Nodes（节点）并定义StateGraph（状态图）中节点执行顺序的关键部分。边主要分为以下几种：

  • 普通边（Normal Edges）：这些边表示一个节点总是要在另一个节点之后被调用。在旅行计划中，普通边就像是确定了任务执行的顺序。例如，在找到合适的航班之后，你可能会决定预订酒店。这个顺序确保了任务的有序执行。
  • 条件边（Conditional Edges）：使用函数（通常由LLM提供）来确定首先调用哪个节点。在旅行计划中，条件边就像是根据你的喜好或者天气情况来决定你的下一步行动。比如，如果你发现没有合适的航班，你可能会选择推迟预订酒店，而去查找火车车票。条件边提供了灵活性，使得系统可以根据不同的情况来调整执行的顺序。
  • 起始边（Starting Edge）：作为图的开始。比如在旅行计划中，起始边就是确定你的目的地。一旦目的地被确定，你的旅行计划就可以开始执行了。

边定义了节点之间的依赖关系和执行顺序。起始边确定了图的开始，普通边确保了任务的正确执行顺序，而条件边则根据特定的条件来决定下一步的操作。

2.3.1 普通边

如果您总是想从节点 A 到节点 B，您可以直接使用 add_edge 方法。

graph.add_edge("node_a", "node_b")

2.3.2 条件边

如果您想选择性地路由到一个或多个边（或选择性地终止），您可以使用 add_conditional_edges 方法。此方法接受节点的名称和一个"路由函数"，该函数将在该节点执行后被调用。

graph.add_conditional_edges("node_a", routing_function)

类似于节点，routing_function 接受图形的当前 state 并返回一个值。

在这里插入图片描述

在上图中，routing_function 作为条件边的判定条件，如果返回True，则执行node_b，如果返回False，则执行node_c）

默认情况下，返回值 routing_function 用作要将状态发送到下一个节点的节点名称（或节点列表）。所有这些节点将在下一个超级步骤中进行运行。

您可以选择提供一个字典，该字典将 routing_function 的输出映射到下一个节点的名称。

graph.add_conditional_edges("node_a", routing_function, {True: "node_b", False: "node_c"})

2.3.2 入口点

入口点是图形启动时运行的第一个节点。您可以从虚拟的START节点使用add_edge方法到要执行的第一个节点，以指定进入图形的位置。

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

2.3.3 条件入口点

条件入口点允许您根据自定义逻辑从不同的节点开始。您可以从虚拟的START节点使用add_conditional_edges来实现这一点。

from langgraph.graph import START

graph.add_conditional_edges(START, routing_function)

您可以选择提供一个字典，该字典将 routing_function 的输出映射到下一个节点的名称。

graph.add_conditional_edges(START, routing_my,(True: "my_node", False: "other_node"))

2.4 checkpoint（检查点）

LangGraph 具有一个内置的持久化层，通过 checkpoint（检查点）实现。当您将检查点与图形一起使用时，您可以与该图形的状态进行交互。当您将检查点与图形一起使用时，您可以与图形的状态进行交互并管理它。检查点在每个超级步骤中保存图形状态的检查点，从而实现一些强大的功能。

  • 首先，检查点通过允许人类检查、中断和批准步骤来促进人机交互工作流工作流。检查点对于这些工作流是必需的，因为人类必须能够在任何时候查看图形的状态，并且图形必须能够在人类对状态进行任何更新后恢复执行。

  • 其次，它允许在交互之间进行"记忆"。您可以使用检查点创建线程并在图形执行后保存线程的状态。在重复的人类交互（例如对话）的情况下，任何后续消息都可以发送到该检查点，该检查点将保留对其以前消息的记忆。

许多 AI 应用程序需要内存来跨多个交互共享上下文。在 LangGraph 中，通过 checkpoint（检查点）为任何 StateGraph 提供内存。

在创建任何 LangGraph 工作流时，您可以通过以下方式设置它们以持久保存其状态：

  1. 一个 检查点，例如 AsyncSqliteSaver
  2. 在编译图时调用 compile(checkpointer=my_checkpointer)。

二、LangGraph使用案例

2.1 使用步骤

  1. 初始化模型和工具（Model and Tool）

    • 使用 ChatOpenAI 作为 LLM，并通过 .bind_tools() 方法将 LangChain 工具转换为 OpenAI 工具调用格式。
    • 定义要使用的工具（例如搜索工具），并支持自定义工具。

  2. 用状态初始化图（StateGraph）

    • 通过传递状态模式（如 MessagesState）初始化图（StateGraph）。
    • MessagesState 是预构建的状态模式，包含 LangChain Message 对象列表，并定义了节点更新合并逻辑。

  3. 定义图节点（Node）

    • agent 节点：决定是否采取行动。
    • tools 节点：若代理决定行动，则执行该行动。

节点的主要作用是调用函数，执行一个具体的功能。

  1. 定义入口点和图边
  • 首先，我们需要设置图执行的入口点——agent 节点。
  • 然后，我们定义一个普通边和一个条件边。条件边意味着目的地取决于图状态（MessageState）的内容。在本例中，目的地在代理（LLM）决定之前是未知的。

    • 条件边：调用代理后，我们根据条件选择执行
      a. 如果代理说要采取行动，则运行工具
      b. 如果代理没有要求运行工具，则完成（回复用户）。

    • 普通边：调用工具后，图应该始终返回到代理以决定下一步操作。

下面我们来看一个简单的状态图：在这里插入图片描述

  • 节点：start, agent, tools, end
  • 虚线：条件边
  • 实线：普通边
  1. 编译图
  • 当我们编译图时，会将其转换为LangChain Runnable，这使得可以使用.invoke()、.stream()和.batch()方法来调用输入。
  • 我们还可以选择传递检查点对象，以在图运行之间持久化状态，并支持内存、"人机交互"工作流、时间旅行等功能。在本例中，我们使用MemorySaver——一个简单的内存中检查点。
  1. 执行图
  • LangGraph 将输入消息添加到内部状态，然后将状态传递给入口点节点 “agent”。
  • “agent” 节点执行，调用聊天模型。
  • 聊天模型返回 AIMessage。LangGraph 将其添加到状态中。
  • 图循环以下步骤，直到 AIMessage 上不再有 tool_calls：
    • 如果 AIMessage 具有 tool_calls，则 “tools” 节点执行。
    • “agent” 节点再次执行并返回 AIMessage。
  • 执行进度到特殊的 END 值，并输出最终状态。因此，我们得到所有聊天消息的列表作为输出。

2.2 代码实例

  • 实例一：状态图stateGraph和节点node的使用（不含图状态和注解）

实现功能：随着图的运行，x的值每次加1，y的值每次减1，z的值为10不变。

from langgraph.graph import START, StateGraph

#1.不涉及model和tool

#2.不涉及图状态

#3.定义图节点，定义节点需要设置一个节点的action（函数）
def my_node(state):
    return {"x": state["x"] + 1, "y": state["y"]-1, "z":10}

#4.不需要条件边

#5.定义工作流状态图
builder = StateGraph(dict)  #注意：没有传入图状态，dict默认全部input的字段都作为图状态属性传入，比如后面的x,y都是StateGraph的state
builder.add_node("my_node", my_node)   #添加节点
builder.add_edge(START, "my_node") #添加起始边

#6.编译
graph = builder.compile()   
step1 = graph.invoke({"x": 1, "y":2})
print(step1)

输出如下：

{'x': 2, 'y': 1, 'z': 10}

在上面的代码中，我们基于 state 实现状态的传递。通过debug，可以看到 state 是一个包含 key 和 value 的字典，state = {'x': 1, 'y': 2}，通过该字典实现参数的传递。

如果我们尝试更新节点的action，会发现每一步的图状态更新和节点的返回结果相关：

def my_node(state):
    return {"x": state["x"] + 1}
  • 实例二：状态图stateGraph和节点node的使用（包含图状态和注解）
from langchain_core.runnables import RunnableConfig
from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph

#1.不涉及model和tool


#2.定义图状态
def reducer(a: list, b: list | None) -> list: #进行追加
    if b is not None:
        return a + b
    return a

class State(TypedDict): #这里是图中状态的定义,也是标识运行时的input中哪些字段可以透传给状态图
    #https://blog.youkuaiyun.com/randy521520/article/details/133826255
    x: Annotated[list, reducer] #Annotated: 用于添加类型注解的装饰器。可以在类型提示中添加额外的元数据信息；这里表示更新list数据的时候，通过reducer方法进行更新（第一个参数时原数据list，第二个参数是要更新的数据int）

class ConfigSchema(TypedDict):  #这里是标识运行时的RunnableConfig中哪些字段可以透传给状态图
    r: float

#3.定义图节点，定义节点需要设置一个节点的action（函数）
def node_runner(state: State, config: RunnableConfig) -> dict: #传入图状态，可以进行修改；还可以传入config，config在调用时传递，同时还需要在创建状态图时再声明哪些变量可以传递到图中
    r = config["configurable"].get("r", 1.0) #从config中获取配置字段值
    print(state["x"])
    x = state["x"][-1] #获取最新的状态
    next_value = x * r * (1 - x)    #随便的操作
    return {"x": [next_value],"y":10}    #注意：返回的值，会通过注解里面的reducer进行更新（作为第二个参数），所以类型要一致
    
#4.不需要条件边

#5.定义工作流状态图,没有边
graph = StateGraph(State, config_schema=ConfigSchema)
graph.add_node("A", node_runner) #添加节点，包括节点的action
graph.set_entry_point("A")  #设置进入节点
graph.set_finish_point("A")  #设置结束节点

#6.编译
compiled = graph.compile()
step1 = compiled.invoke({"x": [0.5,1],"y":0.3}, {"configurable": {"r": 3.0}})
print(step1)

输出如下：
在这里插入图片描述

可以看到，我们显式定义了图状态里面的属性后，节点返回的数据在更新图状态时只会去获取图状态定义中的字段进行更新

  • 实例三：包含了model和tool的使用

这里用到了一个新的模型anthropic.claude-3-5-sonnet，Claude 3 是一系列最先进的人工智能（AI）模型，可让您根据自己的需求，从智能、速度和成本方面考虑选择最适合的组合。并且该模型能够可靠地从图像等非结构化数据中提取信息。
https://docs.anthropic.com/zh-CN/docs/intro-to-claude

from typing import Literal

from langchain_core.messages import ToolMessage
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.checkpoint import MemorySaver
from langgraph.graph import END, StateGraph, MessagesState
from langgraph.prebuilt import ToolNode
from langchain.prompts import MessagesPlaceholder,ChatPromptTemplate

#1.初始化model和tools，可以通过agent关联models和tools
@tool
def search(query: str):
    """Call to surf the web."""
    # This is a placeholder, but don't tell the LLM that...
    if "sf" in query.lower() or "san francisco" in query.lower():
        return ["It's 60 degrees and foggy."]
    return ["It's 90 degrees and sunny."]

tools = [search]

prompt = ChatPromptTemplate.from_messages(
                [
                    ("system", "You are a helpful assistant"),
                    MessagesPlaceholder("chat_history", optional=True),
                    ("human", "{messages}"),
                    MessagesPlaceholder("agent_scratchpad", optional=True),
                ]
            )

#model在这里用于选取tools
model = prompt | ChatOpenAI(model="gpt-3.5-turbo", temperature=0).bind_tools(tools)

#2.定义图状态，这里使用的MessagesState，属性如下：
# class MessagesState(TypedDict):
#     messages: Annotated[list[AnyMessage], add_messages]

# 3.定义图节点
# tool_node = ToolNode(tools) 这也是一种方法，定义tool和model的运行action
tools_by_name = {tool.name: tool for tool in tools}
def tool_node(state: dict):
    result = []
    for tool_call in state["messages"][-1].tool_calls:
        tool = tools_by_name[tool_call["name"]]
        observation = tool.invoke(tool_call["args"])
        result.append(ToolMessage(content=observation, tool_call_id=tool_call["id"]))
    return {"messages": result}

def call_model(state: MessagesState):
    response = model.invoke(state)
    return {"messages": [response]} #add_messages兼容list和非list，都会转成list

# 4.定义边的逻辑判断（条件边），判断是否继续
def should_continue(state: MessagesState) -> Literal["tools", "__end__"]: #Literal用于限制返回的值的可选值
    messages = state['messages']
    last_message = messages[-1]
    if last_message.tool_calls: #判断models是否返回tools调用，有则告诉调用tools节点，否则结束
        return "tools"
    return END

# 5.定义工作流状态图
# 5.a.通过图状态初始化工作流
workflow = StateGraph(MessagesState)

# 5.b.添加节点、边
workflow.add_node("agent", call_model)
workflow.add_node("tools", tool_node)

workflow.set_entry_point("agent")
workflow.add_conditional_edges(
    "agent",
    should_continue,    #判断下一个调用的节点
)

workflow.add_edge("tools", 'agent')

# 5.c.编译工作流成一个runnable，通过invoke调用
app = workflow.compile()

# 6.执行状态图
final_state = app.invoke(
    {"messages": "what is the weather in sf"},
    config={"configurable": {"thread_id": 42}}
)

print(final_state["messages"][-1].content)

输出如下：
在这里插入图片描述

参考资料

本文章已经生成可运行项目
LangGraph 入门与实战
张伟的专栏
03-25 4338
工具的定义，可以参考这篇文章，写的比较详细了，比较方便的就是使用 tools 这个注解。雨飞：使用智普清言的Tools功能实现ToolAgentLangGraph 中最基础的类型是 StatefulGraph，这种图就会在每一个Node之间传递不同的状态信息。然后每一个节点会根据自己定义的逻辑去更新这个状态信息。具体来说，可以继承 TypeDict 这个类去定义状态，下图我们就定义了有四个变量的信息。input:这是输入字符串，代表用户的主要请求。
LangSmith与LangGraph深度解析：构建下一代AI Agent的基石
weixin_51702416的博客
05-20 1697
LangSmith与LangGraph不仅代表着技术工具的进步，更预示着一个新纪元的开启：当AI系统的开发过程变得完全透明可控，当复杂认知任务的编排如同搭积木般简单，人类终于站在了构建可靠智能系统的门槛之上。这两个组件的演化轨迹，正勾勒出未来AGI开发平台的雏形——在这里，每个开发者都能像指挥交响乐团般，优雅地驾驭智能的洪流。
LangGraph教程（一）：入门从0到1（零基础）
新人制作，若有问题，请私聊我，或评论区
09-04 964
LangGraph入门指南：从零到一构建自动化流程 本文用厨房流水线比喻，通俗讲解LangGraph核心概念： 核心组件：图（流程图）、节点（步骤）、边（箭头）、状态（共享数据） 最小实例：构建一个复读机器人，展示基本运行流程 进阶功能： 节点串联（文本大写转换） 条件边实现流程控制（识别quit指令） 状态管理（计数器自动累加） 通过多个可运行代码示例（复制即用），演示了如何： 定义状态类型 创建功能节点 构建流程图 实现条件跳转 使用注解实现自动状态累加 每个概念都配有厨房类比，无需前置知识，适合零基础
【收藏必备】LangGraph构建AI智能体：从零开始打造你的大模型应用系统
最新发布
2401_85154887的博客
10-08 774
本文介绍了LangGraph作为LangChain的扩展，如何帮助开发者构建有状态、多角色、可循环计算的AI智能体。文章通过太阳能板节能计算示例，详细展示了LangGraph的核心概念（状态、节点、边）及其在复杂多步任务中的优势。提供了从环境配置、工具定义到工作流构建的完整实现代码，帮助开发者掌握使用LangGraph打造智能、自适应AI系统的技能，适用于客户支持、能源管理等多种应用场景。
LangGraph入门教程
xnuscd的博客
10-16 2835
langgraph入门
从零开始：LangGraph初学者指南！构建你的第一个AI Agent！
xx_nm98的博客
01-09 3442
AI发展飞快！只有动手了，才知道里面会遇到什么问题，才能知道，底层原理是什么！
LangGraph 快速入门
General_zy的博客
05-31 1582
LangGraph简介 LangGraph是由LangChain团队开发的开源框架，专为构建具有状态管理和多智能体协作能力的应用而设计。核心功能包括： 图结构工作流：通过StateGraph组织任务流程，包含节点(Node)和边(Edge)定义执行逻辑 持久化状态管理：支持长时间运行任务的恢复和人工干预 开发工具集成：与LangSmith配合提供可视化调试功能 主要优势： 处理复杂多轮对话 支持多智能体协作 实现生产级部署 应用场景： 客户服务自动化 智能推荐系统 文档处理流程 安装简单： pip inst
深入浅出LangChain AI Agent智能体开发教程（一）—认识LangChain&LangGraph
weixin_42782643的博客
07-15 913
本篇分享从LangChain&LangGraph的核心概念、核心特性、与其它框架的对比以及热门项目四个方面带大家详细了解了LangChain和LangGraph框架特性，为后期系列分享奠定理论基础。
使用LangGraph构建多Agent系统架构？
2501_91383091的博客
04-02 1014
Agent是一个使用大语言模型决定应用程序控制流的系统。随着这些系统的开发，它们随时间推移变得复杂，使管理和扩展更困难。Agent拥有太多的工具可供使用，对接下来应该调用哪个工具做出糟糕决策上下文过于复杂，以至于单个Agent无法跟踪系统中需要多个专业领域（例如规划者、研究员、数学专家等）。为解决这些问题，你可能考虑将应用程序拆分成多个更小、独立的代理，并将它们组合成一个多Agent系统。这些独立的Agent可以简单到一个提示和一个LLM调用，或者复杂到像一个ReActAgent（甚至更多！使用。
【LLM大模型】AI Agent 终结者 LangGraph！
2301_81887304的博客
10-07 1140
LangGraph是一个用于构建具有状态、多参与者应用程序的大语言模型（LLM）的库，用于创建智能体和多智能体的工作流程。
探索LangGraph：构建多专家协作模型
lhx17673139267的博客
07-13 1351
现在是我们开始构建图的时候了。和以前一样，我们将从一个节点开始，用用户的当前信息预填充状态。现在，让我们开始构建我们定制的工作流程。enter_*: 使用你之前定义的工具来创建一个ToolMessage，这个ToolMessage表明新的专业助手已经接管了工作。助手: 这个由提示和大型语言模型（LLM）组成的模块会根据当前状态来决定是使用一个工具、向用户提问还是结束整个工作流程（返回到主助手）。: 这些是助手可以在不需要用户确认的情况下使用的“只读”工具。
LangGraph 入门教程：从单节点到条件分支，并行节点
Harry的博客
08-17 1156
单节点工作流—— 最小可运行示例。多节点顺序执行—— 构建处理链路。条件分支—— 根据输入动态走不同路径。并行执行—— 多个节点同时运行，最后汇合结果。这三种能力基本覆盖了大多数应用场景。并行节点：让多个节点同时运行。循环逻辑：实现循环处理，直到满足条件。结合 LLM：在节点中调用大语言模型，构建智能对话 Agent。LangGraph 的图式工作流思想能让你的代码更直观、可维护，是构建复杂 AI 应用的利器。
一步步教你LangGraph Studio：可视化调试基于LangGraph构建的AI智能体
热门推荐
m0_63171455的博客
09-29 1万+
之前我们在第一时间介绍过使用LangChain的LangGraph开发复杂的RAG或者Agent应用，随着版本的迭代，LangGraph已经成为可以独立于LangChain核心，用于开发多步骤、面向复杂任务、支持循环的AI智能体的强大框架。近期LangGraph推出了一个使得复杂AI智能体开发更加高效的工具：LangGraph Studio，一个为可视化测试与调试基于LangGraph构建的AI智能体而设计的集成环境。本文将带领大家初步探索这个新的工具。1. 回顾LangGraph并创建测试智能体LangG
LangGraph 官方文档翻译 1 - 快速入门及示例教程（聊天、工具、记忆、人工干预、自定义状态、时间回溯）
AI工程化、开源分享、文档翻译、代码笔记
05-16 4467
LangGraph 快速入门 前提条件 1、安装依赖项 2、创建智能体 3、配置大语言模型 4、添加自定义提示 5、添加记忆功能 6、配置结构化输出 后续步骤 概述 学习 LangGraph 基础知识 构建基础聊天机器人 先决条件 1、安装软件包 2、创建 `StateGraph` 3、添加节点 配置模型 集成模型到节点 4、添加 `entry` 入口点 5、编译计算图 6、可视化图表（可选） 7、运行聊天机器人 后续步骤 添加工具 先决条件 1、安装搜索引擎 2、配置环境 3、定义工具 4、定义流程图
LangGraph 实战教程：构建自定义 AI 工作流
2401_84204413的博客
05-09 2575
LangGraph 是 LangChain 生态系统的一部分，专门用于构建基于 LLM（大型语言模型）的复杂工作流和 Agent 系统。它采用有向图结构来定义工作流程，使开发者能够创建动态、可控且可扩展的 AI 应用程序。简单来说，LangGraph 是一个框架，允许你使用图结构来定义 LLM 应用程序的不同组件如何交互，从而实现复杂的、多步骤的 AI 工作流程。LangGraph 是构建复杂 AI 工作流的强大工具，它提供了灵活的流程控制、强大的状态管理和良好的集成能力。
Langgraph小入门
xnuscd的博客
11-04 3589
在 LangGraph 中，节点是图的基本单元，通常是 Python 函数，它们负责执行图中的实际操作。节点可以是同步或异步（async）函数，函数的第一个参数是图的状态，而第二个参数是可选的配置，用于传递额外的可配置参数。"}# 第二个参数是可选的my_node：这是一个包含两个参数的节点函数。第一个参数是state，即图的当前状态。第二个参数是config，这是一个可选的对象，用于传递额外的配置信息（例如user_id节点函数执行后，它返回一个更新后的状态，例如。
Langgraph 学习教程
种一棵树，最好的结果是十年前，其次是现在！
07-01 1128
功能核心方法/类典型应用场景线性流程简单顺序任务条件分支动态路由决策循环控制条件边 + 状态判断迭代处理并行执行多入口边独立任务并行工具调用ToolNode集成外部工具（搜索/API）消息传递多轮对话系统错误处理try-catch + 条件边容错工作流。
langgraph开发入门初稿——简稿
m0_46311043的博客
02-26 1601
整体还是很清晰的，整体的思路就是1.先定义agent的一些基础概念：模型，prompt模板还有用到的工具，最后创建function call格式的对话工具2.然后定义graph图中间可表示运行状态的东西：有输入，对话历史，中间步骤（工具使用情况），最后还有工具的输出3.接着定义agent：定义一个要是用什么工具的判断器，定义一个执行工具的函数，最后定义在条件边缘时的判断方法。
LangGraph入门指南：构建高效LLM Agent
LangGraph作为LangChain生态中的全新利器，标志着大语言模型（LLM）驱动的智能代理（Agent）系统在架构设计与工程实践上迈入了一个更加成熟和结构化的阶段。本文围绕“LangGraph新利器上手[项目代码]”这一主题，...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值