返回专栏
· 25 分钟阅读

Agent 的记忆检索与更新机制


一、为什么记忆检索与更新如此重要?

Agent 的记忆系统通常包含短期记忆和长期记忆,但记忆数据的存在并不意味着 Agent 能够有效利用它们。

假设用户之前告诉 Agent:

后端项目主要使用 Go,数据库使用 PostgreSQL。

几天后,用户提出:

帮我设计一个订单服务。

Agent 需要完成以下工作:

  1. 判断当前任务是否需要历史记忆。
  2. 从记忆库中查找与订单服务相关的信息。
  3. 找到用户之前提供的技术栈。
  4. 判断这些信息是否仍然有效。
  5. 将相关记忆注入当前模型上下文。
  6. 根据新任务产生的信息更新已有记忆。

如果检索失败,Agent 就无法利用历史信息。

如果检索到了过期信息,Agent 可能做出错误决策。

如果更新机制存在缺陷,重复、冲突和错误信息就会不断积累。

因此,记忆系统实际上包含两个相互关联的核心过程:

  • 记忆检索(Memory Retrieval):从已有记忆中找到当前任务需要的信息。
  • 记忆更新(Memory Update):根据新信息修改、合并、补充或删除已有记忆。

二者共同构成 Agent 记忆的动态管理机制。

二、记忆检索与更新的整体架构

从系统架构来看,记忆检索和更新通常由独立的 Memory Manager 统一协调。

主要组件如下:

组件 核心职责
Memory Manager 统一管理记忆生命周期
Query Analyzer 分析当前任务和检索意图
Query Rewriter 将用户请求转换为检索查询
Memory Retriever 从不同存储中召回候选记忆
Reranker 对候选记忆重新排序
Memory Validator 验证记忆有效性和可信度
Context Builder 将相关记忆组织成模型上下文
Memory Extractor 从新交互中提取候选记忆
Memory Merger 处理重复和相似记忆
Conflict Resolver 解决新旧记忆之间的冲突
Memory Store 持久化记忆
Lifecycle Manager 处理过期、归档和删除

整体工作过程:

flowchart TD
    A["Agent Runtime"] --> B["Memory Manager"]

    B --> C["记忆检索模块"]
    B --> D["记忆更新模块"]

    C --> E["查询分析"]
    E --> F["查询改写"]
    F --> G["多路记忆召回"]
    G --> H["候选记忆重排序"]
    H --> I["有效性校验"]
    I --> J["上下文组装"]

    D --> K["候选记忆提取"]
    K --> L["记忆分类与评估"]
    L --> M["去重与合并"]
    M --> N["冲突检测"]
    N --> O["记忆持久化"]

    O --> G
    J --> P["模型推理与任务执行"]
    P --> D

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

需要注意,记忆检索和更新不是完全独立的两个阶段。

检索结果可能发现记忆已经过期或存在冲突,从而触发更新;任务执行产生的新事实,也可能在更新后影响下一次检索。

三、记忆检索的完整过程

记忆检索不是简单地执行一次向量搜索。

一个完整的检索过程通常包括:

  1. 检索触发判断。
  2. 查询意图分析。
  3. 查询改写。
  4. 多路召回。
  5. 候选结果合并。
  6. 相关性重排序。
  7. 有效性和权限校验。
  8. 上下文组装。

1. 检索触发判断

并不是所有任务都需要读取长期记忆。

例如:

用户请求 是否需要检索 原因
解释什么是 TCP 通常不需要 通用知识问题
继续上次的项目分析 需要 依赖历史任务上下文
按照我的代码规范生成代码 需要 依赖用户偏好
查询当前订单状态 应查询业务系统 记忆不能替代实时数据
总结刚才上传的文档 通常不需要长期记忆 当前上下文已有数据

检索触发可以采用规则和模型结合的方式。

规则触发

通过明确条件决定是否检索:

  • 用户提到之前、上次、继续等词语。
  • 当前任务包含用户个性化要求。
  • 任务关联特定项目。
  • 当前会话缺少必要背景信息。

模型判断

由模型分析当前任务,判断是否需要历史信息,以及需要哪种记忆。

例如:

