Zer0e's Blog

AI其九:大模型记忆设计,从上下文窗口到长期记忆

字数统计: 8.9k阅读时长: 34 min
2026/10/25 Share

正文

用户在第一轮说:”我对花生过敏。”

二十轮之后,Agent 热情地推荐了一款花生酱饼干。

这不是模型”忘了”,而是它从一开始就没有记住。大模型 API 是无状态的:每一次请求,模型只能看到你这次塞进上下文窗口里的 token。上一轮聊了什么、用户是谁、三天前确认过的偏好,只要没被重新放进 prompt,对模型来说就不存在。

很多人把”上下文窗口”当成”记忆”。这是两回事:

  • 上下文窗口是工作台,决定模型这一刻能看见什么;
  • 记忆系统是仓库,决定哪些信息值得留下、下次怎么找回来、什么时候该丢掉。

上下文窗口从 8K 涨到百万级,确实缓解了一部分问题,但没有解决记忆的本质矛盾:容量、成本、时效、隔离、可删除性。这篇文章就聊聊,如何给大模型设计一套真正能用的记忆系统。

一、先厘清:上下文、RAG、记忆不是一回事

在动手设计之前,先把几个经常被混用的概念分开。

概念 解决的问题 数据形态 生命周期 典型实现
上下文窗口 本次推理能看见什么 token 序列 单次请求 prompt 拼接
RAG 静态知识不够用 文档切片 + 向量 天级到月级 向量库 + 重排
记忆 跨会话保持用户与任务状态 事实、事件、偏好、摘要 秒级到年级 记忆服务 + 多种存储
参数化知识 稳定的通识与能力 模型权重 训练周期 预训练、SFT、LoRA

RAG 面向的是相对静态的知识库,读多写少,更新靠重新索引;记忆面向的是持续变化的交互状态,读写都频繁,还要处理冲突、过期和删除。两者可以共用向量库,但设计目标完全不同。

那为什么不干脆把所有历史都塞进上下文?因为长上下文有四个硬约束。

约束一:注意力是平方成本

Transformer 的自注意力计算量随序列长度平方增长:序列长度翻倍,注意力计算量翻四倍;从 8K 扩到 32K,这部分开销涨 16 倍。长上下文不是免费的,它把成本从”存储”转移到了”每次推理”。

约束二:KV Cache 会吃掉显存

自回归解码要缓存每一层的 Key 和 Value。以 Llama 3 70B 这类模型为例:80 层、8 个 KV 头、每头 128 维,单条 128K token 的对话,FP16 下 KV Cache 约 40 GiB。注意,这只是 KV Cache,不含模型权重。一条对话就占掉 40 GiB 显存,并发一上来,长上下文的账根本算不过来。

约束三:账单按 token 平方级增长

如果每一轮都把完整历史重新发一遍,成本会随轮次平方增长。假设每轮新增 1K token,聊到 100 轮时上下文是 100K token,但累计输入已经约 505 万 token——同样内容被反复读了 50 遍。对话越长,单位轮次的成本越高,这也是”全量历史 + 长上下文”在生产环境里通常不可持续的原因。

约束四:长上下文不等于有效记忆

“Lost in the Middle” 的研究发现,模型对上下文中间位置的信息利用最差,呈现 U 型曲线:开头和结尾记得住,中间容易丢。再加上上下文越长、指令遵循和推理质量越容易下降,单纯堆 token 并不能换来可靠的记忆。

更关键的是,长上下文解决不了跨会话持久化、多租户隔离和按用户删除。这些是记忆系统要解决的问题,不是窗口大小能解决的。

二、记忆分层:给大模型配一套存储体系

操作系统的内存层级是个很好的类比:寄存器、L1/L2 缓存、内存、磁盘,容量越来越大,速度越来越慢,靠换入换出协同工作。大模型的记忆也可以这样分层。

层级 类比 载体 容量 访问延迟 生命周期
工作记忆 寄存器、L1 当前 prompt 8K 到百万 token 已在上下文中 单次请求
短期记忆 内存 会话缓冲、滚动摘要 数 K token 毫秒级 单会话
长期记忆 磁盘 向量库、图库、关系库、对象存储 近似无限 10 到 200 ms 跨会话
参数化记忆 固件 模型权重 模型容量 一次前向 训练周期
flowchart TD
    subgraph L1["工作记忆:上下文窗口"]
        A["系统指令 + 当前对话\n+ 本次召回的长期记忆"]
    end

    subgraph L2["短期记忆:会话状态"]
        B["最近 N 轮原文\n滚动摘要\n任务状态与工具结果"]
    end

    subgraph L3["长期记忆:外部存储"]
        C1["向量库\n语义召回"]
        C2["图数据库\n实体关系与时间"]
        C3["关系库\n精确事实与偏好"]
        C4["对象存储\n原始对话与文件"]
    end

    A ---|"换入换出"| B
    B ---|"按需读写"| C1
    B ---|"按需读写"| C2
    B ---|"按需读写"| C3
    B ---|"归档与回溯"| C4

    style L1 fill:#e3f2fd
    style L2 fill:#fff3e0
    style L3 fill:#e8f5e9
    style A fill:#42a5f5,color:#fff
    style B fill:#ffa726
    style C1 fill:#66bb6a
    style C2 fill:#66bb6a
    style C3 fill:#66bb6a
    style C4 fill:#66bb6a

