从"金鱼脑"到"长期记忆"：AI Agent 记忆机制的设计与实现

米小虾2026-04-16 10:39

引言

在与 AI Agent 交互的过程中，你是否遇到过这样的困扰：

  • 聊了一半重启服务，Agent 就"失忆"了
  • 跨会话无法保持上下文连贯性
  • 重要信息无法沉淀，每次都要重复交代

这些问题的根源在于 AI Agent 的记忆机制。本文将深入探讨 Agent 记忆系统的设计原理、主流方案对比，以及如何在实际项目中实现一个高效的长期记忆系统。

一、为什么 Agent 需要记忆？

1.1 大模型的"金鱼脑"特性

当前主流的大语言模型（LLM）本质上是无状态的。每次 API 调用都是独立的，模型不会自动保留之前的对话历史。虽然可以通过传入历史消息来模拟"记忆"，但这受限于：

  • 上下文窗口限制：即使是 128K 的上下文，也无法承载长期交互
  • 成本问题：token 越多，调用成本越高
  • 噪声累积：过长的上下文会稀释关键信息

1.2 Agent 对记忆的特殊需求

相比简单的 ChatBot，AI Agent 对记忆有更高的要求：

记忆类型 描述 示例
短期记忆 当前会话的上下文 用户刚才的指令
工作记忆 任务执行中的临时状态 当前步骤的变量
长期记忆 跨会话持久化的知识 用户偏好、历史决策
语义记忆 可检索的知识库 文档、代码库

二、记忆系统的核心设计

2.1 记忆的分层架构

一个完整的 Agent 记忆系统通常采用分层设计：

scss 复制代码 
┌─────────────────────────────────────────┐
│           应用层 (Application)           │
│  - 用户画像、偏好设置、任务历史            │
├─────────────────────────────────────────┤
│           语义层 (Semantic)              │
│  - 向量数据库、知识图谱、文档检索          │
├─────────────────────────────────────────┤
│            episodic 层 (事件记忆)         │
│  - 交互历史、决策记录、执行日志            │
├─────────────────────────────────────────┤
│           缓冲层 (Buffer)                │
│  - 当前会话上下文、工作变量               │
└─────────────────────────────────────────┘

2.2 记忆的存储与检索

向量存储方案

python 复制代码 
# 使用向量数据库存储语义记忆
from langchain.vectorstores import Chroma
from langchain.embeddings import OpenAIEmbeddings

# 初始化向量存储
vectorstore = Chroma(
    collection_name="agent_memory",
    embedding_function=OpenAIEmbeddings(),
    persist_directory="./memory_db"
)

# 存储记忆
def store_memory(text: str, metadata: dict):
    vectorstore.add_texts([text], metadatas=[metadata])

# 检索相关记忆
def retrieve_memory(query: str, k: int = 5):
    return vectorstore.similarity_search(query, k=k)

结构化存储方案

对于需要精确查询的记忆，关系型数据库或图数据库更合适：

python 复制代码 
# 使用 SQLite 存储结构化记忆
import sqlite3
from datetime import datetime