{
  "need_memory": true,
  "memory_types": [
    "preference",
    "semantic",
    "episodic"
  ],
  "reason": "当前任务需要了解用户的技术栈和历史项目背景"
}

生产环境中,模型判断不应成为唯一的检索入口。对于必须遵守的项目约束、权限边界和明确的任务关联,应该使用确定性的规则保障。

2. 查询意图分析

确定需要检索后,系统需要理解当前任务究竟想查什么。

例如:

帮我按照之前的技术栈设计一个订单服务。

这句话至少包含三个检索意图:

  • 用户之前使用什么技术栈?
  • 当前项目是否有既定架构?
  • 用户是否有特定的代码或设计偏好?

可以将检索意图结构化:

{
  "intent": "project_design",
  "entities": [
    "订单服务",
    "当前项目"
  ],
  "memory_types": [
    "preference",
    "fact",
    "semantic"
  ],
  "constraints": {
    "scope": "current_project"
  }
}

意图分析的目标是将自然语言请求转换为明确的检索任务。

3. 查询改写(Query Rewriting)

用户的原始请求不一定适合直接用于向量检索。

例如:

继续按照之前的方式做。

这句话缺少具体的检索语义。

系统需要结合当前会话和任务状态,将它改写为更明确的查询:

检索当前项目之前确认的技术栈、架构设计约束、
代码规范和已经完成的设计方案。

查询改写可以包含:

  • 指代消解。
  • 实体补全。
  • 同义词扩展。
  • 关键词提取。
  • 时间范围补充。
  • 项目和用户范围限定。
  • 记忆类型指定。

一个重要原则:

查询改写只能补充检索语义,不能凭空创造用户事实。

例如,不能因为用户要求设计订单服务,就自行假设项目使用 Go,再把 Go 作为检索条件。

4. 多路记忆召回

长期记忆可能分散在不同的存储系统中。

不同类型的记忆需要使用不同的检索方式。

检索方式 适合内容 主要特点
精确查询 用户 ID、项目 ID、记忆 ID 准确、可控
关键词检索 错误码、类名、服务名称 适合精确词项
向量检索 语义知识、历史经验 适合语义相似内容
结构化过滤 类型、时间、作用域、状态 适合条件约束
图关系检索 实体关系、依赖关系 适合关联信息

例如,当前任务是设计订单服务,可以同时执行:

  • 向量检索:查找与订单架构相关的记忆。
  • 关键词检索:查找 order-service、PostgreSQL 等关键词。
  • 结构化查询:限定当前用户和项目。
  • 图关系检索:查找订单服务与支付服务之间的历史关系。

多路检索的价值在于互补,而不是简单地增加查询数量。

5. 候选结果合并

多路检索可能返回重复记录。

例如:

向量检索:
用户偏好使用 Go 开发后端。

关键词检索:
后端开发语言为 Go。

结构化查询:
backend_language = Go。

这些结果可能指向同一条记忆。

需要根据记忆 ID、实体、内容和来源进行去重与合并。

同时保留必要的来源信息,避免合并后丢失可信度和时间信息。

6. 相关性重排序(Reranking)

召回结果并不一定按照实际价值排序。

例如,用户要求设计订单服务,候选记忆如下:

记忆 向量相似度 实际相关性
当前项目的订单架构 0.92 极高
历史订单故障记录 0.88 高
用户对页面颜色的偏好 0.85 低
支付服务的设计规范 0.81 高

单纯按照向量相似度排序,可能把页面颜色偏好排在前面。

因此,需要使用重排序模型或综合评分机制。

一个常见评分模型:

Score(m,q)= \alpha S_{semantic} +\beta S_{keyword} +\gamma S_{scope} +\delta S_{recency} +\epsilon S_{importance} +\zeta S_{confidence}

其中:

  • S_{semantic}:语义相关性。
  • S_{keyword}:关键词匹配程度。
  • S_{scope}:记忆与当前用户、项目或任务的作用域匹配程度。
  • S_{recency}:时间新鲜度。
  • S_{importance}:记忆重要性。
  • S_{confidence}:记忆可信度。

各项权重应根据业务场景调整。

