Agent Memory 进阶教程:从认知科学到 2025 年最佳实践

1.1 Agent Memory 在 LLM Agent 系统中的位置

LLM 本质上是无状态(stateless)函数:response = f(prompt)。但一个真正的 Agent 必须跨调用保存状态、跨会话学习、跨任务复用经验。Zhang et al., 2024 在《A Survey on the Memory Mechanism of Large Language Model based Agents》(arXiv:2404.13501)中将这种能力定义为 Agent 的 self-evolving capability——这是 LLM 与 Agent 的本质区别:

"Compared with original LLMs, LLM-based agents are featured in their self-evolving capability, which is the basis for solving real-world problems that need long-term and complex agent-environment interactions. The key component to support agent-environment interactions is the memory of the agents." — Zhang et al., 2024

图 1.1 · Memory 位于 LLM 与环境之间的核心位置;每一轮决策都包含 memory 的读、写与演化。

1.2 借鉴认知科学:CoALA 的四类记忆

CoALA(Cognitive Architectures for Language Agents,Sumers et al., 2023, arXiv:2309.02427, TMLR 2024)直接借鉴 Soar 与 ACT-R 等经典认知架构,将 Agent 形式化为元组:

其中 M_w 是工作记忆,M_lt 是长期记忆(三类),𝒜_i/𝒜_e 是内部/外部动作,D 是决策过程。CoALA 还把 LLM 重新定位为"probabilistic production systems"——这是与传统符号 AI 桥接的关键概念跨度。

1.3 上下文窗口 vs 外部记忆:本质区别

2.1 MemGPT / Letta:LLM 即操作系统

arXiv:2310.08560Packer, Wooders, Lin, Fang, Patil, Gonzalez (UC Berkeley)2023

核心洞察:Context Window 就是 RAM,外部存储就是磁盘,LLM 应通过 function calling 自主"分页"——这正是 OS 虚拟内存的隐喻。

图 2.1 · MemGPT 三层记忆:Core(RAM)— Recall(SSD)— Archival(冷存储)。

自编辑工具(原始 paper):core_memory_append、core_memory_replace、archival_memory_insert、archival_memory_search、conversation_search、conversation_search_date。

Letta(产品化):MemGPT 项目已并入 Letta(Packer 等创办的公司)。最关键的产品抽象是 Memory Block:可命名、可共享、可只读的上下文片段——它把"持久身份"从隐式 prompt 提升为 first-class object。

2.2 A-MEM:Zettelkasten 启发的 Agentic Memory

arXiv:2502.12110Xu, Liang, Mei, Gao, Tan, Y. Zhang(Rutgers + AIOS Foundation)2025-02

核心洞察:静态向量库不够——记忆应该像 Niklas Luhmann 的 Zettelkasten 卡片盒那样,自组织、互链接、可演化。

2.2.1 Memo 节点的数学定义

每条记忆 m_i 是一个原子笔记,包含:

• c_i:原始内容 / t_i:时间戳
• K_i:LLM 生成的关键词集合 / G_i:tags / X_i:contextual summary
• e_i = encode(c_i ⊕ K_i ⊕ G_i ⊕ X_i):稠密向量
• L_i:指向其他笔记的链接集合

2.2.2 两个核心机制

1. Link Generation:新笔记 m_n 入库时,检索 top-s(默认 s=10)相似历史笔记,让 LLM 判断是否建立链接。"box" 概念允许同一笔记属于多个语义簇(突破传统目录的单层归属)。
2. Memory Evolution:新笔记可触发对旧笔记的 K_j, G_j, X_j 的覆盖式更新。这是论文最反直觉的设计——旧记忆的"理解"会随新经验加深。

2.2.3 LoCoMo 实验结果(GPT-4o-mini,F1 / BLEU-1)

A-MEM 在 ~85-93% token 削减下,在 Temporal 类问题上比 MemGPT 高近 20 F1 点;每次操作约 1,200 token、< $0.0003、5.4s(GPT-4o-mini)。测了 6 个 foundation 模型:GPT-4o-mini、GPT-4o、Qwen2.5-1.5B/3B、Llama 3.2-1B/3B。

2.3 Mem0 / Mem0g:可生产部署的事实抽取记忆

arXiv:2504.19413Chhikara, Khant, Aryan, Singh, Yadav (Mem0 Inc.)2025-04

两阶段架构:

1. Extraction Phase:LLM 从最近 m 条消息(默认 m=10)抽取候选事实
2. Update Phase:对每条候选,LLM 判定四选一操作 → ADD / UPDATE / DELETE / NOOP

