《AI Agent 技术原理与架构·决策、记忆与学习》8.1 记忆分层:工作/情景/语义/程序记忆

把 Agent 记忆拆成工作、情景、语义、程序四层,逐层说明每层该存什么、由谁写入、保留多久、检索时按什么优先级进入上下文,并说明 token 成本从哪来;再用一个容量受限的分层实验展示工作记忆淘汰、情景记忆的重复携带与语义去重的收益,最后给出可检查的记忆架构判据与按层核算成本的判据表。

以下模型、容量与 token 数字均为教学假设,只用于展示分层记忆的计算方式,不构成对任何真实系统或供应商的承诺。

“给 Agent 加一个记忆”通常被说成接一个向量库。这个说法跳过了三个更重要的问题:记什么、放哪一层、检索时按什么顺序取。把这三件事混在一起,最常见的结果是:上下文里塞满了旧事件,真正需要的事实被稀释;或者工作记忆一淘汰,当轮任务的关键约束就丢了。

这一节把记忆拆成四层,用一个小模型说明分层如何改变保留率、检索顺序与 token 成本。它不讨论具体向量数据库,也不讨论 embedding 模型选型;这些是实现细节。这里只回答架构问题:四层各自承担什么、检索优先级如何定义、成本从哪里产生。

为什么“一个记忆库”不够

考虑 W1 检索问答的一次会话。用户先问账户等级,再问退款窗口,中途工具返回过两次文档列表。对话结束时,Agent 需要回答的是退款窗口,但它同时带着账户等级、两次工具调用记录、一条升级工单事件。这些信息的使用频率、稳定性和时效完全不同:

  • 账户等级是稳定事实,回答后仍然有用;
  • 两次文档列表是过程事件,只在当轮有用,下一轮就该丢弃;
  • 退款窗口是稳定策略,可以被复用;
  • “先 drain 再 restart 再健康检查”是过程知识,只在特定任务触发时才有用。

把它们放进同一个池子,检索只能靠相似度排序。相似度无法表达“这条是三个月前的工单事件,那条是昨天确认的账户事实”。分层的作用是先按语义角色分类,再在层内做检索;层与层之间的优先级是显式的、可审计的,而不是留给相似度分数去猜。

四层的定义可以写得很小:

层存什么生命周期典型载体进入上下文的时机
工作记忆当前任务的临时状态、最近观测、待办轮次或任务内上下文窗口、状态对象总是
情景记忆带时间戳的事件:谁在什么时候做了什么长期,可衰减事件日志、会话记录按需检索
语义记忆去重后的稳定事实与结论长期,带来源与版本事实表、知识库按需检索
程序记忆可复用的流程、模板、操作手册长期,按任务触发工具脚本、runbook命中任务类型时

这四层不是四个数据库。它们可以落在同一套存储上,但读写策略、保留策略和检索优先级必须分开。否则“记忆”只是一个不断变大的文本堆,越用越慢、越用越吵。

形式化:条目、层与检索顺序

把一条记忆写成五元组:

$$
m = (\text{layer}, \text{key}, \text{value}, \text{tokens}, \text{step}, \text{importance})
$$

其中 tokens 是这条记忆进入上下文时的大致成本,step 是写入时间,importance 是写入方给出的重要性。检索一个键 $k$ 时,返回所有 key = k 的条目,按下面的顺序排序:

  1. 层优先级:工作 > 语义 > 情景 > 程序;
  2. 同层内按 step 从新到旧。

这个顺序不是唯一的正确顺序。W3 运维处置可能希望程序记忆优先,因为 runbook 是权威操作步骤;W2 代码修复可能希望情景记忆优先,因为最近一次失败的测试输出比抽象事实更有用。关键是顺序必须被显式定义并被测试,而不是由检索分数隐式决定。

工作记忆还需要一个容量约束。设容量为 $C$,每次写入后若条目数超过 $C$,淘汰一条:

$$
\text{victim} = \arg\min_{m \in W} (\text{importance}_m, \text{step}_m)
$$

也就是先淘汰重要性最低的,重要性相同时淘汰最旧的。这个规则很粗糙,但它有一个重要性质:淘汰是确定性的、可解释的。生产系统可以用 LRU、注意力分数或学习到的策略替换它,但无论用哪种,都必须能回答“为什么这条被丢了”。

语义记忆需要一个去重规则。同一个键的新值覆盖旧值,而不是并列保留:

$$
\text{store}(k, v, t) = {(k, v, t)} \cup {(k’, v’, t’) \in S \mid k’ \neq k}
$$