尤其需要注意:

  • 作用域不匹配的记忆,即使语义相似,也不应该进入当前上下文。
  • 高风险业务事实不能只依赖相似度判断。
  • 长期稳定的事实不一定因为时间较久就失去价值。
  • 时间新鲜度应该结合信息类型判断。

7. 记忆有效性校验

召回记忆之后,还需要判断它是否仍然有效。

需要检查:

  • 是否已经过期。
  • 是否已经被更新。
  • 是否存在更高版本。
  • 是否被用户明确撤销。
  • 是否与当前项目匹配。
  • 是否具有可信来源。
  • 当前用户是否有权访问。

例如:

旧记忆:订单服务使用 MySQL。
新记忆:当前项目已经迁移到 PostgreSQL。

如果只检索到旧记忆,Agent 可能采用错误的数据库设计。

因此,记忆系统需要支持版本和有效状态判断。

8. 上下文组装

检索结果不能直接无差别地放入 Prompt。

Context Builder 需要完成:

  • 过滤无关记忆。
  • 合并重复信息。
  • 标注信息来源。
  • 区分事实和推测。
  • 保留必要的时间信息。
  • 控制 Token 数量。
  • 标记不可信内容。

示例:

[Relevant Memories]

当前项目信息:
- 后端语言:Go
- 数据库:PostgreSQL
- 服务架构:微服务

用户偏好:
- 优先采用明确的错误处理方式。

历史经验:
- 数据库迁移需要检查时区和字段精度。

[Memory Metadata]
- 来源:历史对话和项目配置
- 状态:有效
- 作用域:当前项目

[Current Task]
设计订单服务。

检索结果应该作为参考数据,而不是能够覆盖系统指令的高优先级指令。

9. 记忆检索完整流程图

flowchart TD
    A["接收用户任务"] --> B["判断是否需要检索"]
    B --> C{"是否需要记忆"}
    C -->|"否"| D["直接构建上下文"]
    C -->|"是"| E["分析检索意图"]

    E --> F["查询改写"]
    F --> G["多路记忆召回"]
    G --> H["候选结果合并"]
    H --> I["相关性重排序"]
    I --> J["权限与有效性校验"]
    J --> K{"是否存在有效记忆"}

    K -->|"否"| D
    K -->|"是"| L["去重与冲突检查"]
    L --> M["Token 预算控制"]
    M --> N["上下文组装"]
    N --> O["模型推理与执行"]
    D --> O

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

四、记忆检索的关键算法与技术

1. 向量相似度检索

向量检索是长期记忆系统中常见的召回方式。

首先,通过 Embedding 模型将记忆文本转换为向量:

v_m=Embedding(m)

当前查询也转换为向量:

v_q=Embedding(q)

然后计算二者之间的相似度。

常见指标包括:

余弦相似度

Cosine(v_q,v_m)= \frac{v_q\cdot v_m}

点积

Dot(v_q,v_m)=v_q\cdot v_m

欧氏距离

D(v_q,v_m)= \sqrt{\sum_{i=1}^{n}(v_{q_i}-v_{m_i})^2}

不同 Embedding 模型对向量归一化和相似度计算方式可能有不同要求,需要根据模型和向量数据库的配置选择。

2. ANN 近似最近邻检索

当记忆规模较小时,可以直接计算查询向量与所有记忆向量之间的距离。

但当向量数量达到百万级甚至更高时,逐条计算的成本会显著增加。

ANN(Approximate Nearest Neighbor)通过索引结构降低检索开销。

常见算法:

算法 核心思想 特点
HNSW 分层小世界图 查询速度快,内存占用较高
IVF 聚类后搜索部分倒排列表 适合大规模向量集合
PQ 向量量化压缩 降低存储成本
DiskANN 基于磁盘的近似最近邻 适合大规模磁盘检索

HNSW 的基本思路是构建多层图结构。

高层图负责快速定位区域,底层图负责精细搜索。

查询向量
   │
   ▼
高层图快速定位
   │
   ▼
逐层进入低层图
   │
   ▼
底层邻居搜索
   │
   ▼
返回 Top-K 候选

3. BM25 关键词检索

BM25 是经典的全文检索相关性算法。

它主要考虑:

  • 查询词在文档中的出现频率。
  • 查询词在整个文档集合中的稀有程度。
  • 文档长度。

