LLM 记忆系统

LLM 记忆系统解决的核心问题是：大模型的上下文窗口（context window，即模型单次推理能”看到”的文本长度上限）有限，无法天然记住跨会话的信息。本页系统梳理从最基础的对话历史管理，到向量长期记忆、实体记忆、记忆流与反思记忆的完整谱系，并补充 2024-2025 年记忆框架的最新进展。相关内容可配合 RAG 检索增强生成、向量数据库、上下文工程 与 Agent 设计模式 阅读。

核心直觉

LLM 本身像一条金鱼——它只有当前上下文窗口（context window）内的记忆。窗口之外的一切，对它来说就像从未发生过。你昨天和它聊了三个小时，今天再打开对话，它一脸茫然。记忆系统就是给这条金鱼装上”笔记本”和”档案柜”，让它不再每次都从零开始。

用生活中的比喻来理解不同层级的记忆：

• 短期记忆（对话历史管理）= 你的工作台。上面摊着最近正在处理的文件，空间有限，放满了就得把旧的收走。滑动窗口就是只保留桌面最近几页，摘要压缩就是把厚厚一叠旧文件浓缩成一页摘要放回桌面。
• 向量长期记忆（RAG 式）= 你的档案柜，按主题分类存放。需要某条信息时，你不会把整个柜子搬上桌，而是”按关键词搜索”，只取相关的那几份档案。这就是向量检索（vector retrieval，将文本转为高维向量后按几何距离度量语义相似度的技术）的本质——按需回忆，而非全部记住。
• 实体记忆（知识图谱）= 你的通讯录和关系网图。“用户女儿叫小美""用户对花生过敏”这类结构化事实，记在通讯录里精确查询，比翻档案柜快得多、也准得多。
• 记忆流（Memory Stream）= 你的日记本，按时间顺序记录每天发生的所有事。回忆时综合考虑三件事：这件事多久前发生的（近期性）、这事重不重要（重要性）、和当前话题相关吗（相关性）。
• 反思记忆（Reflexion）= 你的错题本。做完一道题错了，把错误原因和教训写下来，下次遇到类似题先翻错题本。Agent（智能体，能自主规划并调用工具完成任务的 AI 系统）从失败中学习，把经验教训存成自然语言笔记，指导后续行动。
• 程序化记忆（Procedural Memory）= 你的肌肉记忆。骑自行车一旦学会就不容易忘——这是”身体”层面的记忆。在 LLM 中对应的是经过微调（fine-tuning，用领域数据进一步训练模型权重）固化到模型参数中的技能，区别于外挂的文本记忆。

一句话总结：短期记忆管”眼前”，向量记忆管”按需回忆”，实体记忆管”精确事实”，记忆流管”时间线回忆”，反思记忆管”从错误中学习”，程序化记忆管”内化技能”。

为什么记忆系统在 2025 年变得至关重要？ 随着 Agent 应用爆发，单次任务可能涉及数十轮工具调用和数百条中间结果。没有有效的记忆管理，Agent 要么重复犯错，要么在关键步骤遗忘前置信息。OpenAI、Google、Anthropic 都在 2024-2025 年为各自的 AI 助手加入了系统级记忆功能，记忆系统已从”可选优化”升级为”必选基础设施”。

原理详解

对话历史管理：短期记忆的基础工程

对话历史管理是最基础的记忆层，处理的是”如何在有限的上下文窗口内，最高效地放置对话历史”。

滑动窗口（Sliding Window） 是最简单的策略：只保留最近 N 轮对话，更早的消息直接丢弃。比如窗口大小为 10 轮，第 11 轮进来时，第 1 轮就被挤出去。优点是实现极简、token 消耗可预测；缺点是”记忆断层”——用户提到一个关键信息后聊了 10 轮不相关话题，关键信息就丢了。滑动窗口适用于客服问答、简短任务等短对话场景。

摘要压缩（Summary Compression） 解决滑动窗口的记忆断层问题。思路是：当对话超过窗口时，不是直接丢弃旧消息，而是调用 LLM 把旧对话压缩成一段摘要，再把摘要放回上下文。比如 20 轮对话压成”用户询问了退货政策，已告知 30 天无理由退货，用户表示满意”一句话。这样既腾出了空间，又保留了关键信息。实际工程中常常混合使用：最近 N 轮保持原文，更早的对话压缩成摘要，两者拼接后送入上下文。

