Agent记忆系统：让AI不再失忆

一句话理解

Agent记忆系统 = AI的"海马体"。让Agent能够记住之前的对话、学习新知识、积累经验，而不是每次都从零开始。2026年，记忆系统已成为Agent从"工具"进化为"助手"的关键技术。

---

目录

1. 什么是Agent记忆系统
2. 记忆的分类
3. 记忆架构设计
4. 核心技术实现
5. 2026年最新进展
6. 实战代码
7. 常见问题
8. 延伸阅读
9. 读者互动

---

1. 什么是Agent记忆系统

1.1 问题背景

传统LLM的局限性：

LLM的"金鱼记忆"问题

• 对话1: “我叫张三”
• 对话2: “我叫李四”
• 对话3: “你叫什么名字？” → “我叫李四” ❌

LLM无法跨对话记住信息

原因：LLM的训练数据不含对话历史

1.2 记忆系统的定义

Agent记忆系统 是让Agent具备：

• 持久化存储能力
• 选择性检索能力
• 经验积累能力
• 知识更新能力

的完整解决方案。

1.3 为什么需要记忆系统

维度	无记忆Agent	有记忆Agent
上下文感知	每次都需重新介绍	自动记住偏好
学习能力	无法学习新知识	持续积累经验
个性化	通用回答	定制化服务
效率	重复信息处理	利用已有知识
实用性	玩具级别	可用级别

---

2. 记忆的分类

2.1 三大记忆类型

Agent记忆架构：

记忆类型	说明	特点
感觉记忆 (Sensory Memory)	当前输入、实时感知	信息入口，过滤无关内容
工作记忆 (Working Memory)	当前对话、活跃信息、正在处理的任务	受限于上下文窗口
长期记忆 (Long-Term Memory)	历史对话、经验知识、用户偏好	持久化存储，跨会话

2.2 记忆类型详解

（1）感觉记忆

特性	说明
定义	原始感知输入（视觉、听觉、文本）
持续时间	毫秒~秒
容量	大
作用	信息入口，过滤无关内容
实现	当前输入、传感器数据

（2）工作记忆

特性	说明
定义	当前任务相关信息
持续时间	当前会话
容量	受限于上下文窗口
作用	任务处理、推理
实现	对话历史、上下文

# 工作记忆示例
working_memory = {
    "current_task": "帮用户写一封邮件",
    "task_history": [
        {"role": "user", "content": "帮我写邮件给老板请假"},
        {"role": "assistant", "content": "好的，请问您想请什么假？"},
        {"role": "user", "content": "明天发烧想请一天假"}
    ],
    "active_entities": {
        "recipient": "老板",
        "reason": "发烧",
        "duration": "1天",
        "date": "明天"
    }
}

（3）长期记忆

特性	说明
定义	持久化存储的知识和经验
持续时间	永久/跨会话
容量	无限
作用	知识积累、经验复用
实现	向量数据库、图数据库、文件

2.3 记忆的流转

记忆流转生命周期：

阶段	流转	触发条件
感觉记忆	→ 工作记忆	实时感知
工作记忆	→ 长期记忆	上下文窗口满 / 重要信息
长期记忆	→ 工作记忆	检索/回忆

关键决策点：

1. 什么信息进入工作记忆？
2. 什么信息从工作记忆写入长期记忆？
3. 什么时候从长期记忆检索信息？

---

3. 记忆架构设计

3.1 经典架构：MemGPT

MemGPT（Memory GPT）是最具代表性的Agent记忆系统：

层级	组件	说明
LLM层	大语言模型	核心推理引擎
	控制循环	1.检查上下文窗口 2.触发内存管理 3.保留/检索/总结/遗忘
↓ ↑
外部存储层	对话存档(RAG索引)	历史对话存储
	知识库(向量库)	向量化知识
	摘要存储(总结)	压缩记忆

3.2 五大记忆范式对比

范式	原理	优点	缺点	代表
上下文窗口	所有信息塞进context	简单、无额外成本	受窗口限制	GPT-4
RAG检索	检索相关记忆	可处理无限记忆	检索质量影响大	RAG Memory
文件系统	读写文件存储	简单可靠	检索慢	OS-level
数据库	结构化存储	查询灵活	复杂度高	SQL Memory
图谱	知识图谱存储	关系推理强	构建成本高	KG Memory

3.3 混合记忆架构

层级	组件	说明
Agent核心	-	Agent核心处理单元
↓ ↑
记忆管理层	写入策略	什么时候存？存什么？
	检索策略	什么时候读？读什么？
	遗忘策略	什么时候删？删什么？