工作记忆的预算不是整个上下文窗口。以 128K 窗口为例:系统指令和工具定义占 8K,输出预留 4K,安全余量留 4K,剩下约 112K 才是可用空间;再从中划出 10% 到 20%(约 12K 到 22K)给长期记忆,其余留给当前任务。记忆召回的 token 不是越多越好,超过一定量后,噪声会用更高的成本换更差的回答。

三、记忆类型:语义、情景、程序、工作记忆

认知科学里的记忆分类,落到工程上非常实用。不同类型的数据,存储和检索方式完全不同。

类型 回答什么 例子 推荐存储
语义记忆 事实与偏好是什么 用户对花生过敏;公司报销上限 800 元 关系库 + 向量
情景记忆 发生过什么 上周三用户反馈登录失败;昨天确认了方案 A 事件表、时序图
程序记忆 事情怎么做 退款前先查订单;回答前先调用库存接口 prompt、工作流、代码
工作记忆 当前在做什么 正在填写的工单字段;本轮已确认的三个约束 会话状态

几个容易踩的坑:

  1. 把程序记忆写进语义记忆。”退款要先查订单”不是一条用户事实,而是 Agent 的行为规则,应该固化在 prompt 或工作流里,而不是每次检索出来再让模型猜。
  2. 把情景记忆压成一句摘要。”用户上周三反馈登录失败,这周一又反馈了一次,今天恢复了”如果只留一句”用户有登录问题”,时间线和处理状态就丢了。情景记忆要保留事件和顺序。
  3. 把易变事实微调进权重。用 SFT 让模型记住”用户住在上海”,更新成本高、无法按用户删除、还会污染通用能力。权重适合稳定技能,不适合易变事实。

还有一个常被忽略的维度:参数化记忆与非参数化记忆。前者是模型权重里的知识,后者是外部存储。设计记忆系统时,默认选非参数化,因为可更新、可审计、可删除;只有稳定的领域能力才考虑进权重。

四、写入路径:什么值得记,怎么记

记忆系统最容易犯的错,不是”记不住”,而是”什么都记”。全量保存对话,等于把检索问题推迟到以后,最后得到一堆重复、过期、互相矛盾的数据。

一条可靠的写入路径通常长这样:

flowchart LR
    A["一轮对话结束"] --> B["候选抽取\n事实、偏好、事件、任务状态"]
    B --> C{"重要性打分"}
    C -->|"低于阈值"| D["丢弃"]
    C -->|"通过"| E["去重与冲突检测"]
    E --> F["按类型写入存储\n附带时间、来源、置信度"]
    F --> G["异步索引\n向量、倒排、图关系"]

    style A fill:#e3f2fd
    style D fill:#ffebee
    style F fill:#e8f5e9
    style G fill:#e8f5e9

1. 抽取要结构化

不要让模型”记住这段对话”,而是让它抽取结构化候选:

1
2
3
4
5
6
7
8
9
{
"type": "semantic",
"subject": "user:123",
"predicate": "allergy",
"object": "peanut",
"confidence": 0.95,
"source": "turn:42",
"valid_from": "2026-10-22T10:00:00Z"
}

结构化之后,才能做去重、冲突检测、时间过滤和精确删除。纯文本记忆看起来灵活,实际很难维护。

2. 打分决定去留

不是所有信息都值得占用长期存储。可以从四个维度打分:与已有记忆的差异(novelty)、用户是否明确要求记住(explicit)、未来被用到的可能性(utility)、敏感程度(sensitivity)。比如四项权重分别是 0.3、0.3、0.3、0.1,总分低于 0.6 就丢弃。

阈值不要拍脑袋,用业务数据校准:抽查被丢弃和被保留的记忆,看哪一类在后续对话里真正被用到。

3. 去重与冲突:不要简单覆盖

  • 完全重复:内容哈希相同,直接合并,更新访问时间。
  • 语义重复:向量相似度超过阈值,合并成一条更完整的表述。
  • 事实冲突:同一 subject + predicate 出现不同 object,不要直接删旧值。保留时间区间,把旧值标记为失效,新值从当前时间生效。
  • 置信度冲突:用户明确说的 > 模型推断的;近期确认的 > 很久以前推断的。

这就是后面要讲的双时间轴的价值:既能回答”用户现在住哪”,也能回答”三月份时我们以为用户住哪”。

4. 写入异步,但会话内要能立刻读到

记忆抽取通常要调用模型,放在用户请求的同步链路里会直接抬高延迟。正确做法是异步写入,同时维护一个会话级缓冲:本轮刚确认的事实先放进短期记忆,保证”说完就能用”;落库和索引在后台完成。