Mem0g(图增强变体):用 LLM 抽取实体-关系三元组,构建有向标记图 G=(V, E, L)。冲突时不删除旧边,而是标记为 invalid——保留时序推理能力,这与 Zep 的双时态思想一致。

2.3.1 LoCoMo 上的关键数据(GPT-4o-mini)

Mem0 论文的标题性结论:

"Mem0 attains a 91% lower p95 latency and saves more than 90% token cost" — Chhikara et al., 2025

"Our methods deliver 5%, 11%, and 7% relative improvements in single-hop, temporal, and multi-hop reasoning question types over best performing methods" — Mem0 §5

2.4 Generative Agents:反思(Reflection)与记忆流

arXiv:2304.03442Park, O'Brien, Cai, Morris, Liang, Bernstein(Stanford/Google)UIST 2023

Memory Stream:每条记忆 = (自然语言描述, creation_time, last_access_time)。

检索得分公式(三项归一化到 [0,1] 加权):

• Recency:指数衰减 0.99^Δt(以小时为单位,自上次访问起)
• Importance:让 LLM 输出 1–10 整数分(prompt 提示"区分平凡如刷牙与重要如分手")
• Relevance:query embedding 与记忆 embedding 的 cosine similarity

Reflection 触发:当最近事件 importance 总和超过阈值 150 时触发,论文中代理每天反思 2-3 次。引用原文(Park et al., 2023, arXiv:2304.03442):

"Periodic Trigger: Reflection occurs when the importance score of recent observations exceeds a set threshold (150)."

反思过程:从最近 100 条记忆中让 LLM 提出 3 个高层问题 → 对每个问题再做检索 → 让 LLM 综合出 5 条更抽象的 insight → 写回 Memory Stream(可被再检索)。

2.5 Reflexion:把"反思"当作可学习的 Episodic Memory

arXiv:2303.11366Shinn, Cassano, Berman, Gopinath, Narasimhan, YaoNeurIPS 2023

不更新权重,而把环境反馈转成自然语言"自我反思",写入 episodic memory buffer,下一轮作为 context——作者称之为 verbal reinforcement learning。三个 LLM 角色:

• Actor M_a:执行任务(可以是 ReAct、CoT)
• Evaluator M_e:scalar 或自然语言打分
• Self-Reflection M_sr:把失败痕迹转为可操作的改进文本

原文报道的关键成绩(arXiv:2303.11366):

"Reflexion achieves a 91% pass@1 accuracy on the HumanEval coding benchmark, surpassing the previous state-of-the-art GPT-4 that achieves 80%."

2.6 MemoryBank:艾宾浩斯遗忘曲线

arXiv:2305.10250Zhong, Guo, Tang, Wang, Wang(Sun Yat-sen)AAAI 2024

三大模块:(1) memory storage(对话 + 事件总结 + 用户画像);(2) memory retriever(相似度);(3) memory updater。后者是论文核心创新:基于艾宾浩斯遗忘曲线

其中 R 是保留率,t 是时间,S 是 memory strength。每次成功召回会增加 S(模拟"复习"),低 R 的记忆会被遗忘或弱化。整套思路被植入 SiliconFriend——一个长期 AI 陪伴 agent。

2.7 Zep / Graphiti:双时态(Bi-temporal)知识图谱

arXiv:2501.13956Rasmussen, Paliychuk, Chalef, Rodriguez, Kucherawy(Zep AI)2025-01

Zep 的核心引擎 Graphiti 实现 bi-temporal model:每条边显式记录两个时间区间——

• (t_valid_start, t_valid_end):事实在真实世界有效的区间
• (t_ingested, t_invalidated):系统知道这个事实的区间

当新信息与旧事实冲突,旧边不会被删除,而是被打上 t_invalidated 时间戳。这使得"我去年的工作是什么"(时间旅行查询)与"用户当前的工作"都能精准回答。

图 2.2 · Graphiti 的三层子图架构。

2.7.1 DMR 基准结果(MemGPT 团队设立)

DMR 数据集:恰好 500 条多会话对话,每条含 5 个 chat session、每 session 最多 12 条消息(per Rasmussen et al., 2025, arXiv:2501.13956)。

2.7.2 LongMemEval 上的关键数据(gpt-4o)

Zep 将延迟从 28.9s 降至 2.58s(约 91% 降幅),准确率从 60.2% 提升至 71.2%(+11pp,原文宣称综合改善 18.5pp)。引用原文:

"accuracy improvements of up to 18.5% while simultaneously reducing response latency by 90% compared to baseline implementations." — Rasmussen et al., 2025

4.1 LangChain / LangGraph Memory(2025 最新)

