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

先决条件

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

• 节点
• 边
• Reducer

节点的并行执行对于加速整体图操作至关重要。LangGraph 为节点的并行执行提供原生支持，这可以显著提高基于图的工作流程的性能。这种并行化是通过扇出和扇入机制实现的，利用了标准边和 conditional_edges。以下是一些示例，展示了如何添加为您工作的分支数据流。

设置

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

%%capture --no-stderr
%pip install -U langgraph

设置用于 LangGraph 开发的 LangSmith

注册 LangSmith 以快速发现问题并提高 LangGraph 项目的性能。LangSmith 让您可以使用跟踪数据来调试、测试和监控使用 LangGraph 构建的 LLM 应用程序——阅读此处以了解更多关于如何开始的信息。

如何并行运行图节点

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

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()

API 参考：StateGraph | START | END

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" 都完成后执行。

重要的是，来自并行 superstep 的更新可能不会按顺序一致。如果您需要来自并行 superstep 的更新的顺序一致、预先确定的排序，您应该将输出写入状态中的单独字段，并附带一个用于排序的值。

异常处理？

LangGraph 在 “superstep” 中执行节点，这意味着虽然并行分支并行执行，但整个 superstep 是事务性的。如果这些分支中的任何一个引发异常，则不会将任何更新应用于状态（整个 superstep 都会出错）。

重要的是，当使用 checkpointer 时，来自 superstep 中成功节点的结果会被保存，并且在恢复时不会重复。

如果您有容易出错的（可能想要处理不稳定的 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。

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()

API 参考：StateGraph | START | END

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'}

下一步

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

评论