Agent 的记忆系统：短期、长期与工作记忆

系列：AI Agent 工程实践 | 发布日期：2026-08-18

前言

人类大脑之所以能够持续学习、积累经验并做出明智决策，核心在于记忆系统的精妙设计——短期记忆让我们理解当下的对话，长期记忆让我们铭记过去的经验，工作记忆则让我们在复杂推理中保持关键信息的可及性。

当我们将这一认知模型映射到 AI Agent 系统时，会发现一个根本性挑战：大语言模型（LLM）本身是无状态的。每次推理调用都是独立的，模型不"记得"上一次对话的内容。那么，一个能够持续学习、积累经验并跨会话工作的 Agent，其记忆系统是如何构建的？

本文将从认知科学的记忆分类出发，系统性地拆解 Agent 记忆系统的三大支柱——短期记忆（上下文窗口）、长期记忆（向量数据库）和工作记忆（RAG 集成），结合源码级实现和工程权衡分析，为读者呈现一套完整的 Agent 记忆架构设计方法论。

1. 认知科学中的记忆分类

在深入工程实现之前，我们有必要回顾认知科学对记忆的经典分类，这为 Agent 记忆系统的设计提供了理论基础。

1.1 Atkinson-Shiffrin 记忆模型

1968 年，Atkinson 和 Shiffrin 提出了影响深远的多重存储模型（Multi-Store Model），将人类记忆划分为三个阶段：

• 感觉记忆（Sensory Memory）：持续时间极短（毫秒级），容量巨大，负责暂存感官输入的原始信息。
• 短期记忆 / 工作记忆（Short-Term / Working Memory）：持续时间约 20-30 秒，容量有限（Miller 的 7±2 法则），负责当前任务的信息处理。
• 长期记忆（Long-Term Memory）：理论上无限容量和持续时间，通过编码和巩固过程从短期记忆中形成。

1.2 与 Agent 系统的映射

将此模型映射到 Agent 架构，我们得到一个清晰的对应关系：

认知科学概念	Agent 系统对应	技术实现	容量限制	持续时间
感觉记忆	原始输入缓冲	API 请求体	受限于请求大小	单次请求
短期记忆	上下文窗口	LLM Context Window	4K-200K tokens	单次推理
工作记忆	活跃上下文 + RAG	Prompt + 检索注入	动态管理	单次任务
长期记忆	外部存储	向量数据库 / KV 存储	理论无限	持久化
情景记忆	对话历史归档	结构化日志	按需检索	永久
语义记忆	知识库	向量数据库 + 知识图谱	按需检索	永久

这一映射揭示了一个关键设计原则：Agent 的记忆系统本质上是一个分层的、多模态的信息管理系统，每一层都有不同的容量、速度和持久性特征。

下图展示了 Agent 三层记忆架构的完整数据流：

数据流说明：用户输入先进入短期记忆（上下文窗口），工作记忆引擎根据当前任务从长期记忆中语义检索相关信息并注入上下文，LLM 基于合并后的上下文进行推理，推理结果和反思再写回长期记忆，形成闭环学习。

2. Agent 的短期记忆：上下文窗口

2.1 上下文窗口的本质

短期记忆是 Agent 最基础的记忆机制。从工程角度看，它就是 LLM 的上下文窗口（Context Window）——每次推理时模型能够"看到"的全部文本。

以 GPT-4o（128K tokens）、Claude 3.5 Sonnet（200K tokens）、Gemini 1.5 Pro（1M tokens）为代表的新一代模型，上下文窗口已从早期 GPT-3 的 4K tokens 扩展了数十甚至数百倍。然而，“更大的窗口"并不等同于"更好的记忆”——这涉及三个关键限制：

1. 注意力稀释（Attention Dilution）：随着上下文长度增加，模型对中间位置信息的关注度下降（“Lost in the Middle” 现象，Liu et al. 2023）。
2. 成本线性增长：上下文窗口的 token 数直接影响推理成本，O(n²) 的注意力计算使得长上下文推理代价高昂。
3. 信息衰减：即使窗口足够大，模型对早期信息的利用效率远低于近期信息。

2.2 短期记忆的管理策略

