告别“金鱼脑”：深入剖析 AI Agent 的记忆系统（短期、长期与工作记忆）

Posted on Edited on In

引言：从“聪明的一问一答”到“具备自我意识的智能体”

在大语言模型（LLM）爆发的初期，我们惊叹于它们渊博的知识和强大的逻辑推理能力。然而，随着我们将 LLM 从“聊天机器人”推向更高阶的“AI Agent（智能体）”，一个致命的短板暴露无遗：原生的大模型是“没有记忆的”金鱼脑。

每一次新的会话，对 LLM 来说都是一次重生。它无法记住昨天你和它探讨过的项目细节，也无法在执行一个长达 50 步的复杂自动化任务时，准确 recall 起第 3 步的中间变量。没有记忆的 Agent，就像一个失忆的天才，虽然聪明，但无法完成任何需要持续协作的长期任务。

为了解决这个问题，AI 工程界借鉴了认知心理学中的人类大脑记忆模型，为 AI Agent 构建了一套完善的记忆系统。一个成熟的 Agent不仅需要检索外部知识（RAG），更需要管理和操作自身的记忆。

本文将深入剖析 AI Agent 的三大核心记忆机制：短期记忆、长期记忆与工作记忆。我们将探讨它们的工作原理、技术架构，并辅以实际的代码示例，带你从零构建一个具备完整记忆生命周期的智能体。

一、 短期记忆：上下文窗口内的“秒忆”

1. 什么是短期记忆？

在人类大脑中，短期记忆负责暂时存储当前正在处理的信息，容量有限，且转瞬即逝。在 AI Agent 的架构中，短期记忆直接对应着 LLM 的上下文窗口。

当你在对话中发送一段 Prompt，模型生成的回复以及之前几轮的对话历史，共同构成了 Agent 的短期记忆。这种记忆的检索延迟几乎为零，保真度极高（毕竟原文就在眼前）。

2. 短期记忆的阿喀琉斯之踵

短期记忆最大的问题在于容量限制和注意力稀释。

  • Token 限制：无论 GPT-4o 还是 Claude 3.5，上下文长度总有上限（128k, 200k 等）。在执行需要海量状态的长任务（如自动写一个完整的软件项目）时，上下文极易溢出。
  • Lost in the Middle（迷失在中间）：研究表明，当上下文过长时，LLM 往往会忽略中间的重要信息，只关注开头和结尾。

3. 技术实现：滑动窗口与摘要

为了管理短期记忆，最基础的技术是滑动窗口，保留最近的 KK 轮对话。更高级的做法是引入内存摘要：当对话历史超过阈值时，调用 LLM 将其浓缩为一段摘要，再将摘要作为短期记忆的一部分塞入 Prompt 中。

二、 长期记忆：跨越时空的“经验库”

1. 什么是长期记忆？

长期记忆是 Agent 用来存储跨越多个会话、甚至无穷无尽的知识和经验的地方。它不受上下文窗口的限制，就像人类的大脑皮层或硬盘。当 Agent 需要回忆上个月用户的喜好，或者曾经犯过的一个错误时，就需要去长期记忆中检索。

2. 长期记忆的分类（认知心理学映射）

在设计 Agent 时，我们通常将长期记忆分为两类：

  • 语义记忆：客观的事实、概念和知识。例如“用户的生日是1995年”、“Python 的包管理器是 pip”。通常使用向量数据库（Vector Database，如 Chroma, Pinecone, Milvus）来实现。
  • 情景记忆：过去经历过的事件或具体的操作序列。例如“上周二我帮你重构了数据库，期间遇到了连接池耗尽的问题，最后的解决方案是增大连接数”。通常使用时序知识图谱或带有时间戳的向量数据库来实现。

3. 技术实现：写入与检索（RAG 的进阶版）

长期记忆的写入通常是异步的。Agent 在对话中识别到重要信息，会触发一个 Save Memory 的工具调用，将文本转化为向量并存储。当需要回忆时，通过相似度检索（如 Cosine Similarity）找回相关片段。

三、 工作记忆：Agent 的“草稿本与指挥中心”

1. 什么是工作记忆？

这是近年来在高级 Agent 架构（如 AutoGPT, Devin）中越来越被重视的概念。短期记忆只是“看得到的对话”，长期记忆是“尘封的档案”，而工作记忆则是当前正在运算、规划、逻辑推导的动态缓冲区。

如果说短期/长期记忆是“数据”，那么工作记忆更多是“状态”和“计划”。例如，Agent 在执行一个复杂任务时，当前的待办事项列表、设定的阶段性目标、在代码沙箱中运行的错误输出，都属于工作记忆。

2. 为什么需要工作记忆？