进阶：分层摘要（Hierarchical Summarization）。当对话非常长时，单层摘要会丢失太多细节。更成熟的做法是构建”摘要树”：每 10 轮对话生成一个一级摘要，每 5 个一级摘要再合成一个二级摘要，以此类推。检索时可以按需展开某个分支的细节，类似 B+ 树的索引查询。这种结构让 Agent 在有限的 token 预算内同时拥有”宏观概览”和”按需下钻”的能力。

Token 预算管理（Token Budget Management） 是对话历史管理的底层约束。上下文窗口有硬上限（如 8K、32K、128K、200K token），对话历史、系统提示、用户输入、模型输出共享这个预算。工程上需要实时追踪 token 用量：当历史对话逼近预算时触发摘要压缩或滑动窗口裁剪，给当前轮次的新输入和模型回复预留足够空间。tiktoken（OpenAI 开源的 BPE 分词器，可离线计算 token 数）等工具用于精确计数 token。

2025 年更新：随着 Gemini 2.0（1M token 窗口）、Claude 3.5（200K token）等超长上下文模型的普及，一些工程师认为”窗口够大就不需要记忆系统了”。这是一个误解——即使有百万 token 窗口，(1) 注入全部历史仍然显著增加推理成本（注意力机制的计算量与序列长度的平方成正比）；(2) “大海捞针”测试表明，超长上下文中间位置的信息容易被忽略（lost-in-the-middle 现象）。记忆系统从”压缩以适应窗口”进化为”精选最相关信息以提升效果和降低成本”。

向量记忆：RAG 式长期记忆

向量记忆是 RAG（Retrieval-Augmented Generation，检索增强生成，在生成前先从外部知识库检索相关信息的范式）技术在对话场景中的应用。核心思路：把过去的对话片段、用户偏好、关键事实等存入向量数据库，每轮新对话时，先把当前输入向量化，检索出最相关的若干条历史记忆，再将它们注入上下文。

具体流程：每轮对话结束后，把用户消息和模型回复（或其摘要）做嵌入（embedding，将文本映射为高维向量，使语义相近的文本在向量空间中距离更近），存入向量数据库（如 Chroma、Pinecone、FAISS、Qdrant）。下一轮对话开始时，把用户新消息也做嵌入，在数据库中做相似性检索（通常用余弦相似度或点积），取回 top-k 条最相关的记忆，拼接到当前上下文里。这相当于”按需回忆”——不把所有历史塞进上下文，只取和当前话题相关的部分。

向量记忆的优势在于可扩展性：对话可以持续数万轮，向量数据库可以存储海量记忆，每次只检索相关片段，不受上下文窗口限制。挑战在于：

1. 什么内容值得存：不是每句闲聊都值得记住。mem0 等框架的做法是让 LLM 做写入前的信息提取——先判断”这句话里有没有值得记住的事实/偏好/决策”，有才写入。
2. 嵌入质量：嵌入模型直接决定检索效果。2025 年的主流嵌入模型包括 OpenAI text-embedding-3-large（3072 维）、Cohere embed-v4、BGE bge-m3（多语言）等。选错嵌入模型会导致语义相近但表述不同的记忆无法被召回。
3. 记忆的时效性：旧信息可能已过时（用户三个月前的偏好可能已改变）。需要”遗忘”机制——定期用 LLM 审查旧记忆是否仍然有效，过时的删除或更新。
4. 检索粒度：按整条消息存储还是按句子/段落切分？粒度太粗会带入无关信息，粒度太细会丢失上下文。实践中常按”语义完整的片段”（如一个事实陈述、一个决策结论）作为存储单位。

详见 RAG 检索增强生成 与 向量数据库。

实体记忆：知识图谱追踪

实体记忆用知识图谱（Knowledge Graph，以”实体-关系-实体”三元组形式组织信息的结构化图数据库）结构化地追踪对话中出现的实体及其关系。与向量记忆的”模糊语义检索”不同，实体记忆追求”精确事实查询”。