class MemoryStore:
    def __init__(self, db_path: str):
        self.conn = sqlite3.connect(db_path)
        self._init_tables()
    
    def _init_tables(self):
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS memories (
                id INTEGER PRIMARY KEY,
                session_id TEXT,
                memory_type TEXT,
                content TEXT,
                importance_score REAL,
                created_at TIMESTAMP,
                last_accessed TIMESTAMP
            )
        """)
    
    def add_memory(self, session_id: str, memory_type: str, 
                   content: str, importance: float = 1.0):
        self.conn.execute("""
            INSERT INTO memories 
            (session_id, memory_type, content, importance_score, created_at)
            VALUES (?, ?, ?, ?, ?)
        """, (session_id, memory_type, content, importance, datetime.now()))
        self.conn.commit()

三、主流 Agent 框架的记忆实现

3.1 OpenClaw 的记忆设计

OpenClaw 采用了简洁而有效的记忆方案：

核心文件：

  • SOUL.md - Agent 的人格和核心设定
  • MEMORY.md - 长期记忆的 curated 存储
  • memory/YYYY-MM-DD.md - 每日的原始交互记录

特点：

  • 文件即存储，便于版本控制和人工编辑
  • 分层记忆：人格层、长期层、短期层
  • 支持记忆检索和自动摘要

3.2 LangChain 的记忆组件

LangChain 提供了丰富的记忆抽象：

python 复制代码 
from langchain.memory import (
    ConversationBufferMemory,
    ConversationBufferWindowMemory,
    VectorStoreRetrieverMemory
)

# 缓冲记忆 - 保存完整历史
buffer_memory = ConversationBufferMemory()

# 窗口记忆 - 只保留最近 k 轮
window_memory = ConversationBufferWindowMemory(k=5)

# 向量检索记忆 - 基于语义相似度检索
retriever_memory = VectorStoreRetrieverMemory(
    retriever=vectorstore.as_retriever()
)

3.3 MemGPT 的虚拟上下文管理

MemGPT 提出了创新的"虚拟上下文"概念：

  • 主上下文（Main Context）：LLM 的直接输入窗口
  • 外部上下文（External Context）：存储在数据库中的历史
  • 智能分页：自动决定哪些信息保留在主上下文，哪些归档
python 复制代码 
# MemGPT 风格的记忆管理
class MemGPTStyleMemory:
    def __init__(self, context_limit: int = 8000):
        self.context_limit = context_limit
        self.working_memory = []  # 主上下文
        self.archival_memory = []  # 归档存储
    
    def add_to_memory(self, message: str):
        # 检查是否超出上下文限制
        current_tokens = self._count_tokens(self.working_memory)
        new_tokens = self._count_tokens([message])
        
        if current_tokens + new_tokens > self.context_limit:
            # 将最旧的消息归档
            self._archive_oldest()
        
        self.working_memory.append(message)
    
    def _archive_oldest(self):
        # 将工作记忆中最旧的消息移到归档
        if self.working_memory:
            oldest = self.working_memory.pop(0)
            self.archival_memory.append(oldest)

四、记忆系统的进阶优化

4.1 记忆的重要性评分

不是所有记忆都同等重要，可以引入评分机制：

python 复制代码 
def calculate_importance(memory: str) -> float:
    """
    基于多种因素计算记忆重要性：
    1. 关键词权重（包含"重要"、"记住"等词汇加分）
    2. 情感强度（使用情感分析模型）
    3. 信息熵（内容的信息量）
    4. 用户显式标记
    """
    score = 0.0
    
    # 关键词检测
    important_keywords = ['重要', '关键', '记住', '务必', '永远']
    for keyword in important_keywords:
        if keyword in memory:
            score += 0.3
    
    # 信息长度（适中长度的记忆更有价值）
    length_score = 1.0 - abs(len(memory) - 100) / 500
    score += max(0, length_score * 0.2)
    
    return min(score, 1.0)

4.2 记忆的遗忘与压缩

人类会遗忘不重要的信息，Agent 也应该如此：

python 复制代码 
import time

class ForgettableMemory:
    def __init__(self):
        self.memories = []
    
    def add_memory(self, content: str, importance: float):
        self.memories.append({
            'content': content,
            'importance': importance,
            'created_at': time.time(),
            'access_count': 0
        })
    
    def decay_memories(self):
        """应用遗忘曲线"""
        current_time = time.time()
        for memory in self.memories:
            age_hours = (current_time - memory['created_at']) / 3600
            # 艾宾浩斯遗忘曲线简化版
            retention = memory['importance'] * (0.9 ** age_hours)
            
            if retention < 0.1:
                self.memories.remove(memory)
    
    def compress_memories(self, memories: list) -> str:
        """将多条记忆压缩为摘要"""
        # 使用 LLM 进行摘要
        combined = "\n".join([m['content'] for m in memories])
        prompt = f"请将以下内容摘要为一段话：\n{combined}"
        return self.llm_summarize(prompt)

4.3 多模态记忆

Agent 的记忆不应局限于文本：

python 复制代码 
class MultimodalMemory:
    def __init__(self):
        self.text_memories = []
        self.image_memories = []
        self.audio_memories = []
    
    def add_image_memory(self, image_path: str, description: str):
        """存储图像及其描述"""
        embedding = self.encode_image(image_path)
        self.image_memories.append({
            'path': image_path,
            'description': description,
            'embedding': embedding
        })
    
    def retrieve_relevant_images(self, query: str):
        """检索与查询相关的图像"""
        query_embedding = self.encode_text(query)
        # 基于向量相似度检索
        return self.vector_search(self.image_memories, query_embedding)

五、实战：构建一个带记忆的 Agent

5.1 完整实现示例

python 复制代码 
from typing import List, Dict, Optional
import json
from datetime import datetime

class MemoryEnhancedAgent:
    def __init__(self, llm_client, vector_store):
        self.llm = llm_client
        self.vector_store = vector_store
        self.session_memories: Dict[str, List[dict]] = {}
        self.user_profiles: Dict[str, dict] = {}
    
    def chat(self, user_id: str, message: str) -> str:
        # 1. 检索相关记忆
        relevant_memories = self._retrieve_memories(user_id, message)
        
        # 2. 构建增强的上下文
        context = self._build_context(user_id, relevant_memories)
        
        # 3. 调用 LLM
        response = self.llm.complete(
            messages=context + [{"role": "user", "content": message}]
        )
        
        # 4. 存储新的交互
        self._store_interaction(user_id, message, response)
        
        return response
    
    def _retrieve_memories(self, user_id: str, query: str) -> List[str]:
        """检索与用户和查询相关的记忆"""
        # 语义检索
        semantic_results = self.vector_store.similarity_search(
            query, 
            filter={"user_id": user_id},
            k=5
        )
        
        # 获取最近的交互
        recent_memories = self.session_memories.get(user_id, [])[-3:]
        
        return semantic_results + [m['content'] for m in recent_memories]
    
    def _build_context(self, user_id: str, memories: List[str]) -> List[dict]:
        """构建系统上下文"""
        user_profile = self.user_profiles.get(user_id, {})
        
        system_prompt = f"""你是一个智能助手。以下是关于用户的信息：
        
