如何创建用于并行节点执行的分支

先决条件

本指南假设您熟悉以下内容

• 节点
• 边
• Reducer

节点并行执行对于加速整个图操作至关重要。LangGraph 原生支持节点并行执行，这可以显著提升基于图的工作流的性能。这种并行化通过扇出和扇入机制实现，利用标准边和条件边（conditional_edges）。下面是一些示例，展示如何创建适合您的分支数据流。

设置

首先，让我们安装所需的软件包

pip install -U langgraph

为 LangGraph 开发设置 LangSmith

注册 LangSmith 以快速发现问题并改进您的 LangGraph 项目性能。LangSmith 允许您使用跟踪数据来调试、测试和监控使用 LangGraph 构建的 LLM 应用 — 在此处阅读更多关于如何入门的信息。

如何并行运行图节点

在此示例中，我们从 Node A 扇出到 B 和 C，然后扇入到 D。通过我们的状态，我们指定了 reducer 的添加操作。这将合并或累加状态中特定键的值，而不是简单地覆盖现有值。对于列表，这意味着将新列表与现有列表连接。有关使用 reducer 更新状态的更多详细信息，请参阅此指南。

API 参考：StateGraph | START | END

import operator
from typing import Annotated, Any

from typing_extensions import TypedDict

from langgraph.graph import StateGraph, START, END


class State(TypedDict):
    # The operator.add reducer fn makes this append-only
    aggregate: Annotated[list, operator.add]


def a(state: State):
    print(f'Adding "A" to {state["aggregate"]}')
    return {"aggregate": ["A"]}


def b(state: State):
    print(f'Adding "B" to {state["aggregate"]}')
    return {"aggregate": ["B"]}


def c(state: State):
    print(f'Adding "C" to {state["aggregate"]}')
    return {"aggregate": ["C"]}


def d(state: State):
    print(f'Adding "D" to {state["aggregate"]}')
    return {"aggregate": ["D"]}


builder = StateGraph(State)
builder.add_node(a)
builder.add_node(b)
builder.add_node(c)
builder.add_node(d)
builder.add_edge(START, "a")
builder.add_edge("a", "b")
builder.add_edge("a", "c")
builder.add_edge("b", "d")
builder.add_edge("c", "d")
builder.add_edge("d", END)
graph = builder.compile()

from IPython.display import Image, display

display(Image(graph.get_graph().draw_mermaid_png()))

使用 reducer，您可以看到在每个节点中添加的值都被累积起来。

graph.invoke({"aggregate": []}, {"configurable": {"thread_id": "foo"}})

Adding "A" to []
Adding "B" to ['A']
Adding "C" to ['A']
Adding "D" to ['A', 'B', 'C']

{'aggregate': ['A', 'B', 'C', 'D']}

注意

在上面的示例中，节点 "b" 和 "c" 在同一个超级步骤（superstep）中并行执行。由于它们在同一个步骤中，节点 "d" 会在 "b" 和 "c" 都完成后执行。

重要的是，并行超级步骤中的更新可能无法保持一致的顺序。如果您需要并行超级步骤中的更新保持一致的、预定的顺序，您应该将输出写入状态中的一个单独字段，并附带一个用于排序的值。

异常处理？

LangGraph 在“超级步骤（supersteps）”中执行节点，这意味着虽然并行分支并行执行，但整个超级步骤是事务性的。如果这些分支中的任何一个抛出异常，没有任何更新会被应用到状态（整个超级步骤都会出错）。

重要的是，当使用检查点（checkpointer）时，超级步骤中成功节点的执行结果会被保存，并在恢复时不会重复执行。

如果您的代码容易出错（例如想处理不稳定的 API 调用），LangGraph 提供了两种方法来解决此问题

1. 您可以在节点内部编写常规 Python 代码来捕获和处理异常。
2. 您可以设置一个 重试策略（retry_policy），以指示图重试抛出特定类型异常的节点。只有失败的分支会被重试，因此您无需担心执行冗余工作。

总之，这些方法让您能够执行并行执行并完全控制异常处理。

包含额外步骤的并行节点扇出和扇入

