返回专栏
· 29 分钟阅读

LangGraph 的状态管理机制


一、什么是 LangGraph 状态管理

在传统程序中,函数通常通过参数接收输入,通过返回值输出结果。多个函数之间需要显式传递数据。

但在 Agent 工作流中,任务往往不是一次函数调用就能完成,而是由多个节点组成的执行图。节点之间需要持续共享信息,例如:

  • 用户最初提出的问题。
  • 当前任务的执行阶段。
  • Agent 已经完成的推理和分析结果。
  • 工具调用记录。
  • 中间执行结果。
  • 错误信息和重试次数。
  • 是否需要人工审核。
  • 最终生成的答案。

如果每个节点都单独维护自己的数据,就会产生大量重复传递和状态同步工作。

LangGraph 使用统一的 State 管理工作流中的共享数据。

可以将 LangGraph 理解为一个基于状态驱动的图执行框架:

  • State:定义整个工作流需要共享的数据结构。
  • Node:读取当前状态,并返回需要更新的字段。
  • Edge:决定节点之间的执行关系。
  • Reducer:定义多个状态更新如何合并。
  • Checkpointer:保存执行过程中的状态快照。
  • Store:保存跨线程、跨会话或跨任务需要复用的数据。

其中,State 是整个状态管理机制的核心。

1. LangGraph 为什么需要状态管理

考虑一个简单的 Agent 工作流:

  1. 用户提交问题。
  2. Planner 分析任务。
  3. Researcher 收集资料。
  4. Analyst 分析资料。
  5. Reviewer 检查结果。
  6. Agent 返回最终答案。

每个阶段都需要读取前面阶段产生的信息。

如果使用普通函数组织:

def planner(user_input):
    return {"plan": "研究技术方案"}

def researcher(plan):
    return {"research": "收集到的技术资料"}

def analyst(research):
    return {"analysis": "技术分析结果"}

def reviewer(analysis):
    return {"review": "审核通过"}

这种方式在步骤较少时没有问题,但随着工作流复杂度增加,会出现:

  • 函数之间需要显式传递越来越多的参数。
  • 多个节点需要访问同一份数据。
  • 并行节点需要合并执行结果。
  • 循环执行需要持续维护状态。
  • 长时间运行任务需要保存和恢复进度。

LangGraph 将这些数据统一放入 State,由图执行引擎负责在节点之间传递和更新。

二、LangGraph State 的基本结构

LangGraph 的 State 通常使用 Python 的 TypedDict 定义,也可以使用其他受支持的结构化类型。

例如:

from typing import TypedDict


class AgentState(TypedDict):
    user_input: str
    plan: str
    research: str
    analysis: str
    final_answer: str

这个 State 定义了工作流中需要共享的五个字段。

每个节点都可以根据自己的职责读取和更新其中的字段。

例如:

def planner(state: AgentState):
    return {
        "plan": f"分析用户需求:{state['user_input']}"
    }


def researcher(state: AgentState):
    return {
        "research": "收集到相关技术资料"
    }


def analyst(state: AgentState):
    return {
        "analysis": f"基于资料进行分析:{state['research']}"
    }

节点通常不需要返回整个 State,只需要返回本次执行需要更新的字段。

LangGraph 会根据 State 的字段定义和归约规则,将节点返回的更新应用到当前状态。

1. State 的初始值

执行图时,可以向图传入初始 State:

initial_state = {
    "user_input": "解释 LangGraph 的状态管理机制",
    "plan": "",
    "research": "",
    "analysis": "",
    "final_answer": ""
}

初始状态代表工作流开始执行时的数据。

随着节点不断执行,State 会持续更新。

2. State 的读取

节点通过参数接收当前 State:

def planner(state: AgentState):
    user_input = state["user_input"]

    return {
        "plan": f"围绕以下问题制定计划:{user_input}"
    }

节点可以读取自己需要的字段,不必关心其他节点如何执行。

这种方式让节点之间形成相对独立的职责边界。

3. State 的更新

节点返回一个字典,表示本次执行产生的状态更新:

def planner(state: AgentState):
    return {
        "plan": "1. 收集资料 2. 分析机制 3. 总结结果"
    }

这里返回的只是更新内容,而不是完整 State。

假设当前状态为:

{
    "user_input": "研究 LangGraph",
    "plan": "",
    "research": "",
    "analysis": "",
    "final_answer": ""
}

执行 planner 后,状态逻辑上更新为:

{
    "user_input": "研究 LangGraph",
    "plan": "1. 收集资料 2. 分析机制 3. 总结结果",
    "research": "",
    "analysis": "",
    "final_answer": ""
}