工程实践中，短期记忆的管理核心在于上下文压缩与滑动窗口。

class ShortTermMemory:
    """
    Agent 短期记忆管理器
    核心思路：维护一个固定大小的滑动窗口，保留系统提示、关键摘要和最近的对话轮次
    """
    
    def __init__(self, max_tokens: int = 8000, summary_threshold: int = 6000):
        self.max_tokens = max_tokens          # 上下文窗口 token 上限
        self.summary_threshold = summary_threshold  # 触发摘要压缩的阈值
        self.messages: list[dict] = []        # 当前消息列表
        self.summary: str = ""                # 历史对话的压缩摘要
        self.token_count: int = 0             # 当前 token 计数
    
    def add_message(self, role: str, content: str) -> None:
        """添加新消息，必要时触发压缩"""
        self.messages.append({"role": role, "content": content})
        self.token_count += self._count_tokens(content)
        
        # 当 token 数超过阈值时，将旧消息压缩为摘要
        if self.token_count > self.summary_threshold:
            self._compress_old_messages()
    
    def _compress_old_messages(self) -> None:
        """
        将前半部分消息压缩为摘要，保留最近的对话轮次
        这是短期记忆管理的核心：用信息密度换取空间
        """
        mid = len(self.messages) // 2
        old_messages = self.messages[:mid]
        
        # 调用 LLM 生成压缩摘要（此处为示意，实际实现需调用 API）
        new_summary = self._generate_summary(old_messages, self.summary)
        
        # 更新状态：摘要替代旧消息，保留后半部分近期消息
        self.summary = new_summary
        self.messages = self.messages[mid:]
        self.token_count = self._recalculate_tokens()
    
    def get_context(self) -> list[dict]:
        """构建完整的推理上下文"""
        context = []
        
        # 1. 系统提示（固定）
        context.append({"role": "system", "content": self.system_prompt})
        
        # 2. 历史摘要（如果存在）
        if self.summary:
            context.append({
                "role": "system", 
                "content": f"以下是之前对话的摘要：\n{self.summary}"
            })
        
        # 3. 最近的消息
        context.extend(self.messages)
        
        return context

这段代码展示了一个经典的滑动窗口 + 摘要压缩策略。关键设计点在于：当 token 数超过阈值时，不是简单地丢弃旧消息，而是通过 LLM 将旧消息压缩为语义摘要，保留核心信息的同时释放空间。这本质上模拟了人类短期记忆中的**复述（Rehearsal）和组块化（Chunking）**机制。

3. Agent 的长期记忆：向量数据库

3.1 从外部存储到语义检索

当 Agent 需要跨会话记住信息时，上下文窗口便力不从心了。这时需要将信息持久化到外部存储，并在需要时按语义相关性检索回来——这就是长期记忆的核心机制。

向量数据库（Vector Database）是实现这一机制的关键基础设施。其工作原理是：

1. 编码（Embedding）：将文本通过 Embedding 模型（如 OpenAI text-embedding-3-small、BGE-M3）转换为高维向量。
2. 存储（Storage）：将向量及其关联的元数据存入向量数据库。
3. 检索（Retrieval）：将查询文本编码为向量，通过近似最近邻（ANN）搜索找到语义最相似的记忆片段。

3.2 主流向量数据库对比

特性	Chroma	Milvus/Zilliz	Pinecone	Qdrant	Weaviate
部署方式	嵌入式 / 客户端-服务器	自托管 / 云服务	纯云服务	自托管 / 云服务	自托管 / 云服务
最大规模	中小规模	十亿级	十亿级	千万级	千万级
混合搜索	基础支持	强（标量+向量+图）	支持	支持	强（BM25+向量）
多租户	有限	原生支持	原生支持	支持	原生支持
适用场景	原型 / 小型 Agent	大规模生产环境	快速上线	中型生产环境	需要混合检索
SDK 生态	Python/JS 丰富	Python/Java/Go/Node	Python/JS/Go	Python/JS/Rust	Python/JS/Go

对于大多数 Agent 应用，Chroma 适合原型阶段快速迭代，Qdrant 或 Milvus 适合中大规模生产部署，而 Pinecone 则适合不想运维基础设施的团队。