上面的示例展示了当每个路径只有一个步骤时的扇出和扇入。但是如果其中一个路径有多个步骤怎么办？让我们在“b”分支中添加一个节点 b_2

def b_2(state: State):
    print(f'Adding "B_2" to {state["aggregate"]}')
    return {"aggregate": ["B_2"]}


builder = StateGraph(State)
builder.add_node(a)
builder.add_node(b)
builder.add_node(b_2)
builder.add_node(c)
builder.add_node(d)
builder.add_edge(START, "a")
builder.add_edge("a", "b")
builder.add_edge("a", "c")
builder.add_edge("b", "b_2")
builder.add_edge(["b_2", "c"], "d")
builder.add_edge("d", END)
graph = builder.compile()

from IPython.display import Image, display

display(Image(graph.get_graph().draw_mermaid_png()))

graph.invoke({"aggregate": []})

Adding "A" to []
Adding "B" to ['A']
Adding "C" to ['A']
Adding "B_2" to ['A', 'B', 'C']
Adding "D" to ['A', 'B', 'C', 'B_2']

{'aggregate': ['A', 'B', 'C', 'B_2', 'D']}

注意

在上面的示例中，节点 "b" 和 "c" 在同一个超级步骤（superstep）中并行执行。下一步会发生什么？

我们在这里使用 add_edge(["b_2", "c"], "d") 来强制节点 "d" 仅在节点 "b_2" 和 "c" 都执行完成后运行。如果我们添加两条单独的边，节点 "d" 将运行两次：一次在节点 b2 完成后，另一次在节点 c 完成后（无论这些节点以何种顺序完成）。

条件分支

如果您的扇出不是确定性的，您可以直接使用 add_conditional_edges。

API 参考：StateGraph | START | END

import operator
from typing import Annotated, Sequence

from typing_extensions import TypedDict

from langgraph.graph import StateGraph, START, END


class State(TypedDict):
    aggregate: Annotated[list, operator.add]
    # Add a key to the state. We will set this key to determine
    # how we branch.
    which: str


def a(state: State):
    print(f'Adding "A" to {state["aggregate"]}')
    return {"aggregate": ["A"]}


def b(state: State):
    print(f'Adding "B" to {state["aggregate"]}')
    return {"aggregate": ["B"]}


def c(state: State):
    print(f'Adding "C" to {state["aggregate"]}')
    return {"aggregate": ["C"]}


def d(state: State):
    print(f'Adding "D" to {state["aggregate"]}')
    return {"aggregate": ["D"]}


def e(state: State):
    print(f'Adding "E" to {state["aggregate"]}')
    return {"aggregate": ["E"]}


builder = StateGraph(State)
builder.add_node(a)
builder.add_node(b)
builder.add_node(c)
builder.add_node(d)
builder.add_node(e)
builder.add_edge(START, "a")


def route_bc_or_cd(state: State) -> Sequence[str]:
    if state["which"] == "cd":
        return ["c", "d"]
    return ["b", "c"]


intermediates = ["b", "c", "d"]
builder.add_conditional_edges(
    "a",
    route_bc_or_cd,
    intermediates,
)
for node in intermediates:
    builder.add_edge(node, "e")

builder.add_edge("e", END)
graph = builder.compile()

from IPython.display import Image, display

display(Image(graph.get_graph().draw_mermaid_png()))

graph.invoke({"aggregate": [], "which": "bc"})

Adding "A" to []
Adding "B" to ['A']
Adding "C" to ['A']
Adding "E" to ['A', 'B', 'C']

{'aggregate': ['A', 'B', 'C', 'E'], 'which': 'bc'}

graph.invoke({"aggregate": [], "which": "cd"})

Adding "A" to []
Adding "C" to ['A']
Adding "D" to ['A']
Adding "E" to ['A', 'C', 'D']

{'aggregate': ['A', 'C', 'D', 'E'], 'which': 'cd'}

下一步

• 继续阅读图 API 基础知识指南。
• 了解如何创建map-reduce分支，其中不同的状态可以分发给节点的多个实例。

评论