工作方式：LLM（或专门的提取模型）从对话中识别关键实体和关系。例如对话中用户说”我女儿小美下周要考期末考试”，系统提取出实体”小美”（类型：人，关系：用户的女儿）和事件”期末考试”（时间：下周）。这些结构化三元组——（用户, has_daughter, 小美）、（小美, has_exam, 期末考试@下周）——存入图数据库（如 Neo4j）或键值存储。后续当用户问”我女儿什么时候考试”时，系统直接查询实体库，精确返回”下周”，而非依赖向量检索的模糊匹配。

实体记忆特别适合存储用户画像（user profile，用户的属性和偏好集合）信息：姓名、家庭关系、职业、偏好、过敏史、重要日期等。这类信息需要精确存取——把”花生过敏”检索成”海鲜过敏”是致命的错误，而向量相似度检索恰好可能犯这种错。将实体记忆与向量记忆结合使用（结构化事实走实体查询，语义回忆走向量检索）是目前业界最佳实践。详见 GraphRAG。

实体记忆的写入流程通常包括三步：

1. 实体抽取（Named Entity Recognition, NER）：从对话中识别人名、地名、组织、日期、事件等实体。
2. 关系抽取（Relation Extraction）：判断实体间的语义关系（“属于""位于""发生在”等）。
3. 冲突消解（Conflict Resolution）：当新信息与已有记忆冲突时（如用户先说”住在上海”后说”搬到了北京”），决定保留哪条、如何更新。

2025 年趋势——GraphRAG 的崛起：微软在 2024 年提出的 GraphRAG 方法将知识图谱构建与 RAG 检索深度融合：先用 LLM 从文档中自动抽取实体和关系构建图谱，再通过社区检测（community detection）算法将实体聚类为主题分组，检索时既能做”实体级精确查询”又能做”社区级概览摘要”。这种结构化+语义混合的方式在处理超长对话和复杂知识时表现优于纯向量检索。

Memory Stream：记忆流

Memory Stream 受 Generative Agents 论文（Park et al., 2023）启发，模拟人类记忆的时间线特性。系统按时间顺序记录 Agent 经历的所有事件（每条记录带时间戳），检索时不是单纯按相似度，而是综合三个维度给每条记忆打分：

• 近期性（Recency）：越近发生的记忆得分越高。实现上通常用指数衰减函数——最近几小时的事件得分接近 1，几天前的事件衰减到 0.5，一周前降到 0.1。人类也是如此，昨天的午餐记得清楚，上周三吃了什么大概想不起来。具体公式：$\text{recency\_score} = \text{decay\_factor}^{\text{hours\_since\_event} / \text{decay\_period}}$，其中 $\text{decay\_factor}$ 通常取 0.99，$\text{decay\_period}$ 取 1 小时。
• 重要性（Importance）：事件越重要得分越高。“女儿出生”重要性是 9 分，“喝了杯咖啡”重要性是 1 分。重要性通常由 LLM 在记录时打分（1-10 分），存入记忆时一并保存。这一步可以用一个简单的 prompt 实现："给以下事件的重要性打分（1-10），只返回数字：{event}"
• 相关性（Relevance）：记忆与当前情境的语义相关度。用向量相似度计算（余弦相似度）——当前话题是”做饭”，那”上次尝试的新菜谱”相关性高（接近 1.0），“昨天的天气”相关性低（接近 0.0）。

最终得分 = $\alpha \times$ 近期性得分 $+ \beta \times$ 重要性得分 $+ \gamma \times$ 相关性得分（$\alpha$、$\beta$、$\gamma$ 为可调权重，原论文中各取 1/3 等权），取 top-k 条记忆注入上下文。这种三维打分比纯向量检索更贴近人类回忆方式——你想起一件事，既因为它刚发生（近期性），也因为它重要（重要性），还因为和现在做的事有关（相关性）。

Reflexion 记忆：从失败中学习