这条规则看起来简单,却解决了一个常见故障:同一事实被重复写入三次,检索返回三个版本,模型不知道该信哪个。情景记忆则相反,它不应该去重,因为两条“账户等级变更”事件记录的是两个不同时刻,都有审计价值。这就是分层带来的第一个直接结论:去重策略是层属性,不是全局属性。

最小实验:容量、重复与蒸馏

实验构造一段 12 步左右的 W1 会话:

  • 工作层加入 6 条备忘,容量只有 3;
  • 情景层加入 6 条事件,其中包含两次账户等级变更;
  • 语义层写入账户等级与退款窗口,账户等级写两次,观察去重;
  • 程序层放一条重启 runbook;
  • 最后用三个查询键统计每层的条目数、总 token、命中数与返回 token。

代码只依赖标准库,输出是确定性的。

# file: agp_lab/memory_layers.py | write
# tier: 3
# verify: python3 -m unittest tests.test_memory_layers
"""四层记忆:工作、情景、语义、程序。

工作记忆是容量受限的当前上下文;情景记忆按时间保存发生过的事件;
语义记忆保存去重后的稳定事实;程序记忆保存按任务触发的过程。
这个最小模型只验证三个机制:

1. 工作记忆会因容量淘汰而丢条目,且淘汰应同时看重要性与新旧;
2. 情景记忆保留得多,但检索时要为重复携带的事件付 token;
3. 语义/程序记忆把事实与过程从事件流里蒸馏出来,降低重复检索成本。
"""
from __future__ import annotations

from dataclasses import dataclass

LAYERS = ("working", "episodic", "semantic", "procedural")
# 检索优先级:当前上下文最高,蒸馏过的语义事实次之,原始事件再次,过程最后。
PRIORITY = {"working": 0, "semantic": 1, "episodic": 2, "procedural": 3}


@dataclass(frozen=True)
class MemoryItem:
    layer: str
    key: str
    value: str
    tokens: int
    step: int
    importance: float = 0.5


class LayeredMemory:
    """按层存放条目;工作层有容量上限,语义层按键去重。"""

    def __init__(self, working_capacity: int = 3) -> None:
        if working_capacity < 1:
            raise ValueError("working_capacity 至少为 1")
        self.working_capacity = working_capacity
        self._items: dict[str, list[MemoryItem]] = {layer: [] for layer in LAYERS}

    def add(self, item: MemoryItem) -> None:
        if item.layer not in LAYERS:
            raise ValueError(f"未知记忆层: {item.layer}")
        if item.tokens <= 0:
            raise ValueError("tokens 必须为正")
        if not 0.0 <= item.importance <= 1.0:
            raise ValueError("importance 必须在 [0, 1] 内")
        if item.layer == "working":
            self._items["working"].append(item)
            self._evict_working()
            return
        if item.layer == "semantic":
            existing = [old for old in self._items["semantic"] if old.key == item.key]
            if existing:
                # 同一事实只保留最新版本,旧版本被覆盖而不是并列。
                self._items["semantic"] = [
                    old for old in self._items["semantic"] if old.key != item.key
                ]
        self._items[item.layer].append(item)

    def _evict_working(self) -> None:
        if len(self._items["working"]) <= self.working_capacity:
            return
        victim = min(
            self._items["working"],
            key=lambda old: (old.importance, old.step),
        )
        self._items["working"].remove(victim)

    def retrieve(self, key: str) -> list[MemoryItem]:
        """按键检索,按层优先级与新旧排序。"""
        found = [
            item
            for layer in LAYERS
            for item in self._items[layer]
            if item.key == key
        ]
        return sorted(found, key=lambda item: (PRIORITY[item.layer], -item.step))

    def layer_items(self, layer: str) -> list[MemoryItem]:
        if layer not in LAYERS:
            raise ValueError(f"未知记忆层: {layer}")
        return list(self._items[layer])

    def token_cost(self) -> dict[str, int]:
        return {
            layer: sum(item.tokens for item in self._items[layer])
            for layer in LAYERS
        }


QUERIES = ("account_tier", "refund_window", "runbook:restart")


