知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# Agent 记忆系统设计 > 导读:本文从"Agent 第二轮就忘了用户要表格、跑到第 20 步把 128K 上下文撑爆、跨会话完全失忆"这三个真实痛点出发,把记忆三层模型、工作记忆压缩策略、短期记忆注入、长期记忆的写入/切片/检索/反思、以及记忆的衰减与归档逐项讲透,最后给出工程实践与踩坑。适合正在做 Agent 上下文工程、或准备 Agent 系统设计面试的同学。 ## 一、先建立全局认知 ### Q:Agent 为什么需要"记忆系统",直接把所有消息塞进上下文不就行了? A:结论先行——因为上下文窗口是**硬限制**,而且 Agent 的消耗远高于普通对话;记忆系统的核心目标是**让 Agent 在单次会话中保持连贯、在跨会话中积累知识、在信息爆炸时有效压缩**。 先把"不加记忆"的三种失败模式列清楚: 1. **窗口撑爆**:一次典型 Agent Run 里,每个工具返回结果可能就有 500~5000 token,10 步下来很容易超过 30K,搜索结果一大就破 100K; 2. **注意力稀释**:即使没撑爆,上下文里塞满无关信息,会让模型的判断质量下降; 3. **跨会话失忆**:用户上次说"我喜欢表格展示",这次 Agent 完全不知道,体验断裂。 所以记忆系统要解决的不是"能不能存",而是"**存什么、存多久、什么时候取、什么时候忘**"。 ### Q:记忆为什么要分三层,而不是一个存储搞定? A:结论先行——因为不同信息的**生命周期和访问速度差别巨大**,必须按"生命周期 + 访问速度"分层:工作记忆(单次 Run)、短期记忆(数小时到数天)、长期记忆(数周到数月)。  *图:Agent 记忆三层架构:工作记忆 / 短期记忆 / 长期记忆* ```text ┌─────────────────────────────────────────────────────────────┐ │ Agent 记忆三层架构 │ ├─────────────────────────────────────────────────────────────┤ │ 工作记忆(Working Memory) │ │ 生命周期:单次 Agent Run │ │ 存储:当前对话 messages、当前 step 中间状态 │ │ 访问:每步都读写,延迟要求极高 │ │ │ 摘要/筛选 │ │ ▼ │ │ 短期记忆(Short-term Memory) │ │ 生命周期:跨会话,数小时到数天 │ │ 存储:用户偏好、当前任务上下文、最近交互摘要 │ │ 访问:会话开始加载,会话中按需查询 │ │ │ 编码/向量化 │ │ ▼ │ │ 长期记忆(Long-term Memory) │ │ 生命周期:持久化,数周到数月 │ │ 存储:知识库、历史经验、反思总结、用户画像 │ │ 访问:语义检索,按相关性返回 │ └─────────────────────────────────────────────────────────────┘ ``` 三层之间不是孤立的:信息从工作记忆经筛选压缩后进入短期记忆,再经进一步提炼进入长期记忆——这是**信息从热到冷、从细粒度到粗粒度**的逐步归档过程。这个分层很重要,因为它决定了每一层的**存储选型、性能预算和清理策略**都完全不同。  *图:Agent 记忆三层架构* ## 二、工作记忆 ### Q:一次 Agent Run 的上下文到底被什么吃掉了? A:结论先行——被四块吃掉:**System Prompt、工具定义、消息历史(其中工具返回最大)、工作变量**,其中工具返回结果是最大的不确定项。  *图:一次典型 Agent Run 的上下文组成* ```text 一次典型 Agent Run 的上下文组成: ┌────────────────────────────────────────────┐ │ System Prompt ~500-2000 tokens │ │ Tool Definitions ~200-1000 tokens/个 │ │ Messages History │ │ User Message ~100-500 tokens │ │ Assistant Thought ~200-800 tokens │ │ Tool Call JSON ~100-500 tokens │ │ Tool Result ~500-5000 tokens ← 大头 │ │ ... × N steps │ │ Working Variables ~200-1000 tokens │ └────────────────────────────────────────────┘ 假设 5 个工具调用、每步 3000 tokens → 10 步 ≈ 30000 tokens 若工具返回大数据(如搜索结果),很容易超过 100K ``` 关键点解读:**工具定义是"隐形开销"**——如果注册了 30 个工具,光工具定义就可能吃掉 6000~30000 token,而且这部分是固定的、每步都要带的。这解释了为什么"工具不是越多越好"(工具选型本身就是一个上下文预算问题)。 ### Q:工作记忆超限,有哪些压缩策略? A:结论先行——三种策略:**滑动窗口 + 前置摘要**(主干)、**基于重要性过滤**(剪枝)、**结构化工作变量**(关键信息外置),生产上通常组合使用。 **策略 A:滑动窗口 + 前置摘要**——保留最近 N 轮完整对话,更早的消息用 LLM 生成摘要压缩后保留。  *图:上下文中的「摘要 + 完整对话」组合示例* ```text ┌────────────────────────────────────────────┐ │ [摘要] 前 20 轮对话的核心信息 │ │ ───────────────────────────── │ │ [完整] 最近 5 轮对话 │ │ User: 帮我分析 Q2 财报 │ │ Agent: Thought → search("Q2财报") │ │ Tool Result: {营收:xxx, 利润:xxx} │ │ Agent: Thought → calculate(毛利) │ │ ... │ └────────────────────────────────────────────┘ 摘要内容示例:Q2 营收 5000 万,毛利率 45%,用户关注现金流。已生成初步分析报告。 ``` ```python class SlidingWindowMemory: def __init__(self, window_size: int = 10, summarize_older: bool = True): self.window_size = window_size self.summarize_older = summarize_older self.messages: list = [] self.summary: str = "" def add_message(self, msg: dict): self.messages.append(msg) if len(self.messages) > self.window_size * 2: # 每轮 user + assistant self._compress() def _compress(self): older = self.messages[:-self.window_size * 2] recent = self.messages[-self.window_size * 2:] new_summary = llm.generate( prompt=f"将以下对话压缩为一段摘要,保留关键事实和决策:\n{older}\n\n已有摘要:{self.summary}" ) self.summary = new_summary self.messages = recent def get_context(self) -> list: context = [] if self.summary: context.append({"role": "system", "content": f"历史对话摘要:{self.summary}"}) return context + self.messages ``` 关键点解读:注意 `_compress` 会把**已有摘要和新对话一起再压缩**(递归摘要),这是必要的——否则摘要本身会随会话无限增长。代价是"递归摘要失真":层次越深,早期细节越模糊。这属于典型的取舍,需要在摘要 prompt 里明确要求"保留关键事实和决策"。 **策略 B:基于重要性过滤**——不机械保留最近 N 轮,而是评估每条消息的重要性,保留高价值信息、丢弃冗余。  *图:记忆价值评估:五类信息分高、低重要性* ```text 评估维度: 1. 包含关键决策或转折点 → 高重要性 2. 包含用户明确偏好 → 高重要性 3. 工具返回的错误信息 → 高重要性(避免重复犯错) 4. 纯确认性回复("好的""继续") → 低重要性 5. 中间推理步骤已体现在最终结论中 → 低重要性 ``` ```python def filter_by_importance(messages: list, max_tokens: int) -> list: scored = [] for msg in messages: importance = evaluate_importance(msg) # 可用规则或小模型评分 scored.append((importance, msg)) scored.sort(key=lambda x: x[0], reverse=True) result, tokens = [], 0 for imp, msg in scored: msg_tokens = count_tokens(msg) if tokens + msg_tokens < max_tokens: result.append(msg) tokens += msg_tokens # 恢复时间顺序,避免打乱因果关系 return sorted(result, key=lambda x: x.get("timestamp", 0)) ``` 关键点解读:最后一步"恢复时间顺序"非常关键——**按重要性筛选后必须重新按时间排序**再喂给模型,否则消息顺序错乱会让模型对因果关系的推理彻底失效。 **策略 C:结构化工作变量**——不把所有信息堆在对话历史里,而是把关键信息提取为结构化字段,注入每步 prompt。这种方式更省 token,而且信息更精确。 ```python from dataclasses import dataclass import json @dataclass class WorkingContext: task_goal: str # 当前任务目标 completed_subtasks: list # 已完成的子任务及结果 current_subtask: str # 正在执行的子任务 key_findings: dict # 关键发现 {key: value} user_preferences: dict # 本次会话中用户表达的偏好 constraints: list # 约束条件(预算、时间、格式要求) step_count: int # 当前执行步数 errors_encountered: list # 已遇到的错误及处理方式 def to_prompt_context(self) -> str: return f""" ## 当前任务状态 - 目标:{self.task_goal} - 进度:{self.step_count} 步 - 已完成的子任务:{', '.join(self.completed_subtasks)} - 当前子任务:{self.current_subtask} - 关键发现:{json.dumps(self.key_findings, ensure_ascii=False)} - 约束:{', '.join(self.constraints)} """ ``` 关键点解读:结构化变量的本质是把"**非结构化的对话历史**"换成"**结构化的状态对象**"。好处是同样的信息只用 1/10 的 token,坏处是需要额外的提取步骤,且提取本身可能漏信息。所以实践中的组合是:滑动窗口提供"原始质感",结构化变量提供"关键事实"。  *图:工作记忆管理策略* ## 三、短期记忆 ### Q:短期记忆应该存什么? A:结论先行——存五类:**用户偏好、当前任务上下文、最近交互摘要、待办/跟进、运行中 Run 的 Handle**,生命周期从数小时到数周不等。 | 存储内容 | 示例 | 生命周期 | |---|---|---| | 用户偏好 | "喜欢表格形式展示数据" | 数天到数周 | | 当前任务上下文 | "上次分析到 Q3 数据,还差 Q4" | 数小时到数天 | | 最近交互摘要 | 最近 3 次会话的主题和结论 | 数天 | | 待办 / 跟进 | "用户要求今天下班前发报告" | 直到完成 | | 运行中 Run 的 Handle | run_id、checkpoint_id | 直到 Run 结束 | ```python @dataclass class ShortTermMemory: user_id: str session_id: str preferences: dict # {"output_format": "table", "language": "zh"} task_context: dict # {"last_topic": "Q3财报分析", "pending_action": "生成Q4对比"} recent_summaries: list # [{"session_id": "s1", "summary": "..."}] reminders: list # [{"deadline": "...", "content": "发Q4报告"}] created_at: datetime ttl: int = 86400 * 7 # 默认 7 天 ``` 存储选型的取舍很清晰: - **Redis**:适合高频读写,TTL 自动过期,**天然匹配短期记忆的生命周期管理**(到期即忘,不需要自己写清理任务); - **PostgreSQL**:适合需要复杂查询的场景(如"找出所有有未完成提醒的用户")。 ### Q:会话开始时,记忆怎么注入才不显得"生硬"? A:结论先行——把短期记忆组装成一段**"上下文回顾"**注入系统提示词,按"偏好 → 上次任务背景 → 最近交互 → 待处理事项"的顺序组织,并且要主动过滤掉已完成项。 ```python def build_session_context(user_id: str, short_term_memory: ShortTermMemory) -> str: """构建新会话的初始上下文""" parts = [] if short_term_memory.preferences: parts.append(f"用户偏好:{json.dumps(short_term_memory.preferences, ensure_ascii=False)}") if short_term_memory.task_context: tc = short_term_memory.task_context parts.append(f"上次任务背景:主题={tc.get('last_topic')},待完成={tc.get('pending_action')}") if short_term_memory.recent_summaries: recent = short_term_memory.recent_summaries[:3] # 只取最近 3 次,避免过长 parts.append(f"最近 3 次交互:{'; '.join([s['summary'] for s in recent])}") if short_term_memory.reminders: active = [r for r in short_term_memory.reminders if not r.get('completed')] if active: parts.append(f"待处理事项:{'; '.join([r['content'] for r in active])}") return "\n".join(parts) ``` 关键点解读:`recent_summaries[:3]` 这个截断和 `not r.get('completed')` 这个过滤都是"注入预算"意识的体现。记忆注入不是越多越好——**注入的信息越多,模型的注意力被稀释得越厉害**。 ## 四、长期记忆 ### Q:长期记忆和短期记忆的本质区别是什么? A:结论先行——短期记忆解决的是"**这个用户上次说了什么**",长期记忆解决的是"**Agent 需要知识而不只是上下文**"。 - 短期记忆示例:"上次用户让我用表格展示"; - 长期记忆示例:向量库里查到的"财报分析最佳实践文档"、"Q1-Q4 的历史数据"。 所以长期记忆的读取方式是**语义检索**(按相关性返回),而不是按 key 精确查。 ### Q:长期记忆的存储架构怎么设计? A:结论先行——**向量库存 embedding 与元数据(负责检索),对象存储/关系库存原文与画像(负责回填)**,检索和原文分离。  *图:记忆的写入路径与读取路径* ```text ┌───────────────┐ 写入 ┌──────────────────────────┐ │ Agent │ ────────→ │ 向量数据库 │ │ (产出内容) │ │ (Milvus/Pinecone/FAISS) │ └───────┬───────┘ │ - 文档 chunk embedding │ │ │ - 元数据过滤 │ │ 检索 └──────────────┬─────────────┘ │ │ ┌───────▼───────┐ ┌──────────────▼─────────────┐ │ Agent │ ◄───────── │ 对象存储 / 关系库 │ │ (使用知识) │ 返回原文 │ (MySQL/MongoDB) │ └───────────────┘ │ - 完整文档、用户画像 │ └────────────────────────────┘ 写入路径:Agent 产出知识 → embed → 向量库 + 原文写入对象存储 读取路径:查询意图 → embed → 向量检索 → 返回 top-k + 原文 ``` 关键点解读:为什么一定要"分离"?因为**向量库里放完整原文会让索引膨胀、检索变慢,而且更新原文时向量可能失效**。分离后,向量库只存"可检索的指针 + 摘要级内容",原文单独维护。 ### Q:什么时候该把内容写进长期记忆? A:结论先行——**不是每段内容都值得记**,用信号评分过滤:包含新领域知识、用户明确要求记住、纠正了错误认知、包含决策依据与结局、被高重复引用,得分超过阈值(示例 0.7)才写入。 ```python def should_store_long_term(content: str, importance_threshold: float = 0.7) -> bool: """判断一段内容是否值得存入长期记忆""" signals = { "包含新的领域知识": "新概念、新定义、新数据", "用户明确要求记住": '"记住这个"、"以后用得上"', "纠正了之前的错误认知": "修正、更新", "包含决策依据和结局": "最终选了 A 方案因为…", "高重复引用": "同一信息被多次引用", } score = evaluate_signals(content, signals) return score >= importance_threshold ``` ### Q:长内容进长期记忆前怎么切片? A:结论先行——**按语义边界切,chunk 大小约 500 tokens、overlap 约 50 tokens**,不要机械按字符切。 ```python def chunk_for_long_term(content: str, chunk_size: int = 500, overlap: int = 50) -> list: """ - chunk_size:500 tokens,保证每个 chunk 的语义完整 - overlap:50 tokens,避免关键信息恰好被切断在边界 """ # 优选按段落或自然语义边界切分,而非机械切分 return semantic_split(content, chunk_size, overlap) ``` 关键点解读:`overlap` 存在的唯一理由是"**关键信息可能恰好落在切分边界上**"——如果一句话被切成两半,两个 chunk 各自的 embedding 都表达不出完整语义,检索时就会双双失配。 ### Q:长期记忆的检索为什么要分层? A:结论先行——因为单次向量检索既不够准也不够稳,要用**"向量粗排 → 元数据过滤 → 重排序 → 阈值过滤"**的分层链路。 ```python class LongTermMemoryRetriever: def retrieve(self, query: str, top_k: int = 5, filters: dict = None, threshold: float = 0.75) -> list: """ 1. 用 query 做 embedding,向量检索 top_k×2 候选 2. 用元数据过滤(时间范围、文档类型、用户标签) 3. 用 reranker 模型对候选重排序 4. 只返回相似度 > threshold 的结果 """ query_vec = embed(query) candidates = vector_db.search(query_vec, k=top_k * 2, filters=filters) reranked = reranker.rerank(query, candidates) return [r for r in reranked[:top_k] if r.score > threshold] ``` 三个参数的取舍: - **`k=top_k*2`(召回放大)**:粗排召回要放宽,因为重排会淘汰一批,如果只召回 5 个再淘汰可能就不够了; - **`reranker`**:把"向量相似"升级成"语义相关",这是精度提升最明显的一步; - **`threshold`(阈值过滤)**:宁可返回空,也不要塞进低相关的结果——低相关的记忆会直接污染 Agent 的推理。  *图:长期记忆检索策略* ### Q:什么是"反思记忆",它为什么重要? A:结论先行——反思记忆(Reflective Memory)让 Agent 记住的不是"事实"而是"**经验**":哪些做法有效、哪些容易出错,这才是 Agent 越用越好的关键。 ```python @dataclass class Reflection: run_id: str task_type: str # "财报分析"、"代码审查" success: bool key_lessons: list # ["搜索时加 site:sec.gov 更准", "先查营收再算毛利"] failure_patterns: list # ["搜索返回空时多换几个关键词", "数据源A在周末更新慢"] embedding: list def to_natural_language(self) -> str: status = "成功" if self.success else "失败" return f""" [经验 - {self.task_type} - {status}] 上次进行 {self.task_type} 时,关键经验: - {chr(10).join('- ' + l for l in self.key_lessons)} {f'失败模式:{chr(10).join("- " + p for p in self.failure_patterns)}' if self.failure_patterns else ''} """ ``` 关键点解读:新任务开始时,先检索**同任务类型**的历史反思(用 `task_type` 做元数据过滤),把它作为执行策略的提示。这比"重新踩一遍坑"高效得多,而且它天然复用了长期记忆的检索通道——**反思就是一类特殊的长期记忆**。 ## 五、记忆的衰减与清理 ### Q:记忆为什么要"忘"? A:结论先行——因为无限膨胀会造成两个具体问题:**检索质量下降**(向量库信息越多、噪声越多、相关性越低)和**注入 prompt 的记忆过多**(挤占 LLM 的有效思考空间)。 这也解释了一个常见误解:"记忆当然越多越好"。实际上记忆系统的核心难点不是"存",而是"**忘得对**"。 ### Q:三层的衰减策略分别是什么? A:结论先行——**工作记忆会话结束即归档、短期记忆每天衰减一次、长期记忆每周/每月清理一次**。  *图:三层记忆的生命周期、触发时机与清理规则* ```text 工作记忆(Working) ↓ 会话结束时 ├── 提取关键信息 → 写入短期记忆 └── 其他信息 → 丢弃 短期记忆(Short-term) ↓ 每 N 天衰减一次 ├── importance_score 高于阈值的 → 保留 ├── 用户偏好长期不变 → 写入长期记忆(用户画像) ├── 低价值摘要 → 合并为更粗粒度的周/月摘要 └── TTL 过期 → 自动删除(Redis EXPIRE) 长期记忆(Long-term) ↓ 每月清理 ├── 访问频率低于阈值 → 归档到冷存储(S3/对象存储) ├── 信息已被更新版本覆盖 → 软删除 └── 相似度过高的重复文档 → 去重合并 ```  *图:记忆衰减生命周期* ### Q:衰减逻辑落到代码上长什么样? A:结论先行——三段:**算重要性 → 低价值合并 → 稳定偏好升迁**。注意"升迁"是最有价值的一步。 ```python class MemoryDecayManager: def decay_short_term(self, user_id: str): memories = self.load_short_term(user_id) # 1. 重要性评分(可用规则或小模型) for m in memories: m['importance'] = self.score_importance(m) m['age_hours'] = (now() - m['created_at']).total_seconds() / 3600 # 2. 低价值旧记忆 → 合并为周摘要 low_value = [m for m in memories if m['importance'] < 0.3 and m['age_hours'] > 24] if len(low_value) > 5: merged_summary = llm.generate( f"将以下多条低价值交互记录合并为一段简短的周摘要:\n{low_value}" ) self.add_summary(user_id, merged_summary) self.delete_many([m['id'] for m in low_value]) # 3. 稳定偏好 → 升迁到长期记忆 stable_prefs = [m for m in memories if m['type'] == 'preference' and m['occurrence_count'] >= 3] for pref in stable_prefs: self.store_long_term(UserProfile( user_id=user_id, preference=pref['content'], confidence=min(pref['occurrence_count'] / 5, 1.0), )) ``` 关键点解读:**"出现 3 次以上的偏好"才升迁为长期画像**,这是在用"重复出现"作为"稳定"的信号。`confidence = min(occurrence_count / 5, 1.0)` 让置信度随证据增加而增长但封顶 1.0,避免偶发行为被当成长期偏好。这个设计直接回应了"记忆需要不断修正"这一本质需求。 ## 六、整体架构与设计决策 ### Q:记忆系统的端到端流程长什么样? A:结论先行——三个阶段:**加载记忆 → 执行循环(工作记忆压缩)→ 会话结束(归档与反思)**,外加后台定期衰减任务。  *图:一次请求的三步记忆流转与各步骤动作* ```text 请求入口(用户发送消息) │ ▼ Step 1: 加载记忆 短期记忆(Redis) ──→ 用户偏好、任务上下文 长期记忆(VectorDB) ─→ query 检索相关历史经验和知识 组装为"记忆上下文"注入 System Prompt │ ▼ Step 2: Agent 执行循环 while not done: - 工作记忆(messages + working_context) - LLM 思考 + 工具调用 - 工具结果写入工作记忆 - 工作记忆超限 → 压缩(滑动窗口 + 摘要) │ ▼ Step 3: 会话结束 checkpoint 保存最终状态 提取关键信息 → 写入短期记忆 产出经验反思 → 写入长期记忆 后台定期:短期记忆衰减/合并、长期记忆去重/归档 ```  *图:记忆系统分层架构* ### Q:关键决策点有没有"经验答案"? A:结论先行——见下表,这是面试里最容易被追问的部分。 | 决策点 | 选项 | 选型建议 | |---|---|---| | 工作记忆超限策略 | 滑动窗口 / 重要性过滤 / 结构化变量 | 组合使用:滑动窗口做主干,重要性过滤做剪枝,结构化变量做关键上下文 | | 短期记忆存储 | Redis / PostgreSQL | Redis(TTL 天然匹配短生命周期) | | 长期记忆存储 | 向量库 + 对象存储 | Milvus/Qdrant + PG,检索和原文分离 | | Chunk 大小 | 256 / 512 / 1024 tokens | 512 tokens,兼顾语义完整性和检索精度 | | 记忆衰减频率 | 实时 / 每小时 / 每天 | 短期每天一次,长期每周一次 | | 反思记忆触发 | 每次 Run 结束 / 每 N 次 / 异常时 | 每次 Run 结束 + 异常时强制 | | 记忆注入时机 | 会话开始 / 每步都注入 / 按需查询 | 会话开始注入短期记忆;长期记忆按需 query | 关键点解读:最后一行的取舍最值得强调——**"每步都注入长期记忆"是非常常见的错误做法**。它会让每步 prompt 都变长、延迟升高、成本翻倍,而收益微乎其微。正确做法是"会话开始注入短期记忆(轻量、固定),长期记忆按需 query(重、按需)"。 ## 七、记忆与相邻子系统的边界 ### Q:记忆和 Checkpoint 有什么区别?会不会重复存? A:结论先行——**Checkpoint 存"一次 Run 的可恢复状态",记忆存"跨 Run 的知识与偏好"**;前者为"精确恢复"服务,后者为"决策更准"服务,不能互相替代。 | 维度 | Checkpoint | 记忆 | |---|---|---| | 生命周期 | 单次 Run(Run 结束后可清理) | 跨会话(数天~数月) | | 目的 | 中断后可恢复执行 | 让后续决策更准 | | 内容 | messages、子任务、工具调用状态、步数 | 偏好、任务上下文、知识、经验反思 | | 一致性要求 | **强**(必须精确,否则恢复出错) | 弱(近似即可,允许模糊) | | 检索方式 | 按 run_id 精确取 | 语义检索(相关性排序) | | 存储选型 | Redis / PG(带版本与 CAS) | 向量库 + 对象存储 + Redis(TTL) | 关键点解读:这个边界的实践意义很直接——**不要用记忆系统承担"恢复执行"的职责**。记忆是近似的、按相关性返回的、还会被衰减和合并;如果拿它去恢复一个中断的 Agent Run,一定会丢状态(比如"少了一条工具返回结果"或"用户偏好被摘要成了错的表述")。反过来,也不要把用户偏好塞进 Checkpoint 当记忆用,那样会话一结束偏好就没了。 ### Q:记忆注入的 token 预算怎么控制? A:结论先行——给记忆注入设一个**固定预算上限**,超出时按"偏好 > 待办 > 最近摘要"的优先级裁剪。 ```text 记忆注入预算(示例): 上下文总预算的 10%~20% 分配给记忆 超预算时的裁剪顺序: 1. 用户偏好(保留,价值最高、体量最小) 2. 待办/跟进(保留,有明确时效性) 3. 最近交互摘要(按时间倒序保留前 3 条) 4. 当前任务上下文(保留,但可压缩成一句话) ``` 关键点解读:**记忆注入是"固定成本"而不是"按需成本"**——它(至少在会话开始时)每轮都要带进上下文。如果没有预算上限,一个长期用户(几百次会话、几十条偏好、上百条摘要)会持续被"记忆税"拖慢,表现为"越用越慢、越用越贵"。这与"长期记忆按需 query"是配套的两条约束:**必然要带的(短期记忆)要有硬上限;能按需取的(长期记忆)不要每步注入**。 ### Q:用户说"忘掉这个"时,系统要做什么? A:结论先行——要做到**定位 + 删除 + 阻止回流**三步:不只是删掉短期记忆里的记录,还要清掉长期向量库中对应的 chunk,并保证后续的摘要/反思不会从旧数据里把它重新"生成"出来。 ```text 删除链路: 1. 定位:按内容匹配 + 来源标记(哪次会话、哪条记忆 id)找出所有副本 2. 删除:短期记忆(Redis/PG)+ 长期记忆(向量库 chunk + 原文对象) 3. 阻止回流: - 已生成的摘要里如果包含该信息 → 重新生成摘要 - 原始对话如果仍在归档中 → 标记不可再用于生成记忆/反思 ``` 关键点解读:**"阻止回流"是最容易漏掉的一步**,也是记忆系统与普通数据库删除最大的差别——普通系统删了就没了,记忆系统里这条信息可能已经"扩散"到摘要、周报、用户画像、经验反思等多个派生载体中。所以记忆系统在设计之初就要给每条记忆保留**来源可追溯**(这也是为什么反思记忆里要带 `run_id` 与 `task_type`)。 ## 八、工程实践与踩坑 ### Q:框架已经提供了记忆能力,还需要自己做什么? A:结论先行——框架(如 `ConversationBufferMemory` / `ConversationSummaryMemory` 对应工作记忆的滑动窗口与摘要策略,`Checkpointer` 提供 state 持久化)只提供**基础能力**;生产级记忆系统还需要三件框架不做的事。 1. **记忆的意图感知检索**:根据当前任务类型,智能决定查询哪些记忆。查"财报分析"任务就只检索财报相关的反思与知识,而不是把用户所有记忆都捞出来; 2. **记忆的更新策略**:信息不是"存进去就完了",而是需要在实践中不断修正(类似人脑的记忆重塑)。例如用户改口说"以后不用表格了",旧偏好必须被覆盖而不是并存; 3. **记忆的生命周期管理**:衰减、合并、归档,框架不做这些。 ### Q:落地时最容易踩哪些坑? A:结论先行——六个高频坑,分别对应成本、正确性、隐私三类风险。 1. **摘要递归失真**:摘要的摘要会越来越模糊。对策是在摘要 prompt 中显式约束"保留关键事实和决策",并对关键事实做结构化外置(不进摘要,进工作变量)。 2. **按重要性筛选后忘记恢复时间序**:消息顺序错乱会让模型推理崩塌,务必重新排序。 3. **每步都注入长期记忆**:成本与延迟双高,收益极低,应改为按需 query。 4. **向量库和原文不一致**:原文更新了但向量没重建,会检索到过期知识。**更新必须是"重建向量 + 换原文"的原子动作**。 5. **短期记忆缓存穿透**:Redis 里没有该用户记忆时会频繁回源;需要空值缓存 + 合理的默认值兜底。 6. **把 PII 无脑写进记忆**:记忆是长期存储,一旦写入很难彻底删除,涉及个人数据时必须做脱敏或明确标注可删除(相关合规要求需结合所在地区法规与版本确认)。 ### Q:怎么评估记忆系统做得好不好? A:结论先行——分过程指标和结果指标:过程看**注入 token 数、检索命中率、记忆命中后的任务成功率提升**;结果看**跨会话的连贯性(用户是否需要重复交代)与总成本变化**。 一个很实用的判断法:**做 A/B——关闭长期记忆 vs 开启长期记忆,看"用户重复交代次数"是否下降**。如果开启记忆后用户仍要反复说同样的偏好,说明记忆写了但没被正确注入或检索。 ## 小结 - 记忆按生命周期分三层:**工作记忆(单次 Run)、短期记忆(数小时~数天)、长期记忆(数周~数月)**,信息从热到冷逐步归档; - 工作记忆的三板斧是**滑动窗口 + 重要性过滤 + 结构化变量**,组合使用而不是三选一; - 短期记忆的杀手级设计是**用 TTL 管理生命周期**(Redis EXPIRE 天然契合); - 长期记忆要"**检索与原文分离**",写入前要过滤(信号评分),切片要按语义边界并留 overlap,检索要走"粗排 → 过滤 → 重排 → 阈值"; - **反思记忆**是让 Agent 越用越好的关键,本质是一类特殊的长期记忆; - 记忆系统的真正难点是"**忘得对**":三层各有衰减策略,稳定偏好要升迁、低价值要合并、冷数据要归档; - 生产上框架之外还要补三件事:意图感知检索、记忆更新策略、生命周期管理。 ## 思考题 1. 如果用户明确说"记住:以后所有报告都用英文",而三个月前的记忆是"喜欢中文",你的记忆更新策略应该怎么处理这对冲突?"并存 + 取最新"和"覆盖"各有什么代价? 2. 递归摘要必然导致早期细节失真,如果你的业务要求"必须记得第 1 轮提到的某个数字",你会怎么设计(提示:结构化外置 vs 摘要)? 3. 长期记忆检索阈值设得过低会污染推理、设得过高会频繁检索为空。你会用什么指标来调这个阈值?"检索为空"时 Agent 应该有怎样的降级行为? 4. 反思记忆要求每次 Run 结束都生成一次反思,这会带来额外成本。在什么情况下你会选择"每 N 次才反思"或"仅失败时反思"? 5. 假设要求你做一个"记忆可审计"的能力——用户能查看并删除 Agent 记住的关于他的所有内容。这会对你的存储选型(Redis TTL 自动过期 vs 可查可删的关系库)产生什么影响?
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入