图定义¶

StateGraph ¶

基类: Graph

一种图，其节点通过读取和写入共享状态进行通信。每个节点的签名是 State -> Partial.

每个状态键可以选择使用一个归约函数进行标注，该函数将用于聚合从多个节点收到的该键的值。归约函数的签名是 (Value, Value) -> Value。

参数

名称	类型	描述	默认值
`state_schema`	`Optional[type[Any]]`	定义状态的模式类。	`None`
`config_schema`	`Optional[type[Any]]`	定义配置的模式类。使用此项可在 API 中暴露可配置参数。	`None`

示例

from langchain_core.runnables import RunnableConfig
from typing_extensions import Annotated, TypedDict
from langgraph.checkpoint.memory import MemorySaver
from langgraph.graph import StateGraph

def reducer(a: list, b: int | None) -> list:
    if b is not None:
        return a + [b]
    return a

class State(TypedDict):
    x: Annotated[list, reducer]

class ConfigSchema(TypedDict):
    r: float

graph = StateGraph(State, config_schema=ConfigSchema)

def node(state: State, config: RunnableConfig) -> dict:
    r = config["configurable"].get("r", 1.0)
    x = state["x"][-1]
    next_value = x * r * (1 - x)
    return {"x": next_value}

graph.add_node("A", node)
graph.set_entry_point("A")
graph.set_finish_point("A")
compiled = graph.compile()

print(compiled.config_specs)
# [ConfigurableFieldSpec(id='r', annotation=<class 'float'>, name=None, description=None, default=None, is_shared=False, dependencies=None)]

step1 = compiled.invoke({"x": 0.5}, {"configurable": {"r": 3.0}})
# {'x': [0.5, 0.75]}

方法

名称	描述
`add_node`	向状态图添加新节点。
`add_edge`	从起始节点（或起始节点列表）向结束节点添加有向边。
`add_conditional_edges`	从起始节点向任意数量的目标节点添加条件边。
`add_sequence`	添加将按提供顺序执行的节点序列。
`compile`	将状态图编译为 `CompiledStateGraph` 对象。

add_node ¶

add_node(
    node: Union[str, RunnableLike],
    action: Optional[RunnableLike] = None,
    *,
    metadata: Optional[dict[str, Any]] = None,
    input: Optional[type[Any]] = None,
    retry: Optional[
        Union[RetryPolicy, Sequence[RetryPolicy]]
    ] = None,
    destinations: Optional[
        Union[dict[str, str], tuple[str, ...]]
    ] = None
) -> Self

向状态图添加新节点。

参数

名称	类型	描述	默认值
`node`	`Union[str, RunnableLike]`	此节点将运行的函数或可运行对象。如果提供字符串，它将用作节点名称，而 action 将用作函数或可运行对象。	必需
`action`	`Optional[RunnableLike]`	与节点关联的操作。（默认值: None）如果 `node` 是字符串（节点名称），将用作节点函数或可运行对象。	`None`
`metadata`	`Optional[dict[str, Any]]`	与节点关联的元数据。（默认值: None）	`None`
`input`	`Optional[type[Any]]`	节点的输入模式。（默认值: 图的输入模式）	`None`
`retry`	`Optional[Union[RetryPolicy, Sequence[RetryPolicy]]]`	节点重试策略。（默认值: None）如果提供序列，将应用第一个匹配策略。	`None`
`destinations`	`Optional[Union[dict[str, str], tuple[str, ...]]]`	指示节点可以路由到哪里的目标。这对于返回 `Command` 对象的无边图很有用。如果提供字典，键将用作目标节点名称，值将用作边的标签。如果提供元组，值将用作目标节点名称。注意：这仅用于图渲染，对图执行没有任何影响。	`None`

引发: ValueError: 如果键已被用作状态键。

示例

from langgraph.graph import START, StateGraph

def my_node(state, config):
    return {"x": state["x"] + 1}

builder = StateGraph(dict)
builder.add_node(my_node)  # node name will be 'my_node'
builder.add_edge(START, "my_node")
graph = builder.compile()
graph.invoke({"x": 1})
# {'x': 2}

自定义名称

builder = StateGraph(dict)
builder.add_node("my_fair_node", my_node)
builder.add_edge(START, "my_fair_node")
graph = builder.compile()
graph.invoke({"x": 1})
# {'x': 2}

返回值

名称	类型	描述
`Self`	`Self`	状态图实例，允许方法链式调用。

add_edge ¶

add_edge(
    start_key: Union[str, list[str]], end_key: str
) -> Self

从起始节点（或起始节点列表）向结束节点添加有向边。

提供单个起始节点时，图将等待该节点完成后再执行结束节点。提供多个起始节点时，图将等待所有起始节点完成后再执行结束节点。

参数

名称	类型	描述	默认值
`start_key`	`Union[str, list[str]]`	边的起始节点键。	必需
`end_key`	`str`	边的结束节点键。	必需

引发

类型	描述
`ValueError`	如果起始键是 'END'，或者起始键或结束键不在图中。

返回值

名称	类型	描述
`Self`	`Self`	状态图实例，允许方法链式调用。

add_conditional_edges ¶

add_conditional_edges(
    source: str,
    path: Union[
        Callable[..., Union[Hashable, list[Hashable]]],
        Callable[
            ..., Awaitable[Union[Hashable, list[Hashable]]]
        ],
        Runnable[Any, Union[Hashable, list[Hashable]]],
    ],
    path_map: Optional[
        Union[dict[Hashable, str], list[str]]
    ] = None,
    then: Optional[str] = None,
) -> Self

从起始节点向任意数量的目标节点添加条件边。

参数

名称	类型	描述	默认值
`source`	`str`	起始节点。退出此节点时将运行此条件边。	必需
`path`	`Union[Callable[..., Union[Hashable, list[Hashable]]], Callable[..., Awaitable[Union[Hashable, list[Hashable]]]], Runnable[Any, Union[Hashable, list[Hashable]]]]`	确定下一个节点或多个节点的可调用对象。如果未指定 `path_map`，它应返回一个或多个节点。如果返回 END，图将停止执行。	必需
`path_map`	`Optional[Union[dict[Hashable, str], list[str]]]`	路径到节点名称的可选映射。如果省略，`path` 返回的路径应为节点名称。	`None`
`then`	`Optional[str]`	在 `path` 选择的节点之后执行的节点的名称。	`None`

返回值

名称	类型	描述
`Self`	`Self`	图实例，允许方法链式调用。

如果在 path 函数的返回值上没有类型提示（例如，-> Literal["foo", "__end__"]:）

或 path_map，图可视化假定该边可以转换到图中的任何节点。

add_sequence ¶

add_sequence(
    nodes: Sequence[
        Union[RunnableLike, tuple[str, RunnableLike]]
    ],
) -> Self

添加将按提供顺序执行的节点序列。

参数

名称	类型	描述	默认值
`nodes`	`Sequence[Union[RunnableLike, tuple[str, RunnableLike]]]`	RunnableLike 对象（例如 LangChain Runnable 或可调用对象）序列或 (名称, RunnableLike) 元组。如果未提供名称，将从节点对象（例如可运行对象或可调用对象名称）推断名称。每个节点将按提供的顺序执行。	必需

引发

类型	描述
`ValueError`	如果序列为空。
`ValueError`	如果序列包含重复的节点名称。

返回值

名称	类型	描述
`Self`	`Self`	状态图实例，允许方法链式调用。

compile ¶