LangGraph 把记忆明确分为两层:

• Checkpointer(thread 内,自动):InMemorySaver、PostgresSaver、MongoDBSaver、RedisSaver、DynamoDBSaver(AWS 2025 新增)、AgentCoreMemorySaver(Bedrock 2025 新增)
• Store(跨 thread 长期,显式):InMemoryStore、PostgresStore、MongoDBStore(2025-08 GA)、RedisStore——以 namespace + key + JSON value 组织,支持向量搜索与 TTL

from langgraph.checkpoint.postgres import PostgresSaver
from langgraph.store.postgres import PostgresStore
from langgraph.graph import StateGraph, MessagesState, START
from langchain.chat_models import init_chat_model
import uuid

DB_URI = "postgresql://user:pass@localhost:5432/lg"
model = init_chat_model("openai:gpt-4o-mini")

def call_model(state: MessagesState, *, store):
    user_ns = ("memories", "user-123")
    # 检索相关长期记忆
    items = store.search(user_ns, query=state["messages"][-1].content, limit=3)
    ctx = "\n".join(f"- {item.value['data']}" for item in items)
    sys = f"You are a helpful assistant. User info:\n{ctx}"
    resp = model.invoke([{"role": "system", "content": sys}, *state["messages"]])
    # 写入新记忆(此处简化为关键词触发,生产中用 LLM 抽取)
    last = state["messages"][-1].content
    if "remember" in last.lower():
        store.put(user_ns, str(uuid.uuid4()), {"data": last})
    return {"messages": resp}

with (PostgresStore.from_conn_string(DB_URI) as store,
      PostgresSaver.from_conn_string(DB_URI) as ck):
    store.setup(); ck.setup()
    builder = StateGraph(MessagesState)
    builder.add_node(call_model)
    builder.add_edge(START, "call_model")
    graph = builder.compile(checkpointer=ck, store=store)

    config = {"configurable": {"thread_id": "t1", "user_id": "user-123"}}
    graph.invoke({"messages": [{"role": "user",
                  "content": "Remember: my favorite IDE is Cursor."}]}, config)

4.2 LlamaIndex Memory(Memory Block 新抽象)

LlamaIndex 在 2025 推出新的 Memory 类,核心抽象是 Memory Block——可插拔的长期记忆模块。三种预置:

• StaticMemoryBlock:不变的核心信息(persona)
• FactExtractionMemoryBlock:LLM 抽取事实,带 max_facts 自动摘要
• VectorMemoryBlock:把 flushed 对话写入向量库(Qdrant/Chroma/Weaviate/Milvus)

from llama_index.core.memory import (
    Memory, StaticMemoryBlock, FactExtractionMemoryBlock, VectorMemoryBlock)
from llama_index.llms.openai import OpenAI
from llama_index.vector_stores.qdrant import QdrantVectorStore
from llama_index.embeddings.openai import OpenAIEmbedding

llm = OpenAI(model="gpt-4o-mini")
emb = OpenAIEmbedding(model="text-embedding-3-small")
qdrant = QdrantVectorStore(client=client, collection_name="agent_mem")

blocks = [
    StaticMemoryBlock(name="core",
        static_content="User: Alice, PM at Acme. Prefers concise replies.",
        priority=0),  # 永不被截断
    FactExtractionMemoryBlock(name="facts", llm=llm, max_facts=50, priority=1),
    VectorMemoryBlock(name="vec", vector_store=qdrant, embed_model=emb,
                      similarity_top_k=3, priority=2),
]

memory = Memory.from_defaults(
    session_id="alice_session_1",
    token_limit=40000,
    chat_history_token_ratio=0.7,   # 28k 短期 / 12k 长期
    token_flush_size=3000,
    memory_blocks=blocks,
    insert_method="system",
)

# 在 FunctionAgent 中使用
from llama_index.core.agent.workflow import FunctionAgent
agent = FunctionAgent(tools=[...], llm=llm, memory=memory)
await agent.run("我上次提到的项目截止日期是?")

4.3 Mem0

Mem0 提供两种部署:Platform(MemoryClient,托管) 与 OSS(Memory,自托管)。OSS 默认 LLM 为 gpt-5-mini,默认 embedding 为 text-embedding-3-small。

from openai import OpenAI
from mem0 import Memory

memory = Memory()  # 默认 ChromaDB + OpenAI
client = OpenAI()

