从金鱼大脑到过目不忘：深入解析 AI Agent 的记忆系统与工程实现

Posted on 2026-05-21 In AI 技术

在当前的大语言模型（LLM）时代，AI Agent（人工智能体）正经历着从“单纯的对话工具”向“自主决策系统”的演变。然而，许多开发者在构建 Agent 时会遇到一个致命的瓶颈：缺乏有效的记忆机制。

想象一下，如果你和一个朋友聊天，他每隔五分钟就会患上“失忆症”，忘记刚才讨论过的一切，你一定会觉得这无法忍受。原生的大语言模型正是如此——它们是无状态的。每一次 API 调用，都是一次全新的开始。

为了让 Agent 具备真正的连贯性、个性化以及学习能力，我们必须为它注入“灵魂”——即记忆系统。借鉴认知心理学和计算机科学的双重概念，一个成熟的 AI Agent 通常需要三种记忆：短期记忆、长期记忆和工作记忆。

本文将深入剖析这三种记忆的底层原理、应用场景，并给出可落地的工程架构与代码实现。

一、核心概念解析：Agent 的三层记忆架构

在人类的大脑中，记忆被划分为感觉记忆、短期记忆、工作记忆和长期记忆。在构建 AI Agent 时，我们通常抽象出以下三个核心层级：

1. 短期记忆

认知学映射：人类的海马体临时存储。
技术实现：上下文窗口。
核心特点：容量有限，但速度极快。
作用：维持当前单次对话或任务的连贯性。模型可以直接通过 Attention 机制访问这些 Token。但随着上下文长度的增加，模型的推理成本（计算复杂度呈平方级增长）和“迷路”（Lost in the middle）的概率也会显著增加。

2. 工作记忆

认知学映射：大脑的“黑板”或“草稿本”，用于当前任务的认知加工。
技术实现：系统提示词、状态机、Scratchpad（便签本）或黑板上。
核心特点：高度结构化，随任务动态更新。
作用：如果说短期记忆是“聊天的历史”，那么工作记忆就是 Agent 当前正在执行的计划、工具调用的中间结果以及系统规则。它告诉 Agent：“我是谁，我现在在干嘛，下一步该干什么”。

3. 长期记忆

认知学映射：大脑的新皮层，负责长久的知识存储。
技术实现：向量数据库、知识图谱或传统关系型数据库 (RDBMS)。
核心特点：容量极大，跨越会话持久化，需要显式的检索机制。
作用：赋予 Agent 跨会话的“个性化”和“经验积累”能力。比如记住用户的偏好、过去发生的重大事件，或者历史上执行成功的代码逻辑。

二、短期记忆：上下文的精细化工程

短期记忆的核心挑战在于上下文长度的限制与注意力的稀释。尽管现在 Gemini 1.5 Pro 已经支持 200 万 Token，但在实际工程中，把所有对话历史塞进 Prompt 是极其昂贵且低效的。

工程优化策略：滑动窗口与摘要记忆

为了管理短期记忆，最常用的技术是结合滑动窗口与记忆摘要。

滑动窗口：只保留最近 $K$ 轮对话。
摘要记忆：当对话轮数超过阈值时，触发一个后台 LLM 调用，将早期的对话总结为一段精炼的文本，作为 System Prompt 的一部分。

这种策略确保了 Agent 既能记住刚才的细节，又不会超出 Token 限制。

三、工作记忆：Agent 的任务推进器

在诸如 LangChain 或 AutoGPT 的实现中，工作记忆是决定 Agent 不陷入死循环的关键。

1. 结构化的状态追踪

工作记忆不仅仅是文本，它通常是高度结构化的数据。在一个 ReAct (Reason + Act) 模式的 Agent 中，工作记忆包括：

Thought（思考）：当前步骤的推理过程。
Action（动作）：决定调用的外部工具及参数。
Observation（观察）：工具返回的结果。

2. Scratchpad（便签本）机制