compile(
    checkpointer: Checkpointer = None,
    *,
    store: Optional[BaseStore] = None,
    interrupt_before: Optional[
        Union[All, list[str]]
    ] = None,
    interrupt_after: Optional[Union[All, list[str]]] = None,
    debug: bool = False,
    name: Optional[str] = None
) -> CompiledStateGraph

将状态图编译为 CompiledStateGraph 对象。

编译后的图实现了 Runnable 接口，可以被调用、流式传输、批量处理和异步运行。

参数

名称	类型	描述	默认值
`checkpointer`	`Checkpointer`	检查点保存对象或标志。如果提供，此 Checkpointer 将作为图的完全版本化的“短期记忆”，允许从任意点暂停、恢复和重放。如果为 None，在用作子图时可能会继承父图的 checkpointer。如果为 False，将不使用或继承任何 checkpointer。	`None`
`interrupt_before`	`Optional[Union[All, list[str]]]`	在这些节点之前中断的可选节点名称列表。	`None`
`interrupt_after`	`Optional[Union[All, list[str]]]`	在这些节点之后中断的可选节点名称列表。	`None`
`debug`	`bool`	指示是否启用调试模式的标志。	`False`
`name`	`Optional[str]`	用于编译后的图的名称。	`None`

返回值

名称	类型	描述
`CompiledStateGraph`	`CompiledStateGraph`	编译后的状态图。

CompiledStateGraph ¶

基类: CompiledGraph

方法

名称	描述
`stream`	为单个输入流式传输图步骤。
`astream`	为单个输入异步流式传输图步骤。
`invoke`	使用单个输入和配置运行图。
`ainvoke`	在单个输入上异步调用图。
`get_state`	获取图的当前状态。
`aget_state`	获取图的当前状态。
`get_state_history`	获取图的状态历史。
`aget_state_history`	异步获取图的状态历史。
`update_state`	使用给定值更新图的状态，就像它们来自
`aupdate_state`	使用给定值异步更新图的状态，就像它们来自
`bulk_update_state`	批量应用更新到图状态。需要设置检查点。
`abulk_update_state`	异步批量应用更新到图状态。需要设置检查点。
`get_graph`	返回计算图的可绘制表示。
`aget_graph`	返回计算图的可绘制表示。
`get_subgraphs`	获取图的子图。
`aget_subgraphs`	获取图的子图。
`with_config`	创建 Pregel 对象的副本并更新配置。

stream ¶

stream(
    input: dict[str, Any] | Any,
    config: RunnableConfig | None = None,
    *,
    stream_mode: (
        StreamMode | list[StreamMode] | None
    ) = None,
    output_keys: str | Sequence[str] | None = None,
    interrupt_before: All | Sequence[str] | None = None,
    interrupt_after: All | Sequence[str] | None = None,
    checkpoint_during: bool | None = None,
    debug: bool | None = None,
    subgraphs: bool = False
) -> Iterator[dict[str, Any] | Any]

为单个输入流式传输图步骤。

参数

名称	类型	描述	默认值
`input`	`dict[str, Any] \| Any`	图的输入。	必需
`config`	`RunnableConfig \| None`	运行使用的配置。	`None`
`stream_mode`	`StreamMode \| list[StreamMode] \| None`	输出流模式，默认为 self.stream_mode。选项有 `"values"`: 在每一步后发出状态中的所有值，包括中断。与函数式 API 一起使用时，值在工作流结束时一次性发出。 `"updates"`: 在每一步后仅发出节点或任务名称以及节点或任务返回的更新。如果在同一步骤中进行多次更新（例如，运行多个节点），则这些更新会单独发出。 `"custom"`: 使用 `StreamWriter` 从节点或任务内部发出自定义数据。 `"messages"`: 逐令牌发出 LLM 消息，并附带节点或任务内任何 LLM 调用的元数据。 `"debug"`: 在每一步中发出尽可能包含详细信息的调试事件。	`None`
`output_keys`	`str \| Sequence[str] \| None`	要流式传输的键，默认为所有非上下文通道。	`None`
`interrupt_before`	`All \| Sequence[str] \| None`	在这些节点之前中断的节点，默认为图中的所有节点。	`None`
`interrupt_after`	`All \| Sequence[str] \| None`	在这些节点之后中断的节点，默认为图中的所有节点。	`None`
`checkpoint_during`	`bool \| None`	是否检查点中间步骤，默认为 True。如果为 False，仅保存最终检查点。	`None`
`debug`	`bool \| None`	执行期间是否打印调试信息，默认为 False。	`None`
`subgraphs`	`bool`	是否流式传输子图，默认为 False。	`False`

生成

类型	描述
`dict[str, Any] \| Any`	图中每个步骤的输出。输出形状取决于 stream_mode。

使用 stream_mode="values"

import operator
from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph, START

class State(TypedDict):
    alist: Annotated[list, operator.add]
    another_list: Annotated[list, operator.add]

builder = StateGraph(State)
builder.add_node("a", lambda _state: {"another_list": ["hi"]})
builder.add_node("b", lambda _state: {"alist": ["there"]})
builder.add_edge("a", "b")
builder.add_edge(START, "a")
graph = builder.compile()

for event in graph.stream({"alist": ['Ex for stream_mode="values"']}, stream_mode="values"):
    print(event)

# {'alist': ['Ex for stream_mode="values"'], 'another_list': []}
# {'alist': ['Ex for stream_mode="values"'], 'another_list': ['hi']}
# {'alist': ['Ex for stream_mode="values"', 'there'], 'another_list': ['hi']}

使用 stream_mode="updates"

for event in graph.stream({"alist": ['Ex for stream_mode="updates"']}, stream_mode="updates"):
    print(event)

# {'a': {'another_list': ['hi']}}
# {'b': {'alist': ['there']}}

使用 stream_mode="debug"

for event in graph.stream({"alist": ['Ex for stream_mode="debug"']}, stream_mode="debug"):
    print(event)

# {'type': 'task', 'timestamp': '2024-06-23T...+00:00', 'step': 1, 'payload': {'id': '...', 'name': 'a', 'input': {'alist': ['Ex for stream_mode="debug"'], 'another_list': []}, 'triggers': ['start:a']}}
# {'type': 'task_result', 'timestamp': '2024-06-23T...+00:00', 'step': 1, 'payload': {'id': '...', 'name': 'a', 'result': [('another_list', ['hi'])]}}
# {'type': 'task', 'timestamp': '2024-06-23T...+00:00', 'step': 2, 'payload': {'id': '...', 'name': 'b', 'input': {'alist': ['Ex for stream_mode="debug"'], 'another_list': ['hi']}, 'triggers': ['a']}}
# {'type': 'task_result', 'timestamp': '2024-06-23T...+00:00', 'step': 2, 'payload': {'id': '...', 'name': 'b', 'result': [('alist', ['there'])]}}

使用 stream_mode="custom"

from langgraph.types import StreamWriter

def node_a(state: State, writer: StreamWriter):
    writer({"custom_data": "foo"})
    return {"alist": ["hi"]}

builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
graph = builder.compile()

for event in graph.stream({"alist": ['Ex for stream_mode="custom"']}, stream_mode="custom"):
    print(event)

# {'custom_data': 'foo'}

使用 stream_mode="messages"

from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph, START
from langchain_openai import ChatOpenAI

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

class State(TypedDict):
    question: str
    answer: str

def node_a(state: State):
    response = llm.invoke(state["question"])
    return {"answer": response.content}

builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
graph = builder.compile()

for event in graph.stream({"question": "What is the capital of France?"}, stream_mode="messages"):
    print(event)