↓ ↑
存储层	向量数据库	语义记忆（语义相似检索）
	图数据库	关系记忆（实体关系）
	缓存	工作记忆（快速访问）

---

4. 核心技术实现

4.1 记忆写入策略

什么时候存？

策略	触发条件	实现
阈值触发	重要性评分 > 阈值	importance_score > 0.8
定期存档	每N轮对话后	session.turns % N == 0
显式请求	用户/Agent要求记住	user_says(“记住…”)
事件触发	特定事件发生	event == “task_completed”

# 记忆写入决策
class MemoryWriter:
    def should_remember(self, content: str, context: dict) -> bool:
        """判断是否应该记住"""
        
        # 1. 重要性评估
        importance = self.evaluate_importance(content, context)
        if importance > 0.8:
            return True
        
        # 2. 新颖性检查
        novelty = self.check_novelty(content)
        if novelty > 0.6:
            return True
        
        # 3. 重复检查
        is_duplicate = self.check_duplicate(content)
        if is_duplicate:
            return False
        
        # 4. 用户偏好
        if context.get("user_explicit_request"):
            return True
        
        return False
    
    def evaluate_importance(self, content: str, context: dict) -> float:
        """评估内容重要性"""
        score = 0.5  # 基础分
        
        # 用户明确提到
        if context.get("is_user_statement"):
            score += 0.2
        
        # 涉及实体（人名、地点、日期）
        if self.extract_entities(content):
            score += 0.1
        
        # 任务关键信息
        if context.get("task_critical"):
            score += 0.2
        
        # 时效性信息
        if context.get("is_time_sensitive"):
            score += 0.1
        
        return min(score, 1.0)

4.2 记忆检索策略

什么时候读？读什么？

# 记忆检索
class MemoryRetriever:
    def retrieve(self, query: str, context: dict, limit: int = 5):
        """检索相关记忆"""
        
        # 1. 生成查询向量
        query_vector = self.embed(query)
        
        # 2. 多路召回
        results = {
            "semantic": self.vector_search(query_vector, limit=limit),
            "keyword": self.keyword_search(query, limit=limit),
            "recent": self.get_recent_memories(limit=3),
            "contextual": self.get_contextual_memories(context)
        }
        
        # 3. 融合排序
        fused_results = self.rerank(results, query, context)
        
        # 4. 后处理
        deduplicated = self.deduplicate(fused_results)
        
        return deduplicated[:limit]
    
    def vector_search(self, query_vector, limit):
        """向量相似度搜索"""
        return milvus.search(
            collection_name="memory",
            query_vector=query_vector,
            limit=limit,
            metric_type="COSINE"
        )
    
    def keyword_search(self, query, limit):
        """关键词搜索"""
        return pgvector.search(
            query=query,
            limit=limit,
            match_type="bm25"
        )
    
    def rerank(self, results, query, context):
        """多路结果融合"""
        # RRF (Reciprocal Rank Fusion)
        fusion_scores = {}
        
        for source, items in results.items():
            for i, item in enumerate(items):
                item_id = item["id"]
                rank = i + 1
                weight = self.get_source_weight(source)
                score = weight / (60 + rank)
                fusion_scores[item_id] = fusion_scores.get(item_id, 0) + score
        
        sorted_ids = sorted(fusion_scores, key=fusion_scores.get, reverse=True)
        return [self.get_memory_by_id(id) for id in sorted_ids]

4.3 记忆遗忘策略

什么时候删？删什么？

策略	说明
1. 基于时间	最近最少使用 (LRU)：超过一定时间未访问 → 标记为"冷"
2. 基于重要性	低重要性 + 低访问频率 → 可删除；高重要性 → 永久保留
3. 基于容量	存储容量达到上限 → 触发淘汰；优先级：近期 > 重要 > 一般

---

5. 2026年最新进展

5.1 Hindsight：生物启发记忆

Hindsight 是2026年提出的新一代记忆架构：

特性	说明
灵感来源	人类记忆系统
核心思想	事件驱动 + 情感标记
三阶段处理	编码 → 巩固 → 检索

Hindsight记忆处理流程：

阶段	处理内容	说明
阶段1：编码	感知输入 → 事件片段	将输入转换为可存储的事件
	情感标记（正面/负面/中性）	情感关联
	关联链接（新记忆与旧记忆）	建立记忆网络
↓
阶段2：巩固	短期 → 长期的转换	信息整合
	睡眠期间的信息整合	记忆巩固
	重要性重评估	动态调整
↓
阶段3：检索	线索驱动检索	按线索回忆
	情感状态调节检索	情感辅助记忆
	情境相似度匹配	情境关联

5.2 A-MEM：主动记忆系统

A-MEM（Active Memory）提出五大范式：

