Persistence（持久化）

先思考下面问题：

Agent 执行到一半怎么办？怎么暂停、恢复、故障恢复？不同对话之间又怎么记住用户？

一、Persistence 到底是什么？

LangGraph 的Persistence（持久化），就是让 Agent 的信息能够超越“一次 graph run”继续存在。

官方把它分成两个互补的机制：

LangGraph Persistence │ ┌───────────┴───────────┐ ↓ ↓ Checkpointer Store 检查点 存储 │ │ 当前 Thread 跨 Thread 短期记忆 长期记忆 │ │ 对话连续性 用户偏好 Human-in-loop 用户事实 故障恢复 共享知识 Time Travel

官方的核心定义是：

• Checkpointer：保存某个 Thread 的 Graph State，属于短期、线程级记忆。
• Store：保存 Graph State 之外的应用数据，属于长期、跨线程记忆。

实际应用中通常二者一起使用。

二、Checkpointer：给 Agent “存档”

这是 Persistence 最重要的概念。

可以把它理解成游戏里的：

Save Point / 存档点

Agent 执行：

START ↓ Node A ↓ Checkpoint ① ↓ Node B ↓ Checkpoint ② ↓ Node C ↓ Checkpoint ③ ↓ END

每一个super-step都可以形成一个 checkpoint，也就是当时整个 Graph State 的快照。([Docs by LangChain][2]) 

因此 Agent 如果执行到 Node B：

Agent 执行 ↓ A → B → C → D → E ↑ 💾 Checkpoint

突然：

• 用户介入
• 程序崩溃
• Tool 出错
• 服务重启

都可以从保存的状态继续，而不是从头开始。

三、为什么 Agent 特别需要 Checkpointer？

官方列出了几个非常关键的能力。

① Human-in-the-loop

Agent 执行到：

LLM ↓ 需要人工确认？ ↓ interrupt() ↓ 💾 保存 State ↓ 等待人 ↓ 恢复执行

人处理完之后，Agent 可以从原来的状态继续。

所以：

没有持久化，很难真正做好可暂停、可恢复的人机协作。

② Memory

同一个 Thread 的后续交互可以继续使用之前保存的状态：

Thread-001 第1轮：你好，我叫 Bob ↓ State ↓ Checkpoint 第2轮：你还记得我的名字吗？ ↓ 从 Thread 恢复 ↓ Bob

所以这里的 Memory，本质上是：

通过持久化的 State，让后续执行能够重新获得之前的信息。

③ Time Travel

这是 LangGraph 很有意思的能力。

因为历史 checkpoint 都保留下来了，所以可以：

Checkpoint 1 ↓ Checkpoint 2 ↓ Checkpoint 3 ↓ Checkpoint 4

回到以前的状态，检查：

“Agent 当时到底发生了什么？”

甚至可以从过去的 checkpointfork 出新的执行轨迹。

这对 Agent Debug 非常重要。

④ Fault Tolerance

假设：

A ✓ ↓ B ✓ ↓ C ✗ ↓ D

如果 B 已经成功并保存：

Checkpoint A + B

那么 C 失败后，可以从最近成功的状态恢复，而不是：

A → B → C

全部重跑。

LangGraph 还保存 super-step 中已经成功完成的 node writes，因此某个并行节点失败时，其他已经成功的节点不必重新执行。

四、Thread 是什么？

理解 Persistence，必须理解Thread。

可以简单理解为：

一个持续存在的 Agent 执行上下文。

例如：

thread_id = "user-001-session-001" ↓ Run 1 ↓ Checkpoint Run 2 ↓ Checkpoint Run 3 ↓ Checkpoint

LangGraph 用thread_id找到这一系列状态。

官方明确指出，使用 Checkpointer 时，需要通过：

{"configurable":{"thread_id":"1"}}

指定 Thread。没有thread_id，Checkpointer 就无法正确保存和恢复对应状态。

五、Checkpoint ≠ Thread

这两个概念容易混。

Thread │ ├── Checkpoint 0 │ ├── Checkpoint 1 │ ├── Checkpoint 2 │ └── Checkpoint 3

Thread 是一条持续的执行轨迹。

Checkpoint 是这条轨迹上的一个状态快照。

而且 Checkpoint 对应的是super-step 边界。LangGraph 在 super-step 完成时保存完整 State Snapshot，同时还会记录节点级 writes，用于故障恢复。

六、Store：解决“跨对话记忆”

这里是 Persistence 中另一个非常重要的概念。

假设：

Thread A 用户：我喜欢物理 Thread B 用户：给我推荐学习内容

Thread B 能不能知道：

用户喜欢物理？

如果只使用 Checkpointer：

不适合。

因为 Checkpointer 主要是：

