05 Planning → 06 记忆系统 → 07

记忆系统

记住该记的,忘掉该忘的
—— 让 Agent 拥有真正的"记忆"

🧠 人脑类比:短期记忆 vs 长期记忆

就像人脑有海马体负责将短期记忆转化为长期记忆,Agent 也需要一套记忆系统来管理信息。

⚡

短期记忆 = 上下文窗口

容量有限,速度快
就像你正在对话时记住的内容
对话结束就可能遗忘

💾

长期记忆 = SQLite 持久化

容量大,可检索
就像写在笔记本上的内容
随时可以翻阅回忆

↓ 向下滚动开始学习
01

核心概念:记住该记的,忘掉该忘的

记忆系统的核心理念是 选择性记忆——不是记住所有事情,而是

记忆系统的两大组件

🗄️

MemoryStore

持久化存储层
基于 SQLite
负责记忆的增删改查

🗜️

ContextCompactor

上下文压缩器
三种压缩策略
防止上下文溢出

02

记忆的三种类型

就像图书馆的分类系统,记忆也按照用途分为三种类型:

📖

情景记忆 (Episodic)

对话历史

记录 Agent 与用户之间的交互过程。就像日记一样,记录"发生了什么"。

// 示例
"用户上次问了关于部署的问题"
🧠

语义记忆 (Semantic)

用户偏好 & 项目知识

存储事实性知识和偏好设定。就像百科全书,记录"知道什么"。

// 示例
"用户偏好用 TypeScript"
"项目使用 React + Vite"
⚙️

程序记忆 (Procedural)

操作步骤

存储如何完成特定任务的知识。就像操作手册,记录"怎么做"。

// 示例
"部署流程:build → test → push"
03

MemoryStore:持久化记忆存储

MemoryStore 使用 SQLite 数据库来持久化存储记忆条目,每个条目包含丰富的元数据。

MemoryEntry 数据结构

id
唯一标识符
key
记忆键名
value
记忆内容
category
记忆类型
importance
重要性 (0-1)
created_at
创建时间
last_accessed
最后访问时间
access_count
访问次数
metadata
额外元数据

MemoryStore 代码实现

Python class MemoryStore: """持久化记忆存储,基于 SQLite""" 📁 整个记忆系统的持久化层,负责所有记忆的存储和检索 def __init__(self, db_path: str = "memory.db"): 💾 db_path 指定 SQLite 数据库文件路径,默认当前目录下的 memory.db self.db_path = db_path self._init_db() # 初始化数据库表结构 🔧 首次启动时自动创建 memories 表 async def add(self, key: str, value: str, category: str = "semantic", importance: float = 0.5) -> MemoryEntry: ➕ 添加一条新记忆。importance 范围 0~1,越高越不会被清理 entry = MemoryEntry( key=key, value=value, category=category, importance=importance, created_at=datetime.now(), last_accessed=datetime.now(), access_count=0 ) 📝 创建 MemoryEntry 对象,记录创建时间和初始访问次数 await self._save_to_db(entry) return entry 💾 保存到 SQLite 数据库并返回条目 async def get(self, key: str) -> Optional[MemoryEntry]: 🔍 根据 key 精确查找记忆,同时更新访问时间和次数 entry = await self._query_db(key=key) if entry: entry.access_count += 1 entry.last_accessed = datetime.now() await self._update_db(entry) 📊 每次访问都会更新计数器,用于判断记忆的重要性衰减 return entry async def search(self, query=None, category=None, min_importance=0.0) -> List[MemoryEntry]: 🔎 多维度搜索:可按关键词、分类、最低重要性过滤 return await self._query_db( query=query, category=category, min_importance=min_importance ) async def consolidate(self): 🧹 记忆整合:清理过期的低重要性记忆,释放存储空间 old_entries = await self._query_db( max_importance=0.3, older_than_days=30 ) 📋 选取:重要性 < 0.3 且超过 30 天未访问的记忆 for entry in old_entries: await self._delete_from_db(entry.id) 🗑️ 删除这些低价值记忆,就像清理文件柜里的旧文件
04

ContextCompactor:上下文压缩器

当对话消息超过上下文窗口阈值时,ContextCompactor 会自动压缩消息,防止上下文溢出。