def build_session() -> LayeredMemory:
    """构造一段 W1 检索问答的会话记忆,用于观察各层的保留与成本。"""
    memory = LayeredMemory(working_capacity=3)
    # 六条工作备忘:前三轮低重要性,后三轮高重要性。
    for step in range(6):
        memory.add(
            MemoryItem(
                layer="working",
                key=f"memo:{step}",
                value=f"turn {step}",
                tokens=10,
                step=step,
                importance=0.2 if step < 3 else 0.8,
            )
        )
    # 情景记忆:逐条保留发生过的事件,包括一次账户等级变更。
    for step, key, value in (
        (2, "account_tier", "silver"),
        (3, "ticket:opened", "billing question"),
        (5, "tool:doc_search", "returned 12 docs"),
        (7, "ticket:escalated", "to billing queue"),
        (8, "account_tier", "gold"),
        (9, "tool:doc_search", "returned 3 docs"),
    ):
        memory.add(MemoryItem("episodic", key, value, tokens=30, step=step, importance=0.5))
    # 语义记忆:稳定事实按键去重,只保留最新值。
    memory.add(MemoryItem("semantic", "account_tier", "gold", tokens=20, step=8, importance=0.9))
    memory.add(MemoryItem("semantic", "refund_window", "7 days", tokens=20, step=9, importance=0.9))
    # 程序记忆:按任务触发的过程,平时不进入上下文。
    memory.add(
        MemoryItem(
            "procedural",
            "runbook:restart",
            "drain -> restart -> healthcheck",
            tokens=40,
            step=1,
            importance=0.8,
        )
    )
    return memory


def experiment() -> list[tuple[str, int, int, int, int]]:
    """返回 (层, 条目数, 总 token, 命中查询数, 返回 token)。"""
    memory = build_session()
    rows: list[tuple[str, int, int, int, int]] = []
    for layer in LAYERS:
        items = memory.layer_items(layer)
        hits = 0
        returned = 0
        for query in QUERIES:
            matched = [item for item in memory.retrieve(query) if item.layer == layer]
            if matched:
                hits += 1
                returned += sum(item.tokens for item in matched)
        rows.append((layer, len(items), sum(item.tokens for item in items), hits, returned))
    return rows


if __name__ == "__main__":
    memory = build_session()
    retained = sorted(memory.layer_items("working"), key=lambda item: item.step)
    print("工作记忆容量=3,加入 6 条后保留:", " ".join(item.key for item in retained))
    print()
    print(f"{'层次':<12}{'条目':>4}{'总token':>8}{'命中':>6}{'返回token':>10}")
    for layer, count, tokens, hits, returned in experiment():
        print(f"{layer:<12}{count:>4}{tokens:>8}{hits:>6}{returned:>10}")

运行:

cd private/labs/agp-lab
python3 -m agp_lab.memory_layers

输出:

工作记忆容量=3,加入 6 条后保留: memo:3 memo:4 memo:5

层次            条目  总token    命中   返回token
working        3      30     0         0
episodic       6     180     1        60
semantic       2      40     2        40
procedural     1      40     1        40

这张表有四行信息,每一行对应一个架构判断:

第一,工作记忆的保留由容量和重要性共同决定。 前三条备忘重要性 0.2,后三条 0.8;容量为 3 时,最终留下的是后三条。如果淘汰只看新旧,留下的也会是后三条;但如果第四条是高重要性、第五条是低重要性,两种规则的差异就会显现。实验里故意把重要性设成两段,是为了说明淘汰规则必须写成代码并测试,而不是口头约定“保留重要的”。

第二,情景记忆保留完整,但返回成本高。 查询 account_tier 时,情景层返回了两条事件:silver 和 gold,共 60 token。两条都是真的,但一条已经过期。如果直接把检索结果拼进上下文,模型要自己判断哪条更新;如果判断错,就会用旧等级回答。情景记忆的价值是审计与回放,不是直接当事实用。

第三,语义层用 40 token 换来了两个查询的命中。 账户等级去重后只剩 gold,退款窗口一条,查询 account_tier 与 refund_window 各返回 20 token。同样回答账户等级,语义层给出唯一值,情景层给出两个值。这就是“蒸馏”的收益:写入时多做一次合并,检索时少一次歧义。

第四,程序记忆平时不占上下文。 只有查询命中 runbook:restart 时才返回 40 token。它没有参与工作记忆的容量竞争,也没有被情景事件淹没。程序记忆的触发条件应该是任务类型或工具意图,而不是文本相似度;否则“重启服务”和“重启数据库”会被检索成同一条流程。

边界与失败模式

分层不是免费的。它至少引入四种新的失败模式。

层归属错误。 把一次性的工具返回写进语义层,会把噪声固化成“事实”;把稳定策略只写进工作层,会在下一轮丢失。归属规则要按“这条信息在任务结束后是否仍然成立”来判断,而不是按“它看起来重不重要”。

检索优先级僵化。 工作 > 语义 > 情景 > 程序只是本实验的选择。W3 的不可逆操作可能要求程序记忆优先,因为 runbook 是经过审批的;W2 的调试可能要求情景优先,因为最近一次测试输出最有信息量。优先级应该按负载配置,并且有回归测试。

容量淘汰误伤。 工作记忆容量为 3 时,一条低重要性但不可替代的约束(比如“不要动生产库”)可能被淘汰。重要性和不可替代性是两回事;生产系统需要为“硬约束”保留独立通道,不参与普通淘汰。

