返回专栏
· 26 分钟阅读

Agent 的短期记忆与长期记忆


一、为什么 Agent 需要记忆?

大语言模型本身通常不具备跨请求持久保存对话状态的能力。每次调用模型时,模型主要依据当前输入的上下文生成结果。

这意味着,如果 Agent 只依赖当前 Prompt,就会遇到几个问题:

  1. 上下文连续性不足:多轮对话中容易丢失之前的任务目标和约束。
  2. 长任务状态丢失:执行复杂任务时,无法可靠保留已经完成的步骤、待处理事项和中间结果。
  3. 用户信息无法复用:用户的偏好、习惯、长期目标无法在后续会话中持续使用。
  4. 重复推理与重复执行:无法记住之前尝试过的方法、失败原因和已经完成的操作。
  5. 经验无法积累:每次任务都从头开始,无法形成跨任务的经验沉淀。

因此,Agent 需要在模型上下文之外建立独立的记忆系统。

从工程角度看,记忆并不是简单地保存聊天记录,而是围绕信息的生命周期建立一套机制:

  • 信息采集:从对话、工具结果和任务执行中提取信息。
  • 信息组织:识别信息类型、重要程度和适用范围。
  • 信息存储:写入短期或长期存储。
  • 信息检索:根据当前任务召回相关记忆。
  • 信息更新:处理新旧信息之间的冲突。
  • 信息遗忘:删除过期、错误或不再需要的信息。

二、Agent 记忆的整体分类

按照信息的保存周期和使用范围,Agent 记忆通常分为短期记忆和长期记忆。

1. 短期记忆(Short-term Memory)

短期记忆用于保存当前会话或当前任务执行过程中需要的信息。

典型内容包括:

  • 最近几轮对话。
  • 当前任务目标。
  • 用户刚刚提出的约束条件。
  • Agent 当前执行计划。
  • 工具调用结果。
  • 尚未完成的子任务。
  • 当前任务的中间推理状态。
  • 最近发生的异常和重试记录。

短期记忆的核心目标是保证当前任务能够连续执行。

它通常具有以下特点:

特征 说明
生命周期 当前会话或任务周期
更新频率 高频更新
数据规模 相对较小,但可能持续增长
访问方式 直接读取、上下文拼接、状态查询
存储方式 内存、Redis、会话数据库、Checkpoint
主要用途 对话连续性、任务状态维护

短期记忆并不意味着数据一定保存在内存中。

例如,一个运行数小时的 Agent 任务,可以将执行状态持久化到 Redis 或数据库。只要这些信息服务于当前任务,就仍然属于短期记忆的范畴。

2. 长期记忆(Long-term Memory)

长期记忆用于保存跨会话、跨任务仍然具有价值的信息。

典型内容包括:

  • 用户长期偏好。
  • 用户稳定的工作习惯。
  • 用户的长期目标。
  • 已确认的业务规则。
  • 历史任务经验。
  • 经常使用的工具和工作流程。
  • 经过验证的事实和知识。
  • 多次交互中形成的用户画像。

长期记忆的核心目标是让 Agent 在不同会话之间积累可复用的信息。

特征 说明
生命周期 跨会话、长期保存
更新频率 相对较低
数据规模 持续增长
访问方式 关键词检索、向量检索、结构化查询
存储方式 关系数据库、文档数据库、向量数据库
主要用途 个性化、经验复用、长期知识积累

长期记忆不等于永久记忆。

信息可能随着时间推移而过期,也可能因为用户偏好发生变化而失效。因此,长期记忆必须具备更新、验证和删除机制。

3. 短期记忆与长期记忆的区别

比较维度 短期记忆 长期记忆
主要目标 维持当前任务连续性 支持跨任务信息复用
时间范围 当前会话或任务 多个会话和任务
数据类型 对话、计划、状态、中间结果 偏好、事实、经验、知识
更新频率 高频 相对低频
存储规模 受上下文和任务规模约束 可持续扩展
检索方式 直接读取、状态恢复 语义检索、关键词检索
数据处理 滑动窗口、摘要、状态更新 去重、归纳、合并、过期处理
典型存储 Redis、Checkpoint PostgreSQL、MongoDB、向量数据库

需要注意:短期和长期是按照记忆的用途与生命周期划分的,不是按照底层存储介质划分的。