对于复杂的代码编写或多步推理任务，我们会强制 Agent 使用一个虚拟的“便签本”。与其让模型在隐式的思维链中计算，不如要求它将中间状态、变量定义写入工作记忆，并在下一步中读取，从而大幅降低幻觉。

四、长期记忆：Agent 的“终身学习”基石

长期记忆是区分“玩具 Agent”和“生产力 Agent”的分水岭。为了实现长期记忆，业界通常采用 RAG（检索增强生成） 架构。

1. 长期记忆的分类

借鉴认知科学，Agent 的长期记忆也可细分：

情景记忆：“在2023年10月，用户要求我写了一首关于秋天的诗”。存储具体的事件和经历，通常带有时间戳。
语义记忆：“用户喜欢 Python 胜过 Java”、“用户的老板叫张三”。这是高度提炼的事实、概念和偏好。
程序性记忆：“当遇到报错时，先重启服务器再查日志”。这是习得的技能，通常表现为 Agent 动态保存的 Few-shot 示例或工具调用逻辑。

2. 核心机制：记忆的写入与召回

写入：并非所有对话都值得记住。优秀的 Agent 系统会在对话结束时，利用 LLM 评估：“这段对话是否包含值得长期保留的用户偏好或关键事实？”如果是，将其转换为向量并存入数据库。
召回：当新对话开始时，将用户的输入向量化，在数据库中检索 Top-K 最相关的历史记忆，注入到 Prompt 中作为背景上下文。

3. 高阶玩法：记忆反思与遗忘机制

人类会遗忘，这是大脑高效运作的保护机制。Agent 同样需要：

重要性评分：为每条记忆打分（比如 1-10 分）。日常问候（“你好”）得分为 1，关键业务规则（“不要删除数据库”）得分为 10。
时间衰减：随着时间推移，检索时降低老旧且未再被访问的记忆的权重。
反思机制：借鉴斯坦福《Generative Agents》论文，Agent 会定期审视自己的记忆库，将多个具体的情景记忆总结为更高维度的语义记忆（例如：从多次“用户深夜点外卖”得出“用户是夜猫子”的结论）。

五、动手实践：构建一个具备完整记忆系统的 Agent

理论需要落地。下面我们使用 Python，结合目前主流的开源框架（如 LangChain 的设计思想），手搓一个具备三层记忆架构的简易 Agent 系统。

为了代码的直观性，我们这里模拟一个本地的向量数据库存储（在实际生产中，请替换为 Chroma, Pinecone 或 Milvus）。

1. 基础环境与类定义

首先，我们需要定义记忆的管理类。我们将使用 Pydantic 来处理结构化的“工作记忆”。

import json
from typing import List, Dict, Optional
from datetime import datetime
import numpy as np

# 假设我们有一个模拟的 LLM 和 Embedding 模型
class MockLLM:
    def generate(self, prompt: str) -> str:
        if "总结" in prompt:
            return "用户之前询问了AI的记忆机制，并表现出浓厚的兴趣。"
        return f"[LLM Response based on prompt: {prompt[:50]}...]"

class MockEmbedding:
    def embed(self, text: str) -> List[float]:
        # 简单模拟向量化：基于字符串长度的伪随机向量
        np.random.seed(len(text))
        return np.random.rand(128).tolist()

llm = MockLLM()
embedder = MockEmbedding()

2. 实现长期记忆（向量检索与重要性评估）

长期记忆不仅需要存储文本，还需要存储元数据（如时间戳、重要性）。