Reflexion 是一种让 Agent 从自身失败中学习的记忆机制。传统 Agent 失败后直接重试，不积累任何经验；Reflexion 则在每次尝试后做”反思”：如果失败了，让 LLM 分析失败原因，把教训以自然语言形式写入记忆。下次遇到类似任务时，先检索相关的历史反思，避免重蹈覆辙。

典型流程：

Agent 执行任务
  ↓
环境给出反馈（成功/失败/评分）
  ↓
如果失败 → LLM 生成反思（"上一步报错是因为 API 参数类型不对，
                                应该传字符串而非整数"）
  ↓
反思存入记忆（向量数据库或文本文件）
  ↓
下次执行类似任务 → 检索相关反思 → 注入上下文作为"注意事项"

这种”自我反思 + 记忆积累”的机制显著提升了 Agent 在多轮试错场景中的表现。论文实验表明，在编程任务（HumanEval）和决策推理（HotpotQA）上，Reflexion 让 Agent 通过 2-3 次反思迭代就能逼近甚至超过更复杂模型的表现。本质上，它用”经验笔记”弥补了模型权重中缺乏的任务特定知识。

Reflexion 与传统强化学习的关键区别：传统 RL（如 RLHF）通过梯度回传更新模型参数来”学习”，需要大量训练数据和算力；Reflexion 则用自然语言作为”语言反馈梯度”，不修改模型权重，只在外部记忆中积累经验。这使得 Reflexion 可以即插即用地应用于任何闭源 API 模型。

记忆的分层模型：认知科学视角

以上各种记忆方式并非互斥，而是构成一个从短期到长期、从具体到抽象的分层体系，类似于认知科学中人类记忆的分类：

记忆类型	对应人类记忆	LLM 实现	保留时长	信息粒度
工作记忆	工作记忆（Working Memory）	上下文窗口中的对话历史	单次会话	完整原文
短期外显记忆	短期记忆（Short-term Memory）	滑动窗口 + 摘要压缩	数轮对话	压缩摘要
长期情景记忆	情景记忆（Episodic Memory）	向量记忆 + 记忆流	跨会话/永久	事件片段
语义记忆	语义记忆（Semantic Memory）	实体知识图谱	永久	结构化事实
程序化记忆	程序化记忆（Procedural Memory）	模型权重（微调固化）	永久	技能/模式
元认知记忆	元认知（Metacognition）	反思记忆 / 经验笔记	跨会话	抽象教训

理解这种对应关系有助于设计更完善的记忆架构——正如人类大脑同时依赖多种记忆系统协同工作，LLM 也需要多层记忆才能实现真正智能的长期交互。

mem0 / LangMem / Letta：记忆管理框架

随着 LLM 记忆系统的重要性日益凸显，一批专用工具框架应运而生，把记忆的提取、存储、检索流程封装成开箱即用的组件。

mem0（前身 Embedchain Memory）是一个开源的 LLM 记忆层，核心理念是”自动记忆管理”。你只需在对话后调用 memory.add()，mem0 会自动判断哪些信息值得记住（用 LLM 做信息提取），存入向量数据库；对话前调用 memory.search()，自动检索相关记忆并返回。mem0 还支持记忆的去重、更新和遗忘（过时信息的自动清理），减少了手工管理记忆的工程负担。

mem0 的内部处理流程：add() 调用后并非简单存储原文，而是经过：(1) LLM 提取值得记住的事实；(2) 与已有记忆做相似度比对，检测是否重复或冲突；(3) 新信息直接存储，冲突信息触发更新，重复信息跳过。这种”提取-去重-更新-存储”的流水线使记忆库保持精炼。

LangMem 是 LangChain 生态的记忆管理模块，提供更细粒度的控制。它支持多种记忆策略（滑动窗口、摘要压缩、向量存储、实体存储等）的组合配置，开发者可以按需选择。LangMem 的设计哲学是”记忆即工具”——把记忆操作（保存、搜索、更新）抽象为 Agent 可调用的工具（tool），让 Agent 自主决定何时记忆、何时回忆。