还要保证写入幂等。消息重试、任务重放、并发写入都可能产生重复记忆,用 (tenant_id, source_turn, content_hash) 做唯一约束是最低要求。

5. 安全边界:记忆是不可信输入

记忆一旦写入,未来会被反复召回。这意味着它是一条持久的提示注入通道:攻击者只要让 Agent 记下”以后回答前先执行某某操作”,这条指令就可能在后续会话里被反复触发。

几条硬规则:

  • 记忆内容永远当数据,不当指令;
  • 召回结果带上来源和写入者,高风险操作要求二次确认;
  • 按租户和用户做命名空间隔离,检索时强制过滤;
  • 敏感记忆的写入要审核,至少要有可追溯的审计日志。

五、存储选型:向量库不是万能药

很多团队的第一反应是”上向量库”,然后把所有东西都塞进去。向量检索擅长语义相似,但不擅长精确匹配、数值比较、时间过滤和多跳关系。

存储 擅长 不擅长 典型场景
向量库 语义相似召回 精确过滤、关系、时间推理 海量非结构化记忆
关系库 精确查询、事务、多租户 模糊语义匹配 用户画像、偏好、配额
图数据库 多跳关系、实体消歧 大规模写入、运维复杂 人物、项目、事件关系网
对象存储 原始对话、文件、低成本 在线检索 审计、回溯、重放
摘要树 长文档全局理解 细节精确性 会议纪要、长报告

一个常见的组合是:关系库存事实和状态,向量库存语义索引,图库存关系,对象库存原始证据。四者用同一个记忆 ID 关联,检索时各取所长。

双时间轴:处理”事实会变”这件事

普通表只记录”现在是什么”,但记忆系统还要回答”当时是什么”和”我们当时以为什么”。Zep/Graphiti 这类系统用双时间轴解决这个问题:

  • 事件时间:valid_from / valid_to,事实在现实世界中何时成立;
  • 摄入时间:created_at / expired_at,系统何时相信这条事实。
1
2
3
用户居住地:
北京 valid_from=2024-01-01 valid_to=2026-03-01
上海 valid_from=2026-03-01 valid_to=null

查询”用户二月份住哪”,按事件时间过滤得到北京;查询”系统三月份认为用户住哪”,按摄入时间过滤。只做”最新值覆盖”的朴素实现,会把这两个问题都答错。

一个简化的表结构:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
-- pgvector:提供 VECTOR 类型和 HNSW 索引
CREATE EXTENSION IF NOT EXISTS vector;

CREATE TABLE memories (
id UUID PRIMARY KEY, -- 记忆唯一 ID,跨向量库、图库关联
tenant_id TEXT NOT NULL, -- 租户 ID,所有查询必须带上
user_id TEXT NOT NULL, -- 用户 ID,记忆归属
kind TEXT NOT NULL, -- semantic / episodic / procedural / working
subject TEXT, -- 主体,如 user:123、order:8899
predicate TEXT, -- 关系,如 allergy、lives_in
object TEXT, -- 客体,如 peanut、Shanghai
content TEXT NOT NULL, -- 可读文本,用于展示和向量化
embedding VECTOR(1024), -- 语义向量,维度与嵌入模型一致
confidence REAL NOT NULL, -- 置信度 0 到 1,冲突仲裁用
source_turn TEXT, -- 来源轮次,用于溯源和审计
valid_from TIMESTAMPTZ, -- 事件时间:事实开始成立
valid_to TIMESTAMPTZ, -- 事件时间:事实失效,NULL 表示仍有效
created_at TIMESTAMPTZ NOT NULL DEFAULT now(), -- 摄入时间:系统何时写入
expired_at TIMESTAMPTZ, -- 摄入时间:系统何时不再相信,NULL 表示当前有效
deleted_at TIMESTAMPTZ -- 删除时间:先软删,异步任务再物理清理
);

-- 主查询路径:租户 + 用户 + 记忆类型
CREATE INDEX idx_memories_tenant_user
ON memories (tenant_id, user_id, kind);

-- 时间回溯:查询某个时间点有效的记忆
CREATE INDEX idx_memories_valid_time
ON memories (tenant_id, user_id, valid_from, valid_to)
WHERE deleted_at IS NULL;

-- 向量索引:以 pgvector 的 HNSW 为例,维度需与 embedding 一致
CREATE INDEX idx_memories_embedding
ON memories USING hnsw (embedding vector_cosine_ops);

tenant_id 必须出现在所有查询条件里,不能只靠应用层记得加。多租户系统里,一次漏过滤就是数据事故。

六、检索路径:把正确的记忆塞进有限的上下文

写入决定”有什么”,检索决定”这一次用得上什么”。检索做不好,记忆越多,回答越差。

