框架

Agent Memory 是什么:别把聊天记录当记忆

Anthropic 将 Agent Memory 拆成写入、组织、检索、更新与遗忘。本文给出一套 SQLite + FTS5 最小实现,并补上评测指标。

字号

Agent Memory 是什么:别把聊天记录当记忆

Anthropic 拆解了 Agent Memory 的组成机制。上下文窗口只是暂存区。真正难的是写入、更新、召回和删除。

Anthropic 最近发布研究文章《The Components of Agent Memory》,讨论 Agent 如何持续积累并再次调用历史信息。

文章登上 Hacker News 首页时,拿到了 97 分和 55 条评论。讨论页在这里:https://news.ycombinator.com/item?id=50402212

这组数字说明开发者关心 Agent Memory。但讨论里最容易被混淆的一点是:聊天记录不等于记忆。

一个窗口开到几十万 token,也不代表 Agent 拥有长期记忆。它可能只是把更多旧文本塞回 prompt。

HN 首页上的 Agent 记忆论文

Anthropic 的《The Components of Agent Memory》不是一篇“给 Agent 加个向量库”的教程。它关注一个更底层的问题:Agent 要形成可用记忆,需要哪些组件,以及这些组件如何组成完整生命周期。

文章聚焦如何为 Agent 构建可持续积累并调用历史信息的记忆系统。现有材料把关键环节概括为四类:

  • 存储:把需要保留的信息落到上下文窗口之外
  • 组织:决定信息以什么结构保存
  • 检索:在需要时找到相关片段
  • 更新:处理新增、修改和已经失效的信息

这也是为什么 Agent Memory 不该被理解成“更长的聊天记录”。聊天记录是 append-only 的事件流。记忆系统则要面对选择:什么值得保存,如何关联,什么时候重新读取,以及旧内容是否应该删除。

Anthropic 原文:https://www.anthropic.com/research/components-of-agent-memory

聊天记录不等于 Agent 记忆

先看一个最小反例。

假设 Agent 第一次执行任务时,用户说:

我的部署脚本放在 infra/ 目录,使用 make deploy。

两周后,用户问:

怎么部署这个项目?

如果系统只保存聊天记录,那么第二次任务可能根本看不到第一次对话。Agent 会重新猜测目录、命令和项目结构。

把整段历史直接塞回上下文,也不等于解决了问题。

第一,历史越长,噪声越多。用户曾经说过的临时路径、已废弃方案和临时猜测,都会被一起召回。

第二,重要事实通常需要改写。比如部署命令从 make deploy 改成 make release。原始聊天里同时存在两个答案,但当前有效状态只有一个。

第三,召回是有成本的。上下文越满,留给当前任务、工具输出和代码修改的空间越少。

所以上下文窗口更像暂存区。它让模型在当前请求里看到材料,却不负责跨任务的长期状态管理。

真正的记忆至少要回答四个问题:

  1. 哪些信息可以进入长期存储?
  2. 记忆按什么结构组织?
  3. 当前任务应该召回哪些内容?
  4. 新事实到来后,旧的记忆怎么处理?

少了写入、检索或更新中的任何一环,都只是“历史信息缓存”,还不是完整的 Agent Memory。

记忆的组件与生命周期

我把 Agent Memory 拆成一条生命周期,而不是一组产品名。

1. 写入:从事件中提取状态

Agent 做完一次任务后,系统不能无脑保存全部 transcript。需要先判断哪些内容具备长期价值。

通常值得写入的是:

  • 用户偏好,例如“回答用中文”
  • 稳定事实,例如项目使用的语言和框架
  • 决策记录,例如“认证方案采用 Auth0”
  • 工作流规则,例如“部署前先跑测试”

不适合长期保存的则包括:

  • 一次性的工具报错
  • 当前 shell 里的临时路径
  • Agent 自己尚未验证的猜测
  • 已经完成任务中的大量中间过程

写入环节需要来源信息和置信状态。否则系统只会把模型的幻觉固化成“用户事实”。

2. 组织:让记忆有结构

原始文本适合阅读,却未必适合机器使用。

一种实用做法是同时保留两类数据:

  • 面向人的可读记忆
  • 面向程序的结构化字段

例如:

{
  "key": "project.deploy_command",
  "value": "make release",
  "scope": "project:web-api",
  "source": "user",
  "confidence": 1.0,
  "updated_at": "2026-08-24T10:30:00Z"
}

