告别“金鱼脑”：深入剖析 AI Agent 的记忆系统与工程实现

Posted on In

在当前的大语言模型（LLM）时代，AI Agent（人工智能智能体）正从简单的“对话机器人”进化为能够执行复杂任务的“数字员工”。然而，一个只有 7 秒记忆的员工是无法胜任复杂工作的。

原生 LLM 的核心痛点之一是无状态性。每一次 API 调用，模型都像是一个刚刚失忆的人，对你的过往经历一无所知。为了让 Agent 能够像人类一样进行连贯的对话、执行多步骤的复杂任务，甚至从经验中学习，我们必须为它构建一套完善的记忆系统。

本文将深入剖析 AI Agent 的三层记忆架构：短期记忆、长期记忆与工作记忆。我们将探讨它们的底层原理、工程实现方案，并辅以实际的代码示例，帮助你构建出具备“长线程”和“个性化”能力的高级 Agent。

一、 借鉴人类认知：AI 的三层记忆架构

在认知心理学中，人类的大脑拥有感觉记忆、短期记忆（海马体）和长期记忆（大脑皮层）。在工程设计上，AI Agent 的记忆系统通常被抽象为以下三个层级：

  1. 短期记忆：当前对话的上下文。对应 LLM 的上下文窗口。
  2. 长期记忆：Agent 的历史经验和知识库。对应外部向量数据库或关系型数据库。
  3. 工作记忆：Agent 在执行当前复杂任务时的中间状态、计划或“草稿本”。对应系统的中间态存储或划线机制。

这三者的协同工作，构成了一个完整且智能的 Agent 记忆中枢。

二、 短期记忆：上下文窗口的极限博弈

短期记忆主要负责维持当前交互会话的连贯性。它直接映射到 LLM 的 Context Window（上下文窗口）。在这个窗口内，模型可以通过注意力机制捕捉词汇间的关联。

1. 短期记忆的挑战

  • 长度限制：尽管现在的模型支持 128K 甚至 200K 的上下文，但token依然是有成本的，且无限堆积上下文会导致**Lost in the middle（中间迷失）**现象，模型对上下文中间的信息提取能力会显著下降。
  • 瞬时性：一旦会话结束或窗口被清理，这些记忆就会永久丢失。

2. 短期记忆的工程优化方案

为了在有限的 Token 内最大化短期记忆的效率，我们通常采用滑动窗口和文本摘要相结合的策略。

代码示例：基于滑动窗口与摘要的短期记忆管理

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from langchain.memory import ConversationSummaryBufferMemory
from langchain.llms import OpenAI

# 使用 ConversationSummaryBufferMemory 
# 它是一个混合体：当对话长度未超过 max_token_limit 时，完整保留对话（纯短期记忆）；
# 一旦超过限制，它会将最旧的对话“摘要化”压缩，保留最新的对话完整记录。

llm = OpenAI(temperature=0)

memory = ConversationSummaryBufferMemory(
    llm=llm, 
    max_token_limit=100, # 设定短期记忆的上限
    return_messages=True
)

# 模拟 Agent 的连续对话
memory.save_context({"input": "你好，我是张三，我今天想学习 Python 的 asyncio 库。"}, {"output": "你好张三！asyncio 是 Python 用来编写并发代码的库，使用 async/await 语法。你想从哪里开始？"})
memory.save_context({"input": "我想了解什么是事件循环。"}, {"output": "事件循环是 asyncio 的核心。它负责监控并执行异步任务..."})

# 当对话继续增加时，较早的对话会被 LLM 摘要压缩，以腾出空间给最新的对话
print(memory.load_memory_variables({}))

通过这种机制，Agent 能够在单次会话中保持极高的响应精度，同时控制住 API 的计算成本。

三、 长期记忆：跨越时空的 RAG 与向量数据库

短期记忆随着会话关闭而消失，但如果用户明天再来，Agent 依然需要记住“张三喜欢 Python”这个事实。这就需要引入长期记忆。

长期记忆是 Agent 实现个性化、知识积累和跨会话连续性的基石。目前主流的实现方式是基于向量检索增强生成。