同一个 Redis 可以保存短期任务状态,也可以保存长期用户偏好;同一个 PostgreSQL 也可以同时存储会话记录和长期记忆。

三、短期记忆的内部结构

短期记忆不应该只是一个不断增长的聊天记录数组。

对于具备工具调用和任务规划能力的 Agent,短期记忆至少需要管理以下几类信息。

1. 对话上下文(Conversation Context)

保存用户与 Agent 之间的交互内容。

例如:

{
  "conversation_id": "conv_1001",
  "messages": [
    {
      "role": "user",
      "content": "帮我分析这个项目的架构"
    },
    {
      "role": "assistant",
      "content": "我会先分析项目目录和依赖关系"
    }
  ]
}

对话上下文通常包含:

  • 用户消息。
  • Agent 回复。
  • 工具调用请求。
  • 工具返回结果。
  • 系统级约束。
  • 必要的多模态内容引用。

但并不是所有历史消息都需要永久放入模型上下文。

当对话不断增长时,需要通过上下文窗口管理机制控制输入规模。

2. 任务状态(Task State)

任务状态用于记录 Agent 当前执行到了什么阶段。

例如:

{
  "task_id": "task_1001",
  "goal": "分析项目架构并生成报告",
  "status": "running",
  "current_step": "dependency_analysis",
  "completed_steps": [
    "scan_project",
    "identify_modules"
  ],
  "pending_steps": [
    "dependency_analysis",
    "generate_report"
  ]
}

任务状态与对话上下文有明显区别:

  • 对话上下文记录发生了什么。
  • 任务状态记录当前处于什么状态。

模型可以通过对话历史推测任务进度,但这种方式不够可靠。

生产环境应当将任务状态结构化保存,而不是依赖模型从大量聊天记录中重新推断。

3. 执行计划(Execution Plan)

对于复杂任务,Agent 通常需要将目标拆分成多个子任务。

例如:

{
  "plan": [
    {
      "step": 1,
      "name": "扫描项目",
      "status": "completed"
    },
    {
      "step": 2,
      "name": "分析模块依赖",
      "status": "running"
    },
    {
      "step": 3,
      "name": "生成架构报告",
      "status": "pending"
    }
  ]
}

执行计划需要随着任务执行动态更新。

当某个子任务失败时,Agent 可能需要:

  • 重试当前步骤。
  • 调整后续计划。
  • 新增补偿步骤。
  • 回滚之前的操作。
  • 将任务标记为失败或等待人工介入。

因此,执行计划实际上是短期记忆中的一种结构化状态。

4. 工具执行记录(Tool Execution History)

Agent 在执行过程中会调用各种外部工具。

例如:

  • 查询数据库。
  • 调用搜索接口。
  • 读取文件。
  • 执行代码。
  • 调用业务 API。

工具执行记录至少应包含:

{
  "tool_call_id": "call_1001",
  "tool_name": "search_database",
  "arguments": {
    "keyword": "订单"
  },
  "status": "success",
  "result_summary": "查询到 128 条订单记录"
}

保存工具执行记录的意义在于:

  1. 避免重复调用已经成功执行的工具。
  2. 支持任务中断后的恢复。
  3. 追踪工具调用失败原因。
  4. 让 Agent 基于真实执行结果继续工作。
  5. 支持审计和问题排查。

对于具有副作用的工具,例如支付、下单、发送邮件,不能仅依赖记忆中的执行记录判断是否可以重试,还需要结合幂等键、业务状态查询和事务机制。

5. 中间结果(Intermediate Results)

复杂任务可能产生大量中间数据。

例如:

  • 文件解析结果。
  • 数据库查询结果。
  • 代码分析结果。
  • 网页搜索结果。
  • 模型生成的阶段性报告。

这些内容不一定全部适合放入模型上下文。

更合理的做法是将完整结果存储在外部系统,短期记忆只保留引用、摘要和关键字段。

{
  "result_id": "result_1001",
  "type": "code_analysis",
  "storage_uri": "storage://task_1001/analysis.json",
  "summary": "识别出 12 个核心模块",
  "created_at": "2026-11-20T10:00:00Z"
}

这样既能保留完整数据,又能避免上下文被大量低价值内容占用。

四、短期记忆的核心管理机制

