一、什么是 LangGraph 状态管理
在传统程序中,函数通常通过参数接收输入,通过返回值输出结果。多个函数之间需要显式传递数据。
但在 Agent 工作流中,任务往往不是一次函数调用就能完成,而是由多个节点组成的执行图。节点之间需要持续共享信息,例如:
- 用户最初提出的问题。
- 当前任务的执行阶段。
- Agent 已经完成的推理和分析结果。
- 工具调用记录。
- 中间执行结果。
- 错误信息和重试次数。
- 是否需要人工审核。
- 最终生成的答案。
如果每个节点都单独维护自己的数据,就会产生大量重复传递和状态同步工作。
LangGraph 使用统一的 State 管理工作流中的共享数据。
可以将 LangGraph 理解为一个基于状态驱动的图执行框架:
- State:定义整个工作流需要共享的数据结构。
- Node:读取当前状态,并返回需要更新的字段。
- Edge:决定节点之间的执行关系。
- Reducer:定义多个状态更新如何合并。
- Checkpointer:保存执行过程中的状态快照。
- Store:保存跨线程、跨会话或跨任务需要复用的数据。
其中,State 是整个状态管理机制的核心。
1. LangGraph 为什么需要状态管理
考虑一个简单的 Agent 工作流:
- 用户提交问题。
- Planner 分析任务。
- Researcher 收集资料。
- Analyst 分析资料。
- Reviewer 检查结果。
- 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 中:
- 当前可执行节点读取对应的状态。
- 节点并行或按图执行规则运行。
- 节点提交状态更新。
- 状态更新经过 Reducer 归约。
- 当前执行阶段完成后形成新的状态版本。
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 管理。