# (AIMessageChunk(content='The', additional_kwargs={}, response_metadata={}, id='...'), {'langgraph_step': 1, 'langgraph_node': 'a', 'langgraph_triggers': ['start:a'], 'langgraph_path': ('__pregel_pull', 'a'), 'langgraph_checkpoint_ns': '...', 'checkpoint_ns': '...', 'ls_provider': 'openai', 'ls_model_name': 'gpt-4o-mini', 'ls_model_type': 'chat', 'ls_temperature': 0.7})
# (AIMessageChunk(content=' capital', additional_kwargs={}, response_metadata={}, id='...'), {'langgraph_step': 1, 'langgraph_node': 'a', 'langgraph_triggers': ['start:a'], ...})
# (AIMessageChunk(content=' of', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' France', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' is', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' Paris', additional_kwargs={}, response_metadata={}, id='...'), {...})

astream `async` ¶

astream(
    input: dict[str, Any] | Any,
    config: RunnableConfig | None = None,
    *,
    stream_mode: (
        StreamMode | list[StreamMode] | None
    ) = None,
    output_keys: str | Sequence[str] | None = None,
    interrupt_before: All | Sequence[str] | None = None,
    interrupt_after: All | Sequence[str] | None = None,
    checkpoint_during: bool | None = None,
    debug: bool | None = None,
    subgraphs: bool = False
) -> AsyncIterator[dict[str, Any] | Any]

为单个输入异步流式传输图步骤。

参数

名称	类型	描述	默认值
`input`	`dict[str, Any] \| Any`	图的输入。	必需
`config`	`RunnableConfig \| None`	运行使用的配置。	`None`
`stream_mode`	`StreamMode \| list[StreamMode] \| None`	输出流模式，默认为 self.stream_mode。选项有 `"values"`: 在每一步后发出状态中的所有值，包括中断。与函数式 API 一起使用时，值在工作流结束时一次性发出。 `"updates"`: 在每一步后仅发出节点或任务名称以及节点或任务返回的更新。如果在同一步骤中进行多次更新（例如，运行多个节点），则这些更新会单独发出。 `"custom"`: 使用 `StreamWriter` 从节点或任务内部发出自定义数据。 `"messages"`: 逐令牌发出 LLM 消息，并附带节点或任务内任何 LLM 调用的元数据。 `"debug"`: 在每一步中发出尽可能包含详细信息的调试事件。	`None`
`output_keys`	`str \| Sequence[str] \| None`	要流式传输的键，默认为所有非上下文通道。	`None`
`interrupt_before`	`All \| Sequence[str] \| None`	在这些节点之前中断的节点，默认为图中的所有节点。	`None`
`interrupt_after`	`All \| Sequence[str] \| None`	在这些节点之后中断的节点，默认为图中的所有节点。	`None`
`checkpoint_during`	`bool \| None`	是否检查点中间步骤，默认为 True。如果为 False，仅保存最终检查点。	`None`
`debug`	`bool \| None`	执行期间是否打印调试信息，默认为 False。	`None`
`subgraphs`	`bool`	是否流式传输子图，默认为 False。	`False`

生成

类型	描述
`AsyncIterator[dict[str, Any] \| Any]`	图中每个步骤的输出。输出形状取决于 stream_mode。

使用 stream_mode="values"

import operator
from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph, START

class State(TypedDict):
    alist: Annotated[list, operator.add]
    another_list: Annotated[list, operator.add]

builder = StateGraph(State)
builder.add_node("a", lambda _state: {"another_list": ["hi"]})
builder.add_node("b", lambda _state: {"alist": ["there"]})
builder.add_edge("a", "b")
builder.add_edge(START, "a")
graph = builder.compile()

async for event in graph.astream({"alist": ['Ex for stream_mode="values"']}, stream_mode="values"):
    print(event)

# {'alist': ['Ex for stream_mode="values"'], 'another_list': []}
# {'alist': ['Ex for stream_mode="values"'], 'another_list': ['hi']}
# {'alist': ['Ex for stream_mode="values"', 'there'], 'another_list': ['hi']}

使用 stream_mode="updates"

async for event in graph.astream({"alist": ['Ex for stream_mode="updates"']}, stream_mode="updates"):
    print(event)

# {'a': {'another_list': ['hi']}}
# {'b': {'alist': ['there']}}

使用 stream_mode="debug"

async for event in graph.astream({"alist": ['Ex for stream_mode="debug"']}, stream_mode="debug"):
    print(event)

# {'type': 'task', 'timestamp': '2024-06-23T...+00:00', 'step': 1, 'payload': {'id': '...', 'name': 'a', 'input': {'alist': ['Ex for stream_mode="debug"'], 'another_list': []}, 'triggers': ['start:a']}}
# {'type': 'task_result', 'timestamp': '2024-06-23T...+00:00', 'step': 1, 'payload': {'id': '...', 'name': 'a', 'result': [('another_list', ['hi'])]}}
# {'type': 'task', 'timestamp': '2024-06-23T...+00:00', 'step': 2, 'payload': {'id': '...', 'name': 'b', 'input': {'alist': ['Ex for stream_mode="debug"'], 'another_list': ['hi']}, 'triggers': ['a']}}
# {'type': 'task_result', 'timestamp': '2024-06-23T...+00:00', 'step': 2, 'payload': {'id': '...', 'name': 'b', 'result': [('alist', ['there'])]}}

使用 stream_mode="custom"

from langgraph.types import StreamWriter

async def node_a(state: State, writer: StreamWriter):
    writer({"custom_data": "foo"})
    return {"alist": ["hi"]}

builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
graph = builder.compile()

async for event in graph.astream({"alist": ['Ex for stream_mode="custom"']}, stream_mode="custom"):
    print(event)

# {'custom_data': 'foo'}

使用 stream_mode="messages"

from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph, START
from langchain_openai import ChatOpenAI

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

class State(TypedDict):
    question: str
    answer: str

async def node_a(state: State):
    response = await llm.ainvoke(state["question"])
    return {"answer": response.content}

builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
graph = builder.compile()

async for event in graph.astream({"question": "What is the capital of France?"}, stream_mode="messages"):
    print(event)

# (AIMessageChunk(content='The', additional_kwargs={}, response_metadata={}, id='...'), {'langgraph_step': 1, 'langgraph_node': 'a', 'langgraph_triggers': ['start:a'], 'langgraph_path': ('__pregel_pull', 'a'), 'langgraph_checkpoint_ns': '...', 'checkpoint_ns': '...', 'ls_provider': 'openai', 'ls_model_name': 'gpt-4o-mini', 'ls_model_type': 'chat', 'ls_temperature': 0.7})
# (AIMessageChunk(content=' capital', additional_kwargs={}, response_metadata={}, id='...'), {'langgraph_step': 1, 'langgraph_node': 'a', 'langgraph_triggers': ['start:a'], ...})
# (AIMessageChunk(content=' of', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' France', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' is', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' Paris', additional_kwargs={}, response_metadata={}, id='...'), {...})

invoke ¶

invoke(
    input: dict[str, Any] | Any,
    config: RunnableConfig | None = None,
    *,
    stream_mode: StreamMode = "values",
    output_keys: str | Sequence[str] | None = None,
    interrupt_before: All | Sequence[str] | None = None,
    interrupt_after: All | Sequence[str] | None = None,
    checkpoint_during: bool | None = None,
    debug: bool | None = None,
    **kwargs: Any
) -> dict[str, Any] | Any

使用单个输入和配置运行图。

参数