def chat(msg, user_id="alice"):
    rel = memory.search(query=msg, filters={"user_id": user_id}, top_k=3)
    ctx = "\n".join(f"- {r['memory']}" for r in rel["results"])
    messages = [
        {"role": "system",
         "content": f"You are a helpful AI.\nUser Memories:\n{ctx}"},
        {"role": "user", "content": msg},
    ]
    resp = client.chat.completions.create(model="gpt-5-mini", messages=messages)
    out = resp.choices[0].message.content
    messages.append({"role": "assistant", "content": out})
    memory.add(messages, user_id=user_id)  # LLM 自动抽取事实并 ADD/UPDATE/DELETE/NOOP
    return out

from agents import Agent, Runner, function_tool, RunContextWrapper
from mem0 import MemoryClient

mem0 = MemoryClient()  # Platform 模式

@function_tool
def save_memory(ctx: RunContextWrapper, fact: str) -> str:
    mem0.add([{"role":"user","content":fact}], user_id=ctx.user_id)
    return "saved"

@function_tool
def recall_memory(ctx: RunContextWrapper, query: str) -> str:
    res = mem0.search(query=query, user_id=ctx.user_id, top_k=5)
    return "\n".join(r["memory"] for r in res["results"])

agent = Agent(name="learning_companion",
              instructions="Use save_memory/recall_memory when needed.",
              tools=[save_memory, recall_memory])

from mem0 import Memory
from anthropic import Anthropic

cfg = {"llm": {"provider": "anthropic",
               "config": {"model": "claude-3-5-sonnet-latest"}}}
memory = Memory.from_config(cfg)
claude = Anthropic()

# add / search 用法相同
memory.add([{"role":"user","content":"我吃素,坚果过敏"}], user_id="alice")
# Mem0 会自动拆成两个事实:vegetarian / allergic to nuts

4.4 Letta(原 MemGPT)

from letta_client import Letta
import os

client = Letta(api_key=os.getenv("LETTA_API_KEY"))

# 创建 Stateful Agent
agent_state = client.agents.create(
    model="openai/gpt-4o-mini",
    memory_blocks=[
        {"label": "human", "value": "Name: Alice. Role: PM."},
        {"label": "persona",
         "value": "I am a precise, helpful product assistant."},
    ],
    tools=["web_search"],          # 自定义工具
    include_base_tools=True,        # 启用 core_memory_*、archival_memory_*
)
print(agent_state.id)

# 发送消息(agent 内部自动调 core_memory_append / archival_memory_insert)
resp = client.agents.messages.create(
    agent_id=agent_state.id,
    messages=[{"role": "user",
               "content": "记一下:我最喜欢的 IDE 是 Cursor,讨厌 toast 通知。"}]
)
for m in resp.messages: print(m)

# 取出 human block 看 agent 学到什么
human = client.agents.blocks.retrieve(agent_id=agent_state.id, block_label="human")
print(human.value)
# → "Name: Alice. Role: PM. Favorite IDE: Cursor. Dislikes toast notifications."

# 共享块(multi-agent 协调原语)
org = client.blocks.create(label="organization", value="Acme Inc, PM tooling team")
supervisor = client.agents.create(
    model="openai/gpt-4o-mini",
    memory_blocks=[{"label":"persona","value":"I am supervisor"}],
    block_ids=[org.id])
worker = client.agents.create(
    model="openai/gpt-4o-mini",
    memory_blocks=[{"label":"persona","value":"I am worker"}],
    block_ids=[org.id])
# 一方写入 org block,另一方立刻可见

4.5 Zep

from zep_cloud.client import Zep
import os

zep = Zep(api_key=os.getenv("ZEP_API_KEY"))

# 1. 用户与会话
zep.user.add(user_id="alice", first_name="Alice", email="alice@acme.com")
zep.memory.add_session(session_id="s1", user_id="alice")

# 2. 追加消息(Graphiti 异步抽取实体、关系、时态)
zep.memory.add(session_id="s1", messages=[
    {"role_type": "user",
     "content": "I'm allergic to peanuts and changed jobs to Acme last month."},
    {"role_type": "assistant",
     "content": "Noted your peanut allergy and new role at Acme."},
])

# 3. 检索:语义 + BM25 + 图遍历融合,典型 < 100ms(不含 embedding API)
memory = zep.memory.get(session_id="s1")
print(memory.context)
# memory.context 包含:
#   - 最近 N 条原始消息
#   - 抽取的 facts(带 valid_at / invalid_at)
#   - 相关 entity summaries
#   - 时态推理所需的 episode 引用

# 4. 跨会话事实检索
facts = zep.memory.search_sessions(
    user_id="alice",
    text="peanut allergy",
    search_scope="facts")
for f in facts.facts:
    print(f.fact, f.valid_at, f.invalid_at)

4.6 框架对比表