在 ReAct (Reason + Act) 模式或 Plan-and-Solve 模式下，Agent 不能仅仅依赖短期记忆。如果在第 10 步发现了一个错误，Agent 需要在这个“草稿本”上修改它的计划，重新评估当前状态，然后再去调用工具。工作记忆通常以结构化的数据（如 JSON, Scratchpad, 状态机）存在于系统的运行时内存（RAM）中。

四、 架构设计：三位一体的记忆流转

一个工业级的 AI Agent，其记忆系统不是孤立的，而是像人脑一样协同工作的：

  1. 感知：接收到用户的新 Input。
  2. 检索：将 Input 向量化，去长期记忆（Vector DB）中检索相关的历史事实。
  3. 加载：将检索到的历史事实，加上最近的短期记忆（对话历史），一起打包。
  4. 思考与规划：LLM 结合上述信息，在工作记忆（Scratchpad/状态机）中更新计划、推导下一步动作。
  5. 行动：执行工具调用或回复用户。
  6. 反思与固化：将本轮产生的重要结论、用户偏好更新到长期记忆中；将当前对话追加到短期记忆。

五、 代码实战：用 Python 构建一个具备三级记忆的 Agent

接下来，我们将使用 Python，结合最流行的编排框架 LangChain，从零手搓一个具备短期、长期和工作记忆的简易 Agent。

为了代码的易读性，我们使用内存模拟向量数据库（实际生产中可替换为 Chroma/Pinecone）。

1. 基础组件准备

1
2
3
4
5
6
7
8
9
10
11
12
import json
from collections import deque
from datetime import datetime
from langchain_openai import ChatOpenAI
from langchain.memory import ConversationSummaryBufferMemory
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage

# 初始化 LLM 和 Embedding 模型
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
embeddings = OpenAIEmbeddings()

2. 构建短期记忆（结合摘要的滑动窗口）

我们使用 LangChain 内置的 ConversationSummaryBufferMemory。它完美结合了“滑动窗口”和“摘要”机制：保留最近的几轮对话，把更早的对话让 LLM 总结成摘要。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class ShortTermMemory:
    def __init__(self, llm, max_token_limit=1000):
        # 使用摘要缓冲记忆
        self.memory = ConversationSummaryBufferMemory(
            llm=llm, 
            max_token_limit=max_token_limit,
            return_messages=True
        )

    def add_message(self, human_msg, ai_msg):
        self.memory.save_context({"input": human_msg}, {"output": ai_msg})

    def get_history(self):
        return self.memory.load_memory_variables({})["history"]

3. 构建长期记忆（基于向量检索）

长期记忆需要持久化。这里我们演示如何存取情景和语义记忆。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class LongTermMemory:
    def __init__(self, embeddings):
        # 实际情况请使用 FAISS.from_texts 初始化
        self.texts = []
        self.embeddings = embeddings
        self.vector_store = None

    def save_memory(self, text: str):
        """将重要信息存入长期记忆"""
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        doc = f"[{timestamp}] {text}"
        self.texts.append(doc)
        # 重建向量库 (生产环境中应该使用 add_documents)
        self.vector_store = FAISS.from_texts(self.texts, self.embeddings)
        print(f"->[长期记忆已固化]: {doc}")

    def retrieve_memory(self, query: str, k=2) -> str:
        """从长期记忆中检索相关信息"""
        if not self.vector_store:
            return "无长期记忆"
        docs = self.vector_store.similarity_search(query, k=k)
        return "\n".join([doc.page_content for doc in docs])

4. 构建工作记忆（当前的规划与状态草稿本）

工作记忆是 Agent 运行时的“白板”。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class WorkingMemory:
    def __init__(self):
        self.current_task = None
        self.plan = []
        self.scratchpad = [] # 记录推理步骤

    def update_task(self, task: str):
        self.current_task = task
        self.plan = [] # 新任务重置计划

    def add_step(self, thought: str, action: str, observation: str):
        self.scratchpad.append({
            "thought": thought,
            "action": action,
            "observation": observation
        })
    
    def get_context(self) -> str:
        return json.dumps({
            "current_task": self.current_task,
            "recent_scratchpad": self.scratchpad[-3:] # 只取最近3步，防止太长
        }, indent=2, ensure_ascii=False)

5. 组装：三位一体的 Agent 类