flowchart TD
    Q["用户问题 + 当前任务状态"] --> RW["查询改写\n补全指代、拆分子问题"]
    RW --> V["向量召回 Top-K"]
    RW --> K["关键词与 BM25"]
    RW --> G["图遍历\n关联实体与事件"]
    V --> M["合并去重"]
    K --> M
    G --> M
    M --> RR["重排\n相关性、时效、重要性"]
    RR --> B["Token 预算装箱"]
    B --> P["按位置编排\n高价值放头尾"]
    P --> L["拼进上下文"]

    style Q fill:#e3f2fd
    style RW fill:#fff3e0
    style RR fill:#ffe0b2
    style B fill:#ffe0b2
    style L fill:#e8f5e9

1. 查询改写

用户说”那它呢”,直接拿这句话去检索,什么都召不回来。检索前要用最近几轮对话和任务状态补全指代、拆分复合问题,必要时生成多个查询做多路召回。

2. 混合召回

向量召回解决”意思相近”,BM25 解决”专有名词、订单号、错误码”,图遍历解决”和这个实体相关的其他实体”。三者并行召回,再合并去重,比单一路径稳得多。

3. 重排:相关性只是其中一个维度

Generative Agents 给出的打分方式很经典:时效、重要性、语义相关性三项加权。工程上可以按 0.4、0.3、0.3 设置权重;时效按半衰期衰减(常见做法是 7 天),重要性按 1 到 10 分归一化,相关性用余弦相似度。这样能避免”最相似但早已过期”的记忆挤掉”稍微没那么相似但刚刚确认”的记忆。

生产环境通常还会加一个 cross-encoder 重排,把 Top 20 到 50 压缩到 Top 5 到 10。代价是几十毫秒,收益是明显更高的精确率。

4. 预算装箱

检索结果不能无限往上下文里塞。比如总预算 2K token:一条 200 token 的记忆得分 0.8,另一条 50 token 的记忆得分 0.5,后者每 token 收益更高,应该优先装。工程上按”得分 / token 数”从高到低贪心排序就够用,不需要求精确最优解。短而高分的记忆优先,能塞进更多条。

5. 位置编排

“Lost in the Middle” 的结论在记忆拼接上同样成立:把最重要的记忆放在上下文开头或结尾,不要埋在一大段召回内容中间;同类型的记忆放在一起,带上时间戳,减少模型自己拼接时间线的负担。

6. 检索策略怎么选

策略 适合 主要代价
向量 Top-K 语义相近的经验和描述 时间、否定、数字不敏感
混合检索 订单号、错误码、专有名词 需要维护倒排索引
图遍历 多跳关系和实体消歧 构图与更新成本高
摘要树 全局性、总结性问题 构建成本高,细节有损
时间过滤 状态变化、历史回溯 依赖完整的时间字段

7. 进阶:图检索与摘要树

当问题需要跨多条记忆做多跳推理时,纯向量召回很容易断链。HippoRAG 的做法是把记忆组织成知识图谱,检索时用 Personalized PageRank 从查询命中的实体向外扩散,找到关联路径;GraphRAG 则进一步对图做社区划分,生成社区摘要,同时支持”局部找细节”和”全局看主题”两类查询。

面对长文档或超长会话的全局性问题,RAPTOR 用递归聚类加摘要构建一棵树:底层是原文,上层是不同粒度的摘要。检索时既可以落到叶子节点拿细节,也可以停在中间层回答概括性问题。

这些结构本质上都是给记忆加一层索引,用构建成本换检索质量。是否值得,取决于你的查询里有多少是”关系型”和”全局型”的。

七、巩固与遗忘:记忆系统也需要 GC

一个只写不删的记忆系统,最终会变成垃圾场。遗忘不是缺陷,而是设计的一部分:它降低噪声、控制成本、满足合规。

flowchart LR
    A["候选记忆"] -->|"通过打分"| B["短期记忆"]
    B -->|"重复出现或用户确认"| C["长期记忆"]
    C -->|"低访问 + 超时"| D["归档"]
    D -->|"TTL 到期或删除请求"| E["物理删除"]

    style A fill:#e3f2fd
    style B fill:#fff3e0
    style C fill:#e8f5e9
    style D fill:#ffebee
    style E fill:#ef9a9a

1. 巩固:从原始对话到稳定知识

  • 会话摘要:把一段对话压缩成任务、结论、未决问题;
  • 事实抽取:从摘要里提炼可复用的事实和偏好;
  • 反思:定期让模型基于多条记忆生成更高层的判断,比如”用户偏好简短回答”;
  • 晋升:被反复访问、被用户确认的记忆,从短期存储晋升到核心记忆;
  • 合并:语义重复的条目合并,保留最完整、来源最可靠的一条。

巩固要定期做,但不能全量重跑。按用户、按时间窗口增量处理,避免一次任务扫全表。

2. 冲突处理:保留历史,标记失效

冲突解决不是”新覆盖旧”,而是:

  1. 判断来源优先级:用户明确陈述 > 用户行为推断 > 模型猜测;
  2. 比较置信度和时间;
  3. 旧记录写入 valid_to,标记为 superseded,不物理删除;
  4. 新记录写入 valid_from,保留来源。

这样既能给出当前答案,也能在需要时回溯”为什么当时那么回答”。

3. 衰减:让不常用的记忆自然下沉