没有被更新的字段会保留原来的值。

4. State 的完整更新过程

flowchart TD
    A["创建初始 State"] --> B["节点读取当前 State"]
    B --> C["执行节点逻辑"]
    C --> D["返回部分字段更新"]
    D --> E["应用字段归约规则"]
    E --> F["生成更新后的 State"]
    F --> G{"是否还有后续节点"}
    G -->|"是"| B
    G -->|"否"| H["输出最终 State"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F

三、State Schema 与类型定义

State Schema 是 LangGraph 状态结构的定义。

它决定工作流中有哪些字段、字段采用什么数据类型,以及字段更新时使用什么规则。

1. 使用 TypedDict 定义 State

TypedDict 是 LangGraph 中常见的 State 定义方式。

from typing import TypedDict


class AgentState(TypedDict):
    question: str
    plan: str
    documents: list[str]
    answer: str

优点:

  • 定义直观。
  • 类型提示清晰。
  • 适合描述结构化状态。
  • 能够与 Python 类型检查工具配合使用。

2. 使用 Annotated 定义 Reducer

有些字段并不是简单覆盖,而是需要执行合并操作。

例如,多个节点可能分别向同一个列表追加数据。

这时可以使用 Annotated 为字段指定 Reducer。

import operator
from typing import Annotated, TypedDict


class AgentState(TypedDict):
    question: str
    documents: Annotated[list[str], operator.add]

这里的 operator.add 表示列表更新采用加法合并。

例如:

current = ["文档 A"]
update = ["文档 B"]

result = current + update

print(result)

输出:

['文档 A', '文档 B']

如果没有指定 Reducer,普通字段通常采用覆盖更新语义。

3. 使用 Optional 和 NotRequired

在真实业务中,不是所有字段在工作流开始时都存在。

可以使用 NotRequired 或 total=False 描述非必填字段。

from typing import TypedDict, NotRequired


class AgentState(TypedDict):
    question: str
    answer: NotRequired[str]
    error: NotRequired[str]
    retry_count: NotRequired[int]

这样可以表达:

  • question 是必要字段。
  • answer 可以在后续节点执行时产生。
  • error 只在发生异常时产生。
  • retry_count 可以在重试过程中更新。

需要区分类型定义与运行时校验:TypedDict 主要提供静态类型信息,并不自动保证所有运行时输入都符合定义。需要严格校验时,可以结合 Pydantic 等数据校验工具。

4. 使用 Pydantic 定义状态

对于需要严格数据校验的场景,可以使用 Pydantic 模型定义 State。

from pydantic import BaseModel


class AgentState(BaseModel):
    question: str
    plan: str = ""
    answer: str = ""
    retry_count: int = 0

Pydantic 能够提供:

  • 字段类型校验。
  • 默认值管理。
  • 数据转换。
  • 结构化数据验证。

选择 TypedDict 还是 Pydantic,应根据工作流的类型约束、校验需求和具体版本支持情况决定。

四、Reducer:状态归约机制

Reducer 是 LangGraph 状态管理中非常重要的概念。

它决定节点返回的更新内容应该如何与当前 State 合并。

如果没有理解 Reducer,就很难正确处理并行节点、列表追加和共享状态更新。

1. 默认更新规则:覆盖

对于没有指定 Reducer 的普通字段,LangGraph 通常采用覆盖更新。

例如:

from typing import TypedDict


class AgentState(TypedDict):
    answer: str

当前状态:

{
    "answer": "初始答案"
}

节点返回:

{
    "answer": "更新后的答案"
}

更新后的状态:

{
    "answer": "更新后的答案"
}

旧值被新值替换。

这种方式适合:

  • 当前任务阶段。
  • 最终答案。
  • 当前执行者。
  • 当前审核状态。
  • 单一配置值。

2. 使用 operator.add 追加列表

当多个节点需要向同一个列表追加内容时,可以定义列表 Reducer。

import operator
from typing import Annotated, TypedDict


class AgentState(TypedDict):
    documents: Annotated[list[str], operator.add]

假设当前状态为:

{
    "documents": ["文档 A"]
}

节点返回:

{
    "documents": ["文档 B"]
}

更新结果:

{
    "documents": ["文档 A", "文档 B"]
}

注意,Reducer 的合并语义取决于字段类型和指定函数,不是所有字段都应该使用 operator.add。

3. 自定义 Reducer

对于更复杂的状态,可以定义自己的归约函数。

例如,需要合并多个 Agent 的分析结果,并保留所有结果:

from typing import Annotated, TypedDict


def merge_results(current, update):
    return current + update


class AgentState(TypedDict):
    results: Annotated[list[dict], merge_results]

Reducer 接收两个参数:

  • current:当前字段已有的值。
  • update:节点提交的新值。

返回值就是归约后的字段值。

自定义 Reducer 可以实现:

  • 列表合并。
  • 字典合并。
  • 去重。
  • 结果聚合。
  • 版本比较。
  • 冲突处理。

例如,合并字典:

def merge_metadata(current, update):
    return {
        **current,
        **update
    }

需要注意,普通字典合并采用后者覆盖前者的语义。如果多个节点同时更新相同键,仍然需要明确冲突解决规则。

4. Reducer 的核心执行机制

flowchart TD
    A["当前 State"] --> C["Reducer"]
    B["节点返回 Update"] --> C
    C --> D["执行合并逻辑"]
    D --> E["得到归约结果"]
    E --> F["写入更新后的 State"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F

Reducer 解决的是状态更新如何合并的问题,而不是节点之间如何调度的问题。

这两个概念需要区分:

  • 节点调度决定哪些节点执行。
  • Reducer 决定节点更新如何应用到状态。

五、并行节点与状态合并

LangGraph 支持多个节点在同一执行阶段并行运行。

并行节点可能同时读取相同的 State,并分别返回不同的更新内容。

这就产生了一个关键问题:多个节点如何更新同一个状态字段?

1. 并行节点更新不同字段

例如:

  • Research Agent 更新 research。
  • Analysis Agent 更新 analysis。
from typing import TypedDict


class AgentState(TypedDict):
    question: str
    research: str
    analysis: str


def research_agent(state):
    return {
        "research": "收集到技术资料"
    }


def analysis_agent(state):
    return {
        "analysis": "完成初步分析"
    }

两个节点分别更新不同字段,不会发生字段覆盖冲突。

2. 并行节点更新同一个字段

如果两个节点同时更新同一个普通字段,例如:

class AgentState(TypedDict):
    result: str

Research Agent 返回:

{
    "result": "研究结果"
}

Analysis Agent 返回:

{
    "result": "分析结果"
}

由于普通字段默认采用覆盖语义,多个并行更新可能产生更新冲突。

在 LangGraph 中,同一个 super-step 内多个节点对同一通道产生更新时,如果该通道没有能够处理多更新的 Reducer,可能触发 InvalidUpdateError。

正确做法是根据业务语义定义 Reducer。

3. 使用列表 Reducer 合并并行结果

import operator
from typing import Annotated, TypedDict


class AgentState(TypedDict):
    results: Annotated[list[str], operator.add]


def research_agent(state):
    return {
        "results": ["研究结果"]
    }


def analysis_agent(state):
    return {
        "results": ["分析结果"]
    }

这样多个节点可以向 results 提交更新,由 Reducer 进行合并。

并行执行过程:

flowchart TD
    A["共享初始 State"] --> B["并行节点调度"]

    B --> C["Research Agent"]
    B --> D["Analysis Agent"]
    B --> E["Security Agent"]

    C --> F["返回结果"]
    D --> G["返回结果"]
    E --> H["返回结果"]

    F --> I["Reducer 合并"]
    G --> I
    H --> I

    I --> J["更新共享 State"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4. 并行结果的顺序问题

并行节点的执行完成顺序可能不同,因此不能随意假设结果列表的顺序始终符合业务要求。

如果结果顺序很重要,可以在每个结果中携带:

  • 任务 ID。
  • 节点名称。
  • 排序序号。
  • 创建时间。
  • 结果版本。

随后由专门的汇总节点按照业务规则排序。

例如:

def merge_results(current, update):
    merged = current + update

    return sorted(
        merged,
        key=lambda item: item["order"]
    )

这比依赖节点完成时间更可靠。

六、State 与节点、边的关系

State、Node 和 Edge 是 LangGraph 图执行模型的三个基础组成部分。

1. State:保存共享数据

State 描述整个工作流需要管理的数据。

例如:

class AgentState(TypedDict):
    question: str
    plan: str
    result: str

2. Node:执行任务并更新状态

Node 是图中的执行单元。

def planner(state):
    return {
        "plan": "先分析需求,再生成答案"
    }

Node 可以调用:

  • LLM。
  • 外部工具。
  • 数据库。
  • 检索系统。
  • 其他 Agent。

3. Edge:控制执行路径

Edge 决定节点之间如何连接。

普通边表示固定的后续节点:

graph.add_edge("planner", "researcher")

条件边根据当前 State 决定下一步执行哪个节点:

def route_task(state):
    if state["task_type"] == "research":
        return "researcher"

    return "analyst"

4. 三者之间的关系

flowchart TD
    A["State 共享状态"] --> B["Node 读取状态"]
    B --> C["执行节点逻辑"]
    C --> D["返回状态更新"]
    D --> A

    C --> E["Edge 判断执行路径"]
    E --> F["选择下一个 Node"]
    F --> B

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976

State 负责数据,Node 负责执行,Edge 负责流程控制。

三者结合形成完整的状态驱动执行机制。

七、MessagesState 与消息状态管理

在对话型 Agent 中,消息通常是最重要的状态数据。

LangGraph 提供了 MessagesState,用于管理消息列表。

它本质上是一个预定义的状态结构,包含 messages 字段,并使用消息归约逻辑处理消息更新。

1. 使用 MessagesState

from langgraph.graph import MessagesState


class AgentState(MessagesState):
    user_name: str
    task_status: str

这样就可以同时管理:

  • 对话消息。
  • 用户信息。
  • 当前任务状态。

2. 使用 add_messages

消息字段通常需要特殊的合并规则。

例如:

from typing import Annotated
from typing_extensions import TypedDict

from langgraph.graph.message import add_messages
from langchain_core.messages import AnyMessage


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

add_messages 不只是简单地追加消息,还会根据消息 ID 处理更新。

典型行为包括:

  • 新消息追加到列表。
  • 相同 ID 的消息可以被更新。
  • 支持消息删除标记。
  • 维护消息列表的结构。

3. 为什么不能简单使用 operator.add

对于普通文本列表:

["消息 A"] + ["消息 B"]

通常可以满足追加需求。

但对话消息还可能包含:

  • HumanMessage。
  • AIMessage。
  • SystemMessage。
  • ToolMessage。
  • 工具调用信息。
  • 消息 ID。
  • 多模态内容。

因此,直接使用普通列表拼接无法完整表达消息更新和删除语义。

add_messages 更适合管理 LangChain 消息对象。

4. 对话消息状态的更新过程

flowchart TD
    A["当前 Messages"] --> C["add_messages"]
    B["新消息或消息更新"] --> C

    C --> D{"消息 ID 是否已存在"}

    D -->|"否"| E["追加新消息"]
    D -->|"是"| F["更新对应消息"]

    E --> G["生成新的消息列表"]
    F --> G

    G --> H["写入 State"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style C fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F

八、Input Schema、Output Schema 与 Private State

真实应用中,工作流的内部状态通常比用户需要看到的内容复杂得多。

例如,一个研究 Agent 内部可能需要保存:

  • 原始用户请求。
  • 任务规划。
  • 检索文档。
  • 中间分析。
  • 调用日志。
  • 审核意见。
  • 最终答案。

但用户只需要最终答案。

LangGraph 可以通过不同的 Schema 区分输入、输出和内部状态。

1. Input Schema

Input Schema 描述调用工作流时允许传入的数据结构。

from typing_extensions import TypedDict


class InputState(TypedDict):
    question: str

2. Output Schema

Output Schema 描述工作流最终向外暴露的数据结构。

class OutputState(TypedDict):
    answer: str

3. Internal State

内部状态包含工作流执行过程中需要的数据。

class OverallState(TypedDict):
    question: str
    plan: str
    research: str
    analysis: str
    answer: str

4. 完整示例

from typing_extensions import TypedDict
from langgraph.graph import StateGraph, START, END


class InputState(TypedDict):
    question: str


class OutputState(TypedDict):
    answer: str


class OverallState(TypedDict):
    question: str
    plan: str
    research: str
    analysis: str
    answer: str


def planner(state: OverallState):
    return {
        "plan": "制定研究计划"
    }


def researcher(state: OverallState):
    return {
        "research": "收集相关技术资料"
    }


def analyst(state: OverallState):
    return {
        "analysis": "完成技术分析"
    }


def writer(state: OverallState):
    return {
        "answer": (
            f"问题:{state['question']};"
            f"分析:{state['analysis']}"
        )
    }


builder = StateGraph(
    OverallState,
    input_schema=InputState,
    output_schema=OutputState
)

builder.add_node("planner", planner)
builder.add_node("researcher", researcher)
builder.add_node("analyst", analyst)
builder.add_node("writer", writer)

builder.add_edge(START, "planner")
builder.add_edge("planner", "researcher")
builder.add_edge("researcher", "analyst")
builder.add_edge("analyst", "writer")
builder.add_edge("writer", END)

graph = builder.compile()

result = graph.invoke({
    "question": "LangGraph 如何管理状态?"
})

print(result)

这个例子展示了三种 Schema 的关系:

  • InputState:约束外部输入。
  • OverallState:管理工作流内部状态。
  • OutputState:约束最终输出。

Private State 也可以通过独立的内部 Schema 或节点专属状态字段组织。需要注意,内部字段是否对外可见,取决于图的输入输出 Schema 和具体 API 设计,不能仅仅因为字段被称为 private 就认为它自动获得了安全隔离。

九、Checkpoint:状态持久化机制

State 负责管理当前执行过程中的数据,但如果程序退出或服务崩溃,内存中的状态也可能丢失。

LangGraph 使用 Checkpointer 保存执行过程中的状态快照。

Checkpoint 是某个执行时刻的状态记录。

它通常包含:

  • 当前图的状态。
  • 执行配置。
  • 任务线程标识。
  • 检查点 ID。
  • 父检查点信息。
  • 待处理的执行任务和相关元数据。

1. Checkpoint 的作用

Checkpoint 主要解决三个问题:

状态持久化

将执行状态保存到持久化存储中,避免完全依赖内存。

中断恢复

工作流暂停或异常退出后,可以根据之前的检查点继续执行。

执行历史管理

保存多个执行阶段的状态快照,支持查看历史状态和进行时间旅行操作。

2. Checkpoint 与 State 的区别

对比 State Checkpoint
定义 当前工作流状态 某个时刻的状态快照
生命周期 随工作流执行持续变化 随执行过程产生多个版本
主要作用 节点间共享数据 状态持久化与恢复
是否一定持久化 不一定 由 Checkpointer 保存
典型用途 数据传递和流程控制 恢复、回溯、人工介入

可以理解为:

State 是正在变化的工作流状态,Checkpoint 是某个时刻保存下来的状态记录。

3. Checkpoint 的执行过程

flowchart TD
    A["开始执行 Graph"] --> B["加载当前 State"]
    B --> C["执行一个 Super-step"]
    C --> D["节点提交状态更新"]
    D --> E["应用 Reducer"]
    E --> F["形成新的 State"]
    F --> G["保存 Checkpoint"]
    G --> H{"工作流是否结束"}

    H -->|"否"| B
    H -->|"是"| I["保留最终执行状态"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

这里需要理解 Super-step 的概念。

LangGraph 采用 Pregel 风格的执行模型组织图运行。一个 Super-step 可以包含多个并行执行的节点。

在一个 Super-step 中:

  1. 当前可执行节点读取对应的状态。
  2. 节点并行或按图执行规则运行。
  3. 节点提交状态更新。
  4. 状态更新经过 Reducer 归约。
  5. 当前执行阶段完成后形成新的状态版本。

Checkpoint 通常在 Super-step 边界保存状态。具体保存内容和时机还会受到执行模式及 Checkpointer 实现影响。

4. 使用 MemorySaver 保存状态

下面演示使用内存 Checkpointer:

from typing_extensions import TypedDict

from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import InMemorySaver


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


def answer_node(state):
    return {
        "answer": f"你提出的问题是:{state['question']}"
    }


builder = StateGraph(AgentState)

builder.add_node("answer", answer_node)

builder.add_edge(START, "answer")
builder.add_edge("answer", END)

checkpointer = InMemorySaver()

graph = builder.compile(
    checkpointer=checkpointer
)

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

result = graph.invoke(
    {
        "question": "什么是 LangGraph?",
        "answer": ""
    },
    config=config
)

print(result)

这里有两个关键概念:

  • InMemorySaver:将检查点保存在内存中,适合开发和测试。
  • thread_id:标识一个持续运行的工作流线程,用于区分不同执行上下文。

需要注意,InMemorySaver 不适合需要跨进程重启或生产级持久化的场景。生产环境应使用适合部署架构的数据库 Checkpointer。

5. Thread ID 的作用

Thread ID 是 LangGraph 状态持久化中的重要标识。

例如:

config_a = {
    "configurable": {
        "thread_id": "user_001"
    }
}

config_b = {
    "configurable": {
        "thread_id": "user_002"
    }
}

不同 thread_id 对应不同的执行线程和检查点历史。

这样可以让多个用户的工作流状态相互隔离。

但需要注意,thread_id 本身不是身份认证机制。系统仍然需要验证调用者是否有权限访问对应线程,不能允许用户通过猜测 thread_id 读取其他用户的状态。

十、Store:跨 Thread 的长期数据存储

Checkpoint 主要围绕一个工作流线程保存执行状态。

但在实际应用中,有些信息需要跨线程、跨会话长期保存。

例如:

  • 用户偏好。
  • 长期记忆。
  • 历史任务摘要。
  • 用户配置。
  • 可复用的业务知识。

这类数据可以通过 LangGraph Store 管理。

1. Checkpoint 与 Store 的区别