短期记忆最重要的问题不是存储,而是如何在有限的上下文窗口内保留最有价值的信息。

1. 滑动窗口(Sliding Window)

滑动窗口是最直接的上下文管理方式。

保留最近 N 条消息,超出范围的历史消息被移出当前上下文。

例如:

原始消息:
M1 → M2 → M3 → M4 → M5 → M6 → M7

窗口大小为 4:

M4 → M5 → M6 → M7

Mermaid 流程图:

flowchart TD
    A["接收新消息"] --> B["追加到消息列表"]
    B --> C{"是否超过窗口限制"}
    C -->|"否"| D["保留全部消息"]
    C -->|"是"| E["移除最早的消息"]
    E --> F["保留最近 N 条消息"]
    D --> G["构建模型上下文"]
    F --> G

    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:#F7EAE7,stroke:#C98D7C,color:#754438
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F

优点:

  • 实现简单。
  • 处理成本低。
  • 保留最近交互内容。
  • 不需要额外的摘要模型调用。

缺点:

  • 可能丢失早期的重要约束。
  • 可能丢失任务初始目标。
  • 无法区分重要消息和普通消息。
  • 对长时间运行的任务不够可靠。

滑动窗口适合短对话,不适合直接作为复杂 Agent 的完整记忆策略。

2. 对话摘要(Conversation Summarization)

对话摘要通过模型将历史消息压缩成结构化摘要。

例如,原始对话包含大量细节:

用户:帮我分析订单系统。
Agent:我先查看项目结构。
用户:重点关注支付和订单模块。
Agent:发现订单模块依赖支付模块。
用户:还要分析失败重试机制。
Agent:支付模块使用消息队列进行异步处理。

可以压缩成:

任务目标:分析订单系统架构。

用户关注点:
1. 订单模块。
2. 支付模块。
3. 失败重试机制。

已发现:
1. 订单模块依赖支付模块。
2. 支付模块通过消息队列进行异步处理。

待完成:
分析支付失败后的重试和补偿机制。

摘要不是简单缩短文本,而是提取对后续任务有用的信息。

一个可靠的摘要应尽量保留:

  • 原始任务目标。
  • 用户明确提出的约束。
  • 已确认的事实。
  • 已完成的工作。
  • 未完成的事项。
  • 关键决策及其依据。
  • 尚未解决的问题。

摘要生成后,最好采用结构化格式,避免重要信息被自然语言压缩过程遗漏。

{
  "goal": "分析订单系统架构",
  "constraints": [
    "重点分析支付模块",
    "关注失败重试机制"
  ],
  "facts": [
    "订单模块依赖支付模块",
    "支付模块使用消息队列"
  ],
  "completed": [
    "项目结构分析"
  ],
  "pending": [
    "支付失败重试分析"
  ]
}

3. 分层上下文(Hierarchical Context)

复杂 Agent 可以将上下文划分为多个层次。

层次 保存内容 处理方式
核心上下文 系统约束、任务目标 长期保留至任务结束
当前上下文 最近对话、当前操作 高频更新
摘要上下文 历史对话的关键内容 定期压缩
外部结果 大型工具输出、文件内容 按需读取

构建模型输入时,根据当前任务动态组合不同层次的信息。

Mermaid 流程图:

flowchart TD
    A["短期记忆存储"] --> B["核心上下文"]
    A --> C["当前对话上下文"]
    A --> D["历史摘要"]
    A --> E["外部结果引用"]

    B --> F["上下文组装器"]
    C --> F
    D --> F
    E --> G["按需加载外部数据"]
    G --> F

    F --> H["Token 预算检查"]
    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:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

4. Checkpoint 与任务恢复

对于长时间运行的 Agent,仅保存对话摘要是不够的。

还需要保存任务执行快照,即 Checkpoint。

Checkpoint 通常包括:

  • 当前任务状态。
  • 当前执行步骤。
  • 已完成步骤。
  • 待执行步骤。
  • 工具调用记录。
  • 关键中间结果引用。
  • 当前上下文摘要。
  • 重试次数和错误信息。

当进程崩溃或任务中断时,可以根据 Checkpoint 恢复执行。