3.3 长期记忆的实现

import chromadb
from chromadb.utils import embedding_functions
from datetime import datetime
from typing import Optional

class LongTermMemory:
    """
    基于向量数据库的 Agent 长期记忆系统
    核心能力：记忆的写入、语义检索、时间衰减和重要性评分
    """
    
    def __init__(self, collection_name: str = "agent_memory"):
        # 使用 Chroma 作为向量存储，OpenAI Embedding 作为编码器
        self.client = chromadb.PersistentClient(path="./memory_db")
        self.embed_fn = embedding_functions.OpenAIEmbeddingFunction(
            model_name="text-embedding-3-small"
        )
        self.collection = self.client.get_or_create_collection(
            name=collection_name,
            embedding_function=self.embed_fn,
            metadata={"hnsw:space": "cosine"}  # 使用余弦相似度
        )
    
    def store(self, content: str, memory_type: str = "episodic",
              importance: float = 0.5, metadata: Optional[dict] = None) -> str:
        """
        存储一条记忆
        
        Args:
            content: 记忆内容
            memory_type: 记忆类型 - episodic(情景)/semantic(语义)/procedural(程序性)
            importance: 重要性评分 [0, 1]，影响检索排序
            metadata: 附加元数据（来源、时间戳等）
        """
        memory_id = f"mem_{datetime.now().isoformat()}_{hash(content) % 10000}"
        
        # 构建元数据，包含时间戳、类型和重要性
        full_metadata = {
            "type": memory_type,
            "importance": importance,
            "timestamp": datetime.now().isoformat(),
            "access_count": 0,  # 记录被检索次数，用于遗忘曲线
            **(metadata or {})
        }
        
        self.collection.add(
            ids=[memory_id],
            documents=[content],
            metadatas=[full_metadata]
        )
        return memory_id
    
    def recall(self, query: str, n_results: int = 5,
               memory_type: Optional[str] = None,
               time_decay: bool = True) -> list[dict]:
        """
        语义检索相关记忆
        
        核心算法：结合向量相似度、重要性评分和时间衰减的混合排序
        这模拟了人类记忆的"可及性"——越重要、越近期、越相关的内容越容易被想起
        """
        where_filter = {"type": memory_type} if memory_type else None
        
        results = self.collection.query(
            query_texts=[query],
            n_results=n_results * 2,  # 多取一些，后续重排序
            where=where_filter
        )
        
        memories = []
        for i, doc in enumerate(results["documents"][0]):
            meta = results["metadatas"][0][i]
            distance = results["distances"][0][i]
            
            # 计算综合得分：相似度 × 重要性 × 时间衰减
            similarity_score = 1 - distance  # 余弦距离转相似度
            importance_score = meta.get("importance", 0.5)
            
            if time_decay:
                # 指数衰减：每过一天，记忆强度衰减 5%
                stored_time = datetime.fromisoformat(meta["timestamp"])
                days_elapsed = (datetime.now() - stored_time).total_seconds() / 86400
                decay_factor = 0.95 ** days_elapsed
            else:
                decay_factor = 1.0
            
            final_score = similarity_score * importance_score * decay_factor
            
            memories.append({
                "content": doc,
                "metadata": meta,
                "score": final_score,
                "similarity": similarity_score
            })
        
        # 按综合得分排序，返回 top-k
        memories.sort(key=lambda x: x["score"], reverse=True)
        return memories[:n_results]

这段代码展示了长期记忆系统的两个核心设计：

1. 混合评分排序：检索时不仅考虑向量相似度，还融合了重要性评分和时间衰减因子。这模拟了人类记忆的遗忘曲线（Ebbinghaus Forgetting Curve）——越久远的记忆越难被提取，但高重要性的记忆可以抵抗衰减。

2. 记忆分类：借鉴认知科学的情景记忆（episodic）和语义记忆（semantic）分类，不同类型的记忆有不同的存储和检索策略。

4. 工作记忆与检索增强

4.1 工作记忆的独特角色

工作记忆（Working Memory）是 Agent 记忆系统中最精妙的部分。它既不是简单的上下文窗口扩展，也不是被动的信息检索，而是主动的、任务驱动的信息整合过程。