名称	类型	描述	默认值
`input`	`dict[str, Any] \| Any`	图的输入数据。可以是字典或任何其他类型。	必需
`config`	`RunnableConfig \| None`	可选。图运行的配置。	`None`
`stream_mode`	`StreamMode`	可选[str]。图运行的流模式。默认为 "values"。	`'values'`
`output_keys`	`str \| Sequence[str] \| None`	可选。从图运行中检索的输出键。	`None`
`interrupt_before`	`All \| Sequence[str] \| None`	可选。在这些节点之前中断图运行的节点。	`None`
`interrupt_after`	`All \| Sequence[str] \| None`	可选。在这些节点之后中断图运行的节点。	`None`
`debug`	`bool \| None`	可选。为图运行启用调试模式。	`None`
`**kwargs`	`Any`	传递给图运行的附加关键字参数。	`{}`

返回值

类型	描述
`dict[str, Any] \| Any`	图运行的输出。如果 stream_mode 是 "values"，则返回最新输出。
`dict[str, Any] \| Any`	如果 stream_mode 不是 "values"，则返回输出块列表。

ainvoke `async` ¶

ainvoke(
    input: dict[str, Any] | Any,
    config: RunnableConfig | None = None,
    *,
    stream_mode: StreamMode = "values",
    output_keys: str | Sequence[str] | None = None,
    interrupt_before: All | Sequence[str] | None = None,
    interrupt_after: All | Sequence[str] | None = None,
    checkpoint_during: bool | None = None,
    debug: bool | None = None,
    **kwargs: Any
) -> dict[str, Any] | Any

在单个输入上异步调用图。

参数

名称	类型	描述	默认值
`input`	`dict[str, Any] \| Any`	计算的输入数据。可以是字典或任何其他类型。	必需
`config`	`RunnableConfig \| None`	可选。计算的配置。	`None`
`stream_mode`	`StreamMode`	可选。计算的流模式。默认为 "values"。	`'values'`
`output_keys`	`str \| Sequence[str] \| None`	可选。结果中包含的输出键。默认为 None。	`None`
`interrupt_before`	`All \| Sequence[str] \| None`	可选。在这些节点之前中断的节点。默认为 None。	`None`
`interrupt_after`	`All \| Sequence[str] \| None`	可选。在这些节点之后中断的节点。默认为 None。	`None`
`debug`	`bool \| None`	可选。是否启用调试模式。默认为 None。	`None`
`**kwargs`	`Any`	附加关键字参数。	`{}`

返回值

类型	描述
`dict[str, Any] \| Any`	计算结果。如果 stream_mode 是 "values"，则返回最新值。
`dict[str, Any] \| Any`	如果 stream_mode 是 "chunks"，则返回块列表。

get_state ¶

get_state(
    config: RunnableConfig, *, subgraphs: bool = False
) -> StateSnapshot

获取图的当前状态。

aget_state `async` ¶

aget_state(
    config: RunnableConfig, *, subgraphs: bool = False
) -> StateSnapshot

获取图的当前状态。

get_state_history ¶

get_state_history(
    config: RunnableConfig,
    *,
    filter: dict[str, Any] | None = None,
    before: RunnableConfig | None = None,
    limit: int | None = None
) -> Iterator[StateSnapshot]

获取图的状态历史。

aget_state_history `async` ¶

aget_state_history(
    config: RunnableConfig,
    *,
    filter: dict[str, Any] | None = None,
    before: RunnableConfig | None = None,
    limit: int | None = None
) -> AsyncIterator[StateSnapshot]

异步获取图的状态历史。

update_state ¶

update_state(
    config: RunnableConfig,
    values: dict[str, Any] | Any | None,
    as_node: str | None = None,
) -> RunnableConfig

使用给定值更新图的状态，就像它们来自节点 as_node。如果未提供 as_node，如果无歧义，则将其设置为更新状态的最后一个节点。

aupdate_state `async` ¶

aupdate_state(
    config: RunnableConfig,
    values: dict[str, Any] | Any,
    as_node: str | None = None,
) -> RunnableConfig

使用给定值异步更新图的状态，就像它们来自节点 as_node。如果未提供 as_node，如果无歧义，则将其设置为更新状态的最后一个节点。

bulk_update_state ¶

bulk_update_state(
    config: RunnableConfig,
    supersteps: Sequence[Sequence[StateUpdate]],
) -> RunnableConfig

批量应用更新到图状态。需要设置检查点。

参数

名称	类型	描述	默认值
`config`	`RunnableConfig`	应用更新的配置。	必需
`supersteps`	`Sequence[Sequence[StateUpdate]]`	超步列表，每个超步包含一个要按顺序应用于图状态的更新列表。每个更新都是一个形式为 `(values, as_node)` 的元组。	必需

引发

类型	描述
`ValueError`	如果未设置检查点或未提供更新。
`InvalidUpdateError`	如果提供了无效更新。

返回值

名称	类型	描述
`RunnableConfig`	`RunnableConfig`	更新后的配置。

abulk_update_state `async` ¶

abulk_update_state(
    config: RunnableConfig,
    supersteps: Sequence[Sequence[StateUpdate]],
) -> RunnableConfig

异步批量应用更新到图状态。需要设置检查点。

参数

名称	类型	描述	默认值
`config`	`RunnableConfig`	应用更新的配置。	必需
`supersteps`	`Sequence[Sequence[StateUpdate]]`	超步列表，每个超步包含一个要按顺序应用于图状态的更新列表。每个更新都是一个形式为 `(values, as_node)` 的元组。	必需

引发

类型	描述
`ValueError`	如果未设置检查点或未提供更新。
`InvalidUpdateError`	如果提供了无效更新。

返回值

名称	类型	描述
`RunnableConfig`	`RunnableConfig`	更新后的配置。

get_graph ¶

get_graph(
    config: RunnableConfig | None = None,
    *,
    xray: int | bool = False
) -> Graph

返回计算图的可绘制表示。

aget_graph `async` ¶

aget_graph(
    config: RunnableConfig | None = None,
    *,
    xray: int | bool = False
) -> Graph

返回计算图的可绘制表示。

get_subgraphs ¶

get_subgraphs(
    *, namespace: str | None = None, recurse: bool = False
) -> Iterator[tuple[str, PregelProtocol]]

获取图的子图。

参数

名称	类型	描述	默认值
`namespace`	`str \| None`	用于过滤子图的命名空间。	`None`
`recurse`	`bool`	是否递归进入子图。如果为 False，则仅返回直接子图。	`False`

返回值

类型	描述
`Iterator[tuple[str, PregelProtocol]]`	Iterator[tuple[str, PregelProtocol]]: (命名空间, 子图) 对的迭代器。

aget_subgraphs `async` ¶

aget_subgraphs(
    *, namespace: str | None = None, recurse: bool = False
) -> AsyncIterator[tuple[str, PregelProtocol]]

获取图的子图。

参数

名称	类型	描述	默认值
`namespace`	`str \| None`	用于过滤子图的命名空间。	`None`
`recurse`	`bool`	是否递归进入子图。如果为 False，则仅返回直接子图。	`False`

返回值

类型	描述
`AsyncIterator[tuple[str, PregelProtocol]]`	AsyncIterator[tuple[str, PregelProtocol]]: (命名空间, 子图) 对的异步迭代器。

with_config ¶

with_config(
    config: RunnableConfig | None = None, **kwargs: Any
) -> Self

创建 Pregel 对象的副本并更新配置。

Graph ¶

方法

名称	描述
`add_node`	向图添加新节点。
`add_edge`	从起始节点向结束节点添加有向边。
`add_conditional_edges`	从起始节点向任意数量的目标节点添加条件边。
`compile`	将图编译为 `CompiledGraph` 对象。

add_node ¶