范式	特点	适用场景
上下文窗口	直接塞入context	短期任务
RAG-based	向量检索增强	知识问答
文件系统	读写本地文件	持久化需求
数据库	结构化存储	企业应用
多模态	支持图片/音视频	复杂感知

5.3 Agentic RAG Memory

2026年，RAG进化为Agent的记忆层：

# Agentic RAG Memory架构
class AgenticRAGMemory:
    """Agent记忆的RAG增强"""
    
    def __init__(self):
        # 向量记忆库
        self.vector_memory = MilvusCollection("agent_memory")
        
        # 图记忆库（关系）
        self.graph_memory = Neo4jGraph("agent_relations")
        
        # 缓存（快速访问）
        self.cache = RedisCache()
    
    def remember(self, experience):
        """记忆存储"""
        # 1. 向量化存储
        vector = embed(experience.content)
        self.vector_memory.insert(vector, experience)
        
        # 2. 关系存储（图数据库）
        for entity in extract_entities(experience):
            self.graph_memory.add_entity(entity)
        for relation in extract_relations(experience):
            self.graph_memory.add_relation(relation)
        
        # 3. 缓存更新
        self.cache.set(experience.key, experience)
    
    def recall(self, query):
        """记忆检索"""
        # 1. 缓存优先
        cached = self.cache.get(query)
        if cached:
            return cached
        
        # 2. 混合检索
        vector_results = self.vector_memory.search(query, top_k=5)
        graph_results = self.graph_memory.traverse(query)
        
        # 3. 结果融合
        return self.fuse_results(vector_results, graph_results)

---

6. 实战代码

6.1 基础记忆Agent实现

# 简单的Agent记忆系统
import json
from datetime import datetime
from typing import List, Dict

class SimpleAgentMemory:
    """轻量级Agent记忆系统"""
    
    def __init__(self):
        self.short_term = []  # 工作记忆
        self.long_term = []   # 长期记忆
        self.max_short_term = 10  # 工作记忆上限
    
    def add_interaction(self, role: str, content: str):
        """添加对话"""
        memory = {
            "role": role,
            "content": content,
            "timestamp": datetime.now().isoformat()
        }
        self.short_term.append(memory)
        
        # 如果工作记忆满了，转移到长期记忆
        if len(self.short_term) > self.max_short_term:
            self._archive_to_long_term()
    
    def _archive_to_long_term(self):
        """归档到长期记忆"""
        if self.short_term:
            # 简单策略：保留摘要
            summary = self._summarize(self.short_term)
            self.long_term.append({
                "type": "session_archive",
                "summary": summary,
                "timestamp": datetime.now().isoformat()
            })
            self.short_term = []
    
    def _summarize(self, memories: List[Dict]) -> str:
        """生成摘要"""
        # 简化版：提取关键信息
        return f"对话记录，共{len(memories)}轮"
    
    def get_context(self) -> str:
        """获取当前上下文"""
        context_parts = []
        
        # 添加长期记忆
        if self.long_term:
            context_parts.append("【历史摘要】")
            for mem in self.long_term[-3:]:
                context_parts.append(mem.get("summary", ""))
        
        # 添加近期对话
        if self.short_term:
            context_parts.append("【当前对话】")
            for mem in self.short_term[-5:]:
                context_parts.append(f"{mem['role']}: {mem['content']}")
        
        return "\n".join(context_parts)

6.2 RAG增强记忆实现

# RAG增强的Agent记忆
from sentence_transformers import SentenceTransformer
import numpy as np

class RAGMemory:
    """基于RAG的Agent记忆系统"""
    
    def __init__(self, embedding_model: str = "all-MiniLM-L6-v2"):
        self.model = SentenceTransformer(embedding_model)
        self.memories = []  # List of (vector, memory_dict)
    
    def add(self, content: str, metadata: dict = None):
        """添加记忆"""
        vector = self.model.encode(content)
        memory = {
            "content": content,
            "metadata": metadata or {},
            "importance": self._assess_importance(content)
        }
        self.memories.append((vector, memory))
    
    def _assess_importance(self, content: str) -> float:
        """评估重要性"""
        # 简化版：基于关键词
        important_keywords = ["记住", "重要", "偏好", "计划"]
        return 1.0 if any(kw in content for kw in important_keywords) else 0.5
    
    def retrieve(self, query: str, top_k: int = 5) -> List[dict]:
        """检索相关记忆"""
        query_vector = self.model.encode(query)
        
        # 计算相似度
        scores = []
        for vec, mem in self.memories:
            sim = np.dot(query_vector, vec) / (np.linalg.norm(query_vector) * np.linalg.norm(vec))
            scores.append((sim, mem))
        
        # 排序返回
        scores.sort(key=lambda x: x[0], reverse=True)
        return [mem for _, mem in scores[:top_k]]
    
    def build_prompt(self, query: str) -> str:
        """构建带记忆的prompt"""
        relevant = self.retrieve(query)
        
        if not relevant:
            return ""
        
        memory_text = "【相关记忆】\n"
        for mem in relevant:
            memory_text += f"- {mem['content']}\n"
        
        return memory_text