在认知科学中，工作记忆的核心组件是 Baddeley 提出的中央执行系统（Central Executive）——负责协调来自不同记忆系统的信息，决定哪些信息应当被激活并用于当前任务。映射到 Agent 架构，这正是 RAG（Retrieval-Augmented Generation） 所扮演的角色。

4.2 RAG 作为工作记忆的引擎

Lewis et al. 在 2020 年提出的 RAG 框架（Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks）最初是为了解决 LLM 的知识截止问题，但其架构天然适合作为 Agent 的工作记忆机制。

RAG 的核心流程是：

1. 查询构建：根据当前任务，将上下文转换为检索查询。
2. 检索：从长期记忆（向量数据库）中检索相关片段。
3. 增强：将检索结果注入到 LLM 的提示中。
4. 生成：基于增强后的上下文进行推理和生成。

这一流程本质上就是工作记忆的运作方式——从长期记忆中按需提取信息，临时加载到活跃处理区域。

4.3 Reflexion：从记忆中学习

Shinn et al. 2023 年提出的 Reflexion 框架将 Agent 的记忆使用推向了新的高度。Reflexion 的核心创新在于引入了情景记忆缓冲（Episodic Memory Buffer），Agent 不仅记住事实，还记住自己的反思（Reflection）——即对过去行动成功或失败原因的分析。

from dataclasses import dataclass, field
from enum import Enum

class MemoryType(Enum):
    """记忆类型枚举，对应认知科学的记忆分类"""
    WORKING = "working"      # 工作记忆：当前任务的活跃上下文
    EPISODIC = "episodic"    # 情景记忆：过去经历的具体事件（Reflexion 核心）
    SEMANTIC = "semantic"    # 语义记忆：抽象知识和事实
    PROCEDURAL = "procedural"  # 程序性记忆：如何执行特定任务的操作步骤

@dataclass
class MemoryEntry:
    """记忆条目：一条记忆的完整结构"""
    content: str                              # 记忆内容
    memory_type: MemoryType                   # 记忆类型
    importance: float = 0.5                   # 重要性 [0,1]
    embedding: list[float] = field(default_factory=list)  # 向量表示
    references: list[str] = field(default_factory=list)   # 关联的其他记忆 ID
    access_count: int = 0                     # 被访问次数
    reflection: str = ""                      # Reflexion：对这条经验的反思