1. 长期记忆的分类

在 Agent 系统中，长期记忆通常分为两类：

  • 语义记忆：客观事实和概念知识。例如文档库、API 使用手册。
  • 情景记忆：过去发生的事件和经验。例如“张三昨天问了什么问题”、“上次执行代码报了什么错”。

2. 长期记忆的存储与检索流程

  1. 写入：用户的重要输入或 Agent 的执行日志，被切分后通过 Embedding 模型转化为高维向量，存入向量数据库（如 Chroma, Pinecone, Milvus）。
  2. 检索：每次用户发起对话时，将当前 Query 向量化，在数据库中进行相似度检索（如余弦相似度），召回最相关的 K 条历史记忆。
  3. 注入：将召回的记忆作为上下文 Prompt 注入到 LLM 中，辅助其回答。

代码示例：基于 Chroma 的 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
import chromadb
from chromadb.utils import embedding_functions

# 1. 初始化向量数据库客户端
client = chromadb.PersistentClient(path="./agent_long_term_memory")

# 使用 OpenAI 的 Embedding 模型 (需配置 OPENAI_API_KEY)
embed_fn = embedding_functions.OpenAIEmbeddingFunction(
    model_name="text-embedding-ada-002"
)

# 创建或获取一个名为 "user_history" 的集合
collection = client.get_or_create_collection(
    name="user_history", 
    embedding_function=embed_fn
)

# 2. 模拟将重要对话写入长期记忆
def save_to_long_term_memory(user_id, text, metadata):
    doc_id = f"{user_id}_{hash(text)}"
    collection.add(
        documents=[text],
        metadatas=[metadata],
        ids=[doc_id]
    )

# 记录：张三在多轮对话中的偏好
save_to_long_term_memory("user_001", "张三是一个后端开发工程师，最近在做高并发系统的重构。", {"user": "张三", "type": "profile"})
save_to_long_term_memory("user_001", "张三在部署 Docker 时遇到了网络代理问题，通过配置 daemon.json 解决了。", {"user": "张三", "type": "experience"})

# 3. 记忆检索：当张三再次提问时，唤醒相关记忆
def retrieve_memory(query, n_results=2):
    results = collection.query(
        query_texts=[query],
        n_results=n_results
    )
    return results['documents'][0]

# 假设张三今天问了一个新问题
current_query = "我该怎么优化我的高并发系统？"
recalled_memories = retrieve_memory(current_query)

# Agent 系统拼接 Prompt
prompt = f"""
已知用户的历史记忆：
{recalled_memories}

用户新问题：{current_query}
请结合用户的历史记忆，给出个性化的回答。
"""
print(prompt)

通过这种方式，Agent 的记忆不再受制于上下文窗口的限制。它可以记住几周前、甚至一年前的交互细节。

四、 工作记忆：Agent 执行复杂任务的“草稿本”

随着 Agent 能力的增强（如 AutoGPT、BabyAGI），我们需要 Agent 能够自主规划任务并执行多步操作。这时，仅靠短期和长期记忆就不够了。

工作记忆类似于人类大脑的“前台”，它用于存储 Agent 当前正在执行的计划、中间状态和工具调用的结果。工作记忆具备极高的读写频率，并在任务执行期间处于动态变化之中。

1. 工作记忆的作用

在 ReAct (Reasoning and Acting) 框架或 Plan-and-Solve 框架中，Agent 会经历“思考 -> 行动 -> 观察”的循环。

  • Thought (思考)：记录在草稿本上，防止在多步推理中迷失。
  • Action (行动)：调用外部工具（如搜索引擎、代码执行器）。
  • Observation (观察)：工具返回的海量结果往往不需要送入长期记忆，而是暂存在工作记忆中，供 Agent 提取关键信息。

2. 划线机制

当 LLM 面对超长文档或需要调用数据库等产生大量返回数据的工具时，工作记忆常采用“划线”机制。Agent 将大块数据读入 Scratchpad，通过代码或 LLM 自身过滤掉无用信息，只将精炼后的结论写入下一步的短期/长期记忆中。