class LongTermMemory:
    def __init__(self):
        self.vector_store = [] # 存储向量
        self.text_store = []   # 存储原始文本与元数据

    def add_memory(self, text: str, importance: int = 5):
        """写入长期记忆"""
        vector = embedder.embed(text)
        self.vector_store.append(vector)
        self.text_store.append({
            "text": text,
            "importance": importance,
            "timestamp": datetime.now().isoformat(),
            "access_count": 0
        })
        print(f"[长期记忆写入]: {text} (重要性: {importance})")

    def retrieve(self, query: str, top_k: int = 2) -> List[Dict]:
        """检索相关的长期记忆"""
        if not self.text_store:
            return []
            
        query_vec = np.array(embedder.embed(query))
        
        # 计算余弦相似度
        vectors = np.array(self.vector_store)
        similarities = np.dot(vectors, query_vec) / (np.linalg.norm(vectors, axis=1) * np.linalg.norm(query_vec))
        
        # 获取 Top-K 索引
        top_indices = np.argsort(similarities)[-top_k:][::-1]
        
        results = []
        for idx in top_indices:
            memory = self.text_store[idx]
            # 每次检索到，增加其访问计数（体现记忆的强化）
            memory['access_count'] += 1
            results.append(memory)
            
        return results

3. 实现工作记忆（结构化状态）

工作记忆用于追踪当前任务的结构化状态，例如当前的意图、提取的参数等。

from pydantic import BaseModel, Field

class WorkingMemory(BaseModel):
    """Agent的工作记忆，类似于系统的RAM"""
    current_task: str = Field(default="", description="当前正在执行的主要任务")
    user_intent: str = Field(default="", description="分析出的用户意图")
    scratchpad: List[str] = Field(default_factory=list, description="草稿本，记录中间思考过程")
    context: Dict[str, str] = Field(default_factory=dict, description="当前提取的关键实体或状态")

    def update_task(self, task: str):
        self.current_task = task
        print(f"[工作记忆更新] 任务更新为: {task}")

    def add_to_scratchpad(self, thought: str):
        self.scratchpad.append(thought)
        print(f"[工作记忆更新] 草稿记录: {thought}")

    def get_context_str(self) -> str:
        return json.dumps(self.context, ensure_ascii=False)

4. 整合三层记忆的智能体

最后，我们将短期、长期和工作记忆整合到一个 Agent 类中。

class MemoryAugmentedAgent:
    def __init__(self):
        self.short_term_memory = []  # 短期记忆：简单的对话历史列表
        self.working_memory = WorkingMemory() # 工作记忆
        self.long_term_memory = LongTermMemory() # 长期记忆
        
    def chat(self, user_input: str) -> str:
        print("\n" + "="*50)
        print(f"[用户输入]: {user_input}")
        
        # 1. 更新短期记忆
        self.short_term_memory.append({"role": "user", "content": user_input})
        
        # 2. 检索长期记忆，作为背景信息注入
        related_memories = self.long_term_memory.retrieve(user_input, top_k=1)
        ltm_context = "\n".join([mem['text'] for mem in related_memories])
        
        # 3. 更新工作记忆（这里简化处理，实际中通常通过 LLM 提取）
        self.working_memory.update_task(f"处理用户查询: {user_input}")
        self.working_memory.add_to_scratchpad("分析用户意图，准备调用 LLM...")
        
        # 4. 构建 Prompt (模拟 RAG 过程)
        prompt = f"""
        你是一个拥有记忆的高级AI助手。
        
        [系统工作记忆/当前状态]:
        任务: {self.working_memory.current_task}
        
        [长期记忆召回]:
        {ltm_context if ltm_context else "无相关历史记忆"}
        
        [近期对话历史 (短期记忆)]:
        {self._get_recent_history()}
        
        请根据以上信息回答用户的最新问题。
        """
        
        # 5. 获取 LLM 响应
        response = llm.generate(prompt)
        
        # 6. 判断是否需要存入长期记忆 (模拟 LLM 评估重要性)
        if "我的名字" in user_input or "我喜欢" in user_input:
            self.long_term_memory.add_memory(user_input, importance=8)
            
        # 7. 处理短期记忆（滑动窗口机制，保留最近3轮）
        self.short_term_memory.append({"role": "assistant", "content": response})
        if len(self.short_term_memory) > 6:
            # 触发摘要机制 (这里简化为直接丢弃最早的，实际应用中应调用LLM总结)
            self.short_term_memory = self.short_term_memory[-6:]
            
        return response

    def _get_recent_history(self, k=3) -> str:
        return "\n".join([f"{msg['role']}: {msg['content']}" for msg in self.short_term_memory[-k:]])