其典型形式为:

BM25(D,Q)= \sum_{q_i\in Q} IDF(q_i) \cdot \frac{f(q_i,D)(k_1+1)} {f(q_i,D)+k_1(1-b+b\frac{|D|}{avgdl})}

其中:

  • f(q_i,D):查询词在文档中的词频。
  • |D|:文档长度。
  • avgdl:平均文档长度。
  • k_1,b:调节参数。
  • IDF:逆文档频率。

BM25 特别适合检索具体技术名词、错误码、服务名称和配置项。

4. 混合检索

向量检索和关键词检索各有优势。

因此,实际系统通常采用混合检索。

一种常见方式是加权融合:

Score(m)= \alpha \cdot Score_{vector}(m) + \beta \cdot Score_{BM25}(m)

但需要注意,不同检索算法的分数分布可能不一致,不能直接假设两个分数具有相同量纲。

另一种方式是 RRF(Reciprocal Rank Fusion),通过排名融合结果:

RRF(d)= \sum_{i=1}^{n} \frac{1}{k+rank_i(d)}

其中:

  • rank_i(d):文档在第 i 个检索结果中的排名。
  • k:平滑参数。

RRF 不依赖原始检索分数的统一尺度,适合融合多路排序结果。

5. 重排序模型

召回模型负责从大量数据中快速找出候选记忆。

重排序模型则负责对候选结果进行更精细的相关性判断。

常见实现方式:

  • Cross-Encoder。
  • 专门训练的 Reranker。
  • LLM 相关性判断。

Cross-Encoder 通常将查询和候选文档一起输入模型,直接计算相关性。

它通常比单纯的向量相似度更精细,但计算成本也更高。

典型架构:

flowchart TD
    A["用户查询"] --> B["Embedding 检索"]
    A --> C["BM25 检索"]
    B --> D["候选集合"]
    C --> D
    D --> E["RRF 或分数融合"]
    E --> F["Top-K 候选"]
    F --> G["Cross-Encoder 重排序"]
    G --> H["最终相关记忆"]

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

五、记忆更新的核心机制

记忆更新的目标不是简单地增加新记录,而是让记忆库始终保持准确、相关和可维护。

1. 记忆更新的触发来源

记忆更新可能来自多个渠道:

来源 示例
用户明确表达 用户修改长期偏好
新的对话内容 用户补充项目背景
工具执行结果 查询到最新项目配置
任务执行结果 某个方案经过验证
外部数据变化 业务规则或技术文档更新
定期维护任务 清理过期、重复记忆

不同来源的可信度不同。

例如:

  • 用户明确确认的信息,通常具有较高可信度。
  • 经过权威业务系统验证的数据,适合更新对应业务事实。
  • 模型自行推测的信息,不应直接作为确定事实写入。
  • 外部网页和文档中的内容,需要经过来源与安全检查。

2. 候选记忆提取

Agent 在任务执行过程中会产生大量信息,但并非所有信息都值得更新长期记忆。

记忆提取器需要识别:

  • 新事实。
  • 新偏好。
  • 新经验。
  • 已发生的状态变化。
  • 已验证的操作流程。
  • 用户明确撤销的信息。

例如:

用户:之前项目使用 MySQL,现在已经迁移到 PostgreSQL。

提取结果:

{
  "memory_type": "project_fact",
  "entity": "current_project",
  "attribute": "database",
  "old_value": "MySQL",
  "new_value": "PostgreSQL",
  "operation": "update",
  "source": "user_statement"
}

3. 记忆重要性评估

候选记忆需要经过重要性评估。

常见维度:

维度 评估标准
重要性 是否影响未来任务
稳定性 是否可能长期有效
可复用性 是否能够用于多个任务
可信度 来源是否可靠
时效性 是否具有有效期限
作用范围 适用于用户、项目还是单次任务
敏感性 是否涉及不应保存的信息

可以构建一个综合评分:

Importance(m)= w_1 I+w_2 S+w_3 R+w_4 C

其中:

  • I:重要程度。
  • S:稳定程度。
  • R:可复用程度。
  • C:可信程度。

该评分主要用于辅助决策,不能代替用户授权、隐私策略和安全规则。