代码示例：基于工作记忆的多步任务执行

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
class AgentWithWorkingMemory:
    def __init__(self, llm):
        self.llm = llm
        self.working_memory = { # 初始化工作记忆（草稿本）
            "current_task": None,
            "task_plan": [],
            "scratchpad": [] # 存放中间执行结果
        }
        self.toolkit = {
            "search_web": lambda q: f"搜索结果：关于 {q} 的最新资讯是...",
            "run_code": lambda code: f"代码执行成功，输出：10"
        }

    def execute_task(self, main_task):
        self.working_memory['current_task'] = main_task
        
        # 步骤 1: 规划任务
        plan_prompt = f"为了完成 '{main_task}'，请制定包含两步的计划。"
        plan = self.llm(plan_prompt)
        self.working_memory['task_plan'] = plan.split('\n')
        
        # 步骤 2: 逐步执行并记录到草稿本
        for i, step in enumerate(self.working_memory['task_plan']):
            action_prompt = f"当前执行：{step}\n请决定使用哪个工具（search_web 或 run_code）并给出参数。格式：TOOL_NAME|PARAM"
            action = self.llm(action_prompt)
            
            tool_name, param = action.split('|')
            observation = self.toolkit[tool_name](param)
            
            # 将中间结果写入工作记忆
            self.working_memory['scratchpad'].append(f"Step {i+1} Result: {observation}")
            
        # 步骤 3: 汇总工作记忆，生成最终结果
        final_prompt = f"任务：{self.working_memory['current_task']}\n"
        final_prompt += "执行记录：\n" + "\n".join(self.working_memory['scratchpad'])
        final_prompt += "\n请根据执行记录，给出最终的回答。"
        
        return self.llm(final_prompt)

# 假设有一个 LLM 实例
# agent = AgentWithWorkingMemory(llm=mock_llm)
# agent.execute_task("分析当前最受欢迎的编程语言并计算其运行速度的排名。")

在这个架构中，工作记忆充当了系统总线，连接了工具、LLM 以及最终的输出。

五、 终极进化：面向对象的记忆架构 (MemGPT)

在了解了三种基础记忆后，我们不得不提当前 Agent 记忆管理的前沿研究方向——MemGPT (Memory-GPT)。

传统的 RAG 只能做简单的“搜索与拼接”，属于被动记忆。而 MemGPT 借鉴了操作系统的虚拟内存管理机制。

在 MemGPT 架构中：

  • 主内存 对应短期记忆。
  • 外部存储 对应长期记忆。
  • 操作系统（OS） 则是 LLM 本身。

LLM 不再仅仅是回答问题的模型，它被赋予了管理自身内存的“系统权限”。当主内存不足时，LLM 会自主决定将哪些旧记忆**“分页”写入硬盘（长期记忆），或者从硬盘中将需要的知识“加载”**回主内存。

这种架构使得 Agent 能够处理极其庞大的上下文（例如阅读整本书并在多次会话中深度讨论），是未来 AI Agent 发展的重要方向。

六、 总结

从简单的聊天框到复杂的自主智能体，记忆系统的演进是 AI Agent 具备实用价值的核心驱动力。通过本文的梳理，我们可以得出以下工程实践指南：

  1. 短期记忆（对话上下文）：必须精打细算。利用摘要、滑动窗口等技术过滤噪音，保证当前推理的高效与准确。
  2. 长期记忆（外部存储）：是 Agent 真正的“灵魂”所在。通过向量数据库和 RAG 技术，赋予 Agent 跨会话的个性和经验积累能力。
  3. 工作记忆（草稿本）：是解决复杂任务的“车间”。通过 ReAct 循环和 Scratchpad 机制，Agent 能够从容应对多步骤、高并发的复杂业务场景。

未来的 AI Agent 将不可避免地走向 “自我管理记忆” 的道路。当 Agent 能够像人类一样，在睡梦中（后台处理）将白天的短期经验转化为长期知识时，真正意义上的通用人工智能（AGI）或许就近在咫尺了。

作为开发者，深入理解这套记忆系统，不仅能够帮助我们开发出更智能的应用，更能让我们在 AI 技术的汹涌浪潮中，把握住系统设计的底层逻辑。