# --- 运行测试 ---
if __name__ == "__main__":
    agent = MemoryAugmentedAgent()
    
    # 第一轮对话：建立一些短期和工作记忆
    agent.chat("你好，我想了解一下AI Agent的记忆系统。")
    
    # 第二轮对话：触发长期记忆存储
    agent.chat("对了，顺便说一下，我喜欢用Python写代码，请记住我是Python开发者。")
    
    # 第三轮对话：跨越上下文测试记忆召回
    # 假设此时开启了一个全新的短期记忆窗口，但 Agent 仍然能从长期记忆中找到偏好
    agent.short_term_memory.clear() 
    agent.chat("帮我写一个Hello World程序。")
    
    # 检查输出，我们能看到系统在检索长期记忆时，召回了"Python开发者"的信息

代码解析

在这个简化的框架中，我们清晰地看到了三层记忆的协同作战：

短期记忆 (self.short_term_memory) 保存了原始的对话文本，并利用滑动窗口控制 Token 消耗。
工作记忆 (self.working_memory) 使用 Pydantic 模型实时追踪当前的推理状态（草稿本、当前任务）。
长期记忆 (self.long_term_memory) 通过向量相似度检索，在用户问“帮我写程序”时，虽然没有明说用什么语言，但由于召回了之前的偏好记忆，系统知道用户是 Python 开发者。

六、前沿探索：下一代 Agent 记忆架构

虽然上述的三层架构已经能解决大部分问题，但在追求 AGI（通用人工智能）的道路上，Agent 的记忆系统仍在快速演进。以下几个方向值得开发者持续关注：

1. MemGPT (虚拟上下文管理)

MemGPT（Memory-GPT）借鉴了传统操作系统的内存管理机制（分页和交换空间）。在 OS 中，当 RAM 不够用时，会将数据交换到硬盘。MemGPT 将 LLM 的上下文窗口视为 RAM，将庞大的向量数据库视为硬盘。Agent 自己决定何时进行“上下文换页”——即主动将当前不重要的信息写入数据库，并从数据库中检索需要的信息进入上下文。这实现了真正意义上的无限上下文记忆管理。

2. 记忆的主动反思与 consolidation (整合)

目前的记忆系统大多是被动检索的。未来的 Agent 将具备在“空闲时间”自我反省的能力。就像人类在睡眠时会将海马体的短期记忆转化为新皮层的长期记忆一样，Agent 会定期后台运行任务，清理冗余记忆，将多次相似的经验抽象为底层的“常识规则”，从而提升未来的决策速度。

3. GraphRAG 与知识图谱的结合

纯向量检索在处理复杂的实体关系和跨文档推理时显得乏力。结合知识图谱的 GraphRAG 正在成为构建长期记忆的新范式。Agent 不仅能记住“某个事实”，还能理解事实之间的网状结构，这对于构建企业级的高阶业务 Agent 至关重要。

七、总结

如果我们把大语言模型比作 Agent 的“CPU”，那么记忆系统就是它的“寄存器”、“内存”和“硬盘”。

短期记忆 让 Agent 能够理解当前的语境，保持对话的流畅连贯；
工作记忆 让 Agent 能够维持理智，不被多步推理的复杂度绕晕，按部就班地执行计划；
长期记忆 则赋予了 Agent 生命厚度，让它能够积累经验、理解用户偏好，成为真正的专属数字分身。

构建一个高质量的 AI Agent，绝不仅仅是调优 Prompt，记忆架构的设计才是真正的“银弹”。作为开发者，我们需要像架构分布式系统一样去架构 Agent 的记忆流，处理好状态的一致性、检索的召回率以及写入的时效性。

从“金鱼大脑”到“过目不忘”，AI Agent 的进化才刚刚开始。希望本文的架构思路和代码实践，能为你在构建下一代智能体时提供坚实的基石。

一、 核心概念解析：Agent 的三层记忆架构