跨层重复。 同一个事实既在情景层又在语义层,检索时返回两条。实验里语义层优先,所以模型先看到蒸馏值;但如果模板把结果按写入时间排序,旧事件可能排在前面。跨层去重应该发生在注入前的组装阶段,而不是假设检索器会自动处理。

架构含义

把四层落到系统上,至少有五条可检查的要求:

  1. 每层有独立的写入入口。 工作记忆由运行时写,情景记忆由事件日志写,语义记忆由事实抽取或人工确认写,程序记忆由版本化的 runbook 写。不要让一个通用 save() 承担四种语义。
  2. 每层有独立的保留策略。 工作记忆按轮次清空,情景记忆按时间衰减或归档,语义记忆按版本覆盖,程序记忆按发布版本更新。保留策略不同,存储引擎才可能不同。
  3. 检索顺序显式且可配置。 顺序是策略,不是实现细节;它应该出现在配置和测试里,而不是藏在某个排序函数里。
  4. 注入前做跨层合并。 同一键的多个来源要在组装上下文前解决冲突,并记录胜出来源与理由。
  5. 成本按层核算。 工作记忆的 token 是每轮固定成本,情景与语义是按需成本,程序记忆是触发成本。只统计总 token 无法判断成本花在哪一层。

对三条工作负载,分层的重点并不相同:

负载最该保护的一层原因常见错误
W1 检索问答语义层答案需要唯一、可引用的事实把检索到的原文段落当事实,不去重
W2 代码修复情景层最近一次失败输出与改动历史最关键只存抽象结论,丢掉复现步骤
W3 运维处置程序层runbook 是审批过的权威流程让模型即兴生成操作步骤

判据表

判据合格的样子不合格的样子验证方式
层归属每层有明确写入方与语义所有内容进一个库抽查 20 条记忆的归属理由
工作记忆容量有上限、有淘汰规则、有硬约束通道无限增长或只按时间截断构造超容量写入,检查保留集合
语义去重同键新值覆盖旧值同键多版本并列返回重复写入同一事实,检查检索结果
情景审计事件带时间、来源、不可变事件被就地覆盖回放一次会话,检查事件序列
程序触发按任务类型或工具意图触发按文本相似度触发构造近义任务,检查误触发
成本核算分层统计 token只统计总上下文输出每层条目与 token 表

小结

  • “加一个记忆库”不是架构方案;先回答记什么、放哪层、按什么顺序取。
  • 工作、情景、语义、程序四层的区别不在存储,而在写入方、保留策略与检索优先级。
  • 工作记忆必须容量受限,淘汰规则要确定、可解释,并为硬约束保留独立通道。
  • 情景记忆保留事件,适合审计与回放,不适合直接当事实;语义记忆按键去重,适合回答唯一事实。
  • 程序记忆按任务触发,平时不占上下文;触发条件应该是任务类型,不是文本相似度。
  • 同样回答账户等级,情景层返回两条 60 token 的事件,语义层返回一条 20 token 的事实;蒸馏的成本在写入时付,收益在每次检索时拿。

阅读导航:上一节:7.3 验证器与奖励黑客防线 · 下一节:8.2 读写策略:什么该记、什么时候记 。

常见错误与边界

  1. 把向量库当记忆架构。 向量库只解决“怎么按相似度找”,没有回答层归属、去重与保留策略;这些不定义,库越大越难用。
  2. 所有内容走同一个写入接口。 工作记忆、事件、事实、流程的写入方与生命周期完全不同;合并成一个 save() 会让保留策略无法按层实施。
  3. 工作记忆只按时间截断。 最近的不一定最重要;只按时间淘汰会把关键约束挤掉。至少要有重要性维度,并为硬约束留通道。
  4. 语义记忆不去重。 同一事实多版本并列,模型会在旧值和新值之间随机选;去重必须发生在写入或注入前。
  5. 情景记忆当事实用。 情景记录的是“当时发生了什么”,不是“现在成立什么”;直接拼接会引入过期值。
  6. 程序记忆按相似度触发。 “重启服务”和“重启数据库”文本相近但流程不同;触发条件应该是结构化的任务类型或工具意图。
  7. 只统计总 token。 不按层核算,就无法判断成本是工作记忆的固定开销,还是情景检索的重复携带。

继续阅读

探索更多技术文章

浏览归档,发现更多关于系统设计、工具链和工程实践的内容。

全部文章 返回首页

「books」更多文章

  1. 《大规模分布式计算深入解析》15.3 落地:从 Neo4j 到自研图引擎
  2. 《大规模分布式计算深入解析·图计算与图数据库内核》 · 目录与学习路径(45 篇)
  3. 《大规模分布式计算深入解析》15.2 十一卷主线:从切分到图