add_node(
    node: Union[str, RunnableLike],
    action: Optional[RunnableLike] = None,
    *,
    metadata: Optional[dict[str, Any]] = None
) -> Self

向图添加新节点。

参数

名称	类型	描述	默认值
`node`	`Union[str, RunnableLike]`	此节点将运行的函数或可运行对象。如果提供字符串，它将用作节点名称，而 action 将用作函数或可运行对象。	必需
`action`	`Optional[RunnableLike]`	与节点关联的操作。（默认值: None）如果 `node` 是字符串（节点名称），将用作节点函数或可运行对象。	`None`
`metadata`	`Optional[dict[str, Any]]`	与节点关联的元数据。（默认值: None）	`None`

add_edge ¶

add_edge(start_key: str, end_key: str) -> Self

从起始节点向结束节点添加有向边。

参数

名称	类型	描述	默认值
`start_key`	`str`	边的起始节点键。	必需
`end_key`	`str`	边的结束节点键。	必需

add_conditional_edges ¶

add_conditional_edges(
    source: str,
    path: Union[
        Callable[..., Union[Hashable, list[Hashable]]],
        Callable[
            ..., Awaitable[Union[Hashable, list[Hashable]]]
        ],
        Runnable[Any, Union[Hashable, list[Hashable]]],
    ],
    path_map: Optional[
        Union[dict[Hashable, str], list[str]]
    ] = None,
    then: Optional[str] = None,
) -> Self

从起始节点向任意数量的目标节点添加条件边。

参数

名称	类型	描述	默认值
`source`	`str`	起始节点。退出此节点时将运行此条件边。	必需
`path`	`Union[Callable[..., Union[Hashable, list[Hashable]]], Callable[..., Awaitable[Union[Hashable, list[Hashable]]]], Runnable[Any, Union[Hashable, list[Hashable]]]]`	确定下一个节点或多个节点的可调用对象。如果未指定 `path_map`，它应返回一个或多个节点。如果返回 END，图将停止执行。	必需
`path_map`	`Optional[Union[dict[Hashable, str], list[str]]]`	路径到节点名称的可选映射。如果省略，`path` 返回的路径应为节点名称。	`None`
`then`	`Optional[str]`	在 `path` 选择的节点之后执行的节点的名称。	`None`

返回值

名称	类型	描述
`Self`	`Self`	图实例，允许方法链式调用。

如果在 path 函数的返回值上没有类型提示（例如，-> Literal["foo", "__end__"]:）

或 path_map，图可视化假定该边可以转换到图中的任何节点。

compile ¶

compile(
    checkpointer: Checkpointer = None,
    interrupt_before: Optional[
        Union[All, list[str]]
    ] = None,
    interrupt_after: Optional[Union[All, list[str]]] = None,
    debug: bool = False,
    name: Optional[str] = None,
) -> CompiledGraph

将图编译为 CompiledGraph 对象。

编译后的图实现了 Runnable 接口，可以被调用、流式传输、批量处理和异步运行。

参数

名称	类型	描述	默认值
`checkpointer`	`Checkpointer`	检查点保存对象或标志。如果提供，此 Checkpointer 将作为图的完全版本化的“短期记忆”，允许从任意点暂停、恢复和重放。如果为 None，在用作子图时可能会继承父图的 checkpointer。如果为 False，将不使用或继承任何 checkpointer。	`None`
`interrupt_before`	`Optional[Union[All, list[str]]]`	在这些节点之前中断的可选节点名称列表。	`None`
`interrupt_after`	`Optional[Union[All, list[str]]]`	在这些节点之后中断的可选节点名称列表。	`None`
`debug`	`bool`	指示是否启用调试模式的标志。	`False`
`name`	`Optional[str]`	用于编译后的图的名称。	`None`

返回值

名称	类型	描述
`CompiledGraph`	`CompiledGraph`	编译后的图。

CompiledGraph ¶

基类: Pregel

方法

名称	描述
`stream`	为单个输入流式传输图步骤。
`astream`	为单个输入异步流式传输图步骤。
`invoke`	使用单个输入和配置运行图。
`ainvoke`	在单个输入上异步调用图。
`get_state`	获取图的当前状态。
`aget_state`	获取图的当前状态。
`get_state_history`	获取图的状态历史。
`aget_state_history`	异步获取图的状态历史。
`update_state`	使用给定值更新图的状态，就像它们来自
`aupdate_state`	使用给定值异步更新图的状态，就像它们来自
`bulk_update_state`	批量应用更新到图状态。需要设置检查点。
`abulk_update_state`	异步批量应用更新到图状态。需要设置检查点。
`get_graph`	返回计算图的可绘制表示。
`aget_graph`	返回计算图的可绘制表示。
`get_subgraphs`	获取图的子图。
`aget_subgraphs`	获取图的子图。
`with_config`	创建 Pregel 对象的副本并更新配置。

stream ¶

stream(
    input: dict[str, Any] | Any,
    config: RunnableConfig | None = None,
    *,
    stream_mode: (
        StreamMode | list[StreamMode] | None
    ) = None,
    output_keys: str | Sequence[str] | None = None,
    interrupt_before: All | Sequence[str] | None = None,
    interrupt_after: All | Sequence[str] | None = None,
    checkpoint_during: bool | None = None,
    debug: bool | None = None,
    subgraphs: bool = False
) -> Iterator[dict[str, Any] | Any]

为单个输入流式传输图步骤。

参数

名称	类型	描述	默认值
`input`	`dict[str, Any] \| Any`	图的输入。	必需
`config`	`RunnableConfig \| None`	运行使用的配置。	`None`
`stream_mode`	`StreamMode \| list[StreamMode] \| None`	输出流模式，默认为 self.stream_mode。选项有 `"values"`: 在每一步后发出状态中的所有值，包括中断。与函数式 API 一起使用时，值在工作流结束时一次性发出。 `"updates"`: 在每一步后仅发出节点或任务名称以及节点或任务返回的更新。如果在同一步骤中进行多次更新（例如，运行多个节点），则这些更新会单独发出。 `"custom"`: 使用 `StreamWriter` 从节点或任务内部发出自定义数据。 `"messages"`: 逐令牌发出 LLM 消息，并附带节点或任务内任何 LLM 调用的元数据。 `"debug"`: 在每一步中发出尽可能包含详细信息的调试事件。	`None`
`output_keys`	`str \| Sequence[str] \| None`	要流式传输的键，默认为所有非上下文通道。	`None`
`interrupt_before`	`All \| Sequence[str] \| None`	在这些节点之前中断的节点，默认为图中的所有节点。	`None`
`interrupt_after`	`All \| Sequence[str] \| None`	在这些节点之后中断的节点，默认为图中的所有节点。	`None`
`checkpoint_during`	`bool \| None`	是否检查点中间步骤，默认为 True。如果为 False，仅保存最终检查点。	`None`
`debug`	`bool \| None`	执行期间是否打印调试信息，默认为 False。	`None`
`subgraphs`	`bool`	是否流式传输子图，默认为 False。	`False`

生成

类型	描述
`dict[str, Any] \| Any`	图中每个步骤的输出。输出形状取决于 stream_mode。

使用 stream_mode="values"

import operator
from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph, START

class State(TypedDict):
    alist: Annotated[list, operator.add]
    another_list: Annotated[list, operator.add]

builder = StateGraph(State)
builder.add_node("a", lambda _state: {"another_list": ["hi"]})
builder.add_node("b", lambda _state: {"alist": ["there"]})
builder.add_edge("a", "b")
builder.add_edge(START, "a")
graph = builder.compile()