class AgentMemorySystem:
    """
    统一的 Agent 记忆系统，整合短期、长期和工作记忆
    
    架构设计遵循 Baddeley 的工作记忆模型：
    - 中央执行系统 → 记忆协调器（决定加载哪些记忆）
    - 语音回路 → 上下文窗口（短期记忆）
    - 视觉空间画板 → 多模态缓冲（扩展点）
    - 情景缓冲 → RAG 检索注入（工作记忆的核心机制）
    """
    
    def __init__(self, llm_client, vector_store, max_context_tokens: int = 16000):
        self.llm = llm_client
        self.vector_store = vector_store       # 长期记忆（向量数据库）
        self.short_term = ShortTermMemory(max_tokens=max_context_tokens)
        self.working_memory: list[MemoryEntry] = []  # 当前激活的记忆
        self.episodic_buffer: list[dict] = []  # Reflexion 情景缓冲
    
    def perceive(self, observation: str) -> None:
        """感知：将外部观察写入短期记忆"""
        self.short_term.add_message("user", observation)
    
    def reflect_and_store(self, trajectory: str, outcome: str, 
                          success: bool) -> str:
        """
        Reflexion 核心：对过去的行动轨迹进行反思并存储
        
        这是 Agent 从经验中学习的关键机制：
        1. 分析行动轨迹和结果
        2. 生成结构化反思（哪些做得好、哪些需要改进）
        3. 将反思存入情景记忆，供未来任务检索
        """
        reflection_prompt = f"""你是一位经验丰富的 AI Agent。请分析以下任务轨迹并生成反思。

## 任务轨迹
{trajectory}

## 结果
{outcome}
{'任务成功完成。' if success else '任务未成功完成。'}

请从以下维度进行反思：
1. 做得好的方面（保留的策略）
2. 需要改进的方面（调整的策略）
3. 关键教训（未来类似任务应记住的要点）

输出简洁的结构化反思。"""
        
        reflection = self.llm.generate(reflection_prompt)
        
        # 将反思存入情景记忆（Reflexion 的关键步骤）
        memory_id = self.vector_store.store(
            content=f"任务结果：{'成功' if success else '失败'}\n反思：{reflection}",
            memory_type="episodic",
            importance=0.8 if not success else 0.6,  # 失败的经验更重要
            metadata={"trajectory": trajectory[:500]}
        )
        
        return reflection
    
    def retrieve_for_task(self, task_description: str, 
                          top_k: int = 5) -> str:
        """
        任务驱动的记忆检索：从长期记忆中提取与当前任务相关的信息
        
        这是工作记忆的核心操作——从长期记忆中"激活"相关信息
        """
        # 1. 从向量数据库语义检索
        relevant_memories = self.vector_store.recall(
            query=task_description,
            n_results=top_k
        )
        
        # 2. 将检索结果组织为工作记忆上下文
        working_context_parts = []
        for mem in relevant_memories:
            working_context_parts.append(
                f"[{mem['metadata'].get('type', 'unknown')}] "
                f"(相关度: {mem['score']:.2f}) {mem['content']}"
            )
        
        # 3. 将工作记忆注入上下文（RAG 增强）
        working_context = "\n---\n".join(working_context_parts)
        self.short_term.add_message(
            "system",
            f"以下是与当前任务相关的记忆：\n{working_context}"
        )
        
        return working_context
    
    def think(self, task: str) -> str:
        """
        完整的 Agent 推理循环：感知 → 检索 → 推理 → 行动
        """
        # 步骤 1：检索相关记忆（加载工作记忆）
        self.retrieve_for_task(task)
        
        # 步骤 2：构建完整上下文（短期记忆 + 工作记忆）
        context = self.short_term.get_context()
        context.append({"role": "user", "content": task})
        
        # 步骤 3：调用 LLM 推理
        response = self.llm.generate(context)
        
        # 步骤 4：将交互写入短期记忆
        self.short_term.add_message("assistant", response)
        
        return response

这段代码展示了一个完整的三层记忆架构：

• 短期记忆（ShortTermMemory）：管理上下文窗口，实现滑动窗口压缩。
• 长期记忆（vector_store）：基于向量数据库的持久化存储，支持语义检索。
• 工作记忆（retrieve_for_task）：通过 RAG 机制，将长期记忆中的相关信息动态注入到当前推理上下文中。

特别值得注意的是 reflect_and_store 方法——这是 Reflexion 框架的核心。Agent 在每次任务后进行自我反思，将反思结果存入情景记忆。当遇到类似任务时，这些反思会被检索回来，指导 Agent 避免重复犯错。这本质上是**元认知（Metacognition）**在 Agent 系统中的实现。

4.4 MemGPT：分页式虚拟上下文管理

Packer et al. 2023 年提出的 MemGPT（Towards LLMs as Operating Systems）从操作系统内存管理中汲取灵感，提出了**虚拟上下文管理（Virtual Context Management）**的概念。

MemGPT 的核心思想是：

• 将 LLM 的上下文窗口类比为 CPU 的主存（Main Memory / RAM）。
• 将外部存储（向量数据库、文件系统）类比为磁盘（Disk）。
• 引入**分页（Paging）**机制：Agent 可以主动将上下文中的信息"换出（page out）"到外部存储，或从外部存储"换入（page in）"相关信息。

这种设计使得 Agent 突破了上下文窗口的物理限制，实现了"无限"上下文——实际上，这正是工作记忆的工程实现：通过主动管理有限的活跃区域，实现对无限长期记忆的有效利用。

5. 记忆系统的设计权衡

构建 Agent 记忆系统时，需要在多个维度进行权衡。以下是工程实践中最常见的决策点：

5.1 检索精度 vs. 计算成本

纯向量检索速度快但精度有限（语义相似不等于任务相关）。混合检索（向量 + BM25 关键词 + 重排序）精度更高但成本更大。实践中建议：