Python class ContextCompactor: """上下文压缩器,自动管理对话历史的长度""" 🗜️ 当消息数量超过阈值时,自动压缩旧消息 def __init__(self, max_messages=50, strategy="smart"): ⚙️ max_messages: 触发压缩的阈值 | strategy: 压缩策略 self.max_messages = max_messages self.strategy = strategy async def compact(self, messages: List[Message]) -> List[Message]: 🔧 核心方法:检查消息数量,超过阈值则执行压缩 if len(messages) <= self.max_messages: return messages # 未超限,原样返回 ✅ 消息数量在阈值内,无需压缩 if self.strategy == "simple": return await self._simple_compact(messages) elif self.strategy == "smart": return await self._smart_compact(messages) elif self.strategy == "summary": return await self._summary_compact(messages) 🔀 根据选择的策略执行对应的压缩算法

三种压缩策略对比

✂️

Simple 策略

保留最近的消息

最简单粗暴:只保留最近 N 条消息,丢弃更早的。像撕掉笔记本的前几页。

// messages[-max_messages:]
🎯

Smart 策略

保留重要 + 工具调用 + 首尾

智能选择:保留重要消息、含工具调用的消息、以及第一条和最后一条。

// 重要性排序 + 关键消息保护
📝

Summary 策略

LLM 生成摘要

用 LLM 将旧消息总结为一段摘要,替换原始消息。信息保留最完整。

// LLM summarize → replace old msgs
05

记忆操作示例

让我们通过实际例子看看记忆系统的四种核心操作:

💾 保存记忆 (Save)

Python # 保存用户的偏好设置 await memory_store.add( key="user_pref_language", value="TypeScript", category="semantic", importance=0.8 )

🔍 回忆记忆 (Recall)

Python # 根据 key 检索特定记忆 pref = await memory_store.get("user_pref_language") print(pref.value) # → "TypeScript"

🔎 搜索记忆 (Search)

Python # 按分类搜索所有语义记忆 memories = await memory_store.search( category="semantic", min_importance=0.5 ) # 按关键词搜索 results = await memory_store.search(query="部署")

🗜️ 压缩上下文 (Compact)

Python # 当对话过长时自动压缩 compactor = ContextCompactor(max_messages=50) messages = await compactor.compact(messages) # 压缩后的消息更短,但仍保留关键信息
06

集成到 Agent 中

记忆系统如何与 Agent 整合?看这个完整的集成流程:

🔄 记忆集成流程

1
加载相关记忆
从 MemoryStore 检索与当前任务相关的记忆
↓
2
注入到系统提示词
将记忆作为上下文注入 system prompt
↓
3
检查是否需要压缩
ContextCompactor 检查消息是否超过阈值
↓
4
执行压缩(如需要)
使用选定策略压缩消息,保留关键信息
Python class Agent: def __init__(self): self.memory = MemoryStore("agent_memory.db") self.compactor = ContextCompactor(max_messages=50) 🔧 初始化记忆存储和上下文压缩器 async def process_message(self, user_msg: str): # 第一步:加载相关记忆 relevant = await self.memory.search( query=user_msg, min_importance=0.3 ) 🔍 根据用户消息搜索相关记忆,最低重要性 0.3 # 第二步:注入到系统提示词 system_prompt = self._build_prompt( base=self.base_prompt, memories=relevant ) 💉 将相关记忆格式化后注入系统提示词 # 第三步:检查是否需要压缩 self.messages = await self.compactor.compact( self.messages ) 🗜️ 超过 50 条消息时自动压缩 # 第四步:正常处理 response = await self.llm.chat( system=system_prompt, messages=self.messages ) 🤖 带着记忆上下文,正常调用 LLM # 第五步:保存新记忆 await self.memory.add( key=f"conv_{datetime.now().timestamp()}", value=user_msg, category="episodic" ) 💾 将对话记录保存为情景记忆
07

🧪 知识测验

检验一下你对记忆系统的理解吧!

Q1: MemoryStore 使用什么数据库来持久化存储记忆?

A. MongoDB
B. SQLite
C. Redis
D. PostgreSQL
✅ 正确!MemoryStore 使用 SQLite 进行轻量级本地持久化存储。
❌ 不对哦,MemoryStore 使用的是 SQLite 数据库。

