如果说上下文管理决定了 Agent 的"瞬时智商"，那么记忆系统决定了 Agent 的"长期智慧"。本文深入探讨 Agent 记忆的层次、架构设计与实现方案。
目录
- [记忆的本质：Agent 为什么需要记忆](#记忆的本质：Agent 为什么需要记忆 "#1-%E8%AE%B0%E5%BF%86%E7%9A%84%E6%9C%AC%E8%B4%A8agent-%E4%B8%BA%E4%BB%80%E4%B9%88%E9%9C%80%E8%A6%81%E8%AE%B0%E5%BF%86")
- 记忆的三层架构
- 短期记忆：对话窗口内的信息保持
- 长期记忆：跨越会话的知识沉淀
- 工作记忆：任务执行中的状态维持
- 记忆检索：从"存"到"取"的关键链路
- 记忆更新与遗忘机制
- 记忆系统的工程实现
- 前沿探索：认知架构中的记忆
- 参考资料
1. 记忆的本质：Agent 为什么需要记忆
1.1 无记忆 Agent 的困境
考虑一个没有记忆系统的 Agent：
makefile
用户（第1天）: 我叫张三，喜欢简洁的回答风格。
Agent: 好的，张三。
用户（第2天）: 帮我总结这份报告。
Agent: 好的，我会为您总结一份详细的报告...（2000字长篇大论）
用户: ...（我明明说了要简洁）没有记忆的 Agent 面临的核心问题：
- 身份遗忘：每次对话都是"初次见面"
- 偏好丢失：无法积累对用户偏好的理解
- 知识断层：无法利用历史交互中的信息和决策
- 重复劳动：相同的问题需要反复解释和确认
1.2 记忆赋予 Agent 的能力
一个有良好记忆系统的 Agent 能够：
arduino
第一层：记住事实
"用户叫张三"、"上次处理到第3步"
第二层：理解模式
"张三习惯在周一早上查看周报"、"偏好 Markdown 格式输出"
第三层：形成知识
"张三的项目使用 React + FastAPI 技术栈，认证模块经常出问题"
第四层：主动服务
"快到周一了，要不要我提前准备周报模板？"2. 记忆的三层架构
受认知心理学启发，现代 Agent 系统普遍采用三层记忆架构：
scss
┌─────────────────────────────────────────────────────┐
│ │
│ ┌──────────────┐ 注意力 ┌──────────────┐ │
│ │ 短期记忆 │ ◄────────► │ 工作记忆 │ │
│ │ (对话窗口) │ │ (任务状态) │ │
│ └──────┬───────┘ └──────┬───────┘ │
│ │ 提取/固化 │ 暂存/读取 │
│ ▼ ▼ │
│ ┌──────────────────────────────────────────┐ │
│ │ 长期记忆 (向量数据库 + 结构化存储) │ │
│ │ ┌─────────┐ ┌─────────┐ ┌─────────┐ │ │
│ │ │ 语义记忆 │ │ 情景记忆 │ │ 程序记忆 │ │ │
│ │ │ (事实/知识)│ │ (经历/事件)│ │ (技能/方法)│ │ │
│ │ └─────────┘ └─────────┘ └─────────┘ │ │
│ └──────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────┘| 记忆层 | 容量 | 持久性 | 访问速度 | 类比 |
|---|---|---|---|---|
| 短期记忆 | 受上下文窗口限制 | 会话内 | 即时 | 人脑的"工作记忆" |
| 工作记忆 | 受任务复杂度限制 | 任务内 | 即时 | 便利贴 / 草稿纸 |
| 长期记忆 | 近乎无限 | 永久 | 需检索 | 硬盘 / 知识库 |
3. 短期记忆：对话窗口内的信息保持
短期记忆是 Agent 记忆系统中最直接的一层------它就是对话历史本身。
3.1 短期记忆的结构化存储
python
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
class MessageRole(Enum):
SYSTEM = "system"
USER = "user"
ASSISTANT = "assistant"
TOOL_CALL = "tool_call"
TOOL_RESULT = "tool_result"
MEMORY_INJECTION = "memory_injection"
class Importance(Enum):
CRITICAL = 5 # 安全约束、任务目标
HIGH = 4 # 用户偏好、关键决策
MEDIUM = 3 # 工具结果、数据事实
LOW = 2 # 中间推理、试探性操作
TRANSIENT = 1 # 问候、填充对话
@dataclass
class Message:
role: MessageRole
content: str
timestamp: datetime = field(default_factory=datetime.now)
importance: Importance = Importance.MEDIUM
metadata: dict = field(default_factory=dict)
# 元数据示例：
# - turn_number: 对话轮次
# - tool_name: 关联的工具调用
# - token_count: token 数估算
# - referenced_memories: 引用了哪些长期记忆
class ShortTermMemory:
"""短期记忆管理器"""
def __init__(self, max_messages: int = 50):
self.messages: list[Message] = []
self.max_messages = max_messages
def add(self, message: Message):
self.messages.append(message)
self._maybe_evict()
def _maybe_evict(self):
"""超出上限时，按重要性驱逐消息"""
if len(self.messages) <= self.max_messages:
return
# 找出可驱逐的消息（LOW 和 TRANSIENT 重要性）
candidates = [
(i, msg) for i, msg in enumerate(self.messages)
if msg.importance in (Importance.LOW, Importance.TRANSIENT)
]
if candidates:
# 驱逐最早的低重要性消息
idx, _ = candidates[0]
evicted = self.messages.pop(idx)
# 可选：将被驱逐的消息送往长期记忆
self._archive_to_long_term(evicted)
def _archive_to_long_term(self, message: Message):
"""将被驱逐的消息中有价值的内容固化到长期记忆"""
if message.importance == Importance.LOW:
# 生成摘要后存入长期记忆
pass
def get_context(self, max_tokens: int | None = None) -> list[dict]:
"""获取当前短期记忆的上下文表示"""
return [
{"role": msg.role.value, "content": msg.content}
for msg in self.messages
]3.2 重要性评分机制
并非所有对话内容都值得被记住。引入重要性评分，为后续的记忆固化提供依据：
python
class ImportanceScorer:
"""基于启发式规则的重要性评分器（生产环境可升级为 LLM 评分）"""
IMPORTANCE_KEYWORDS = {
Importance.CRITICAL: [
"安全", "密码", "删除", "格式化", "必须", "禁止",
"最重要的", "核心目标是", "基本原则"
],
Importance.HIGH: [
"偏好", "习惯", "总是", "从不", "记住", "以后都",
"我的名字是", "我的工作是"
],
Importance.MEDIUM: [
"帮我", "查找", "分析", "总结", "生成"
],
Importance.LOW: [
"试试", "可能", "或许", "看看能不能"
],
}
@classmethod
def score(cls, message: Message) -> Importance:
"""对消息进行重要性评分"""
content_lower = message.content.lower()
# 因子1: 关键词匹配
for level, keywords in cls.IMPORTANCE_KEYWORDS.items():
if any(kw in content_lower for kw in keywords):
return level
# 因子2: 消息长度（极短消息往往是填充对话）
if len(message.content) < 10:
return Importance.TRANSIENT
# 因子3: 角色权重
if message.role == MessageRole.MEMORY_INJECTION:
return Importance.HIGH # 记忆注入的消息通常很重要
return Importance.MEDIUM4. 长期记忆：跨越会话的知识沉淀
长期记忆是 Agent 记忆系统的核心------它让 Agent 在对话之间保持"人格连续性"。
4.1 长期记忆的子类型
借鉴人脑记忆分类，Agent 的长期记忆可以分为：
scss
长期记忆
├── 语义记忆 (Semantic Memory)
│ ├── 用户档案：姓名、职业、技术栈、时区
│ ├── 事实知识：公司制度、项目文档、API 规范
│ └── 偏好配置：输出风格、工具使用偏好、语言
│
├── 情景记忆 (Episodic Memory)
│ ├── 对话摘要：历史对话的关键决策和结论
│ ├── 任务记录：完成过的任务及结果
│ └── 交互模式：用户典型的提问方式和协作模式
│
└── 程序记忆 (Procedural Memory)
├── 工作流：常用的多步骤操作序列
├── 技能卡片：加载过的 Skill 及其使用场景
└── 纠错经验：之前的错误及修正方案4.2 长期记忆的存储与检索
python
import hashlib
import json
from datetime import datetime, timedelta
from typing import Any
@dataclass
class MemoryEntry:
"""长期记忆条目"""
memory_id: str
content: str
memory_type: str # "semantic" | "episodic" | "procedural"
embedding: list[float] | None = None
importance: float = 0.5 # 0-1
created_at: datetime = field(default_factory=datetime.now)
last_accessed: datetime = field(default_factory=datetime.now)
access_count: int = 0
ttl: timedelta | None = None # None 表示永不过期
metadata: dict = field(default_factory=dict)
@classmethod
def create_id(cls, content: str) -> str:
return f"mem_{hashlib.sha256(content.encode()).hexdigest()[:16]}"
def is_expired(self) -> bool:
if self.ttl is None:
return False
return datetime.now() > self.created_at + self.ttl
class LongTermMemoryStore:
"""长期记忆存储（简化实现，生产环境使用向量数据库）"""
def __init__(self, embedding_model=None):
self._entries: dict[str, MemoryEntry] = {}
self._embedding_model = embedding_model
def store(
self,
content: str,
memory_type: str = "semantic",
importance: float = 0.5,
metadata: dict | None = None,
ttl: timedelta | None = None,
) -> str:
"""存储一条长期记忆"""
memory_id = MemoryEntry.create_id(content)
entry = MemoryEntry(
memory_id=memory_id,
content=content,
memory_type=memory_type,
importance=importance,
ttl=ttl,
metadata=metadata or {},
)
# 生成向量嵌入
if self._embedding_model:
entry.embedding = self._embedding_model.encode(content)
self._entries[memory_id] = entry
return memory_id
def retrieve(
self,
query: str,
memory_type: str | None = None,
top_k: int = 5,
min_importance: float = 0.0,
) -> list[MemoryEntry]:
"""
检索相关记忆。
检索策略：
1. 向量相似度检索（语义匹配）
2. 按重要性加权
3. 按时效性衰减
"""
candidates = [
e for e in self._entries.values()
if not e.is_expired()
and (memory_type is None or e.memory_type == memory_type)
and e.importance >= min_importance
]
# 向量检索（生产环境使用向量数据库的相似度搜索）
if self._embedding_model:
query_embedding = self._embedding_model.encode(query)
candidates.sort(
key=lambda e: self._cosine_similarity(query_embedding, e.embedding)
if e.embedding else 0,
reverse=True,
)
# 更新访问记录
results = candidates[:top_k]
for entry in results:
entry.last_accessed = datetime.now()
entry.access_count += 1
return results
@staticmethod
def _cosine_similarity(a: list[float], b: list[float]) -> float:
dot = sum(x * y for x, y in zip(a, b))
norm_a = sum(x**2 for x in a) ** 0.5
norm_b = sum(y**2 for y in b) ** 0.5
if norm_a == 0 or norm_b == 0:
return 0.0
return dot / (norm_a * norm_b)5. 工作记忆：任务执行中的状态维持
工作记忆是三层架构中常被忽视但至关重要的部分。它维护当前任务的执行状态。
5.1 工作记忆的职责
scss
┌──────────────────────────────────────┐
│ 工作记忆 (Working Memory) │
│ │
│ ┌──────────────────────────────┐ │
│ │ 当前任务目标 │ │
│ │ "整理下载文件夹中的发票" │ │
│ └──────────────────────────────┘ │
│ ┌──────────────────────────────┐ │
│ │ 子任务栈 │ │
│ │ [1/3] 扫描PDF → 完成 ✓ │ │
│ │ [2/3] 提取日期 → 进行中... │ │
│ │ [3/3] 按月份归类 → 待执行 │ │
│ └──────────────────────────────┘ │
│ ┌──────────────────────────────┐ │
│ │ 中间产物引用 │ │
│ │ temp/invoice_list.json │ │
│ │ temp/extracted_dates.csv │ │
│ └──────────────────────────────┘ │
│ ┌──────────────────────────────┐ │
│ │ 阻塞与异常 │ │
│ │ 3张发票缺少日期字段 → 需确认 │ │
│ └──────────────────────────────┘ │
└──────────────────────────────────────┘5.2 工作记忆的实现
python
from enum import Enum
class TaskStatus(Enum):
PENDING = "pending"
IN_PROGRESS = "in_progress"
BLOCKED = "blocked"
COMPLETED = "completed"
FAILED = "failed"
@dataclass
class SubTask:
id: str
description: str
status: TaskStatus = TaskStatus.PENDING
result: str | None = None
artifacts: list[str] = field(default_factory=list) # 产生的中间文件路径
class WorkingMemory:
"""
工作记忆：维护当前任务的执行状态。
生命周期：
- 任务开始时创建
- 任务执行中持续更新
- 任务完成后，有价值的状态固化到长期记忆
"""
def __init__(self, task_id: str, goal: str):
self.task_id = task_id
self.goal = goal
self.subtasks: list[SubTask] = []
self.blockers: list[str] = []
self.decisions: list[str] = [] # 关键决策记录
self.artifacts: dict[str, str] = {} # artifact_name → file_path
def add_subtask(self, description: str) -> str:
sub = SubTask(
id=f"st_{len(self.subtasks) + 1}",
description=description,
)
self.subtasks.append(sub)
return sub.id
def start_subtask(self, subtask_id: str):
for st in self.subtasks:
if st.id == subtask_id:
st.status = TaskStatus.IN_PROGRESS
return
raise ValueError(f"Subtask {subtask_id} not found")
def complete_subtask(self, subtask_id: str, result: str, artifacts: list[str] | None = None):
for st in self.subtasks:
if st.id == subtask_id:
st.status = TaskStatus.COMPLETED
st.result = result
if artifacts:
st.artifacts = artifacts
return
def add_blocker(self, description: str):
self.blockers.append(description)
# 将当前正在执行的子任务设为阻塞
for st in self.subtasks:
if st.status == TaskStatus.IN_PROGRESS:
st.status = TaskStatus.BLOCKED
def generate_summary(self) -> str:
"""生成工作记忆摘要，用于注入 Agent 上下文"""
lines = [f"## 当前任务: {self.goal}", ""]
lines.append("### 子任务进度")
for st in self.subtasks:
icon = {
TaskStatus.COMPLETED: "✓",
TaskStatus.IN_PROGRESS: "►",
TaskStatus.BLOCKED: "✗",
TaskStatus.FAILED: "✗",
TaskStatus.PENDING: "○",
}[st.status]
lines.append(f"- {icon} {st.description}")
if self.blockers:
lines.append("\n### 阻塞项")
for b in self.blockers:
lines.append(f"- ⚠ {b}")
if self.decisions:
lines.append("\n### 关键决策")
for d in self.decisions:
lines.append(f"- {d}")
return "\n".join(lines)6. 记忆检索：从"存"到"取"的关键链路
存储只是记忆系统的一半，另一半------也是更难的一半------是在正确的时间检索出正确的记忆。
6.1 多策略检索管道
python
class MemoryRetrievalPipeline:
"""
记忆检索管道：组合多种策略，提升检索质量。
管道流程：
用户查询 → 关键词提取 → 并行检索 → 重排序 → 去重融合 → Top-K 输出
"""
def __init__(
self,
vector_store, # 向量存储（语义检索）
keyword_index, # 关键词索引（精确匹配）
recent_store, # 近期记忆缓存（时间衰减）
llm_reranker=None, # LLM 重排序器
):
self.vector_store = vector_store
self.keyword_index = keyword_index
self.recent_store = recent_store
self.llm_reranker = llm_reranker
def retrieve(self, query: str, top_k: int = 5) -> list[MemoryEntry]:
"""多策略并行检索 + 融合重排"""
# Step 1: 提取查询中的关键实体和意图
entities = self._extract_entities(query)
# Step 2: 并行多路召回
vector_results = self.vector_store.search(query, top_k=top_k * 2)
keyword_results = self.keyword_index.search(entities, top_k=top_k)
recent_results = self.recent_store.get_recent(limit=top_k)
# Step 3: 去重融合
merged = self._merge_deduplicate(
vector_results, keyword_results, recent_results
)
# Step 4: 重排序
if self.llm_reranker:
merged = self._llm_rerank(query, merged, top_k)
else:
merged = self._score_based_rerank(query, merged, top_k)
return merged
def _extract_entities(self, query: str) -> list[str]:
"""简化版实体提取（生产环境使用 NER 模型）"""
# 这里仅作示意，实际应使用更复杂的方法
import re
# 提取引号中的内容、专有名词等
quoted = re.findall(r'["\']([^"\']+)["\']', query)
return quoted
def _merge_deduplicate(
self, *result_lists: list[MemoryEntry]
) -> list[MemoryEntry]:
seen = set()
merged = []
for results in result_lists:
for entry in results:
if entry.memory_id not in seen:
seen.add(entry.memory_id)
merged.append(entry)
return merged
def _score_based_rerank(
self, query: str, entries: list[MemoryEntry], top_k: int
) -> list[MemoryEntry]:
"""
基于多因子评分的重排序。
评分因子：
- 语义相似度 (0-1)
- 重要性 (0-1)
- 新鲜度（时间衰减）
- 访问频率
"""
now = datetime.now()
for entry in entries:
score = 0.0
# 语义相似度（默认权重 0.5）
score += 0.5 * getattr(entry, 'similarity_score', 0.5)
# 重要性（权重 0.2）
score += 0.2 * entry.importance
# 新鲜度衰减（权重 0.2）------ 最近 7 天内记忆加分
age_days = (now - entry.created_at).days
score += 0.2 * max(0, 1 - age_days / 30)
# 访问频率（权重 0.1）
score += 0.1 * min(1.0, entry.access_count / 10)
entry.rerank_score = score
entries.sort(key=lambda e: e.rerank_score, reverse=True)
return entries[:top_k]6.2 检索时机策略
| 触发时机 | 检索策略 | 示例 |
|---|---|---|
| 会话开始 | 检索用户档案 + 偏好 | "你好，张三！还是用 Markdown 格式输出吗？" |
| 任务识别 | 检索相似历史任务 | "上次整理发票时，你要求按公司名分类" |
| 工具调用前 | 检索相关纠错经验 | "上次 auth.py 的 JWT 验证有坑，这次注意..." |
| 遇到阻塞 | 检索相似问题的解决方案 | "类似的权限问题之前用 sudo 解决了" |
| 会话结束 | 生成本次对话摘要并存储 | 自动将关键决策写入长期记忆 |
7. 记忆更新与遗忘机制
7.1 记忆的生命周期
记忆创建 → 强化期 → 稳定期 → 衰减期 → 遗忘/归档
强化期（0-7天）：新记忆被频繁访问，重要性动态评分
稳定期（7-30天）：访问模式趋于稳定，重要性固定
衰减期（30天+）：未访问的记忆逐步降低权重
遗忘/归档（90天+）：低重要性记忆归档或删除7.2 记忆冲突解决
python
class MemoryConflictResolver:
"""
处理记忆冲突：当新信息与旧记忆矛盾时。
策略：
1. 新信息默认优先（用户偏好可能改变）
2. 高重要性记忆需要更强证据才能覆盖
3. 记录冲突历史，方便回溯
"""
@staticmethod
def resolve(
existing: MemoryEntry,
new_content: str,
new_importance: float,
) -> tuple[MemoryEntry, str]:
"""
解决记忆冲突，返回 (最终保留的记忆, 冲突说明)
"""
# 新信息的重要性高于或等于已有记忆 → 覆盖
if new_importance >= existing.importance:
existing.content = new_content
existing.importance = new_importance
existing.metadata["conflict_history"] = existing.metadata.get(
"conflict_history", []
) + [{
"previous": existing.content,
"resolved_at": datetime.now().isoformat(),
"resolution": "overwrite"
}]
return existing, f"记忆已更新（重要性 {existing.importance} → {new_importance}）"
# 已有记忆重要性更高 → 保留，但记录冲突
existing.metadata["conflict_history"] = existing.metadata.get(
"conflict_history", []
) + [{
"conflicting": new_content,
"resolved_at": datetime.now().isoformat(),
"resolution": "keep_existing"
}]
return existing, "新信息重要性较低，保留原有记忆"7.3 程序化遗忘
python
class MemoryGarbageCollector:
"""记忆垃圾回收器：定期清理低价值记忆"""
def __init__(self, store: LongTermMemoryStore):
self.store = store
def collect(
self,
min_importance: float = 0.2,
max_age_days: int = 90,
min_access_count: int = 1,
) -> list[str]:
"""
回收低价值记忆。
同时满足以下条件的记忆将被标记为可回收：
- 重要性低于阈值
- 超过最大年龄
- 访问次数低于阈值
"""
to_remove = []
now = datetime.now()
for mem_id, entry in list(self.store._entries.items()):
age = (now - entry.created_at).days
if (
entry.importance < min_importance
and age > max_age_days
and entry.access_count < min_access_count
):
# 归档而非直接删除
self._archive(entry)
to_remove.append(mem_id)
del self.store._entries[mem_id]
return to_remove
def _archive(self, entry: MemoryEntry):
"""将被回收的记忆归档到冷存储"""
archive_path = f"memory_archive/{entry.created_at.year}/{entry.created_at.month:02d}/"
# 实际实现中写入文件或对象存储
pass8. 记忆系统的工程实现
8.1 技术栈选型
| 组件 | 推荐方案 | 备选方案 |
|---|---|---|
| 向量数据库 | Qdrant / Milvus | Pinecone, Weaviate, Chroma |
| 嵌入模型 | text-embedding-3-small | bge-large-zh, m3e-base |
| 关键词索引 | Elasticsearch | Meilisearch, Typesense |
| 结构化存储 | PostgreSQL + pgvector | SQLite, MongoDB |
| 缓存层 | Redis | Memcached |
| 重排序 | Cohere Rerank / bge-reranker | LLM-as-reranker |
8.2 完整的记忆管理器
python
class AgentMemorySystem:
"""
Agent 记忆系统：整合三层记忆的完整管理器。
使用方式：
memory = AgentMemorySystem(...)
# 会话开始
memory.start_session(session_id="abc123", user_query="帮我整理发票")
# 对话中注入记忆
context_injection = memory.get_context_injection(current_query)
# 存储新记忆
memory.remember("用户偏好 PDF 格式输出", memory_type="semantic", importance=0.8)
# 会话结束
memory.end_session(generate_summary=True)
"""
def __init__(
self,
short_term: ShortTermMemory,
long_term: LongTermMemoryStore,
retrieval_pipeline: MemoryRetrievalPipeline,
):
self.short_term = short_term
self.long_term = long_term
self.retrieval = retrieval_pipeline
self.working_memory: WorkingMemory | None = None
def start_session(self, session_id: str, user_query: str):
"""会话开始时的记忆初始化"""
# 检索用户档案和偏好
profile = self.long_term.retrieve(
query="用户档案 偏好设置",
memory_type="semantic",
top_k=5,
)
# 检索相关历史交互
history = self.long_term.retrieve(
query=user_query,
memory_type="episodic",
top_k=3,
)
# 将检索结果注入短期记忆
for mem in profile + history:
injection = Message(
role=MessageRole.MEMORY_INJECTION,
content=mem.content,
importance=Importance.HIGH,
metadata={"memory_id": mem.memory_id, "memory_type": mem.memory_type},
)
self.short_term.add(injection)
def get_context_injection(self, current_query: str) -> str:
"""获取当前查询的记忆注入"""
relevant = self.retrieval.retrieve(current_query, top_k=3)
if not relevant:
return ""
lines = ["<relevant_memories>"]
for mem in relevant:
lines.append(
f"<memory type=\"{mem.memory_type}\" "
f"importance=\"{mem.importance:.2f}\">"
f"{mem.content}"
f"</memory>"
)
lines.append("</relevant_memories>")
return "\n".join(lines)
def remember(
self,
content: str,
memory_type: str = "semantic",
importance: float = 0.5,
**kwargs,
) -> str:
"""存储一条长期记忆"""
return self.long_term.store(
content=content,
memory_type=memory_type,
importance=importance,
**kwargs,
)
def end_session(self, generate_summary: bool = True):
"""会话结束时的记忆固化"""
if generate_summary:
# 从短期记忆中提取关键信息，固化为情景记忆
self._consolidate_session()
# 清理工作记忆
self.working_memory = None
def _consolidate_session(self):
"""
记忆固化：将会话中的关键信息写入长期记忆。
固化的内容：
- 关键决策和结论
- 用户表达的新偏好
- 重要的用户信息
"""
high_importance = [
msg for msg in self.short_term.messages
if msg.importance in (Importance.CRITICAL, Importance.HIGH)
]
for msg in high_importance:
self.long_term.store(
content=msg.content,
memory_type="episodic",
importance=msg.importance.value / 5.0,
)9. 前沿探索：认知架构中的记忆
9.1 MemGPT：虚拟上下文管理
MemGPT（Packer et al., 2023）将操作系统的虚拟内存概念引入 LLM 上下文管理：
scss
传统方式：固定的上下文窗口，超出的信息被截断
MemGPT 方式：
┌─────────────────────────────────┐
│ 主上下文 (Main Context) │ ← 类似 RAM
│ 当前对话 + 关键信息 │
├─────────────────────────────────┤
│ 外部上下文 (External Context) │ ← 类似磁盘
│ 完整对话历史 + 长期记忆 │
└─────────────────────────────────┘
通过函数调用实现上下文的分页：
- read(page) → 从外部上下文加载一页到主上下文
- write(page) → 将主上下文的一页写回外部上下文9.2 Reflexion：从错误中学习
Reflexion（Shinn et al., 2023）让 Agent 通过"自我反思"积累经验记忆：
python
# Reflexion 的核心循环
class ReflexiveAgent:
def execute_and_reflect(self, task: str) -> str:
# 1. 尝试执行任务
result = self.actor.run(task)
# 2. 自我评估
evaluation = self.evaluator.evaluate(result)
if evaluation["success"]:
# 存储成功经验
self.memory.store(
f"成功完成任务：{task}\n策略：{evaluation['strategy']}",
memory_type="procedural",
importance=0.6,
)
else:
# 存储失败反思
self.memory.store(
f"任务失败：{task}\n原因：{evaluation['reason']}\n改进：{evaluation['suggestion']}",
memory_type="procedural",
importance=0.8, # 失败的教训更重要
)
# 用反思结果指导重试
result = self.actor.run(f"{task}\n注意：{evaluation['suggestion']}")
return result9.3 生成式记忆（Generative Memory）
Google DeepMind 在 2024 年提出的生成式记忆概念：记忆不仅仅是检索过去的数据，而是能够综合 过往经验，生成新的见解：
"你的用户在过去 10 次对话中，有 7 次在周五下午请求生成周报。你可能可以在每周四晚上提前准备一份草稿。"
这需要记忆系统从"检索"升级到"推理"------不仅记得"发生过什么"，还能推断"这意味着什么"。
10. 参考资料
核心论文
-
MemGPT: Towards LLMs as Operating Systems
- Packer et al., UC Berkeley, 2023
- 提出将 LLM 上下文视为虚拟内存的创新方案
- arXiv: 2310.08560
-
Generative Agents: Interactive Simulacra of Human Behavior
- Park et al., Stanford, 2023
- 开创性地探索了 Agent 的记忆流、检索与反思机制
- arXiv: 2304.03442
-
Reflexion: Language Agents with Verbal Reinforcement Learning
- Shinn et al., 2023
- 提出通过语言反思实现 Agent 的自我改进
- arXiv: 2303.11366
-
HippoRAG: Neurobiologically Inspired Long-Term Memory for LLMs
- Gutiérrez et al., 2024
- 借鉴人脑海马体的记忆机制，设计 LLM 长期记忆方案
- arXiv: 2405.14831
-
Augmented Language Models: A Survey
- Mialon et al., Meta AI, 2023
- 全面综述了增强语言模型中的记忆与推理
- arXiv: 2302.07842
工程参考
-
LangChain - Memory Module
- 开源框架中记忆管理的完整实现
- python.langchain.com/docs/concep...
-
LlamaIndex - Chat Engine with Memory
- 包含 ConversationMemory、VectorMemory 等多种实现
- docs.llamaindex.ai
-
Letta (MemGPT)
- MemGPT 的开源实现和维护版本
- github.com/letta-ai/le...
-
CrewAI - Memory System
- 多 Agent 框架中的记忆共享与隔离机制
- docs.crewai.com
推荐阅读路径
- 入门：先读 Generative Agents，理解 Agent 记忆的基本范式
- 深入：读 MemGPT + HippoRAG，理解记忆的架构创新
- 实践：研究 LangChain/LlamaIndex 的 Memory 模块源码
- 前沿：关注 Reflexion 等自我改进机制，以及多 Agent 记忆协同
记忆系统是 Agent 从"工具"走向"伙伴"的关键。设计良好的记忆系统，能让 Agent 真正理解用户、积累经验、持续成长。这仍然是一个蓬勃发展的研究领域，值得持续关注和探索。