4. 记忆分类

不同类型的记忆应该采用不同的更新方式。

例如:

记忆类型 更新策略
用户偏好 合并、覆盖或按作用域隔离
项目事实 按版本和时间更新
语义知识 归纳、补充和版本管理
情景记忆 通常新增事件记录
程序性记忆 经过验证后更新操作流程

特别需要区分事实和事件。

用户更换数据库属于事实变化,可以更新当前有效状态。

某次数据库迁移成功属于历史事件,通常应该保留为情景记忆,而不是直接覆盖掉。

5. 去重与合并

长期记忆中经常存在语义相同但表达不同的内容。

例如:

记忆 A:用户后端主要使用 Go。
记忆 B:用户喜欢使用 Golang 开发服务。
记忆 C:用户的服务端语言是 Go。

这三条记录可能表达相同的信息。

系统可以通过以下方式识别:

  • 精确文本匹配。
  • 关键词匹配。
  • 向量相似度。
  • 实体和属性比较。
  • LLM 语义判断。

合并后的记忆:

{
  "type": "preference",
  "key": "backend_language",
  "value": "Go",
  "sources": [
    "memory_A",
    "memory_B",
    "memory_C"
  ],
  "confidence": 0.98
}

合并时需要保留来源和历史信息,避免丢失证据。

6. 冲突检测

记忆冲突是长期记忆管理中最容易出错的问题之一。

例如:

旧记忆:当前项目使用 MySQL。
新记忆:当前项目使用 PostgreSQL。

这可能是:

  • 用户修改了技术选型。
  • 项目发生了数据库迁移。
  • 两条信息对应不同项目。
  • 新信息只是临时测试环境配置。
  • 新信息本身不准确。

因此,不能直接使用新信息覆盖旧信息。

需要比较:

  1. 实体是否相同。
  2. 属性是否相同。
  3. 作用域是否相同。
  4. 时间范围是否重叠。
  5. 信息来源是否可靠。
  6. 新信息是否明确表示变更。
  7. 是否存在权威数据源可以验证。

7. 冲突处理策略

策略 使用场景
新版本覆盖 同一作用域下明确发生状态变更
保留历史版本 需要追踪信息变化
作用域拆分 不同项目或环境使用不同配置
多值并存 信息本身允许多个值
置信度调整 新旧信息都缺少充分证据
人工确认 冲突影响重大且无法自动判断

例如:

项目 A:使用 Go。
项目 B:使用 Rust。

这不是冲突,应该拆分作用域。

而:

项目 A:
旧版本使用 MySQL。
新版本已经迁移到 PostgreSQL。

这是同一项目的时间状态变化,应该保留历史版本,并更新当前有效状态。

六、记忆更新的事务与版本机制

当多个 Agent 实例同时修改记忆时,简单的读取、修改、写入可能造成数据覆盖。

例如:

初始记忆:版本 1

实例 A 读取版本 1。
实例 B 读取版本 1。

实例 A 更新为版本 2。
实例 B 更新为版本 3。

如果实例 B 直接覆盖实例 A 的结果,就可能丢失更新。

因此,生产级记忆系统需要考虑并发控制。

1. 乐观锁(Optimistic Locking)

通过版本号判断数据是否发生变化。

例如:

UPDATE agent_memories
SET
    memory_value = '{"database": "PostgreSQL"}',
    version = version + 1
WHERE id = 1001
  AND version = 3;

如果更新影响行数为 0,说明数据版本已经发生变化,需要重新读取并处理。

2. 记忆版本管理

建议长期记忆至少包含:

{
  "memory_id": "mem_1001",
  "version": 4,
  "status": "active",
  "content": "当前项目使用 PostgreSQL",
  "source": "user_confirmation",
  "valid_from": "2026-11-20T10:00:00Z",
  "valid_to": null,
  "created_at": "2026-11-20T10:00:00Z"
}

版本管理能够支持:

  • 追踪记忆变化。
  • 恢复历史版本。
  • 比较新旧信息。
  • 处理并发更新。
  • 审计记忆来源。

3. 事务与一致性

记忆系统可能同时维护:

  • 关系数据库中的记忆记录。
  • 向量数据库中的 Embedding。
  • 全文检索索引。
  • 缓存中的热点记忆。