Letta（原名 MemGPT，Packer et al., 2023，2024 年更名为 Letta 并获得融资）提出了另一个重要思路：借鉴操作系统的虚拟内存和分页机制，把 LLM 的上下文窗口视为”内存”（RAM），把外部存储视为”磁盘”（disk），通过”分页调度”（paging）在两者之间自动搬运记忆。Letta 让 LLM 自己管理记忆的分页与唤入（page-in）唤出（page-out），突破了上下文窗口的硬限制。2024-2025 年，Letta 进一步发展为完整的”有状态 Agent”（stateful agent）平台，支持 Agent 的持久化、热加载和多 Agent 协作。

2025 年记忆框架生态：除上述三者外，值得关注的新进展包括：

• Zep 升级为 Graphiti 引擎，将时序知识图谱（temporal knowledge graph）引入记忆管理，支持”时间旅行”查询（如”用户上个月说过什么”）。
• LangGraph 的”检查点”（checkpointing）机制，让 Agent 可以在执行中途保存状态、回滚到历史节点，本质上是 Agent 工作流级别的”程序化记忆”。
• OpenAI Assistants API / Anthropic Computer Use 内置了系统级记忆和文件管理，降低了自建记忆系统的门槛，但灵活性和可控性不如开源方案。

原理图解

LLM 记忆系统全景

从短期到长期，不同记忆层级如何协作：

Memory Stream 三维检索打分

Generative Agents 的记忆检索流程，综合近期性、重要性、相关性三个维度：

mem0 记忆写入流水线

mem0 的 add() 调用背后发生的”提取-去重-更新-存储”流程：

动手实践

使用 mem0 管理对话记忆

以下示例展示 mem0 如何自动提取、存储和检索对话记忆：

from mem0 import Memory

# 初始化记忆（底层用 OpenAI 嵌入 + 向量数据库，需设置 OPENAI_API_KEY）
m = Memory()

# 存入两段对话，mem0 自动提取值得记住的信息
m.add("我女儿小美下周要考期末考试，她有点紧张。", user_id="alice")
m.add("我对花生严重过敏，聚餐时一定要避开。", user_id="alice")

# 检索相关记忆——查询"考试"自动召回小美的信息
results = m.search("家里最近有什么重要安排？", user_id="alice")
for r in results:
    print(r["memory"])
# 输出示例：
#   女儿小美下周要考期末考试
#   对花生严重过敏，聚餐需避开

# 跨会话记住用户画像，无需把所有历史塞进上下文

用 LangChain + ChromaDB 手写向量记忆

如果不用 mem0，也可以用基础组件手动搭建向量记忆层：

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

# 用 ChromaDB 做向量存储，OpenAI 做嵌入
vstore = Chroma(embedding_function=OpenAIEmbeddings())

# 对话结束后存入记忆（实践中应对每条消息做嵌入）
vstore.add_texts([
    "用户偏好：喜欢简洁的技术解释，不喜欢冗长铺垫",
    "用户背景：后端工程师，熟悉 Python 和 Go",
])

# 新对话开始时，检索与当前话题相关的历史记忆
docs = vstore.similarity_search("请用简洁的方式解释这个技术概念", k=2)
for d in docs:
    print(d.page_content)  # 召回用户偏好，指导回复风格

手写分层摘要记忆管理器

以下是一个更完整的分层记忆管理器实现，演示滑动窗口 + 摘要压缩的混合策略：

import openai

client = openai.OpenAI()

class LayeredMemory:
    """分层记忆管理器：最近 N 轮保持原文，更早的压缩成摘要。"""

    def __init__(self, window_size=6, max_summary_tokens=200):
        self.window_size = window_size      # 保留最近几轮原文
        self.max_summary_tokens = max_summary_tokens
        self.recent_messages = []           # 最近 N 轮（原文）
        self.summary = ""                   # 更早对话的累积摘要

    def _compress(self, old_messages):
        """调用 LLM 把旧消息压缩成摘要。"""
        transcript = "\n".join(
            f"{m['role']}: {m['content']}" for m in old_messages
        )
        prompt = (
            "请将以下对话浓缩成一段不超过200 token的摘要，"
            "保留关键事实、决策和用户偏好：\n\n"
            f"{transcript}"
        )
        resp = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=self.max_summary_tokens,
        )
        return resp.choices[0].message.content

    def add(self, role, content):
        """添加一条新消息，必要时触发摘要压缩。"""
        self.recent_messages.append({"role": role, "content": content})

        # 超过窗口时，把最早的几轮压缩进摘要
        if len(self.recent_messages) > self.window_size:
            # 取出超出窗口的部分
            overflow = self.recent_messages[:2]  # 每次压缩 2 轮
            self.recent_messages = self.recent_messages[2:]

            # 把新摘要与旧摘要合并
            old_part = f"\n\n[早期摘要]\n{self.summary}" if self.summary else ""
            new_summary = self._compress(overflow)
            self.summary = new_summary + old_part

    def get_context(self):
        """返回组装后的上下文：摘要 + 最近对话。"""
        context = []
        if self.summary:
            context.append({
                "role": "system",
                "content": f"[对话历史摘要]\n{self.summary}"
            })
        context.extend(self.recent_messages)
        return context