现在，我们将这三种记忆组合成一个能够思考、记忆和行动的 Agent。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
class CognitiveAgent:
    def __init__(self):
        self.stm = ShortTermMemory(llm)
        self.ltm = LongTermMemory(embeddings)
        self.wm = WorkingMemory()

    def think_and_act(self, user_input: str):
        # 1. 更新工作记忆
        self.wm.update_task(user_input)

        # 2. 检索长期记忆
        ltm_context = self.ltm.retrieve_memory(user_input)
        
        # 3. 获取短期记忆
        stm_context = self.stm.get_history()

        # 4. 构建包含三级记忆的复杂 Prompt
        system_prompt = f"""你是一个具备人类级别记忆的强大 AI 助手。
        你的当前任务和工作状态（工作记忆）：
        {self.wm.get_context()}

        你回忆起的过去的事实和经验（长期记忆）：
        {ltm_context}
        """

        # 构造 Messages
        messages = [SystemMessage(content=system_prompt)]
        
        # 加入短期记忆 (最近几轮对话)
        for msg in stm_context:
            if isinstance(msg, HumanMessage):
                messages.append(HumanMessage(content=msg.content))
            elif isinstance(msg, AIMessage):
                messages.append(AIMessage(content=msg.content))
                
        # 加入当前用户的输入
        messages.append(HumanMessage(content=user_input))

        # 5. LLM 思考并输出
        response = llm.invoke(messages)
        ai_reply = response.content

        # 6. 更新短期记忆
        self.stm.add_message(user_input, ai_reply)

        # 7. 模拟记忆固化：判断是否需要将当前对话片段存入长期记忆
        if "我的名字是" in user_input or "我喜欢" in user_input:
            self.ltm.save_memory(f"用户说过: {user_input}")
            
        return ai_reply

# 测试我们的 Agent
if __name__ == "__main__":
    agent = CognitiveAgent()
    
    print("=== 第一轮对话 ===")
    reply1 = agent.think_and_act("你好，我的名字是李白，我是一个软件工程师。")
    print(f"Agent: {reply1}\n")

    print("=== 模拟上下文被清空 / 开启新会话 ===")
    # 在真实的系统中，短期记忆此时可能已经超出 Token 被截断，或者用户开启了新会话
    # 但由于我们把信息存入了长期记忆，Agent 依然认识你
    
    # 模拟短期记忆清空（仅作演示，直接实例化一个新 stm）
    agent.stm = ShortTermMemory(llm) 
    
    print("=== 第二轮对话 (新会话) ===")
    reply2 = agent.think_and_act("你好，我是谁？我适合做什么工作？")
    print(f"Agent: {reply2}\n")

代码运行原理解析：

  1. 在第一轮对话中，用户输入了“我的名字是李白，我是软件工程师”。
  2. Agent 检测到这是重要的用户画像信息，触发了 self.ltm.save_memory()，将其写入了向量数据库。
  3. 在第二轮对话前，我们模拟了短期记忆（上下文）的清空或丢失。
  4. 第二轮对话时，用户问“我是谁”。Agent 会将 query 去 Vector DB 中检索，命中了之前存的“用户说过: 我的名字是李白…”，将其作为 System Prompt 的一部分喂给 LLM。
  5. 最终，即使跨越了会话，Agent 依然通过长期记忆成功找回了对用户的认知。

六、 进阶：从“存储”到“反思”——记忆的最终进化

在上述架构中，长期记忆只是被动地存储和检索。然而，真正像人类的智能体，需要具备一种高级认知能力：反思。

例如，Agent 在做代码生成任务时，连续 3 次因为同一个语法错误失败。这不仅应该作为“情景记忆”存下来，Agent 的工作记忆应该在此时停下任务，触发一个“反思链”：

“为什么我一直失败？我观察到的错误日志都是 ImportError。这说明我的工具调用逻辑有误。我应该总结出一条规则：在执行 Python 代码前，必须先检查 requirements.txt 是否安装。”

这条通过反思得出的高层结论，会被当作高权重的语义记忆永久保存。当下次遇到类似任务时，这条反思记录将被优先检索出来，指导 Agent 绕过之前的坑。

这种机制被称为 Generative Agents（生成式智能体） 架构中的核心创新，它让 Agent 实现了从“记忆事实”到“积累经验”的跨越。

七、 总结

在 AI Agent 狂飙突进的今天，单纯提升大模型的参数量已经无法满足复杂的现实任务。如何设计一个高效、准确、且能自我演进的记忆系统，成为了区分普通 Chatbot 和顶级 Agent 的试金石。

  • 短期记忆 充当信息缓冲区，利用有限的上下文窗口解决眼前的对话连贯性问题。
  • 长期记忆 依托向量数据库与知识图谱，打破了时间与空间的限制，赋予 Agent 跨越会话的“人生经验”。
  • 工作记忆 则是 Agent 的 CPU 缓存与草稿本，承载着规划、逻辑推理和动态状态更新。

随着上下文窗口越来越大（如 Gemini 1.5 Pro 的 200 万 Token），很多人质疑短期记忆和 RAG 是否会失去意义。但事实是，没有遗忘机制的系统是不符合智能直觉的。就像人类不可能把一生所有的细节都塞进大脑皮层一样，未来的 Agent 需要更加智能的记忆调度算法，知道什么时候该记住，什么时候该遗忘，什么时候该反思。

掌握记忆系统的设计与编排，就是掌握了开启通用人工智能（AGI） autonomous 闭环的关键钥匙。希望这篇文章能为你在构建下一代 AI 应用时提供坚实的架构指导。