for event in graph.stream({"alist": ['Ex for stream_mode="values"']}, stream_mode="values"):
    print(event)

# {'alist': ['Ex for stream_mode="values"'], 'another_list': []}
# {'alist': ['Ex for stream_mode="values"'], 'another_list': ['hi']}
# {'alist': ['Ex for stream_mode="values"', 'there'], 'another_list': ['hi']}

使用 stream_mode="updates"

for event in graph.stream({"alist": ['Ex for stream_mode="updates"']}, stream_mode="updates"):
    print(event)

# {'a': {'another_list': ['hi']}}
# {'b': {'alist': ['there']}}

使用 stream_mode="debug"

for event in graph.stream({"alist": ['Ex for stream_mode="debug"']}, stream_mode="debug"):
    print(event)

# {'type': 'task', 'timestamp': '2024-06-23T...+00:00', 'step': 1, 'payload': {'id': '...', 'name': 'a', 'input': {'alist': ['Ex for stream_mode="debug"'], 'another_list': []}, 'triggers': ['start:a']}}
# {'type': 'task_result', 'timestamp': '2024-06-23T...+00:00', 'step': 1, 'payload': {'id': '...', 'name': 'a', 'result': [('another_list', ['hi'])]}}
# {'type': 'task', 'timestamp': '2024-06-23T...+00:00', 'step': 2, 'payload': {'id': '...', 'name': 'b', 'input': {'alist': ['Ex for stream_mode="debug"'], 'another_list': ['hi']}, 'triggers': ['a']}}
# {'type': 'task_result', 'timestamp': '2024-06-23T...+00:00', 'step': 2, 'payload': {'id': '...', 'name': 'b', 'result': [('alist', ['there'])]}}

使用 stream_mode="custom"

from langgraph.types import StreamWriter

def node_a(state: State, writer: StreamWriter):
    writer({"custom_data": "foo"})
    return {"alist": ["hi"]}

builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
graph = builder.compile()

for event in graph.stream({"alist": ['Ex for stream_mode="custom"']}, stream_mode="custom"):
    print(event)

# {'custom_data': 'foo'}

使用 stream_mode="messages"

from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph, START
from langchain_openai import ChatOpenAI

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

class State(TypedDict):
    question: str
    answer: str

def node_a(state: State):
    response = llm.invoke(state["question"])
    return {"answer": response.content}

builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
graph = builder.compile()

for event in graph.stream({"question": "What is the capital of France?"}, stream_mode="messages"):
    print(event)

# (AIMessageChunk(content='The', additional_kwargs={}, response_metadata={}, id='...'), {'langgraph_step': 1, 'langgraph_node': 'a', 'langgraph_triggers': ['start:a'], 'langgraph_path': ('__pregel_pull', 'a'), 'langgraph_checkpoint_ns': '...', 'checkpoint_ns': '...', 'ls_provider': 'openai', 'ls_model_name': 'gpt-4o-mini', 'ls_model_type': 'chat', 'ls_temperature': 0.7})
# (AIMessageChunk(content=' capital', additional_kwargs={}, response_metadata={}, id='...'), {'langgraph_step': 1, 'langgraph_node': 'a', 'langgraph_triggers': ['start:a'], ...})
# (AIMessageChunk(content=' of', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' France', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' is', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' Paris', additional_kwargs={}, response_metadata={}, id='...'), {...})

astream `async` ¶

astream(
    input: dict[str, Any] | Any,
    config: RunnableConfig | None = None,
    *,
    stream_mode: (
        StreamMode | list[StreamMode] | None
    ) = None,
    output_keys: str | Sequence[str] | None = None,
    interrupt_before: All | Sequence[str] | None = None,
    interrupt_after: All | Sequence[str] | None = None,
    checkpoint_during: bool | None = None,
    debug: bool | None = None,
    subgraphs: bool = False
) -> AsyncIterator[dict[str, Any] | Any]

为单个输入异步流式传输图步骤。

参数

名称	类型	描述	默认值
`input`	`dict[str, Any] \| Any`	图的输入。	必需
`config`	`RunnableConfig \| None`	运行使用的配置。	`None`
`stream_mode`	`StreamMode \| list[StreamMode] \| None`	输出流模式，默认为 self.stream_mode。选项有 `"values"`: 在每一步后发出状态中的所有值，包括中断。与函数式 API 一起使用时，值在工作流结束时一次性发出。 `"updates"`: 在每一步后仅发出节点或任务名称以及节点或任务返回的更新。如果在同一步骤中进行多次更新（例如，运行多个节点），则这些更新会单独发出。 `"custom"`: 使用 `StreamWriter` 从节点或任务内部发出自定义数据。 `"messages"`: 逐令牌发出 LLM 消息，并附带节点或任务内任何 LLM 调用的元数据。 `"debug"`: 在每一步中发出尽可能包含详细信息的调试事件。	`None`
`output_keys`	`str \| Sequence[str] \| None`	要流式传输的键，默认为所有非上下文通道。	`None`
`interrupt_before`	`All \| Sequence[str] \| None`	在这些节点之前中断的节点，默认为图中的所有节点。	`None`
`interrupt_after`	`All \| Sequence[str] \| None`	在这些节点之后中断的节点，默认为图中的所有节点。	`None`
`checkpoint_during`	`bool \| None`	是否检查点中间步骤，默认为 True。如果为 False，仅保存最终检查点。	`None`
`debug`	`bool \| None`	执行期间是否打印调试信息，默认为 False。	`None`
`subgraphs`	`bool`	是否流式传输子图，默认为 False。	`False`

生成

类型	描述
`AsyncIterator[dict[str, Any] \| Any]`	图中每个步骤的输出。输出形状取决于 stream_mode。

使用 stream_mode="values"

import operator
from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph, START

class State(TypedDict):
    alist: Annotated[list, operator.add]
    another_list: Annotated[list, operator.add]

builder = StateGraph(State)
builder.add_node("a", lambda _state: {"another_list": ["hi"]})
builder.add_node("b", lambda _state: {"alist": ["there"]})
builder.add_edge("a", "b")
builder.add_edge(START, "a")
graph = builder.compile()

async for event in graph.astream({"alist": ['Ex for stream_mode="values"']}, stream_mode="values"):
    print(event)

# {'alist': ['Ex for stream_mode="values"'], 'another_list': []}
# {'alist': ['Ex for stream_mode="values"'], 'another_list': ['hi']}
# {'alist': ['Ex for stream_mode="values"', 'there'], 'another_list': ['hi']}

使用 stream_mode="updates"

async for event in graph.astream({"alist": ['Ex for stream_mode="updates"']}, stream_mode="updates"):
    print(event)

# {'a': {'another_list': ['hi']}}
# {'b': {'alist': ['there']}}

使用 stream_mode="debug"

async for event in graph.astream({"alist": ['Ex for stream_mode="debug"']}, stream_mode="debug"):
    print(event)

# {'type': 'task', 'timestamp': '2024-06-23T...+00:00', 'step': 1, 'payload': {'id': '...', 'name': 'a', 'input': {'alist': ['Ex for stream_mode="debug"'], 'another_list': []}, 'triggers': ['start:a']}}
# {'type': 'task_result', 'timestamp': '2024-06-23T...+00:00', 'step': 1, 'payload': {'id': '...', 'name': 'a', 'result': [('another_list', ['hi'])]}}
# {'type': 'task', 'timestamp': '2024-06-23T...+00:00', 'step': 2, 'payload': {'id': '...', 'name': 'b', 'input': {'alist': ['Ex for stream_mode="debug"'], 'another_list': ['hi']}, 'triggers': ['a']}}
# {'type': 'task_result', 'timestamp': '2024-06-23T...+00:00', 'step': 2, 'payload': {'id': '...', 'name': 'b', 'result': [('alist', ['there'])]}}