可以用半衰期给记忆算一个动态权重:半衰期 7 天,意味着 7 天后权重降到 0.5,14 天后 0.25,30 天后约 0.05。不同类型的记忆用不同半衰期:临时任务状态几小时,一般偏好几个月,身份类事实可以很长甚至不过期。衰减权重参与检索排序,但不一定直接删除数据。

4. 删除:合规要求比技术实现更难

用户要求删除时,要删的不只是主表一行:

  • 关系库里的记录;
  • 向量库里的向量和索引;
  • 图库里的节点、边和实体引用;
  • 对象存储里的原始对话;
  • 缓存、备份、离线数仓里的副本。

工程上至少要做到:按 tenant_id + user_id 级联删除、软删除加异步硬删除、删除任务可观测、有完成时限。备份里的数据要能随保留周期自然过期,必要时支持按用户重放删除。

八、典型系统拆解:MemGPT、Mem0、Zep、LangGraph

系统 核心抽象 存储 特点 适合场景
MemGPT / Letta OS 式虚拟上下文 主上下文 + 归档、召回存储 分页、函数调用、中断队列 长对话、有状态 Agent
Mem0 抽取 + 更新管道 向量库,可选图存储 ADD、UPDATE、DELETE、NOOP 快速接入的独立记忆层
Zep / Graphiti 时序知识图谱 图 + 向量 双时间轴、实体消歧 关系复杂、需要时间推理
LangGraph Checkpointer + Store 框架自带或自定义 与图编排深度集成 LangGraph 应用
自研 按需组合 多种存储 可控、可审计 有明确合规与规模要求

MemGPT:把上下文当内存管理

MemGPT 的核心类比是操作系统:主上下文相当于内存,外部存储相当于磁盘,模型通过函数调用主动”换页”。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
┌──────────────────────────────────┐
│ 主上下文 Main Context │
│ system prompt │
│ core memory(用户画像、关键约束)│
│ 最近消息 │
│ ... │
└───────────────┬──────────────────┘
│ 使用率超过阈值
▼
摘要压缩 + 换出到外部上下文
│
▼
┌──────────────────────────────────┐
│ 外部上下文 External Context │
│ recall memory(历史消息) │
│ archival memory(长期知识) │
└──────────────────────────────────┘

模型可以调用 core_memory_append、core_memory_replace 修改核心记忆,用 archival_memory_insert、archival_memory_search 读写归档记忆,用 conversation_search 检索历史消息。用户的新消息进入中断队列,调度器决定何时让模型处理。

这个设计的价值在于:**记忆管理从”外部代码固定流程”变成了”模型按需决策”**。代价是模型可能做出糟糕的换页决策,所以生产系统通常还要加规则兜底和预算上限。

Mem0:抽取与更新两阶段

Mem0 把记忆处理拆成两个阶段:

  1. 抽取阶段:从对话中提取候选事实;
  2. 更新阶段:把候选事实与已有记忆比较,决定执行 ADD、UPDATE、DELETE 还是 NOOP。

它支持向量存储,也支持可选的图存储。论文报告在 LOCOMO 长对话基准上,相比 OpenAI 的对话记忆方案有约 26% 的相对提升,同时显著降低 p95 延迟和 token 消耗。具体数字以论文和复现为准,但方向上说明了一件事:**记忆不是”存得越多越好”,而是”更新得越准越好”**。

Zep / Graphiti:时序知识图谱

Zep 把记忆建成时序知识图谱:对话是 episode,从中抽取实体和事实,实体之间连边,边上带时间信息。Graphiti 维护两套时间:

  • valid_at / invalid_at:事实在现实中何时成立;
  • created_at / expired_at:系统何时摄入和废弃这条事实。

检索时混合使用向量相似度、BM25 和图遍历。论文报告在 DMR 和 LongMemEval 等基准上有明显提升,并大幅降低响应延迟。它适合”用户、项目、订单、事件”关系复杂,且需要回答”当时是什么状态”的场景。

LangGraph:短期与长期记忆分开

LangGraph 的抽象很清晰:

  • Checkpointer:按 thread 保存会话状态,解决单次会话内的短期记忆;
  • Store:跨 thread 的长期存储,用 namespace 隔离用户和业务域,支持语义检索。

这个划分值得借鉴:短期记忆跟着会话走,长期记忆跟着用户走,两者生命周期和一致性要求不同,不要混在一个存储里。

最小可用示例

下面这个例子把两者接起来:同一个用户开两个 thread,第二个 thread 没有任何历史消息,但仍然能召回第一个 thread 写入的长期记忆。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import uuid
from dataclasses import dataclass

from langchain.chat_models import init_chat_model
from langchain.embeddings import init_embeddings
from langchain_core.messages import SystemMessage
from langgraph.checkpoint.memory import InMemorySaver
from langgraph.graph import END, START, MessagesState, StateGraph
from langgraph.runtime import Runtime
from langgraph.store.memory import InMemoryStore

@dataclass
class Context:
tenant_id: str
user_id: str