这些系统通常不共享同一个数据库事务。

因此,不能假设一次记忆更新可以原子地修改所有存储。

一种常见设计是:

  1. 在主数据库中提交记忆变更。
  2. 同一事务写入 Outbox 事件。
  3. 后台消费者读取事件。
  4. 更新向量索引和全文索引。
  5. 更新或失效相关缓存。
  6. 记录同步状态并支持重试。

这种方式可以降低跨存储更新失败导致的数据不一致问题。

4. 记忆更新流程

flowchart TD
    A["接收新信息"] --> B["提取候选记忆"]
    B --> C["类型分类与重要性评估"]
    C --> D{"是否允许保存"}
    D -->|"否"| E["丢弃或仅保留短期记录"]
    D -->|"是"| F["读取相关已有记忆"]
    F --> G["去重与语义合并"]
    G --> H{"是否存在冲突"}

    H -->|"否"| I["创建或补充记忆"]
    H -->|"是"| J["分析作用域和来源"]
    J --> K{"能否自动解决"}
    K -->|"是"| L["执行更新或版本变更"]
    K -->|"否"| M["标记待确认"]

    I --> N["主数据库事务提交"]
    L --> N
    M --> O["保留原有效状态"]

    N --> P["写入 Outbox 事件"]
    P --> Q["同步向量与全文索引"]
    Q --> R["更新缓存"]
    R --> S["更新完成"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style D fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style E fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style K fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style N fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style O fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style P fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style Q fill:#EAF3EC,stroke:#83A995,color:#315D49
    style R fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style S fill:#DCEFE5,stroke:#4F8B70,color:#24563F

七、记忆遗忘与清理机制

记忆更新不仅包括新增和修改,还包括删除与归档。

长期记忆持续增长后,需要避免低价值信息无限积累。

1. 时间过期

为具有明确时效性的记忆设置有效期。

例如:

  • 临时项目状态。
  • 短期任务安排。
  • 临时业务活动。
  • 阶段性配置。

过期记忆不一定需要立即物理删除。

可以先将其标记为失效,避免参与正常检索,再根据保留策略进行归档或删除。

2. 访问频率与重要性衰减

可以根据访问频率和时间调整记忆的检索优先级。

例如:

Priority(m)= \alpha Importance(m) +\beta Recency(m) +\gamma Frequency(m)

其中:

  • Importance(m):记忆的重要性。
  • Recency(m):最近更新时间或使用时间。
  • Frequency(m):访问频率。

需要注意,访问频率低并不意味着记忆没有价值。

例如,用户的长期安全约束可能很少被访问,但仍然必须保留。

3. 合并压缩

多条重复记忆可以归纳为更精简的知识。

例如:

记忆 A:用户后端使用 Go。
记忆 B:用户的 API 服务采用 Go。
记忆 C:用户偏好 Go 进行服务端开发。

可以归纳为:

用户后端技术偏好:Go。

但需要保留来源、作用范围和必要的历史记录。

4. 显式删除

用户要求删除记忆时,需要执行完整的数据删除策略。

可能涉及:

  • 主记忆记录。
  • 向量数据库中的对应向量。
  • 全文索引。
  • 缓存。
  • 派生摘要。
  • 备份和归档数据。

对于有合规要求的系统,还需要提供删除审计记录。

5. 遗忘与清理流程

flowchart TD
    A["定期记忆维护任务"] --> B["扫描记忆记录"]
    B --> C["检查有效期"]
    C --> D{"是否已经过期"}
    D -->|"是"| E["标记失效"]
    D -->|"否"| F["评估重要性与使用情况"]
    F --> G{"是否需要合并或归档"}
    G -->|"是"| H["归纳压缩或归档"]
    G -->|"否"| I["保留有效记忆"]
    E --> J["检查是否需要物理删除"]
    H --> K["更新索引与元数据"]
    J --> L{"是否允许删除"}
    L -->|"是"| M["清理存储与索引"]
    L -->|"否"| N["保留在隔离或归档区"]
    M --> O["记录清理结果"]
    N --> O
    K --> P["完成维护"]
    I --> P
    O --> P

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