AI Agent 的记忆系统怎么设计？从短期记忆到长期记忆，我踩过的 6 个坑

haoxinpoju

132人浏览 · 2026-06-10 09:05:16

haoxinpoju · 2026-06-10 09:05:16 发布

AI Agent 的记忆系统怎么设计？从短期记忆到长期记忆，我踩过的 6 个坑

适合正在开发 AI Agent、想让 Agent "记住"历史对话和用户偏好的开发者。
本文讲解 AI Agent 记忆系统的 3 层架构设计，附 Python 实现代码。

为什么 Agent 需要记忆

没有记忆的 AI Agent 就像一个每天失忆的人——你今天告诉它"我喜欢简洁的写作风格"，明天它就忘了，又写一堆废话。

记忆系统解决的核心问题：

问题	没有记忆	有记忆
用户偏好	每次重新交代	自动记住
历史上下文	只看当前对话	能回忆过去
知识积累	每次从零开始	持续学习
个性化	千人一面	越用越懂你

记忆系统的 3 层架构

┌─────────────────────────────────────┐
│         长期记忆（Long-term）         │  用户画像、偏好、历史知识
├─────────────────────────────────────┤
│         工作记忆（Working）           │  当前任务的上下文
├─────────────────────────────────────┤
│         感官记忆（Sensory）           │  最近几轮对话原文
└─────────────────────────────────────┘

感官记忆：最近几轮对话

最简单的记忆，就是把最近 N 轮对话原文塞进 prompt。

class SensoryMemory:
    """感官记忆：保存最近 N 轮对话"""

    def __init__(self, max_turns=10):
        self.history = []
        self.max_turns = max_turns

    def add(self, role, content):
        self.history.append({"role": role, "content": content})
        # 超过上限，删除最早的
        if len(self.history) > self.max_turns * 2:
            self.history = self.history[-self.max_turns * 2:]

    def get_context(self):
        """返回最近的对话历史"""
        return self.history

    def clear(self):
        self.history = []

问题：对话越来越长，token 超限。10 轮对话可能就占了 3000 token。

工作记忆：当前任务上下文

工作记忆保存当前正在做的事情的关键信息，不是对话原文，而是摘要。

class WorkingMemory:
    """工作记忆：当前任务的关键信息摘要"""

    def __init__(self):
        self.summary = ""
        self.current_task = ""
        self.key_facts = []

    def update(self, task, facts):
        """更新工作记忆"""
        self.current_task = task
        self.key_facts = facts
        self.summary = f"当前任务: {task}\n关键信息: {', '.join(facts)}"

    def get_context(self):
        """返回工作记忆上下文"""
        if not self.summary:
            return ""
        return f"[工作记忆]\n{self.summary}"

    def add_fact(self, fact):
        """添加一个关键信息"""
        if fact not in self.key_facts:
            self.key_facts.append(fact)
            self.summary = f"当前任务: {self.current_task}\n关键信息: {', '.join(self.key_facts)}"

长期记忆：用户画像和历史知识

长期记忆存在外部存储（数据库/文件），包含用户偏好、历史交互总结、学到的知识。

import json
from pathlib import Path

class LongTermMemory:
    """长期记忆：持久化存储用户画像和历史知识"""

    def __init__(self, storage_path="memory.json"):
        self.path = Path(storage_path)
        self.data = self._load()

    def _load(self):
        if self.path.exists():
            return json.loads(self.path.read_text(encoding="utf-8"))
        return {"user_profile": {}, "preferences": [], "learned": []}

    def _save(self):
        self.path.write_text(json.dumps(self.data, ensure_ascii=False, indent=2), encoding="utf-8")

    def add_preference(self, key, value):
        """记录用户偏好"""
        self.data["preferences"] = [p for p in self.data["preferences"] if p["key"] != key]
        self.data["preferences"].append({"key": key, "value": value})
        self._save()

    def add_learned(self, knowledge):
        """记录学到的知识"""
        if knowledge not in self.data["learned"]:
            self.data["learned"].append(knowledge)
            self._save()

    def get_context(self):
        """返回长期记忆上下文"""
        parts = []
        if self.data["preferences"]:
            prefs = [f"{p['key']}: {p['value']}" for p in self.data["preferences"]]
            parts.append(f"[用户偏好]\n" + "\n".join(prefs))
        if self.data["learned"]:
            parts.append(f"[历史知识]\n" + "\n".join(self.data["learned"][-10:]))  # 最近 10 条
        return "\n\n".join(parts)