用户偏好：{json.dumps(user_profile, ensure_ascii=False)}

相关历史记忆：
{chr(10).join(f"- {m}" for m in memories)}

请基于以上信息回答用户问题。"""
        
        return [{"role": "system", "content": system_prompt}]
    
    def _store_interaction(self, user_id: str, user_msg: str, assistant_msg: str):
        """存储交互到记忆系统"""
        memory_entry = {
            'user_id': user_id,
            'user_message': user_msg,
            'assistant_message': assistant_msg,
            'timestamp': datetime.now().isoformat()
        }
        
        # 更新会话记忆
        if user_id not in self.session_memories:
            self.session_memories[user_id] = []
        self.session_memories[user_id].append(memory_entry)
        
        # 存储到向量数据库
        combined_text = f"用户：{user_msg}\n助手：{assistant_msg}"
        self.vector_store.add_texts(
            [combined_text],
            metadatas=[{"user_id": user_id, "timestamp": memory_entry['timestamp']}]
        )

# 使用示例
agent = MemoryEnhancedAgent(llm_client=my_llm, vector_store=my_vectorstore)

# 第一次对话
response1 = agent.chat("user_001", "我喜欢用 Python 写代码")

# 重启服务后再次对话 - Agent 仍然记得用户偏好
response2 = agent.chat("user_001", "给我推荐一个编程项目")
# Agent 会基于之前的记忆，推荐 Python 相关的项目

5.2 性能优化建议

  1. 异步存储：记忆写入不应阻塞主流程

    python 复制代码 
    import asyncio

async def async_store_memory(self, memory):
    asyncio.create_task(self._persist_memory(memory))

  2. 记忆缓存：热点记忆缓存到内存

    python 复制代码 
    from functools import lru_cache

@lru_cache(maxsize=1000)
def get_user_profile(self, user_id: str):
    return self.db.query(UserProfile).filter_by(user_id=user_id).first()

  3. 批量处理：向量存储的批量写入

    python 复制代码 
    def batch_store_memories(self, memories: List[dict]):
    texts = [m['content'] for m in memories]
    metadatas = [m['metadata'] for m in memories]
    self.vector_store.add_texts(texts, metadatas=metadatas)

六、未来展望

6.1 记忆技术的演进方向

  1. 端到端学习：让模型自己学习何时记忆、何时遗忘
  2. 神经符号结合：结合神经网络和符号推理的记忆系统
  3. 联邦记忆：跨设备、跨应用的分布式记忆共享
  4. 隐私保护记忆：差分隐私、同态加密在记忆系统中的应用

6.2 值得关注的开源项目

  • MemGPT：虚拟上下文管理的先驱
  • LangChain Memory：丰富的记忆抽象和实现
  • OpenClaw：文件化记忆管理的实践
  • AutoGPT：早期探索长期记忆的 Agent 框架

结语

记忆是智能的基石。一个优秀的 AI Agent 不仅需要强大的推理能力，更需要完善的记忆系统来支撑持续学习和个性化服务。

从简单的对话历史缓存，到复杂的分层记忆架构，记忆系统的设计需要在成本、延迟、准确性之间找到平衡。希望本文能为你在构建 Agent 记忆系统时提供有价值的参考。

参考链接：

本文首发于稀土掘金，转载请注明出处。

相关推荐
AI视觉网奇2 小时前
探索 InternVL3.5：从权重解析到多模态推理的全栈实践笔记
人工智能·大模型
xixixi777772 小时前
智算中心建设新范式：GPT-6/Rubin架构+1.6T光模块+量子安全网关+AI安全沙箱，算力·效率·安全·成本的最优平衡
人工智能·gpt·安全·机器学习·架构·大模型·通信
云烟成雨TD2 小时前
Spring AI Alibaba 1.x 系列【14】ReactAgent 工具执行异常处理
java·人工智能·spring
耿雨飞2 小时前
第五章：工具系统与函数调用 —— 从定义到执行的完整链路
人工智能·langchain
fzxwl2 小时前
集成MidScene的AI测试管理平台
人工智能
涵星同学2 小时前
从深度学习到大模型的跃迁：Transformer的核心突破
人工智能·深度学习·transformer
Magic-Yuan2 小时前
如何提高AI落地的成功率 - 成功率函数
大数据·人工智能
Zldaisy3d2 小时前
数字孪生与AI的共生将如何影响职业发展和企业竞争力
人工智能
ShiMetaPi2 小时前
NeurIPS 2024 | 丝滑视觉新极限：EPA 框架利用事件相机突破插帧伪影瓶颈
人工智能·嵌入式硬件·计算机视觉·自动驾驶·事件相机·evs
热门推荐
012026年4月技术前沿：AI大模型爆发、智能体革命与量子安全新纪元02GitHub 镜像站点03一周AI热点速览（2026.03.31-04.06）：GPT-6曝光、谷歌开源Gemma 4、资本狂飙与模型军备竞赛04GPT-6核心能力解析及与现有主流大模型对比05基于 Docker 部署 Hermes Agent 并接入飞书机器人的完整指南06GPT-6发布日深度解析-Symphony架构200万Token实战07零成本！Ollama本地部署国产大模型全指南（支持Kimi-K2.5/GLM-5/Qwen，新手秒上手）08AI Weekly | 2026年4月第二周 · GitHub热门项目与AI发展趋势深度解析09从限购到畅通：GLM-5.1 Coding Plan接入攻略10CodeBuddy与WorkBuddy深度对比：腾讯两款AI工具差异及实操指南