# 使用示例
memory = LayeredMemory(window_size=6)
memory.add("user", "我是后端工程师，主要用 Python 和 Go。")
memory.add("assistant", "了解！有什么我可以帮你的？")
# ... 继续对话，超过 6 轮后旧对话自动压缩

用 Reflexion 机制实现自我改进的 Agent

"""一个最小化的 Reflexion Agent：从失败中学习。"""
import openai

client = openai.OpenAI()

class ReflexionAgent:
    def __init__(self):
        self.reflections = []  # 存储历史反思

    def attempt(self, task, max_retries=3):
        """带反思重试的任务执行。"""
        for attempt_num in range(1, max_retries + 1):
            # 组装上下文：任务 + 历史反思（如果有）
            system_msg = "你是一个编程助手。请直接给出代码解决方案。"
            if self.reflections:
                system_msg += "\n\n过去尝试中的经验教训（请避免同样错误）：\n"
                for ref in self.reflections[-3:]:  # 只取最近 3 条反思
                    system_msg += f"- {ref}\n"

            # 生成答案
            resp = client.chat.completions.create(
                model="gpt-4o",
                messages=[
                    {"role": "system", "content": system_msg},
                    {"role": "user", "content": task},
                ],
            )
            answer = resp.choices[0].message.content
            print(f"--- 第 {attempt_num} 次尝试 ---")

            # 模拟环境反馈（实际应用中替换为测试/编译结果）
            success, feedback = self.evaluate(task, answer)

            if success:
                print("✅ 成功！")
                return answer

            # 失败 → 生成反思并存入记忆
            print(f"❌ 失败：{feedback}")
            reflection = self.reflect(task, answer, feedback)
            self.reflections.append(reflection)
            print(f"📝 反思：{reflection}\n")

        return answer  # 返回最后一次尝试

    def evaluate(self, task, answer):
        """评估答案正确性（实际中替换为测试套件）。"""
        # 这里用简化逻辑演示；生产环境应运行实际测试
        if "placeholder" in answer.lower() or "todo" in answer.lower():
            return False, "代码包含未实现的占位符"
        return True, "通过"

    def reflect(self, task, answer, feedback):
        """让 LLM 分析失败原因，生成可复用的经验笔记。"""
        resp = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=[{
                "role": "user",
                "content": (
                    f"任务：{task}\n"
                    f"上次回答：{answer[:500]}\n"
                    f"失败原因：{feedback}\n\n"
                    "用一句话总结下次应该注意什么："
                ),
            }],
            max_tokens=100,
        )
        return resp.choices[0].message.content

# 使用：Agent 会从每次失败中学习，后续尝试避免同类错误
agent = ReflexionAgent()
result = agent.attempt("用 Python 实现一个线程安全的单例模式")

实践要点