Q2: 以下哪种不属于记忆的三种类型?

A. 情景记忆 (Episodic)
B. 语义记忆 (Semantic)
C. 程序记忆 (Procedural)
D. 工作记忆 (Working)
✅ 正确!记忆系统只有三种类型:情景、语义和程序记忆,不包含工作记忆。
❌ 不对哦,"工作记忆"不在三种记忆类型中。正确答案是 D。

Q3: ContextCompactor 的 "smart" 策略保留哪些消息?

A. 只保留最近的 N 条
B. 重要消息 + 工具调用 + 首条和末条
C. 用 LLM 生成摘要替换
D. 随机保留一半消息
✅ 正确!Smart 策略通过重要性排序、保护工具调用消息和首尾消息来智能选择保留内容。
❌ 不对哦,A 是 simple 策略,C 是 summary 策略。Smart 答案是 B。

Q4: consolidate() 操作会清理什么样的记忆?

A. 所有超过 7 天的记忆
B. 低重要性且长时间未访问的记忆
C. 最近 30 天的高重要性记忆
D. 所有情景记忆
✅ 正确!consolidate 清理重要性 < 0.3 且超过 30 天未访问的低价值记忆。
❌ 不对哦,consolidate 只清理低重要性(< 0.3)且超过 30 天未访问的记忆。答案是 B。

Q5: 记忆集成到 Agent 的正确顺序是?

A. 压缩 → 加载 → 注入 → 保存
B. 注入 → 加载 → 保存 → 压缩
C. 加载 → 注入 → 检查压缩 → 执行压缩
D. 保存 → 加载 → 注入 → 压缩
✅ 正确!标准流程是:加载相关记忆 → 注入系统提示词 → 检查是否需要压缩 → 如需要则执行压缩。
❌ 不对哦,正确顺序是 C:加载 → 注入 → 检查压缩 → 执行压缩。
08

🔬 深度探索

深度探索 1:重要性评分算法

▼

记忆的 importance 分数不是静态的,它会随时间衰减。评分算法考虑以下因素:

Algorithm # 动态重要性评分 = 基础分 × 时间衰减 × 访问频率加成 score = base_importance × decay(days_since_access) # 时间越久,分越低 × frequency_boost(access_count) # 访问越多,分越高 # 衰减函数:指数衰减 decay(t) = e^(-λt), λ = 0.01 # 频率加成:对数增长 frequency_boost(n) = 1 + log(1 + n) × 0.1

设计思路:就像人类记忆一样,经常被回忆的事情不容易遗忘(访问频率加成),而长期不用的记忆会慢慢模糊(时间衰减)。这种机制确保了 Agent 的记忆"活"起来,常用常新,不用则淡。

深度探索 2:何时进行记忆整合 (Consolidate)

▼

记忆整合的触发时机很关键:

触发条件 说明
定时触发 每天/每周自动执行一次清理
阈值触发 记忆总数超过设定上限时
手动触发 用户或管理员主动调用
空闲触发 Agent 空闲时后台自动执行

最佳实践:建议在 Agent 空闲时定期执行 consolidate,而不是在处理用户请求时。就像图书馆会在闭馆后整理书架,而不是在读者借书时。

深度探索 3:Smart 压缩启发式算法

▼

Smart 策略的"智能"体现在它的启发式选择算法:

Heuristic # 每条消息的保留优先级 = f(类型, 位置, 工具调用) def retention_score(msg, index, total): score = 0 # 首条消息(设定了对话背景) if index == 0: score += 10 # 末条消息(最近的上下文) if index == total - 1: score += 10 # 包含工具调用(有重要操作记录) if msg.has_tool_calls: score += 8 # 最近的消息(时效性强) recency = 1 - (index / total) score += recency × 5 return score

核心洞察:首尾消息之所以重要,是因为首条消息设定了整个对话的背景和目标,末条消息是最新的上下文。中间的消息虽然可能包含有价值的信息,但优先级相对较低。这个算法就像翻书时会特别注意第一页和最后一页。

09

📋 本章总结

🧠 记忆系统核心要点

🎉

恭喜完成「记忆系统」的学习!

你已经理解了 Agent 如何像人脑一样管理记忆。
下一章我们将探索更高级的主题。