flowchart TD
    A["Agent 执行任务"] --> B["完成一个执行步骤"]
    B --> C["更新任务状态"]
    C --> D["持久化 Checkpoint"]
    D --> E{"任务是否完成"}
    E -->|"是"| F["保存最终结果"]
    E -->|"否"| G["继续执行下一步骤"]

    G --> B

    H["进程异常或服务重启"] --> I["读取最近 Checkpoint"]
    I --> J["恢复任务状态"]
    J --> K["校验外部副作用"]
    K --> L["从安全位置继续执行"]

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

这里有一个非常重要的工程问题:

Checkpoint 恢复不等于从上一次保存的位置直接重新执行。

假设 Agent 已经调用支付接口,但在保存 Checkpoint 之前进程崩溃。恢复后,如果直接重新调用支付接口,可能造成重复支付。

因此,恢复机制必须结合:

  • 幂等键。
  • 外部系统状态查询。
  • 工具调用日志。
  • 事务或补偿机制。
  • 执行步骤的提交状态。

五、长期记忆的内部结构

长期记忆不能简单地把所有历史对话永久保存。

大量原始对话中包含重复、临时、错误和低价值信息。直接保存会导致检索噪声不断增加。

更合理的方式是将长期记忆组织为不同类型。

1. 事实记忆(Factual Memory)

保存已经确认、具有持续价值的事实。

例如:

{
  "type": "fact",
  "subject": "project",
  "predicate": "language",
  "object": "Go",
  "confidence": 0.98
}

事实记忆适合保存:

  • 项目技术栈。
  • 业务规则。
  • 系统架构信息。
  • 已确认的配置。
  • 用户明确提供的背景信息。

事实记忆应当区分来源和可信度。

模型推测出来的信息不能直接当成已经确认的事实保存。

2. 用户偏好记忆(Preference Memory)

保存用户相对稳定的偏好。

例如:

{
  "type": "preference",
  "subject": "user",
  "key": "code_style",
  "value": "prefer_explicit_error_handling",
  "confidence": 0.95
}

典型内容:

  • 喜欢的输出格式。
  • 编程风格。
  • 技术选型偏好。
  • 文档组织方式。
  • 对回答深度的要求。

偏好记忆的价值在于减少重复沟通,让 Agent 在后续任务中更好地适配用户。

但偏好可能发生变化,因此不能将一次临时要求永久固化。

3. 语义记忆(Semantic Memory)

语义记忆保存经过归纳、整理的知识。

例如:

  • 某个项目的整体架构。
  • 某个业务领域的核心概念。
  • 某个系统的模块关系。
  • 某项技术方案的设计原则。

它与原始对话不同,重点是保存知识本身,而不是知识产生时的完整交互过程。

语义记忆通常可以通过文档切分、实体抽取、知识图谱和向量化等方式组织。

4. 情景记忆(Episodic Memory)

情景记忆保存过去发生的具体事件和任务经历。

例如:

{
  "type": "episode",
  "task": "数据库迁移",
  "context": "将订单数据从 MySQL 迁移到 PostgreSQL",
  "action": "采用分批迁移策略",
  "outcome": "迁移成功",
  "lesson": "迁移前需要统一时区和字段精度"
}

情景记忆关注:

  • 当时的任务是什么。
  • 处于什么环境。
  • Agent 做了什么。
  • 最终结果如何。
  • 得到了什么经验。

它可以帮助 Agent 在遇到相似任务时参考历史经验。

5. 程序性记忆(Procedural Memory)

程序性记忆保存执行任务的方法和流程。

例如:

  • 如何部署某个服务。
  • 如何排查某类故障。
  • 如何执行数据迁移。
  • 如何调用某组业务 API。
  • 如何按照组织规范生成报告。

它与情景记忆的区别在于:

  • 情景记忆记录一次任务经历。
  • 程序性记忆提炼可重复使用的方法。

例如,情景记忆保存某次数据库迁移的过程;程序性记忆则保存经过验证的数据库迁移操作规范。

6. 长期记忆类型对比

类型 保存内容 典型用途
事实记忆 已确认的事实 准确回答背景问题
偏好记忆 用户稳定偏好 个性化交互
语义记忆 归纳后的知识 知识复用
情景记忆 历史事件和经历 参考过去经验
程序性记忆 方法、流程和技能 复用执行策略

这些类型不是互斥的。