3 层记忆组合使用

class AgentMemory:
    """Agent 记忆系统：3 层组合"""

    def __init__(self):
        self.sensory = SensoryMemory(max_turns=10)
        self.working = WorkingMemory()
        self.long_term = LongTermMemory()

    def add_turn(self, role, content):
        """添加一轮对话"""
        self.sensory.add(role, content)

    def build_prompt(self, system_prompt):
        """组装完整的 prompt，包含所有记忆层"""
        messages = [{"role": "system", "content": system_prompt}]

        # 长期记忆（放在 system prompt 里）
        lt_ctx = self.long_term.get_context()
        if lt_ctx:
            messages[0]["content"] += f"\n\n{lt_ctx}"

        # 工作记忆
        wk_ctx = self.working.get_context()
        if wk_ctx:
            messages[0]["content"] += f"\n\n{wk_ctx}"

        # 感官记忆（最近对话）
        messages.extend(self.sensory.get_context())

        return messages

    def learn_from_conversation(self):
        """从对话中提取值得记住的信息"""
        # 简化实现：让 LLM 总结对话中的关键信息
        recent = self.sensory.get_context()
        if len(recent) < 4:
            return

        summary_prompt = f"""从以下对话中提取值得长期记住的信息（用户偏好、关键知识）。
只输出 JSON 格式：
{{"preferences": [{{"key": "xxx", "value": "xxx"}}], "learned": ["xxx"]}}

对话：
{json.dumps(recent[-6:], ensure_ascii=False)}"""

        # 调用 LLM 提取（这里简化处理）
        # result = local_chat(summary_prompt)
        # parsed = json.loads(result)
        # for p in parsed.get("preferences", []):
        #     self.long_term.add_preference(p["key"], p["value"])
        pass

使用示例

# 初始化
memory = AgentMemory()

# 模拟对话
memory.add_turn("user", "帮我写一篇关于 Python 的文章，风格要口语化")
memory.add_turn("assistant", "好的，我来写一篇口语化的 Python 文章...")
memory.add_turn("user", "不错，但代码注释太少了")
memory.add_turn("assistant", "明白了，以后代码我会加更多注释")

# 记住用户偏好
memory.long_term.add_preference("写作风格", "口语化")
memory.long_term.add_preference("代码要求", "需要详细注释")

# 下次对话时，Agent 自动知道用户的偏好
messages = memory.build_prompt("你是一个技术写作助手")
# messages 会包含：[系统提示 + 用户偏好 + 工作记忆 + 最近对话]

记忆压缩：对话太长怎么办

对话超过 20 轮后，token 会超限。这时候需要压缩：把旧对话总结成摘要，只保留最近几轮原文。

def compress_history(history, keep_recent=6):
    """压缩对话历史：旧的总结成摘要，最近的保留原文"""
    if len(history) <= keep_recent:
        return history

    old = history[:-keep_recent]
    recent = history[-keep_recent:]

    # 让 LLM 总结旧对话
    old_text = json.dumps(old, ensure_ascii=False)
    summary_prompt = f"用 100 字总结这段对话的要点：\n{old_text}"
    summary = local_chat(summary_prompt)

    # 用摘要替代旧对话
    compressed = [{"role": "system", "content": f"[历史摘要] {summary}"}]
    compressed.extend(recent)

    return compressed