Thread A ↓ 自己的 State

而 Store 是：

Store │ ┌─────────┼─────────┐ ↓ ↓ ↓ Thread A Thread B Thread C │ │ │ └────共享长期信息───┘

Store 保存的是应用定义的 Key-Value 数据，可以跨 Thread 使用。官方给出的典型例子包括：

• 用户偏好
• 用户事实
• 累积知识
• 共享知识。

七、Checkpointer vs Store：一定要分清

Checkpointer	Store
保存什么	Graph State 快照	应用定义的数据
范围	单个 Thread	跨 Thread
类型	短期记忆	长期记忆
典型用途	对话连续、暂停恢复	用户偏好、事实、知识
核心标识	thread_id	namespace + key
核心问题	“我这次执行到哪了？”	“关于这个用户，我长期知道什么？”

这张表基本就是整个 Persistence 文档的核心。([Docs by LangChain][1])

八、两者组合起来才是真正的 Agent Memory

这是我认为最值得记住的架构：

Agent │ ┌────────┴────────┐ ↓ ↓ Checkpointer Store │ │ 当前 Thread 跨 Thread │ │ ┌─────┴─────┐ ┌────┴─────┐ ↓ ↓ ↓ ↓ 当前状态 历史状态 用户偏好 用户知识 │ │ │ │ └───────────┴──────┴──────────┘ ↓ LLM

因此：

Memory 并不是 LLM 自己拥有的一项神奇能力，而是 Agent Runtime 通过 Persistence 为 LLM 提供可持续访问的信息。

这与之前讨论的Context vs Memory是直接对应的。

九、Persistence 与 LangGraph Agent Loop 的关系

把之前面研究的 Tool Calling、Thinking in LangGraph、Workflow/Agent 串起来，就非常清楚了：

START ↓ LLM ↓ Tool Calling ↓ Tool ↓ Tool Result ↓ State ↓ 💾 Checkpoint ↓ LLM ↓ 是否继续？ ↙ ↘ 否 是 ↓ ↓ END Tool ↓ ...

所以：

• LLM：决定下一步
• Tool：执行动作
• Node：执行单元
• State：当前工作记忆
• Checkpoint：把执行状态保存下来
• Thread：串起一次持续的执行上下文
• Store：保存跨 Thread 的长期信息
• Loop：让 Agent 持续行动

这也是为什么 LangGraph 不只是一个“流程图框架”，而是一个面向有状态、长时间运行 Agent 的执行运行时。

十、生产环境还要考虑什么？

官方 Persistence 页面还特别列了几个实际问题。

1. InMemory 不适合生产

MemorySaver / InMemorySaver数据存在 RAM 中，进程重启后 checkpoint 会丢失。

生产环境可以使用：

• PostgreSQL
• SQLite（本地开发）
• MongoDB 等持久化实现。([Docs by LangChain][1]) 

2. Checkpoint 会不断增长

长对话会产生大量 checkpoint：

Run 1 → 💾 Run 2 → 💾 Run 3 → 💾 ... Run 10000 → 💾

会增加：

• 存储成本
• 延迟

因此需要考虑 pruning / retention。官方也提供了DeltaChannel，可以针对适合的场景只保存增量数据，以降低 checkpoint 大小。([Docs by LangChain][1]) 

3. 持久化的可靠性可以分级

Checkpointer 支持三种 durability mode：

exit ↓ async ↓ sync

从低到高：

性能 ↑ ←→ 持久性/可靠性 ↑

• exit：执行退出时才持久化
• async：异步持久化
• sync：进入下一步前同步完成持久化。

十一、最终知识框架

如果把这篇文档压缩成一张知识图，我建议记住：

LangGraph Persistence │ ┌──────────┴──────────┐ ↓ ↓ Checkpointer Store │ │ Thread-scoped Cross-thread │ │ 短期记忆 / 状态 长期记忆 │ │ ┌──────┼──────┐ ┌──────┼──────┐ ↓ ↓ ↓ ↓ ↓ ↓ Memory HITL Recovery 偏好 事实 知识 │ ├── Checkpoint ├── Time Travel ├── Replay └── Fault Tolerance

一句话总结

LangGraph Persistence = Checkpointer 管“当前这条执行链的状态”，Store 管“跨执行链长期存在的信息”。

再往 Agent 工程化的角度提升一层：

Workflow 解决“怎么执行”，Agent 解决“下一步做什么”，State 解决“当前知道什么”，Persistence 解决“执行中断后还能不能接着做，以及跨对话还能记住什么”。

这几篇文档连起来，已经形成了一个非常完整的 LangGraph 核心认知链：

Workflows & Agents → Thinking in LangGraph → State → Tool Calling → Persistence → Agent Loop。