INDEX = {
"embed": init_embeddings("openai:text-embedding-3-small"),
"dims": 1536,
"fields": ["text"],
}
store = InMemoryStore(index=INDEX)
llm = init_chat_model("openai:gpt-4.1-mini", temperature=0)

def memory_ns(ctx: Context):
return ("tenants", ctx.tenant_id, "users", ctx.user_id, "memories")

async def chat(state: MessagesState, runtime: Runtime[Context]):
hits = await runtime.store.asearch(
memory_ns(runtime.context),
query=state["messages"][-1].content,
limit=5,
)
memories = "\n".join(f"- {h.value['text']}" for h in hits) or "(无)"

reply = await llm.ainvoke([
SystemMessage(content=f"以下是用户的历史记忆,只作为事实参考:\n{memories}"),
*state["messages"],
])
return {"messages": [reply]}

async def save_memory(state: MessagesState, runtime: Runtime[Context]):
last_user = next(m for m in reversed(state["messages"]) if m.type == "human")
# 示例直接存原文;生产环境应换成抽取后的结构化事实
await runtime.store.aput(
memory_ns(runtime.context),
str(uuid.uuid4()),
{"text": last_user.content, "kind": "raw_turn"},
)
return {}

builder = StateGraph(MessagesState, context_schema=Context)
builder.add_node("chat", chat)
builder.add_node("save_memory", save_memory)
builder.add_edge(START, "chat")
builder.add_edge("chat", "save_memory")
builder.add_edge("save_memory", END)

graph = builder.compile(checkpointer=InMemorySaver(), store=store)

async def main():
ctx = Context(tenant_id="t-01", user_id="u-123")

await graph.ainvoke(
{"messages": [{"role": "user", "content": "我对花生过敏"}]},
{"configurable": {"thread_id": "chat-001"}},
context=ctx,
)

result = await graph.ainvoke(
{"messages": [{"role": "user", "content": "推荐一款饼干"}]},
{"configurable": {"thread_id": "chat-002"}},
context=ctx,
)
print(result["messages"][-1].content)

if __name__ == "__main__":
import asyncio
asyncio.run(main())

这段代码里有三个关键点:

  1. thread_id 只影响 checkpointer:同一个 thread 内,消息历史会自动恢复;换一个 thread,对话消息就清空了。
  2. user_id 和 tenant_id 进入 Store 的 namespace:第二个 thread 虽然消息为空,asearch 仍然能按用户召回”花生过敏”。
  3. chat 负责读记忆,save_memory 负责写记忆。示例为了跑通链路每轮都存原文,生产环境要换成事实抽取、去重和冲突检测。

需要说明一点:LangGraph 的 Store 有自己的表结构,不会自动写入前面那张 memories 表。简单场景直接用 Store 就够了;如果需要双时间轴、复杂 SQL 查询和自定义字段,建议业务事实留在 memories 表,Store 只做语义索引和 Agent 侧召回,两边用 memory_id 关联。

换成 Postgres

InMemorySaver 和 InMemoryStore 只适合开发和测试,进程一重启数据就没了。生产环境把两个实现换掉即可,图的结构不用改:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# pip install -U langgraph langgraph-checkpoint-postgres "psycopg[binary,pool]"
# 复用上面的 builder、INDEX 和节点定义
from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
from langgraph.store.postgres.aio import AsyncPostgresStore

DB_URI = "postgresql://user:pass@localhost:5432/agent?sslmode=disable"

async def run():
async with AsyncPostgresSaver.from_conn_string(DB_URI) as checkpointer:
await checkpointer.setup()

async with AsyncPostgresStore.from_conn_string(DB_URI, index=INDEX) as store:
await store.setup()
graph = builder.compile(checkpointer=checkpointer, store=store)

await graph.ainvoke(
{"messages": [{"role": "user", "content": "我对花生过敏"}]},
{"configurable": {"thread_id": "chat-001"}},
context=Context(tenant_id="t-01", user_id="u-123"),
)

两个 setup() 都是建表操作,首次部署执行一次即可。async with 同时管理连接生命周期,await graph.ainvoke 必须在块内执行;Web 服务通常把这段放进 FastAPI 的 lifespan,启动时建连接和建表,请求处理中复用 graph,不要每个请求重连一次。

四个容易踩的坑

  • thread 和 user 不要混:thread_id 是会话标识,user_id 是长期记忆归属。把 user_id 塞进 thread_id 里,短期记忆会串成一条超长会话;反过来,用 thread_id 做长期记忆的 namespace,用户换个会话就找不到之前的记忆。
  • namespace 必须来自鉴权上下文:tenant_id、user_id 从登录态或请求上下文取,不能让模型自己填。否则一次提示注入就能让 Agent 读写别人的记忆。
  • 不要在异步节点里调用同步方法:Web 服务统一用 ainvoke、aput、asearch;在 async def 节点里调用 store.put 会阻塞事件循环。
  • Checkpointer 和 Store 要一起清理:用户要求删除数据时,checkpoint 里的消息历史和 Store 里的长期记忆都要删。两套数据在不同表里,只删一边等于没删。