• 分层记忆优于单一方案：不要指望一种记忆策略包打天下。最佳实践是短期窗口管最近对话、摘要压缩衔接中短期、向量数据库做长期语义检索、实体图谱存结构化事实、反思笔记存经验教训。各层各司其职，协同覆盖不同记忆需求。
• 不是所有信息都值得记住：记忆写入应做过滤。闲聊（“今天天气不错”）不值得存储，用户偏好、关键事实、决策结论才值得。用 LLM 做写入前的信息提取和判断，能大幅减少记忆库噪声。mem0 的”提取-去重-更新”流水线就是这一原则的工程化实现。
• 记忆有时效性，需要”遗忘”机制：用户三个月前的偏好可能已改变（“我换了工作""我现在开始健身了”）。定期做记忆清理和更新——用 LLM 判断旧记忆是否仍然有效，过时信息及时删除或更新，避免错误记忆误导回复。MemoryBank 论文提出的基于艾宾浩斯遗忘曲线（Ebbinghaus Forgetting Curve，描述人类记忆随时间衰退规律的心理学模型）的方案值得参考。
• 实体记忆与向量记忆互补而非替代：向量检索擅长”模糊语义匹配”，但”花生过敏”检索成”海鲜过敏”这种错误是不可接受的。涉及精确事实（健康、财务、身份信息）的场景，务必用结构化实体存储，向量检索只做辅助。
• Token 预算要留安全余量：注入记忆会消耗上下文窗口。始终为当前用户输入和模型回复预留至少 1/4 的窗口空间，避免记忆塞满后模型没有空间生成高质量回复。用 tiktoken 等 token 计数工具实时监控。
• 评估记忆系统的效果要靠端到端指标：不要只看检索召回率（recall@k，前 k 条结果中包含正确答案的比例），要测最终对话质量。多轮对话数据集（如 MultiSessionChat、LoCoMo）能评估记忆系统是否真正提升了用户体验。
• 记忆格式要结构化：存储为”（主体, 属性, 值, 时间戳）“的结构化格式，而非原始对话文本。这使后续的查询、更新、冲突消解都更高效。例如存”（alice, 所在城市, 上海, 2025-01-15）“而非”用户说住在上海”。
• 保护用户隐私：记忆系统存储了用户的个人信息，需要遵循数据保护法规（如 GDPR）。提供用户查看、编辑、删除记忆的功能（类似 ChatGPT 的 Memory 管理界面），并在用户要求时一键清除。

典型应用

• ChatGPT Memory 功能：OpenAI 在 2024 年推出的记忆功能，ChatGPT 会自动记住跨会话的用户信息（偏好、背景、过往讨论的话题），在后续对话中自然引用。用户可在设置中查看和管理已保存的记忆。这本质上是实体记忆 + 向量记忆的产品化落地。2025 年，ChatGPT 的记忆进一步与自定义指令（Custom Instructions）融合，并可引用历史对话中的上下文。
• Character.AI 角色记忆：虚拟角色陪伴平台需要长期记住与每个用户的互动历史，维持角色设定的一致性和情感连续性。这类场景对记忆的”情感一致性”要求极高——角色不能突然忘记上次承诺过的事。
• Pi（Inflection）的长期对话记忆：Inflection AI 的 Pi 以”高情商长程对话”著称，其核心技术之一就是强大的长期记忆系统，能在数月甚至数年的对话中保持对用户的深度理解。
• 编程 Agent 的错误学习：Cursor、Devin、Claude Code 等编程助手利用 Reflexion 式记忆，从用户的纠错反馈和执行失败中积累项目特定的经验教训，减少同类错误的重复发生。一些工具已开始维护项目级的 .agent_memory 文件，持久化记录项目约定和常见坑。
• 客服系统的用户画像记忆：企业级客服 Agent 用实体记忆存储用户的历史工单、购买记录、偏好设置，在多次咨询间保持服务连续性，避免用户反复陈述背景信息。
• 多 Agent 协作中的共享记忆：当多个 Agent 协作完成任务时（如 CrewAI、AutoGen 场景），需要一个共享记忆黑板（shared memory blackboard），让各 Agent 感知彼此的工作进展和中间结果，避免重复劳动和信息不一致。

典型类库与工具

