以下模型、容量与 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 的条目,按下面的顺序排序:
- 层优先级:工作 > 语义 > 情景 > 程序;
- 同层内按
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 时,一条低重要性但不可替代的约束(比如“不要动生产库”)可能被淘汰。重要性和不可替代性是两回事;生产系统需要为“硬约束”保留独立通道,不参与普通淘汰。
跨层重复。 同一个事实既在情景层又在语义层,检索时返回两条。实验里语义层优先,所以模型先看到蒸馏值;但如果模板把结果按写入时间排序,旧事件可能排在前面。跨层去重应该发生在注入前的组装阶段,而不是假设检索器会自动处理。
架构含义
把四层落到系统上,至少有五条可检查的要求:
- 每层有独立的写入入口。 工作记忆由运行时写,情景记忆由事件日志写,语义记忆由事实抽取或人工确认写,程序记忆由版本化的 runbook 写。不要让一个通用
save()承担四种语义。 - 每层有独立的保留策略。 工作记忆按轮次清空,情景记忆按时间衰减或归档,语义记忆按版本覆盖,程序记忆按发布版本更新。保留策略不同,存储引擎才可能不同。
- 检索顺序显式且可配置。 顺序是策略,不是实现细节;它应该出现在配置和测试里,而不是藏在某个排序函数里。
- 注入前做跨层合并。 同一键的多个来源要在组装上下文前解决冲突,并记录胜出来源与理由。
- 成本按层核算。 工作记忆的 token 是每轮固定成本,情景与语义是按需成本,程序记忆是触发成本。只统计总 token 无法判断成本花在哪一层。
对三条工作负载,分层的重点并不相同:
| 负载 | 最该保护的一层 | 原因 | 常见错误 |
|---|---|---|---|
| W1 检索问答 | 语义层 | 答案需要唯一、可引用的事实 | 把检索到的原文段落当事实,不去重 |
| W2 代码修复 | 情景层 | 最近一次失败输出与改动历史最关键 | 只存抽象结论,丢掉复现步骤 |
| W3 运维处置 | 程序层 | runbook 是审批过的权威流程 | 让模型即兴生成操作步骤 |
判据表
| 判据 | 合格的样子 | 不合格的样子 | 验证方式 |
|---|---|---|---|
| 层归属 | 每层有明确写入方与语义 | 所有内容进一个库 | 抽查 20 条记忆的归属理由 |
| 工作记忆容量 | 有上限、有淘汰规则、有硬约束通道 | 无限增长或只按时间截断 | 构造超容量写入,检查保留集合 |
| 语义去重 | 同键新值覆盖旧值 | 同键多版本并列返回 | 重复写入同一事实,检查检索结果 |
| 情景审计 | 事件带时间、来源、不可变 | 事件被就地覆盖 | 回放一次会话,检查事件序列 |
| 程序触发 | 按任务类型或工具意图触发 | 按文本相似度触发 | 构造近义任务,检查误触发 |
| 成本核算 | 分层统计 token | 只统计总上下文 | 输出每层条目与 token 表 |
小结
- “加一个记忆库”不是架构方案;先回答记什么、放哪层、按什么顺序取。
- 工作、情景、语义、程序四层的区别不在存储,而在写入方、保留策略与检索优先级。
- 工作记忆必须容量受限,淘汰规则要确定、可解释,并为硬约束保留独立通道。
- 情景记忆保留事件,适合审计与回放,不适合直接当事实;语义记忆按键去重,适合回答唯一事实。
- 程序记忆按任务触发,平时不占上下文;触发条件应该是任务类型,不是文本相似度。
- 同样回答账户等级,情景层返回两条 60 token 的事件,语义层返回一条 20 token 的事实;蒸馏的成本在写入时付,收益在每次检索时拿。
阅读导航:上一节:7.3 验证器与奖励黑客防线 · 下一节:8.2 读写策略:什么该记、什么时候记 。
常见错误与边界
- 把向量库当记忆架构。 向量库只解决“怎么按相似度找”,没有回答层归属、去重与保留策略;这些不定义,库越大越难用。
- 所有内容走同一个写入接口。 工作记忆、事件、事实、流程的写入方与生命周期完全不同;合并成一个
save()会让保留策略无法按层实施。 - 工作记忆只按时间截断。 最近的不一定最重要;只按时间淘汰会把关键约束挤掉。至少要有重要性维度,并为硬约束留通道。
- 语义记忆不去重。 同一事实多版本并列,模型会在旧值和新值之间随机选;去重必须发生在写入或注入前。
- 情景记忆当事实用。 情景记录的是“当时发生了什么”,不是“现在成立什么”;直接拼接会引入过期值。
- 程序记忆按相似度触发。 “重启服务”和“重启数据库”文本相近但流程不同;触发条件应该是结构化的任务类型或工具意图。
- 只统计总 token。 不按层核算,就无法判断成本是工作记忆的固定开销,还是情景检索的重复携带。
继续阅读
探索更多技术文章
浏览归档,发现更多关于系统设计、工具链和工程实践的内容。