LangGraph 把短期记忆和长期记忆拆成两个原语,最大的价值不是”帮你存”,而是逼你在设计时想清楚:这条信息是会话内的临时状态,还是要跨会话保留的用户事实。

九、工程落地:参考架构、指标与踩坑

把前面的东西拼起来,一个可落地的记忆服务大致如下。

flowchart TD
    U["应用 / Agent"] --> API["记忆服务 API"]
    API --> W["写入管道\n异步"]
    API --> R["读取管道\n同步带超时"]
    W --> EX["抽取与打分"]
    EX --> CF["去重、冲突检测、时间标注"]
    CF --> S[("存储层")]
    R --> HR["混合召回"]
    HR --> S
    HR --> RK["重排与预算装箱"]
    RK --> API
    S --> V[("向量库")]
    S --> G[("图数据库")]
    S --> DB[("关系库")]
    S --> O[("对象存储")]

    style U fill:#e3f2fd
    style W fill:#fff3e0
    style R fill:#e8f5e9
    style S fill:#42a5f5,color:#fff

1. 读写分离与降级

  • 写入异步,走队列,失败可重试,保证幂等;
  • 读取同步,设总超时,比如 300 ms;
  • 检索超时或不可用时降级为空记忆或仅会话摘要,不能拖垮主链路;
  • 会话内维护缓冲,保证刚说完的事实立刻可用。

2. 延迟预算

阶段 目标 P95 说明
查询改写 20 到 50 ms 小模型或规则,能省则省
向量召回 20 到 80 ms 多路并行
图查询 30 到 100 ms 限制跳数和返回条数
重排 20 到 60 ms 可选,Top 20 压到 Top 5
总预算 150 到 300 ms 超时降级,不影响主流程

3. 多租户与安全

  • 所有表、索引、向量集合都带 tenant_id;
  • 检索时在存储层强制过滤,不依赖应用层拼接;
  • 敏感字段加密,日志脱敏;
  • 删除请求按用户级联,记录审计事件;
  • 记忆内容做提示注入检测,召回结果标记为不可信数据。

4. 可观测指标

指标 含义 关注点
每轮写入条数 记忆膨胀速度 突增说明抽取过宽
召回命中率 检索是否有效 持续偏低说明查询或索引有问题
记忆精确率 召回中真正相关的比例 抽样人工评估
过期记忆占比 陈旧数据比例 上升说明失效机制缺失
记忆 token 占比 记忆占上下文的比重 超过 30% 要警惕
删除完成时长 合规删除 SLA 超时是合规风险
每轮记忆成本 抽取、嵌入、检索费用 与业务价值对比

5. 评测:不要只看”回答像不像”

记忆系统的评测要拆成两层:

  • 记忆层:写入是否完整、检索是否召回、冲突是否正确处理;
  • 任务层:回答是否正确、是否遵守用户偏好、是否能拒绝过期信息。

公开基准可以用 LongMemEval 和 LoCoMo。LongMemEval 覆盖信息抽取、多会话推理、时间推理、知识更新和弃答五类能力;LoCoMo 侧重超长对话中的问答、事件总结和多模态对话理解。业务上还要自建 golden set,覆盖”偏好变化、事实冲突、跨会话指代、删除后不可召回”这些真实场景。

6. 常见故障

故障 表现 根因 对策
记忆污染 模型执行恶意指令 没把记忆当不可信输入 数据与指令分离、溯源、审核
陈旧事实 推荐已取消的套餐 新值覆盖旧值、无失效时间 双时间轴、有效期
过度召回 回答跑题、成本上升 Top-K 过大、无重排 重排、阈值、预算装箱
记忆膨胀 存储和延迟持续上涨 没有遗忘和合并 TTL、衰减、定期巩固
跨租户泄漏 用户看到他人记忆 命名空间或过滤缺失 强制 tenant_id、行级安全
写入风暴 延迟与费用飙升 每轮全量抽取 异步、批处理、小模型
反馈回路 错误被反复强化 模型写入未验证 置信度、来源、人工确认

十、设计清单

最后给一份可以直接拿去评审的清单:

  1. 先划边界:哪些信息放上下文,哪些进短期记忆,哪些进长期存储,哪些根本不记。
  2. 按类型分存储:事实、事件、规则、任务状态分开,不要一个向量库打天下。
  3. 写入异步、幂等、带溯源:每条记忆都能回答”谁在什么时候、根据什么写的”。
  4. 读路径并行召回、重排、装箱:先保证召回,再保证精确,最后控制 token。
  5. 每个事实带时间和置信度:支持”当时是什么”和”现在是什么”两种查询。
  6. 设计遗忘和删除:TTL、衰减、合并、级联删除,和写入同等重要。
  7. 多租户隔离从第一天做:tenant_id 进入所有查询路径。
  8. 把记忆当不可信输入:防止持久化提示注入和错误自我强化。
  9. 建立评测集:公开基准加业务 golden set,覆盖冲突、过期、删除。
  10. 监控四件事:写入量、召回命中率、上下文占比、删除 SLA。