同一段历史交互可能同时产生事实记忆、偏好记忆和情景记忆。

六、长期记忆的存储架构

长期记忆通常需要组合多种存储方式,而不是依赖单一数据库。

1. 结构化存储

结构化存储适合保存字段明确、需要精确查询的数据。

例如:

  • 用户偏好。
  • 用户配置。
  • 业务规则。
  • 任务元数据。
  • 记忆状态和版本信息。

常见技术:

  • PostgreSQL。
  • MySQL。
  • MongoDB。
  • Redis。

例如,使用关系数据库保存用户偏好:

CREATE TABLE agent_memories (
    id BIGSERIAL PRIMARY KEY,
    user_id VARCHAR(128) NOT NULL,
    memory_type VARCHAR(32) NOT NULL,
    memory_key VARCHAR(255) NOT NULL,
    memory_value JSONB NOT NULL,
    confidence FLOAT DEFAULT 1.0,
    source VARCHAR(64),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    expires_at TIMESTAMP,
    status VARCHAR(32) DEFAULT 'active'
);

这种方式可以支持:

  • 按用户查询。
  • 按类型过滤。
  • 按键精确匹配。
  • 按状态筛选。
  • 按时间判断是否过期。

2. 向量存储

向量存储适合处理语义相似度检索。

例如,用户之前说过:

我更喜欢使用 Go 开发后端服务。

当前用户提出:

帮我设计一个高并发 API 服务。

两段文本没有完全相同的关键词,但语义上存在关联。

通过 Embedding 模型将文本转换为向量,可以根据语义相似度召回相关记忆。

典型向量数据库:

  • Milvus。
  • Qdrant。
  • Weaviate。
  • Chroma。
  • PostgreSQL + pgvector。

向量检索的基本流程:

flowchart TD
    A["历史交互或知识"] --> B["记忆提取"]
    B --> C["文本清洗与归纳"]
    C --> D["Embedding 模型"]
    D --> E["生成向量"]
    E --> F["写入向量数据库"]

    G["当前任务"] --> H["构造检索查询"]
    H --> I["生成查询向量"]
    I --> J["向量相似度检索"]
    F --> J
    J --> K["返回候选记忆"]

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

需要注意,向量数据库保存的是向量及其关联元数据,不是记忆系统的全部。

生产环境通常还需要保存原始内容、记忆 ID、用户 ID、来源、时间和状态等信息。

3. 全文检索

向量检索擅长语义匹配,但不一定擅长精确关键词查询。

例如:

  • 错误码 E1024。
  • 数据库表名 order_payment。
  • 服务名称 payment-service。
  • 具体版本号 v2.3.1。

这些信息通常更适合全文检索或精确匹配。

常见技术:

  • Elasticsearch。
  • OpenSearch。
  • PostgreSQL Full Text Search。

4. 混合检索(Hybrid Search)

实际 Agent 记忆检索通常会结合:

  • 向量检索:召回语义相关内容。
  • 全文检索:召回关键词匹配内容。
  • 结构化查询:按照用户、时间、类型和状态过滤。
  • 重排序:对候选记忆重新计算相关性。

一个典型的混合检索架构:

flowchart TD
    A["当前任务"] --> B["查询理解"]
    B --> C["向量检索"]
    B --> D["关键词检索"]
    B --> E["结构化过滤"]

    C --> F["候选记忆集合"]
    D --> F
    E --> F

    F --> G["去重与合并"]
    G --> H["重排序 Rerank"]
    H --> I["相关性阈值过滤"]
    I --> J["构建记忆上下文"]

    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:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

混合检索可以提升召回覆盖率,但也会增加系统复杂度和查询成本。

七、长期记忆的写入机制

Agent 不应该将每条对话都写入长期记忆。

例如:

用户:今天帮我查询一下北京的天气。

这通常只是一次临时请求,没有必要作为长期记忆保存。

而:

用户:以后生成后端代码时,优先使用 Go。

这可能是值得保存的稳定偏好。

长期记忆写入通常包括以下步骤。

1. 记忆候选提取

从对话、工具结果和任务执行记录中提取候选信息。

可提取的信息包括:

  • 明确表达的偏好。
  • 已确认的事实。
  • 长期目标。
  • 重要决策。
  • 任务经验。
  • 重复出现的行为模式。