key 负责去重和覆盖,scope 控制隔离,source 记录依据,updated_at 用来判断新旧。

这比把十条记忆塞进一个向量里更容易审计。向量适合找相似语义,不适合单独承担一致性判断。

3. 检索:先精确,再扩展

检索不该只有“向量搜索 top-k”这一条路径。

一个更可靠的小系统通常会混合:

  • 精确匹配:按 key、项目 ID、用户 ID 读取
  • 关键词检索:找命令、错误码、专有名词
  • 向量检索:处理自然语言改写和语义近似
  • 时间过滤:排除已经过期的候选
  • 权限过滤:只查询当前 Agent 有权访问的记忆

召回结果还需要重新排序。例如,精确命中的当前配置,应排在语义相似但已经过期的讨论之前。

4. 更新与遗忘:让旧事实退场

更新不是简单追加。

新记忆与旧记忆冲突时,至少要处理:

  • 覆盖:用户明确修改了旧偏好
  • 合并:两条信息描述同一事实
  • 失效:时间条件已经结束
  • 保留历史:当前值变了,但仍需要审计旧值
  • 删除:内容不应继续保存

如果系统只做 append,记忆越多,冲突就越多。Agent 每次召回两三个版本,然后自行选择一个。这等于把治理成本推给模型,而且没有保证。

工程实现:先做最小闭环

别一上来就上复杂的多 Agent 记忆图谱。

我建议先实现一个能跑的闭环:结构化存储、混合检索、时间戳、覆盖更新。再加一组固定评测集,检查记忆到底帮了 Agent,还是制造了噪声。

下面这个例子使用 SQLite,不需要向量数据库。它能跑通“写入、按 key 读取、关键词召回”这条最小链路。

import sqlite3
from datetime import datetime, timezone

DB_PATH = "agent_memory.db"

def init_db():
    with sqlite3.connect(DB_PATH) as conn:
        conn.execute(
            """
            CREATE TABLE IF NOT EXISTS memories (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                key TEXT NOT NULL,
                value TEXT NOT NULL,
                scope TEXT NOT NULL,
                source TEXT NOT NULL,
                confidence REAL NOT NULL DEFAULT 1.0,
                updated_at TEXT NOT NULL,
                UNIQUE(key, scope)
            )
            """
        )
        conn.execute(
            """
            CREATE VIRTUAL TABLE IF NOT EXISTS memory_search
            USING fts5(key, value, scope, content='memories', content_rowid='id')
            """
        )
        conn.execute(
            """
            CREATE TRIGGER IF NOT EXISTS memories_ai AFTER INSERT ON memories BEGIN
                INSERT INTO memory_search(rowid, key, value, scope)
                VALUES (new.id, new.key, new.value, new.scope);
            END
            """
        )
        conn.execute(
            """
            CREATE TRIGGER IF NOT EXISTS memories_ad AFTER DELETE ON memories BEGIN
                INSERT INTO memory_search(memory_search, rowid, key, value, scope)
                VALUES ('delete', old.id, old.key, old.value, old.scope);
            END
            """
        )
        conn.execute(
            """
            CREATE TRIGGER IF NOT EXISTS memories_au AFTER UPDATE ON memories BEGIN
                INSERT INTO memory_search(memory_search, rowid, key, value, scope)
                VALUES ('delete', old.id, old.key, old.value, old.scope);
                INSERT INTO memory_search(rowid, key, value, scope)
                VALUES (new.id, new.key, new.value, new.scope);
            END
            """
        )

def remember(key, value, scope="global", source="user", confidence=1.0):
    now = datetime.now(timezone.utc).isoformat()
    with sqlite3.connect(DB_PATH) as conn:
        conn.execute(
            """
            INSERT INTO memories(key, value, scope, source, confidence, updated_at)
            VALUES (?, ?, ?, ?, ?, ?)
            ON CONFLICT(key, scope) DO UPDATE SET
                value = excluded.value,
                source = excluded.source,
                confidence = excluded.confidence,
                updated_at = excluded.updated_at
            """,
            (key, value, scope, source, confidence, now),
        )

def get_exact(key, scope="global"):
    with sqlite3.connect(DB_PATH) as conn:
        row = conn.execute(
            "SELECT key, value, scope, source, confidence, updated_at "
            "FROM memories WHERE key = ? AND scope = ?",
            (key, scope),
        ).fetchone()
    return dict(zip(
        ["key", "value", "scope", "source", "confidence", "updated_at"], row
    )) if row else None