记忆系统的目标不是”记住一切”,而是在正确的时刻,用可接受的成本,把正确的信息放进有限的上下文。上下文窗口决定模型这一秒能看见什么,记忆系统决定它一年后还记得什么。

参考资料

  1. Packer, C., et al. (2023). “MemGPT: Towards LLMs as Operating Systems.” arXiv:2310.08560
  2. Park, J. S., et al. (2023). “Generative Agents: Interactive Simulacra of Human Behavior.” UIST 2023, arXiv:2304.03442
  3. Maharana, A., et al. (2024). “Evaluating Very Long-Term Conversational Memory of LLM Agents.” ACL 2024, arXiv:2402.17753
  4. Wu, D., et al. (2025). “LongMemEval: Benchmarking Chat Assistants on Long-Term Interactive Memory.” ICLR 2025, arXiv:2410.10813
  5. Chhikara, P., et al. (2025). “Mem0: Building Production-Ready AI Agents with Scalable Long-Term Memory.” arXiv:2504.19413
  6. Rasmussen, P., et al. (2025). “Zep: A Temporal Knowledge Graph Architecture for Agent Memory.” arXiv:2501.13956
  7. Liu, N. F., et al. (2024). “Lost in the Middle: How Language Models Use Long Contexts.” TACL 2024, arXiv:2307.03172
  8. Edge, D., et al. (2024). “From Local to Global: A Graph RAG Approach to Query-Focused Summarization.” arXiv:2404.16130
  9. Gutiérrez, B. J., et al. (2024). “HippoRAG: Neurobiologically Inspired Long-Term Memory for Large Language Models.” NeurIPS 2024, arXiv:2405.14831
  10. Sarthi, P., et al. (2024). “RAPTOR: Recursive Abstractive Processing for Tree-Organized Retrieval.” ICLR 2024, arXiv:2401.18059
  11. LangGraph Documentation: Memory and Persistence
  12. Letta Documentation: Stateful Agents and Memory Blocks
CATALOG
  1. 1. 正文
    1. 1.1. 一、先厘清:上下文、RAG、记忆不是一回事
      1. 1.1.1. 约束一:注意力是平方成本
      2. 1.1.2. 约束二:KV Cache 会吃掉显存
      3. 1.1.3. 约束三:账单按 token 平方级增长
      4. 1.1.4. 约束四:长上下文不等于有效记忆
    2. 1.2. 二、记忆分层:给大模型配一套存储体系
    3. 1.3. 三、记忆类型:语义、情景、程序、工作记忆
    4. 1.4. 四、写入路径:什么值得记,怎么记
      1. 1.4.1. 1. 抽取要结构化
      2. 1.4.2. 2. 打分决定去留
      3. 1.4.3. 3. 去重与冲突:不要简单覆盖
      4. 1.4.4. 4. 写入异步,但会话内要能立刻读到
      5. 1.4.5. 5. 安全边界:记忆是不可信输入
    5. 1.5. 五、存储选型:向量库不是万能药
      1. 1.5.1. 双时间轴:处理”事实会变”这件事
    6. 1.6. 六、检索路径:把正确的记忆塞进有限的上下文
      1. 1.6.1. 1. 查询改写
      2. 1.6.2. 2. 混合召回
      3. 1.6.3. 3. 重排:相关性只是其中一个维度
      4. 1.6.4. 4. 预算装箱
      5. 1.6.5. 5. 位置编排
      6. 1.6.6. 6. 检索策略怎么选
      7. 1.6.7. 7. 进阶:图检索与摘要树
    7. 1.7. 七、巩固与遗忘:记忆系统也需要 GC
      1. 1.7.1. 1. 巩固:从原始对话到稳定知识
      2. 1.7.2. 2. 冲突处理:保留历史,标记失效
      3. 1.7.3. 3. 衰减:让不常用的记忆自然下沉
      4. 1.7.4. 4. 删除:合规要求比技术实现更难
    8. 1.8. 八、典型系统拆解:MemGPT、Mem0、Zep、LangGraph
      1. 1.8.1. MemGPT:把上下文当内存管理
      2. 1.8.2. Mem0:抽取与更新两阶段
      3. 1.8.3. Zep / Graphiti:时序知识图谱
      4. 1.8.4. LangGraph:短期与长期记忆分开
        1. 1.8.4.1. 最小可用示例
        2. 1.8.4.2. 换成 Postgres
        3. 1.8.4.3. 四个容易踩的坑
    9. 1.9. 九、工程落地:参考架构、指标与踩坑
      1. 1.9.1. 1. 读写分离与降级
      2. 1.9.2. 2. 延迟预算
      3. 1.9.3. 3. 多租户与安全
      4. 1.9.4. 4. 可观测指标
      5. 1.9.5. 5. 评测:不要只看”回答像不像”
      6. 1.9.6. 6. 常见故障
    10. 1.10. 十、设计清单
    11. 1.11. 参考资料