有哪种记忆，对应到 AI Agent 中分别是什么？

这个问题问得很到位，因为记忆设计几乎决定了 AI Agent 的上限。咱们直接拆开来看，把人类记忆的几种类型平移到 Agent 架构里，顺便配上图标和代码，会更直观。

---

👁️ 1. 感觉记忆（Sensory Memory）

瞬间存储，容量极大，保留时间极短（毫秒~秒级），还没怎么加工。

在 Agent 里对应什么？

就是原始观测缓冲区，比如刚从摄像头拿到的几帧画面、还没来得及处理的传感器数据流、用户输入的原始字符串。这一层只负责暂存，不做理解。

from collections import deque
import time

class SensoryBuffer:
    """原始输入环形缓冲区，只存最近 2 秒的帧"""
    def __init__(self, max_age_sec=2):
        self.buffer = deque()
        self.max_age = max_age_sec

    def add(self, data):
        self.buffer.append((time.time(), data))

    def get_recent(self):
        now = time.time()
        self.buffer = deque(
            [(ts, d) for ts, d in self.buffer if now - ts <= self.max_age]
        )
        return [d for _, d in self.buffer]

为什么需要它？ 如果每帧都立刻进大脑（工作记忆），CPU 会爆炸，所以这里只是“过一下”，后面的模块按需取用。

---

🧠 2. 工作记忆（Working Memory）

也叫短时记忆，容量有限，保持几秒到几十秒，用来执行当前认知任务。

Agent 里就是上下文窗口+暂存器

对话历史、中间推理步骤（Chain-of-Thought）、当前的子目标、工具调用结果……都装在这里。它的核心问题是 容量管理——超过 token 限制就得做截断、摘要或遗忘。

import tiktoken

class WorkingMemory:
    def __init__(self, max_tokens=4000):
        self.messages = []          # 存完整的对话消息
        self.scratchpad = ""       # 当前推理草稿
        self.max_tokens = max_tokens
        self.enc = tiktoken.get_encoding("cl100k_base")

    def add_message(self, role, content):
        self.messages.append({"role": role, "content": content})
        self._truncate()

    def write_scratch(self, text):
        self.scratchpad = text

    def get_context(self):
        return {
            "messages": self.messages,
            "scratchpad": self.scratchpad
        }

    def _truncate(self):
        total = sum(len(self.enc.encode(m["content"])) for m in self.messages)
        while total > self.max_tokens and len(self.messages) > 1:
            oldest = self.messages.pop(1)  # 保留 system prompt
            total -= len(self.enc.encode(oldest["content"]))

很多 Agent 就是在这里“犯傻”——长对话忘掉开头，其实就是工作内存爆了，又没有好的压缩策略。

---

🗄️ 3. 长期记忆（Long-Term Memory）

长期记忆在心理学里又分好几种子类，对应到 Agent 里刚好就是三种典型模块。

🎬 情景记忆（Episodic Memory）

记住“什么时间、在哪里、发生了什么”的具体经历。

Agent 实现：带时间戳的向量化记忆库

每次交互结束后，把事件摘要和元数据存进向量数据库，后续用语义检索“类似的情况”。

import chromadb
from datetime import datetime
from sentence_transformers import SentenceTransformer

class EpisodicMemory:
    def __init__(self):
        self.client = chromadb.Client()
        self.collection = self.client.create_collection("episodes")
        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')

    def store_episode(self, user_input, agent_response, metadata=None):
        text = f"User: {user_input}\nAgent: {agent_response}"
        emb = self.encoder.encode(text).tolist()
        meta = metadata or {}
        meta["timestamp"] = datetime.now().isoformat()
        self.collection.add(
            embeddings=[emb],
            documents=[text],
            metadatas=[meta],
            ids=[str(hash(text))]
        )

    def recall_similar(self, query, k=3):
        emb = self.encoder.encode(query).tolist()
        results = self.collection.query(query_embeddings=[emb], n_results=k)
        return results.get("documents", [[]])[0]

用途：下次遇到类似问题，Agent 会说“上次我们聊过这个，那次你是怎么想的……”

---

📚 语义记忆（Semantic Memory）

记住事实、概念、知识，不依赖具体情境。

Agent 实现：知识库 RAG + 实体图

可以是企业文档、维基、产品手册等，把知识拆成 chunks 做检索增强生成。

# 极简 RAG 示意
class SemanticMemory:
    def __init__(self, docs):
        self.encoder = SentenceTransformer('all-MiniLM-L6-v2')
        self.chunks = []
        self.embeddings = []
        for doc in docs:
            # 实际会有更好的分块策略
            emb = self.encoder.encode(doc).tolist()
            self.chunks.append(doc)
            self.embeddings.append(emb)

    def query(self, question, top_k=2):
        q_emb = self.encoder.encode(question).tolist()
        scores = [
            (i, self._cosine(q_emb, e)) for i, e in enumerate(self.embeddings)
        ]
        scores.sort(key=lambda x: x[1], reverse=True)
        return [self.chunks[i] for i, _ in scores[:top_k]]

    def _cosine(self, a, b):
        dot = sum(x*y for x,y in zip(a,b))
        norm = (sum(x*x for x in a)**0.5) * (sum(y*y for y in b)**0.5)
        return dot / norm

⚙️ 程序性记忆（Procedural Memory）

记住“如何做一件事”的技能，常常内隐（骑车、游泳）。

Agent 实现：工具注册 + 成功路径模板

比如某个 Agent 学会“查天气 → 查路况 → 推荐出发时间”这一条流水线，就可以被固化为一个技能模板，下次直接调用。

class ProceduralMemory:
    def __init__(self):
        self.tools = {}              # 工具名称到函数
        self.procedures = []         # 成功工作流模板

    def register_tool(self, name, func):
        self.tools[name] = func

    def learn_procedure(self, step_sequence: list[dict]):
        """将一次成功的多步操作保存为流程模板"""
        self.procedures.append({
            "steps": step_sequence,   # 比如 [{"tool": "weather"}, {"tool": "traffic"}]
            "score": 1.0
        })

    def recall_best_procedure(self, context):
        # 根据当前上下文匹配最相似的流程，这里简化为返回最高分
        if not self.procedures:
            return None
        return max(self.procedures, key=lambda p: p["score"])

未来微调模型本质也是在固化程序性记忆——从海量经验里蒸馏出“怎么做更好”。

---

🔄 一张图看懂映射关系

查看内嵌表格

---

🤔 一个值得多想一步的问题

我们经常狂加记忆，却很少认真设计“遗忘”——如果情景记忆永远不衰减，Agent 会不会被旧经验绑架？ 或者说，Agent 的“人格”到底是由工作记忆的容量决定，还是由长期记忆的检索策略定义？ 这是我实际踩坑时发现比选什么向量库更关键的问题。

---