def search(query, scope="global", limit=5):
    with sqlite3.connect(DB_PATH) as conn:
        rows = conn.execute(
            """
            SELECT m.key, m.value, m.scope, m.source, m.confidence, m.updated_at
            FROM memory_search AS s
            JOIN memories AS m ON m.id = s.rowid
            WHERE memory_search MATCH ? AND m.scope = ?
            ORDER BY m.updated_at DESC
            LIMIT ?
            """,
            (query, scope, limit),
        ).fetchall()
    return [dict(zip(
        ["key", "value", "scope", "source", "confidence", "updated_at"], row
    )) for row in rows]

init_db()
remember(
    "project.deploy_command",
    "make release",
    scope="project:web-api",
)
remember(
    "response.language",
    "中文",
    scope="user:42",
)

print(get_exact("project.deploy_command", "project:web-api"))
print(search("deploy", scope="project:web-api"))

这里刻意没有调用 embedding API。原因很简单:先验证数据模型和生命周期,再决定是否需要语义检索。

只有当关键词召回频繁漏掉同义表达,或者用户会使用多种描述方式时,再加向量检索。向量库不是记忆系统的起点。

复杂架构也分阶段加:

  1. 单表结构化记忆:验证去重、覆盖和删除
  2. SQLite + FTS5:验证关键词召回
  3. 混合检索:加入 embedding 和 reranker
  4. 独立记忆服务:出现多租户、跨 Agent 共享需求后再做

真正的瓶颈是记忆治理

工程上最难的不是检索算法,而是决定“哪些东西有资格被记住”。

这里有四类常见问题。

过期信息

“当前分支是 main”可能今天有效,明天就过期。如果不记录作用域和时间,Agent 会把旧状态当事实。

冲突事实

项目 README 说用 PostgreSQL,部署脚本却显示 MySQL。系统不能随便选一个。它应该记录冲突,交给用户确认,或者按可信来源排序。

错误写入

Agent 从一句模糊表达里推断出的内容,不应直接变成长期事实。写入前要区分:用户明确陈述、工具验证结果、模型推断。

权限边界

“记住用户说过什么”和“记住用户无权看到的内容”是两回事。记忆库必须带用户、项目、租户和 Agent 权限。检索前的过滤不能只依赖 prompt。

还有一个容易忽略的指标:召回准确率。

只测 top-k 命中率不够。至少要分开测:

  • Precision:该召回的记忆里,多少真正相关
  • Recall:该任务需要的事实,有多少被找到
  • Freshness:召回内容是否仍有效
  • Conflict rate:召回集合内有多少互相矛盾
  • Write precision:写入的记忆里,有多少值得长期保留

如果没有评测集,团队很容易被 demo 误导。Agent 回答得不错,可能只是因为恰好召回了那条正确记忆。换一个任务、换一种问法,系统就失效。

Anthropic 这篇文章登上 HN 首页并获得 97 分、55 条评论,说明记忆已经成了 Agent 工程的核心议题。但架构越复杂,越需要先定义可测的行为。

编辑思考

Agent Memory 重要,不是因为它能让 Agent 记住更多,而是因为记忆会把一次对话里的临时信息变成跨任务状态。一旦写错、过期或越权,错误会持续影响后续任务。存储和检索已有成熟工具,真正难复制的是写入条件、冲突处理、权限边界与删除规则。

我预测,团队落地时会先做记忆评测集,再选向量库。原因很简单:没有固定样本和指标,团队无法判断一次召回是有效帮助,还是碰巧命中。评测对象至少应覆盖写入、召回、覆盖和删除,并分别统计 Precision、Recall、Freshness 与 Conflict rate。

这次和过去的长上下文方案不同。长上下文主要扩大单次请求能看到的材料,Agent Memory 则要管理跨任务状态,允许旧事实失效。它也不是多建一个存储层,而是增加了一套生命周期治理。

目前不确定统一评测标准会多快出现。不同产品对“用户偏好”“项目事实”和“工作流规则”的边界也不一致。在标准成熟前,记录每次写入和召回的来源,先把行为做成可审计,比直接堆复杂架构更稳妥。

来源

https://www.anthropic.com/research/components-of-agent-memory

来源: https://www.anthropic.com/research/components-of-agent-memory