使用 stream_mode="custom"

from langgraph.types import StreamWriter

async def node_a(state: State, writer: StreamWriter):
    writer({"custom_data": "foo"})
    return {"alist": ["hi"]}

builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
graph = builder.compile()

async for event in graph.astream({"alist": ['Ex for stream_mode="custom"']}, stream_mode="custom"):
    print(event)

# {'custom_data': 'foo'}

使用 stream_mode="messages"

from typing_extensions import Annotated, TypedDict
from langgraph.graph import StateGraph, START
from langchain_openai import ChatOpenAI

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

class State(TypedDict):
    question: str
    answer: str

async def node_a(state: State):
    response = await llm.ainvoke(state["question"])
    return {"answer": response.content}

builder = StateGraph(State)
builder.add_node("a", node_a)
builder.add_edge(START, "a")
graph = builder.compile()

async for event in graph.astream({"question": "What is the capital of France?"}, stream_mode="messages"):
    print(event)

# (AIMessageChunk(content='The', additional_kwargs={}, response_metadata={}, id='...'), {'langgraph_step': 1, 'langgraph_node': 'a', 'langgraph_triggers': ['start:a'], 'langgraph_path': ('__pregel_pull', 'a'), 'langgraph_checkpoint_ns': '...', 'checkpoint_ns': '...', 'ls_provider': 'openai', 'ls_model_name': 'gpt-4o-mini', 'ls_model_type': 'chat', 'ls_temperature': 0.7})
# (AIMessageChunk(content=' capital', additional_kwargs={}, response_metadata={}, id='...'), {'langgraph_step': 1, 'langgraph_node': 'a', 'langgraph_triggers': ['start:a'], ...})
# (AIMessageChunk(content=' of', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' France', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' is', additional_kwargs={}, response_metadata={}, id='...'), {...})
# (AIMessageChunk(content=' Paris', additional_kwargs={}, response_metadata={}, id='...'), {...})

invoke ¶

invoke(
    input: dict[str, Any] | Any,
    config: RunnableConfig | None = None,
    *,
    stream_mode: StreamMode = "values",
    output_keys: str | Sequence[str] | None = None,
    interrupt_before: All | Sequence[str] | None = None,
    interrupt_after: All | Sequence[str] | None = None,
    checkpoint_during: bool | None = None,
    debug: bool | None = None,
    **kwargs: Any
) -> dict[str, Any] | Any

使用单个输入和配置运行图。

参数

名称	类型	描述	默认值
`input`	`dict[str, Any] \| Any`	图的输入数据。可以是字典或任何其他类型。	必需
`config`	`RunnableConfig \| None`	可选。图运行的配置。	`None`
`stream_mode`	`StreamMode`	可选[str]。图运行的流模式。默认为 "values"。	`'values'`
`output_keys`	`str \| Sequence[str] \| None`	可选。从图运行中检索的输出键。	`None`
`interrupt_before`	`All \| Sequence[str] \| None`	可选。在这些节点之前中断图运行的节点。	`None`
`interrupt_after`	`All \| Sequence[str] \| None`	可选。在这些节点之后中断图运行的节点。	`None`
`debug`	`bool \| None`	可选。为图运行启用调试模式。	`None`
`**kwargs`	`Any`	传递给图运行的附加关键字参数。	`{}`

返回值

类型	描述
`dict[str, Any] \| Any`	图运行的输出。如果 stream_mode 是 "values"，则返回最新输出。
`dict[str, Any] \| Any`	如果 stream_mode 不是 "values"，则返回输出块列表。

ainvoke `async` ¶

ainvoke(
    input: dict[str, Any] | Any,
    config: RunnableConfig | None = None,
    *,
    stream_mode: StreamMode = "values",
    output_keys: str | Sequence[str] | None = None,
    interrupt_before: All | Sequence[str] | None = None,
    interrupt_after: All | Sequence[str] | None = None,
    checkpoint_during: bool | None = None,
    debug: bool | None = None,
    **kwargs: Any
) -> dict[str, Any] | Any

在单个输入上异步调用图。

参数

名称	类型	描述	默认值
`input`	`dict[str, Any] \| Any`	计算的输入数据。可以是字典或任何其他类型。	必需
`config`	`RunnableConfig \| None`	可选。计算的配置。	`None`
`stream_mode`	`StreamMode`	可选。计算的流模式。默认为 "values"。	`'values'`
`output_keys`	`str \| Sequence[str] \| None`	可选。结果中包含的输出键。默认为 None。	`None`
`interrupt_before`	`All \| Sequence[str] \| None`	可选。在这些节点之前中断的节点。默认为 None。	`None`
`interrupt_after`	`All \| Sequence[str] \| None`	可选。在这些节点之后中断的节点。默认为 None。	`None`
`debug`	`bool \| None`	可选。是否启用调试模式。默认为 None。	`None`
`**kwargs`	`Any`	附加关键字参数。	`{}`

返回值

类型	描述
`dict[str, Any] \| Any`	计算结果。如果 stream_mode 是 "values"，则返回最新值。
`dict[str, Any] \| Any`	如果 stream_mode 是 "chunks"，则返回块列表。

get_state ¶

get_state(
    config: RunnableConfig, *, subgraphs: bool = False
) -> StateSnapshot

获取图的当前状态。

aget_state `async` ¶

aget_state(
    config: RunnableConfig, *, subgraphs: bool = False
) -> StateSnapshot

获取图的当前状态。

get_state_history ¶

get_state_history(
    config: RunnableConfig,
    *,
    filter: dict[str, Any] | None = None,
    before: RunnableConfig | None = None,
    limit: int | None = None
) -> Iterator[StateSnapshot]

获取图的状态历史。

aget_state_history `async` ¶

aget_state_history(
    config: RunnableConfig,
    *,
    filter: dict[str, Any] | None = None,
    before: RunnableConfig | None = None,
    limit: int | None = None
) -> AsyncIterator[StateSnapshot]

异步获取图的状态历史。

update_state ¶

update_state(
    config: RunnableConfig,
    values: dict[str, Any] | Any | None,
    as_node: str | None = None,
) -> RunnableConfig

使用给定值更新图的状态，就像它们来自节点 as_node。如果未提供 as_node，如果无歧义，则将其设置为更新状态的最后一个节点。

aupdate_state `async` ¶

aupdate_state(
    config: RunnableConfig,
    values: dict[str, Any] | Any,
    as_node: str | None = None,
) -> RunnableConfig

使用给定值异步更新图的状态，就像它们来自节点 as_node。如果未提供 as_node，如果无歧义，则将其设置为更新状态的最后一个节点。

bulk_update_state ¶

bulk_update_state(
    config: RunnableConfig,
    supersteps: Sequence[Sequence[StateUpdate]],
) -> RunnableConfig

批量应用更新到图状态。需要设置检查点。

参数

名称	类型	描述	默认值
`config`	`RunnableConfig`	应用更新的配置。	必需
`supersteps`	`Sequence[Sequence[StateUpdate]]`	超步列表，每个超步包含一个要按顺序应用于图状态的更新列表。每个更新都是一个形式为 `(values, as_node)` 的元组。	必需

引发

类型	描述
`ValueError`	如果未设置检查点或未提供更新。
`InvalidUpdateError`	如果提供了无效更新。

返回值

名称	类型	描述
`RunnableConfig`	`RunnableConfig`	更新后的配置。