• 原型阶段：纯向量检索，快速迭代。
• 生产阶段：向量检索 + Cross-Encoder 重排序，兼顾效率和精度。
• 高精度场景：多路召回 + LLM 重排序，代价最高但效果最好。

5.2 记忆粒度

记忆的存储粒度直接影响检索质量：

• 句子级：检索精度高，但缺乏上下文。
• 段落级：平衡精度和上下文，是常见选择。
• 文档级：上下文完整，但检索精度低，需要二次切分。
• 语义块级：基于语义边界切分（而非固定长度），效果最好但实现复杂。

5.3 遗忘机制

并非所有记忆都值得保留。有效的遗忘机制可以：

• 降低存储成本和检索噪声。
• 模拟人类记忆的自然衰减。
• 防止过时信息干扰决策。

常见的遗忘策略包括：时间衰减（越久远的记忆权重越低）、重要性加权（高重要性记忆抵抗衰减）、访问频率（经常被检索的记忆保持活跃）。

5.4 记忆一致性

当 Agent 积累大量记忆后，可能出现矛盾信息。解决方案包括：

• 时间戳优先：新信息覆盖旧信息。
• 来源可信度：不同来源的记忆赋予不同权重。
• 冲突检测：在存储新记忆时，主动检索可能矛盾的旧记忆并标记。

6. 总结

Agent 的记忆系统是其从"无状态推理器"进化为"持续学习的智能体"的关键基础设施。本文的核心观点可以总结为：

1. 认知科学提供了理论框架：Atkinson-Shiffrin 模型和 Baddeley 的工作记忆模型为 Agent 记忆架构的设计提供了经过验证的理论基础。工程实现不必完全照搬认知模型，但理解其设计原理有助于做出更好的架构决策。

2. 三层记忆各司其职：短期记忆（上下文窗口）负责即时推理，长期记忆（向量数据库）负责持久化存储和语义检索，工作记忆（RAG）负责按需整合信息。三者协同工作，构成了完整的记忆系统。

3. Reflexion 和 MemGPT 代表了两个重要方向：Reflexion 通过"反思"机制赋予 Agent 从经验中学习的能力，MemGPT 通过"虚拟上下文管理"突破了物理窗口的限制。两者共同指向一个目标——让 Agent 的记忆能力逼近人类水平。

4. 工程权衡决定系统成败：检索精度与计算成本、记忆粒度与上下文完整性、遗忘与保留、一致性与多样性——这些权衡没有标准答案，需要根据具体应用场景做出选择。

记忆系统的设计，本质上是在有限资源下最大化信息效用的优化问题。理解这一本质，才能在不断演进的技术栈中做出正确的架构决策。

参考文献

1. Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., & Yao, S. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. Advances in Neural Information Processing Systems (NeurIPS 2023). arXiv:2303.11366.

2. Packer, C., Fang, V., Patil, S. G., Lin, K., Wooders, S., & Gonzalez, J. E. (2023). MemGPT: Towards LLMs as Operating Systems. arXiv:2310.08560.

3. Lewis, P., Perez, E., Piktus, A., Petroni, F., Karpukhin, V., Goyal, N., Küttler, H., Lewis, M., Yih, W., Rocktäschel, T., Riedel, S., & Kiela, D. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. Advances in Neural Information Processing Systems (NeurIPS 2020). arXiv:2005.11401.

4. Liu, N. F., Lin, K., Hewitt, J., Paranjape, A., Bevilacqua, M., Petroni, F., & Liang, P. (2023). Lost in the Middle: How Language Models Use Long Contexts. arXiv:2307.03172.

5. Baddeley, A. D. (2000). The episodic buffer: a new component of working memory?. Trends in Cognitive Sciences, 4(11), 417-423.

---

本系列覆盖 AI 大模型基础、Agent 开发、MCP 协议、Skill 开发、RAG、模型微调、部署推理 七大方向，从入门到实战的全栈内容持续更新中。

所有文章的 Markdown 源文件、可运行代码、高清配图已整理成完整资料包。

👍 点赞 + ⭐ 关注，评论区扣「1」，挨个发你领取方式 👇