6.3 完整的记忆Agent

# 完整记忆Agent示例
from openai import OpenAI

class MemoryAgent:
    """带记忆系统的Agent"""
    
    def __init__(self, model: str = "gpt-4"):
        self.client = OpenAI()
        self.memory = RAGMemory()
        self.conversation_history = []
    
    def chat(self, user_input: str) -> str:
        """对话"""
        # 1. 检索相关记忆
        memory_context = self.memory.build_prompt(user_input)
        
        # 2. 构建消息
        messages = [
            {"role": "system", "content": "你是一个有帮助的AI助手。"}
        ]
        
        # 3. 添加记忆上下文
        if memory_context:
            messages.append({
                "role": "system",
                "content": f"参考以下记忆信息来回答：\n{memory_context}"
            })
        
        # 4. 添加对话历史
        messages.extend(self.conversation_history[-10:])
        
        # 5. 添加当前输入
        messages.append({"role": "user", "content": user_input})
        
        # 6. 生成回复
        response = self.client.chat.completions.create(
            model=model,
            messages=messages
        )
        
        assistant_reply = response.choices[0].message.content
        
        # 7. 存储对话
        self.conversation_history.append({"role": "user", "content": user_input})
        self.conversation_history.append({"role": "assistant", "content": assistant_reply})
        
        # 8. 判断是否需要记忆
        self._maybe_remember(user_input, assistant_reply)
        
        return assistant_reply
    
    def _maybe_remember(self, user_input: str, assistant_reply: str):
        """决定是否记住"""
        # 检查用户是否明确要求记住
        if "记住" in user_input or "remember" in user_input.lower():
            self.memory.add(user_input, {"type": "explicit_request"})
        
        # 检查是否是重要信息
        important_keywords = ["我叫", "我叫", "我的名字", "我喜欢"]
        for keyword in important_keywords:
            if keyword in user_input:
                self.memory.add(user_input, {"type": "personal_info"})
                break

---

7. 常见问题

Q1：记忆系统和向量数据库有什么区别？

答：向量数据库是记忆系统的存储层之一。

组件	作用	关系
向量数据库	存储和检索向量	记忆系统的子组件
记忆系统	完整的信息管理方案	包含向量库 + 策略 + 管理

Q2：上下文窗口够用吗？还需要外部记忆吗？

答：取决于场景。

场景	推荐
简单问答	上下文窗口足够
长期助手	需要外部记忆
多会话学习	必须外部记忆
个性化服务	必须外部记忆

Q3：如何平衡记忆的"全"和"精"？

答：采用分层记忆策略。

记忆层级	内容	精度	容量	说明
短期记忆	最近N次对话	高精度	上下文窗口限制	当前会话活跃信息
中期记忆	本周重要信息	中等精度	向量库限制	跨会话重要信息
长期记忆	用户偏好、关键事实	高价值	可按需扩展	持久化核心信息

---

8. 延伸阅读

相关词汇	关联度	推荐理由
W03 RAG	⭐⭐⭐⭐	RAG是记忆系统的检索基础
W27 向量数据库	⭐⭐⭐⭐	记忆系统的重要存储层
W04 Agent	⭐⭐⭐	Agent是记忆系统的载体
W12 嵌入	⭐⭐⭐	向量化是记忆检索的基础

---

🤔 批判性思考

1. 记忆系统是否侵犯隐私？

• 存储用户的对话和个人信息，安全如何保证？
• 用户是否有权删除自己的记忆？

2. 记忆的"真实性"问题

• Agent记忆的信息是否准确？
• 如何处理记忆冲突？

3. 成本问题

• 向量数据库等外部存储的成本
• 检索和管理的计算成本

4. 技术过度复杂

• 真的需要这么复杂的记忆系统吗？
• 简单方案是否足够？

---

本文收录于「AI词汇专栏」，作者：孤岛站岗

本文参考资料（2026年4月）：

• 《Agent Memory全景》AI Insight 2026.3
• 《AI Agent记忆系统全解析》heyuan110.com 2026.2
• 《Hindsight生物启发记忆系统》技术报告 2026.3
• 《RAG技术最新进展》SegmentFault 2026.2