abulk_update_state `async` ¶

abulk_update_state(
    config: RunnableConfig,
    supersteps: Sequence[Sequence[StateUpdate]],
) -> RunnableConfig

异步批量应用更新到图状态。需要设置检查点。

参数

名称	类型	描述	默认值
`config`	`RunnableConfig`	应用更新的配置。	必需
`supersteps`	`Sequence[Sequence[StateUpdate]]`	超步列表，每个超步包含一个要按顺序应用于图状态的更新列表。每个更新都是一个形式为 `(values, as_node)` 的元组。	必需

引发

类型	描述
`ValueError`	如果未设置检查点或未提供更新。
`InvalidUpdateError`	如果提供了无效更新。

返回值

名称	类型	描述
`RunnableConfig`	`RunnableConfig`	更新后的配置。

get_graph ¶

get_graph(
    config: RunnableConfig | None = None,
    *,
    xray: int | bool = False
) -> Graph

返回计算图的可绘制表示。

aget_graph `async` ¶

aget_graph(
    config: RunnableConfig | None = None,
    *,
    xray: int | bool = False
) -> Graph

返回计算图的可绘制表示。

get_subgraphs ¶

get_subgraphs(
    *, namespace: str | None = None, recurse: bool = False
) -> Iterator[tuple[str, PregelProtocol]]

获取图的子图。

参数

名称	类型	描述	默认值
`namespace`	`str \| None`	用于过滤子图的命名空间。	`None`
`recurse`	`bool`	是否递归进入子图。如果为 False，则仅返回直接子图。	`False`

返回值

类型	描述
`Iterator[tuple[str, PregelProtocol]]`	Iterator[tuple[str, PregelProtocol]]: (命名空间, 子图) 对的迭代器。

aget_subgraphs `async` ¶

aget_subgraphs(
    *, namespace: str | None = None, recurse: bool = False
) -> AsyncIterator[tuple[str, PregelProtocol]]

获取图的子图。

参数

名称	类型	描述	默认值
`namespace`	`str \| None`	用于过滤子图的命名空间。	`None`
`recurse`	`bool`	是否递归进入子图。如果为 False，则仅返回直接子图。	`False`

返回值

类型	描述
`AsyncIterator[tuple[str, PregelProtocol]]`	AsyncIterator[tuple[str, PregelProtocol]]: (命名空间, 子图) 对的异步迭代器。

with_config ¶

with_config(
    config: RunnableConfig | None = None, **kwargs: Any
) -> Self

创建 Pregel 对象的副本并更新配置。

函数

名称	描述
`add_messages`	合并两个消息列表，根据 ID 更新现有消息。

add_messages ¶

add_messages(
    left: Messages,
    right: Messages,
    *,
    format: Optional[Literal["langchain-openai"]] = None
) -> Messages

合并两个消息列表，根据 ID 更新现有消息。

默认情况下，除非新消息与现有消息具有相同的 ID，否则这会确保状态为“仅追加”。

参数

名称	类型	描述	默认值
`left`	`消息`	基础消息列表。	必需
`right`	`消息`	要合并到基础列表中的消息列表（或单个消息）。	必需
`格式`	`Optional[Literal['langchain-openai']]`	返回消息的格式。如果为 None，则消息将按原样返回。如果为 'langchain-openai'，则消息将以 BaseMessage 对象的形式返回，其内容格式与 OpenAI 消息格式匹配，这意味着内容可以是字符串、'text' 块或 'image_url' 块，工具响应将作为其自己的 ToolMessages 返回。要求必须安装 `langchain-core>=0.3.11` 才能使用此功能。	`None`

返回值

类型	描述
`消息`	一个新消息列表，其中来自 `right` 的消息已合并到 `left` 中。
`消息`	如果 `right` 中的消息与 `left` 中的消息具有相同的 ID，则
`消息`	来自 `right` 的消息将替换来自 `left` 的消息。

示例

基本用法

from langchain_core.messages import AIMessage, HumanMessage
msgs1 = [HumanMessage(content="Hello", id="1")]
msgs2 = [AIMessage(content="Hi there!", id="2")]
add_messages(msgs1, msgs2)
# [HumanMessage(content='Hello', id='1'), AIMessage(content='Hi there!', id='2')]

覆盖现有消息

msgs1 = [HumanMessage(content="Hello", id="1")]
msgs2 = [HumanMessage(content="Hello again", id="1")]
add_messages(msgs1, msgs2)
# [HumanMessage(content='Hello again', id='1')]

在 StateGraph 中使用

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph

class State(TypedDict):
    messages: Annotated[list, add_messages]

builder = StateGraph(State)
builder.add_node("chatbot", lambda state: {"messages": [("assistant", "Hello")]})
builder.set_entry_point("chatbot")
builder.set_finish_point("chatbot")
graph = builder.compile()
graph.invoke({})
# {'messages': [AIMessage(content='Hello', id=...)]}

使用 OpenAI 消息格式

from typing import Annotated
from typing_extensions import TypedDict
from langgraph.graph import StateGraph, add_messages

class State(TypedDict):
    messages: Annotated[list, add_messages(format='langchain-openai')]

def chatbot_node(state: State) -> list:
    return {"messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Here's an image:",
                    "cache_control": {"type": "ephemeral"},
                },
                {
                    "type": "image",
                    "source": {
                        "type": "base64",
                        "media_type": "image/jpeg",
                        "data": "1234",
                    },
                },
            ]
        },
    ]}

builder = StateGraph(State)
builder.add_node("chatbot", chatbot_node)
builder.set_entry_point("chatbot")
builder.set_finish_point("chatbot")
graph = builder.compile()
graph.invoke({"messages": []})
# {
#     'messages': [
#         HumanMessage(
#             content=[
#                 {"type": "text", "text": "Here's an image:"},
#                 {
#                     "type": "image_url",
#                     "image_url": {"url": "data:image/jpeg;base64,1234"},
#                 },
#             ],
#         ),
#     ]
# }

图定义¶

StateGraph ¶

add_node ¶

add_edge ¶

add_conditional_edges ¶

add_sequence ¶

compile ¶

CompiledStateGraph ¶

stream ¶

astream async ¶

invoke ¶

ainvoke async ¶

get_state ¶

aget_state async ¶

get_state_history ¶

aget_state_history async ¶

update_state ¶

aupdate_state async ¶

bulk_update_state ¶

abulk_update_state async ¶

get_graph ¶

aget_graph async ¶

get_subgraphs ¶

aget_subgraphs async ¶

with_config ¶

Graph ¶

add_node ¶

add_edge ¶

add_conditional_edges ¶

compile ¶

CompiledGraph ¶

stream ¶

astream async ¶

invoke ¶

ainvoke async ¶

get_state ¶

aget_state async ¶

get_state_history ¶

aget_state_history async ¶

update_state ¶

aupdate_state async ¶

bulk_update_state ¶

abulk_update_state async ¶

get_graph ¶

aget_graph async ¶

get_subgraphs ¶

aget_subgraphs async ¶

with_config ¶

add_messages ¶

评论

astream `async` ¶

ainvoke `async` ¶

aget_state `async` ¶

aget_state_history `async` ¶

aupdate_state `async` ¶

abulk_update_state `async` ¶

aget_graph `async` ¶

aget_subgraphs `async` ¶

astream `async` ¶

ainvoke `async` ¶

aget_state `async` ¶

aget_state_history `async` ¶

aupdate_state `async` ¶

abulk_update_state `async` ¶

aget_graph `async` ¶

aget_subgraphs `async` ¶