2. 重要性评估

不是所有候选信息都值得长期保存。

可以综合考虑:

维度 评估内容
重要性 对未来任务是否有价值
稳定性 是否可能长期保持
可复用性 是否能用于其他任务
可信度 信息是否有可靠来源
时效性 是否容易过期
敏感性 是否涉及不应保存的信息

尤其需要注意:信息重要性高,不代表就可以无条件保存。还必须遵循用户授权、隐私要求和数据治理规则。

3. 记忆归纳与标准化

将原始文本转换成结构化记忆。

例如:

原始对话:

用户:我们后端主要使用 Go,数据库使用 PostgreSQL,
以后设计服务时尽量按照这个技术栈考虑。

归纳后的记忆:

{
  "type": "preference",
  "category": "technology_stack",
  "content": {
    "backend": "Go",
    "database": "PostgreSQL"
  },
  "confidence": 0.98
}

结构化之后,更容易进行查询、去重和更新。

4. 去重与冲突检测

假设系统已经保存:

用户偏好:后端使用 Go。

新对话又提取出:

用户偏好:后端使用 Go。

这时不需要重复创建一条记忆。

如果新信息是:

用户偏好:新项目优先使用 Rust。

也不一定意味着旧记忆错误。

因为两条信息可能适用于不同项目。

因此,冲突检测不能只比较文本,还要考虑:

  • 记忆作用域。
  • 生效时间。
  • 适用项目。
  • 信息来源。
  • 是否明确表达为偏好变更。

5. 持久化存储

完成校验后,根据记忆类型写入相应存储。

例如:

  • 用户偏好写入结构化数据库。
  • 语义知识写入文档存储和向量数据库。
  • 历史任务经历写入情景记忆库。
  • 可复用流程写入程序性记忆库。

6. 长期记忆写入流程

flowchart TD
    A["产生新的交互或任务结果"] --> B["提取候选记忆"]
    B --> C["判断是否具有长期价值"]
    C -->|"否"| D["仅保留在短期上下文"]
    C -->|"是"| E["敏感信息与授权检查"]
    E --> F{"是否允许保存"}
    F -->|"否"| G["拒绝写入或脱敏处理"]
    F -->|"是"| H["归纳与结构化"]
    H --> I["重要性与可信度评估"]
    I --> J["去重与冲突检测"]
    J --> K["选择存储类型"]
    K --> L["持久化记忆"]
    L --> M["记录来源与版本"]

    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:#F7EAE7,stroke:#C98D7C,color:#754438
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#F7EAE7,stroke:#C98D7C,color:#754438
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style J fill:#EAE8FA,stroke:#A49BD5,color:#51477D
    style K fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style M fill:#DCEFE5,stroke:#4F8B70,color:#24563F

八、长期记忆的检索与使用

记忆写入只是第一步。真正决定记忆价值的是 Agent 能否在正确的时间召回正确的信息。

1. 检索触发

并不是每次模型调用都需要检索长期记忆。

例如:

  • 用户询问一个独立的数学问题,可能不需要检索用户偏好。
  • 用户要求继续上次的项目分析,需要检索相关任务经历。
  • 用户要求生成代码,可以检索项目技术栈和代码风格偏好。

因此,可以通过任务类型和查询意图决定是否触发记忆检索。

2. 查询改写

用户的当前问题可能比较简短,直接用于向量检索的效果不一定理想。

例如:

用户:继续按照之前的方式做。

系统需要结合当前会话和任务状态,识别这里的“之前的方式”具体指什么。

查询改写可以补充:

  • 当前任务主题。
  • 相关实体。
  • 项目名称。
  • 用户意图。
  • 需要召回的记忆类型。

3. 候选召回

从长期记忆中召回一批候选结果。

常见策略:

  • Top-K 向量检索。
  • BM25 关键词检索。
  • 按用户 ID 过滤。
  • 按项目 ID 过滤。
  • 按时间范围过滤。
  • 按记忆类型过滤。

4. 重排序

向量相似度不等于最终相关性。

例如,用户询问支付服务架构时,历史记忆中可能存在多条包含“支付”关键词的内容:

  • 支付服务技术架构。
  • 某次支付失败的日志。
  • 用户对支付页面颜色的偏好。
  • 支付业务的历史报表。