类库	语言	说明
mem0	Python	开源 LLM 记忆层，自动提取/去重/存储/检索记忆，支持多种向量数据库后端
LangMem	Python	LangChain 生态记忆模块，支持滑动窗口、摘要、向量、实体等多种策略组合
Letta (MemGPT)	Python	基于操作系统分页思想的记忆框架，2024 年升级为有状态 Agent 平台，支持持久化和多 Agent
LangGraph	Python	LangChain 的 Agent 工作流引擎，提供检查点（checkpointing）实现工作流级记忆和回滚
Zep / Graphiti	Python	开源长期记忆服务，2025 年引入时序知识图谱（Graphiti 引擎），支持”时间旅行”查询
LangChain Memory	Python	LangChain 内置的记忆组件，提供 ConversationBufferMemory、ConversationSummaryMemory 等基础实现
LlamaIndex Memory	Python	LlamaIndex 的记忆模块，与 RAG 管道深度集成
ChromaDB	Python	轻量级向量数据库，常作为记忆系统的存储后端

术语表

术语	英文	解释
上下文窗口	Context Window	LLM 单次推理能处理的最大 token 数，是短期记忆的硬上限
滑动窗口	Sliding Window	只保留最近 N 轮对话的策略，超出窗口的旧消息直接丢弃
摘要压缩	Summary Compression	用 LLM 将旧对话压缩成摘要，腾出上下文空间同时保留关键信息
分层摘要	Hierarchical Summarization	对摘要再做摘要，形成树状索引，兼顾概览与细节
Token 预算	Token Budget	上下文窗口中分配给对话历史、系统提示、输入输出的 token 配额
向量记忆	Vector Memory	将历史信息存入向量数据库，按语义相似度按需检索的记忆方式
实体记忆	Entity Memory	用知识图谱结构化存储对话中的实体和关系，支持精确事实查询
记忆流	Memory Stream	按时间线记录所有事件，检索时综合近期性、重要性、相关性三维打分
近期性	Recency	Memory Stream 打分维度之一，越近发生的记忆得分越高（指数衰减）
重要性	Importance	Memory Stream 打分维度之一，事件越关键得分越高（LLM 打分）
相关性	Relevance	Memory Stream 打分维度之一，与当前情境语义越相关得分越高（余弦相似度）
反思记忆	Reflexion Memory	Agent 从失败中总结教训，以自然语言形式存储并指导后续行动的记忆机制
程序化记忆	Procedural Memory	通过微调固化到模型权重中的技能，区别于外挂的文本记忆
记忆分页	Memory Paging	MemGPT/Letta 提出的概念，借鉴操作系统在上下文（内存）和外部存储（磁盘）间搬运记忆
时序知识图谱	Temporal Knowledge Graph	带时间戳的知识图谱，支持查询某时间点的实体状态（如”用户上个月住在哪里”）
有状态 Agent	Stateful Agent	具备持久记忆和状态的 Agent，可在不同会话间保持连续性

延伸阅读

• Park et al.,「Generative Agents: Interactive Simulacra of Human Behavior」(UIST 2023)：记忆流（Memory Stream）的奠基论文，斯坦福”虚拟小镇”实验让 25 个 AI Agent 在沙盒中自主生活、社交、计划，三维记忆检索是核心机制之一。
• Packer et al.,「MemGPT: Towards LLMs as Operating Systems」(2023)：将操作系统的虚拟内存和分页机制引入 LLM 记忆管理，让模型自主管理记忆的唤入唤出，突破上下文窗口限制。后发展为 Letta 框架。
• Shinn et al.,「Reflexion: Language Agents with Verbal Reinforcement Learning」(NeurIPS 2023)：反思记忆原始论文，提出用自然语言自我反思替代梯度更新的”语言强化学习”范式。
• Zhong et al.,「MemoryBank: Enhancing Large Language Models with Long-Term Memory」(AAAI 2024)：提出基于艾宾浩斯遗忘曲线的记忆增强方案，模拟人类记忆的遗忘与巩固规律。
• Edge et al.,「From Local to Global: A GraphRAG Approach to Query-Focused Summarization」(Microsoft, 2024)：微软 GraphRAG 论文，将知识图谱与 RAG 结合，用社区检测实现层次化检索，对实体记忆设计有重要参考价值。
• mem0 官方文档（docs.mem0.ai）：开源记忆框架的文档与教程，适合动手实践记忆系统的工程落地。
• Letta 官方文档（docs.letta.com）：MemGPT 的后续产品文档，提供有状态 Agent 的完整开发指南。