有一个比「越聊越笨」更隐蔽的问题:它的记性太好。
举个例子。三周前你和博客选题助手闲聊,随口说了一句:“最近想多写点偏工程的东西,别老是入门向。”
这句话被它忠实地记进了偏好。之后每一次生成,它都在往工程向靠。今天你明确告诉它:“我想写一篇给完全没写过代码的人看的 Agent 入门。”它嘴上答应得很痛快,输出的五个选题里还是有三个带着“架构”“编排”“可观测性”。
你打开它的记忆文件,那句话好好地躺在里面,没有过期标记,没有来源说明,也没有任何东西告诉它“这条只在八月份成立”。
问题不是它记不住,恰恰相反——它记得太牢、太不挑,也太不分场合。
上一讲我们说,上下文是模型唯一的工作台。记忆回答的是另一个问题:哪些信息有资格跨会话进入那个工作台,进来之后待多久,什么时候该被请出去。
新手系列第 5 篇我们做过一个 memory.json,那是“记住偏好、保存历史”的及格线。这一篇要做的是从「存文件」走到「会遗忘」。遗忘不是记忆的反面,遗忘是记忆系统的一部分,而且是最容易被跳过的那一部分。
阅读提示:本文是「Agent 工程进阶」系列的第 2 篇,面向已经给 Agent 加过记忆、但发现它越来越不准的读者。如果你还没做过第一个 Agent,建议先看新手系列的让 Agent 更像项目:工具、记忆、文件读写和简单界面。如果你想要一张整体地图,可以看第 0 篇从 Demo 到可交付:如何做一个 Agent 项目。
先分清三种记忆:别再往一个文件里塞所有东西
大多数记忆问题,根源不是“存错了内容”,而是把三种性质完全不同的东西存在了一起。
| 工作记忆 | 会话记忆 | 长期记忆 | |
|---|---|---|---|
| 作用域 | 这一次调用 | 一个会话线程 | 跨会话、跨任务 |
| 活多久 | 调用结束即弃 | 会话结束后归档或压缩 | 天 / 月 / 永久,取决于类型 |
| 谁写 | 程序填进 messages | 程序 + 模型(本轮结论) | 用户 / 程序 / 模型,但都必须可追溯 |
| 典型内容 | 系统指令、工具返回、当前输入 | 已确认的事实、试过的步骤、没做完的待办 | 偏好、事实、教训 |
| 最常见的错 | 大体积返回长期留在里面 | 会话一结束什么都不留,下次从零开始 | 什么都往里塞,且永不清理 |
这三层不是我拍脑袋分的,认知架构里早就有对应的划分:工作记忆对应当前 context,情景记忆对应“发生过什么”,语义记忆对应“关于世界的稳定知识”。工程上的差别在于,我们还要额外回答一件事:谁来写,写坏了谁负责。
看一个真实的三条记录,它们常常被塞进同一个 memory.json:
1. "用户想要 1500-2500 字" <- 规则,几乎每次都用
2. "2026-08-20 生成过 AI 工具入门方向" <- 流水,只在去重时才用
3. "用户说最近想多写工程向" <- 临时意图,八月底就该失效
这三条的生命周期、使用时机、失效条件全都不同。但在一个单文件实现里,它们会被一起读出来、一起拼进 prompt、一起永久保留。
于是三种坏结果同时发生:临时的被当成永久(第三条)、流水被当成规则(第二条每次都占位置)、所有东西全量注入(干扰项的数量随着使用时长线性增长)。
有个很实用的自检问题,可以对着你的记忆文件一条一条问:
这条记忆该活多久?什么时候该被拿出来用?被什么推翻?
三个问题里有一个答不上来,它就不该在那个文件里。当你没办法回答一条记忆“什么时候该失效”,你的记忆系统其实还没有被设计,只是碰巧在存东西。
写入:不是聊完就全存
新手最常见的做法是:一轮对话结束,把这段对话交给模型,让它“总结一下值得记住的”,然后存起来。
这个做法有三个问题:写入者不对、写入时机不对、写入内容没有类型。
三种写入者,可信度差很多
| 写入者 | 例子 | 可信度 | 该怎么用 |
|---|---|---|---|
| 代码 | 任务成功了、用户点了采纳、日期、文件已生成 | 最高 | 能用代码写的,绝不交给模型 |
| 用户显式 | “记住我不写标题党” | 高 | 立刻生效,且优先级最高 |
| 模型抽取 | 从对话里推断出“用户似乎偏好实战向” | 低 | 必须带依据,最好先进待确认区 |
这一条值得单独强调:能用代码写的,不要交给模型。
“这次生成了 5 个选题、用户采纳了第 2 个、时间是 2026-10-05”,这些是事实,代码顺手写一行就行。让模型去“总结”这些,是花钱买一个它会算错的计算器。
模型的价值在于处理真正需要语言理解的部分:用户这句抱怨背后是不喜欢什么、这一次的方向和上个月那次是不是重复。
四类内容,四种命运
不给记忆分类,就没办法给它设置不同的过期策略和召回权重。我习惯分成四类:
| 类型 | 是什么 | 触发条件 | 默认寿命 | 例子 |
|---|---|---|---|---|
fact 事实 | 可验证的客观信息 | 用户提供,或工具返回且可追溯 | 长期,被证伪即废 | “已发布文章 12 篇”“读者以新手为主” |
preference 偏好 | 影响输出方式的稳定倾向 | 用户明确表达,或同类选择重复 3 次以上 | 长期,直到被改 | “1500-2500 字”“口语化、少术语” |
todo 待办 | 还没完成、以后要接着做的事 | 任务中断,或用户说“以后再说” | 完成即消除 | “等 MCP 那篇写完再定系列结构” |
lesson 教训 | 失败过的做法 | 工具报错、用户否定、回归测试失败 | 长期 | “一次生成 10 个选题,用户只用前 3 个” |
lesson 是最值钱、也最常被漏掉的一类。上一讲讲压缩时说过“失败过的原因必须保留”——那是在上下文里的一次性保留;跨会话的那一份,就是 lesson。 没有 lesson 的 Agent 会反复踩同一个坑,而且每次都踩得很真诚。
顺便说一句:把 todo 和 lesson 分开,也是为了让它们走不同的召回路径。待办只在任务开始时看一眼,教训只在当前任务和历史失败相近时才需要出现。
一条记忆应该长什么样
格式本身不重要,JSON、JSONL、SQLite 都行。重要的是字段要能支撑后面的遗忘和召回。
# src/memory/store.py
import json
import time
import uuid
from pathlib import Path
STORE = Path("data/memory.jsonl") # 已生效的记忆
PENDING = Path("data/memory_pending.jsonl") # 待确认的记忆
def new_record(type_, content, *, source, quote="", confidence=0.6,
ttl_days=None, tags=None, status="active"):
"""type_: fact / preference / todo / lesson"""
return {
"id": uuid.uuid4().hex[:8],
"type": type_,
"content": content,
"source": source, # user / code:<fn> / tool:<name> / model:<session_id>
"quote": quote, # 原文依据:这条记忆是从哪句话来的
"confidence": round(confidence, 2),
"created_at": time.time(),
"expires_at": time.time() + ttl_days * 86400 if ttl_days else None,
"hit_count": 0, # 被召回过几次
"last_hit_at": None,
"status": status, # active / pending / deprecated
"superseded_by": None, # 被哪条取代
"tags": tags or [],
}
def add(rec):
target = PENDING if rec["status"] == "pending" else STORE
target.parent.mkdir(parents=True, exist_ok=True)
with target.open("a", encoding="utf-8") as f:
f.write(json.dumps(rec, ensure_ascii=False) + "\n")
return rec["id"]
def load(include_pending=False):
files = [STORE] + ([PENDING] if include_pending else [])
recs = []
for p in files:
if not p.exists():
continue
for line in p.read_text(encoding="utf-8").splitlines():
if line.strip():
recs.append(json.loads(line))
return recs
几个字段值得单独解释,因为它们是后面所有机制的地基:
source:谁写的。冲突消解时第一眼看它。quote:原文依据。没有依据的记忆,本质上和无据可查的传言一样。expires_at:不是所有记忆都需要,但“最近”“这周”“等 X 之后”这类一定要有。hit_count:被真正用过几次。它同时是「有用程度」和「可信程度」的信号。status和superseded_by:为软删除准备的,后面会讲为什么不能真删。
抽取提示词:先要求引用,再要求内容
如果这一步交给模型,提示词里最重要的是逼它给出依据:
EXTRACT_PROMPT = """从下面这段对话里抽取值得跨会话记住的信息。
只允许四类,其他一律不抽:
1. fact:可验证的客观事实。
2. preference:影响以后输出方式的稳定倾向。
3. todo:还没完成、以后要接着做的事。
4. lesson:这次踩过的坑,或用户明确否定的做法。
规则:
- 每条必须附 quote:从对话中原样抄一句能支撑它的用户原话。抄不出来就不写这条。
- 用户只是随口提到、并未表达倾向的,不要写成 preference。
- 带时间范围的说法("最近""这周""等 X 之后")要写进 content,并给 ttl_days。
- 不要抽取 API Key、密码、路径之外的个人敏感信息。
- 输出 JSON 数组,每条字段:type / content / quote / tags / ttl_days / confidence(0-1)。
- 宁可少抽。最多 3 条,没有就返回空数组。
"""
最后一行“宁可少抽”是整套设计里最反直觉、也最有用的一条约束。记忆系统的失败模式几乎从来不是“记得太少”,而是“记了一堆不该记的,然后在里面迷路”。
遗忘与冲突消解
这一部分是新手篇完全没覆盖的,也是记忆从“能存”变成“可用”的分界线。
三种过期方式
时间过期:最直白,expires_at 到了就失效。适合“最近想写工程向”这类带时间范围的意图。
条件过期:记忆里记着“等 MCP 那篇写完再决定系列结构”,那就要把触发条件一起存下来。任务完成时由代码检查一遍待办,条件满足就标记完成。这类最容易被漏掉,因为实现它需要在任务结束时多一步检查。
被取代:不是时间到了,而是出现了更可信的新信息。这条不会自己消失,需要冲突消解来判定。
置信度衰减:给每条记忆一个“还信不信”的分
一个简单但够用的做法:
def decay(confidence, days, hit_count, half_life=30):
"""随时间衰减,但每次被成功召回都会补一点回来。"""
time_factor = 0.5 ** (days / half_life)
use_factor = min(hit_count / 10, 1)
return confidence * (0.6 + 0.4 * time_factor) + 0.15 * use_factor
含义是:一条记忆就算没人推翻它,也会随时间慢慢变淡;但如果它一直在被使用、一直在证明自己有用,就会保持在较高位置。
低于阈值的(比如 0.3)不直接删除,转成 deprecated。它仍然躺在文件里,只是不再参与召回——这样你既能让系统忘掉它,又能在“咦它怎么不记得了”的时候查到原因。
冲突时以什么为准
新旧信息打架,是最常见也最难发现的问题。四条规则,按优先级排:
- 显式 > 推断:用户明确说的,压过模型猜的。
- 有据 > 无据:带
quote的,压过抄不出原话的。 - 具体 > 笼统:“这篇写给完全新手”压过“想多写工程向”。
- 新 > 旧:前三条都打平,才比时间。
注意顺序:新 > 旧被排在最后。 很多人默认“后说的就是最新的想法”,但一次随口的、笼统的、模型推断出来的新说法,不应该推翻三个月前你认真确认过的偏好。
用开头的例子走一遍:
旧:content="想多写工程向内容" source=model:s07 quote="最近想多写点偏工程的东西" created_at=9/14
新:content="这篇写给完全新手" source=user quote="给完全没写过代码的人看" created_at=10/05
第一条规则就分出胜负了:用户显式 > 模型推断。新的胜出,旧的不删除,只标 deprecated 并记 superseded_by。
SOURCE_RANK = {"user": 3, "code": 3, "tool": 2, "model": 1}
def rank(rec):
return SOURCE_RANK.get(rec["source"].split(":")[0], 0)
def resolve(new_rec, records):
"""返回要落库的记录;同时把被取代的旧记录标记掉。"""
for old in records:
if old["status"] != "active" or old["type"] != new_rec["type"]:
continue
if not same_topic(old, new_rec): # 同主题判定:关键词/标签/向量相似度都行
continue
if rank(new_rec) > rank(old):
winner, loser = new_rec, old
elif rank(new_rec) < rank(old):
return None # 旧的更可信,新的干脆不写
elif bool(new_rec["quote"]) and not old["quote"]:
winner, loser = new_rec, old
elif len(new_rec["content"]) > len(old["content"]) * 1.5:
winner, loser = new_rec, old # 更具体的胜出
elif new_rec["created_at"] >= old["created_at"]:
winner, loser = new_rec, old
else:
return None
loser["status"] = "deprecated"
loser["superseded_by"] = winner["id"]
return winner
return new_rec
same_topic 你可以先用最简单的标签重合或关键词重合实现,等记忆量上来了再换成向量相似度。先有机制,再优化精度。
怎么避免一条错误信息被永久记住
这是记忆系统里最危险的一种失败:一条幻觉被写进长期记忆,然后在之后每一个会话里反复被引用,越用越像真的。
上一讲讲过上下文污染——那是单次会话内的污染。记忆污染是它的跨会话版本,破坏力大一个量级。
我用三道防线:
第一道:写入前必须有依据。 上面那个 EXTRACT_PROMPT 里的 quote 要求,就是这一道。模型说“你之前写过一篇 MCP 的文章”,但对话里根本找不到这句话,那这条就写不出来。
第二道:推断类先进待确认区。 来源是 model 的、或者置信度低于阈值的,先落 pending,不进主库。两种情况下转正:用户确认过,或者它在后续对话里被独立命中两次(同一件事被不同方式验证了两次)。
第三道:可纠正。 用户说“不是这样,我没写过那篇”,系统要能定位到具体那条,标记作废,并且顺手写一条 lesson。没有这最后一步,同一条错误记忆会在下一次对话里被重新抽取出来——因为产生它的那个误解还在。
这三道防线有个共同点:它们都不阻止系统记住东西,只是让“记住”这件事变得可追溯、可撤销。 记忆系统的可靠性不来自“写得准”,来自“写错了能改回来”。
还有一条底线:永远不要真删。 用 status=deprecated 软删除,保留 30 天。磁盘成本几乎为零,但你能回答“它为什么突然不记得这件事了”,也能在误判时一键恢复。
检索:记忆不是全量塞进 prompt
有了会遗忘的记忆库,还有最后一步:每次调用只把该拿的那几条拿出来。
这一节是上一讲「选」这个手法在记忆上的具体化。
分层注入,而不是一起注入
| 类型 | 注入方式 | 位置 | 数量 |
|---|---|---|---|
preference | 全量 | 系统提示词之后 | 通常不超过 10 条 |
todo | 任务开始时看一眼 | 系统提示词之后 | 全部未完成的 |
fact | 按需召回 | 当前输入之前 | k <= 5 |
lesson | 按需召回,且只在相近时 | 当前输入之前 | k <= 3 |
偏好全量注入是有道理的:它条数少、内容稳定、几乎每次都影响输出。把它放在系统提示词后面,正好还是上一讲说的「稳定前缀」,能命中 prompt caching。
事实和教训必须按需召回。它们是长尾的——一百条里通常只有两三条和当前任务有关,全塞进去就是纯粹的干扰。
打分:相关性 + 新鲜度 + 使用频率
TYPE_WEIGHT = {"preference": 0.15, "fact": 0.05, "lesson": 0.10, "todo": 0.0}
def recall(records, query, *, k=5, types=None):
now = time.time()
scored = []
for r in records:
if r["status"] != "active":
continue
if types and r["type"] not in types:
continue
if r["expires_at"] and r["expires_at"] < now:
continue
rel = similarity(r["content"], query) # 0~1,关键词或向量都行
age_days = (now - r["created_at"]) / 86400
recency = 1 / (1 + age_days / 30) # 越新越接近 1
freq = min(r["hit_count"] / 10, 1) # 用得越多越可信
score = 0.5 * rel + 0.2 * recency + 0.1 * freq + TYPE_WEIGHT[r["type"]]
scored.append((score, r))
scored.sort(key=lambda x: x[0], reverse=True)
picked = []
for score, r in scored[:k]:
if score < 0.3: # 太不相干就不要硬凑
continue
r["hit_count"] += 1 # 记录命中,供下次打分和衰减使用
r["last_hit_at"] = now
picked.append(r)
return picked
三个维度各有分工:相关性保证对得上当前任务,新鲜度保证不被陈年旧事带跑,使用频率让那些被反复验证过的记忆稳定在前排。
那句 if score < 0.3: continue 值得留着。召回凑不满 k 条是完全正常的,硬凑几条不相干的进去,比少召回几条更糟。
记忆和 RAG 的分工
这两个东西经常被混为一谈,但它们解决的是不同问题。
| 记忆 | RAG | |
|---|---|---|
| 记的是 | 关于用户、关于这件事 | 关于世界 |
| 规模 | 几十到几百条 | 几万到几百万 |
| 一致性要求 | 强:一条错了会一直错 | 弱:召回错了只影响这一次 |
| 可写性 | 频繁增删改 | 通常只读 |
| 失效表现 | 缓慢污染,很难发现 | 当场答错,容易被发现 |
| 典型存储 | JSONL / SQLite | 向量库 |
一句好记的总结:记忆是小而贵的东西,RAG 是大而便宜的东西。 小而贵要精挑细选、逐条审计;大而便宜才需要索引和近似检索。
边界也很清楚:新手系列第 5 篇里那份 published-topics.md,一开始只有几条,当记忆读进 prompt 完全没问题;等它涨到几百条、每次都要在里面找相关项时,它就不再是记忆了,该搬去 RAG。
判断标准:如果一份内容每次都要“先检索再使用”,而且你从不会去改其中某一条,它就是知识,不是记忆。
动手改一遍:把第 5 篇的 memory.json 拆开
现在把新手系列第 5 篇那个记忆实现拿出来改。
改之前
# 原来的做法
memory = json.load(open("data/memory.json", encoding="utf-8"))
prompt = (
SYSTEM_PROMPT
+ "\n用户偏好:" + json.dumps(memory["preferences"], ensure_ascii=False)
+ "\n历史记录:" + json.dumps(memory["history"][-10:], ensure_ascii=False)
)
短短四行,五个问题:
- 偏好和历史混在一个文件里,无法区别对待。
- 历史取最近 10 条,和当前任务可能一条都不相关。
- 没有来源,不知道哪句是用户说的、哪句是模型猜的。
- 没有过期,三周前的临时意图永远有效。
- 全量注入,文件越大干扰越多。
改之后:目录
blog-topic-agent/
src/
main.py
memory/
store.py # 记录的读写、过期、软删除
extract.py # 从对话里抽取(带 quote 约束)
recall.py # 打分召回
data/
memory.jsonl # 已生效
memory_pending.jsonl # 待确认
published-topics.md
用 JSONL 而不是一个 JSON 数组,是因为追加写入不需要读改写整个文件,也不容易在一次崩溃里丢掉全部记忆。
第一步:写入时带上来源和依据
def remember_from_turn(conversation, session_id):
raw = call_model(EXTRACT_PROMPT + "\n\n" + conversation)
for item in json.loads(raw):
rec = new_record(
item["type"],
item["content"],
source=f"model:{session_id}",
quote=item.get("quote", ""),
confidence=item.get("confidence", 0.6),
ttl_days=item.get("ttl_days"),
tags=item.get("tags"),
# 模型推断出来的,先不生效
status="active" if item.get("quote") and item["confidence"] >= 0.8 else "pending",
)
add(rec)
有 quote 且置信度够高的直接生效;其余进待确认区,等你哪天在命令行菜单里顺手点一下。
顺带一提,第 5 篇那个命令行菜单正好可以加一项「查看待确认记忆」。这个功能几乎不花成本,但它把「模型偷偷记住了什么」变成了一件你能看见的事。
第二步:冲突消解后再落库
records = load()
winner = resolve(rec, records)
if winner is not None and winner is not rec:
add(winner)
注意 resolve 返回 None 的情况:那说明库里已经有一条更可信的记录了,这一条就不该写。“不写”在这里是正确行为,不是失败。
第三步:按需召回,分层注入
def build_context(user_input, records):
prefs = [r for r in records if r["type"] == "preference" and r["status"] == "active"]
todos = [r for r in records if r["type"] == "todo" and r["status"] == "active"]
picked = recall(records, user_input, k=5, types={"fact", "lesson"})
lines = ["以下是关于这位用户的已知信息,只在与当前任务相关时参考:"]
for p in prefs:
lines.append(f"- [偏好] {p['content']}")
for t in todos:
lines.append(f"- [待办] {t['content']}")
for r in picked:
lines.append(f"- [{r['type']}] {r['content']}(记录于 {fmt_date(r['created_at'])})")
return "\n".join(lines)
messages = [
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "system", "content": build_context(user_input, records)}, # 半稳定
*recent_turns,
{"role": "user", "content": user_input},
]
偏好放在系统提示词之后、对话历史之前,正好落在稳定前缀里。而按需召回的事实和教训如果每次都在变,可以放到用户消息之前——代价是缓存命中率略降,但换来的相关性提升通常更值。
改完之后的对比
| 指标 | 改造前 | 改造后 |
|---|---|---|
| 记忆注入量 | 全部偏好 + 最近 10 条历史 | 全部偏好 + 最多 5 条相关 |
| 第 30 天时的记忆条数 | 只增不减 | 过期与被取代的自动转入 deprecated |
| 临时意图 | 永久有效 | 带 ttl_days,到期自动失效 |
| 错误信息 | 写进去就一直在 | 需 quote,可疑的进 pending |
| 冲突 | 两条都在,模型随机选 | 按四条规则判定,旧的被标记取代 |
| “它为什么不记得了” | 无法回答 | 查 superseded_by 即可 |
最有价值的其实是最后两行。改造前你只能观察到“它好像记错了”,改造后你能说出“它按照哪条规则、被哪一条取代了”。可解释性不是锦上添花,它是你能不能继续迭代这套系统的前提。
怎么验证记忆真的有用
到这里为止,所有设计都有一个共同的风险:你以为它记住了,实际上只是 prompt 里碰巧有那句话。
所以最后一步必须能验证。不要问“它记住了吗”,要问“记住之后,它有没有变得更好”。
回放测试
把一段真实对话录下来,固化成脚本,每次改完记忆逻辑都跑一遍:
SCRIPT = [
("记住:我不写标题党", "assert_stored"),
("帮我想 5 个选题,方向是给新手看的 Agent 入门", "assert_no_clickbait"),
("刚才那个方向作废,改成偏工程向", "assert_preference_updated"),
]
def replay(script):
for turn, check in script:
output = run_agent(turn)
CHECKS[check](output, load())
第二、三步是关键。第三步尤其能测出冲突消解有没有真的生效——很多实现在这一步会同时保留两条偏好,输出变得两头不讨好。
反例测试
比回放更重要的,是专门测“不该发生的事”:
NEGATIVE_CASES = [
{
"name": "过期偏好不该生效",
"seed": [{"type": "preference", "content": "最近想多写工程向内容",
"created_at": days_ago(21), "expires_at": days_ago(7),
"source": "model:s07", "status": "active"}],
"input": "我想写一篇给完全没写过代码的人看的 Agent 入门",
"assert": lambda out: "工程向" not in out,
},
{
"name": "被取代的记忆不该再出现",
"seed": [{"type": "fact", "content": "用户已发布 20 篇文章",
"status": "deprecated", "superseded_by": "a1b2c3d4"}],
"input": "根据我写过的文章数量给个建议",
"assert": lambda out: "20 篇" not in out,
},
{
"name": "无依据的推断不该直接生效",
"seed": [{"type": "preference", "content": "用户偏好英文输出",
"quote": "", "source": "model:s09", "status": "pending"}],
"input": "随便给我一个选题",
"assert": lambda out: is_chinese(out),
},
]
这三条分别对应过期、冲突、可信度。它们看起来很简单,但我见过太多记忆系统栽在第一条上。
三个值得长期盯的指标
| 指标 | 怎么算 | 健康值 | 异常说明 |
|---|---|---|---|
| 命中率 | 召回的记忆里,真正影响输出的比例 | > 50% | 低说明召回策略太松 |
| 陈旧率 | 召回里已过期或被取代的比例 | < 5% | 高说明过期机制没生效 |
| 待确认堆积量 | pending 里的条数 | < 20 | 一直涨说明没人看,等于失效 |
第三个指标是最容易被忽略的。一个从不被清空的待确认区,等于一个没人审计的记忆库,只是把问题推迟了而已。
常见误区
第一个误区:把对话全存起来就叫记忆。 那是日志,不是记忆。日志的价值在追溯,记忆的价值在影响下一次决策。把全量对话塞进上下文,只会得到上一讲说过的“中间丢失”和“上下文干扰”。
第二个误区:接个向量数据库就等于有记忆系统了。 检索只是最后一环。写入什么、什么时候失效、冲突怎么办、写错了怎么改——这些都不由向量库负责。先把 JSONL 那套跑顺,再考虑换存储。
第三个误区:删掉错误的记忆就算修好了。 不记录为什么删,下次模型还会从同样的误解里重新抽出同样的一条。正确做法是软删除 + 写一条 lesson。
第四个误区:让模型全权决定记什么。 模型可以做抽取,但必须受 schema 约束、必须给依据、必须可审计。把“记什么”完全交给模型,等于把系统的长期行为交给了一次次不可复现的采样。
记忆在整套系统里的位置
记忆不是孤立的一块,它和后面几讲的关系很直接:
- 工具设计(第 3 篇):工具返回值是记忆最可靠的写入者之一,工具报错则是 lesson 的主要来源。
- 编排与多 Agent(第 4 篇):拆成多个 Agent 之后,第一个要回答的问题就是「谁记什么、记忆放在哪一层」。这个问题答不好,多 Agent 会立刻退化成一堆互相不知道对方做过什么的角色。
- 评估体系(第 5 篇):记忆是最容易被评估漏掉的维度——它出错时通常不会报错,只是让输出慢慢变差。
- 人机边界(第 7 篇):记忆里存着关于用户的信息,「用户能不能查看、能不能要求删除」不是一个可选功能。
回到开头那个例子。改造之后,三周前那句“最近想多写工程向”会在到期时自动转入 deprecated,而今天这句“给完全没写过代码的人看”因为来自用户显式表达,优先级最高。
它并没有变得更聪明,它只是终于学会了一件事:有些话你只是随口说说。
这是记忆系统里最难、也最像人的一部分——知道该忘掉什么。
本系列目录
这是「Agent 工程进阶」系列的第 2 篇。
- 第 0 篇(地图):从 Demo 到可交付:如何做一个 Agent 项目
- 第 1 篇:上下文工程:为什么你的 Agent 越聊越笨
- 第 2 篇:记忆系统:Agent 怎么记住该记的,忘掉该忘的(当前篇)
- 第 3 篇:工具设计深水区:粒度、错误语义、幂等与 MCP
- 第 4 篇:编排与多 Agent:什么时候该拆,什么时候千万别拆
- 第 5 篇:评估体系:怎么知道你的 Agent 变差了
- 第 6 篇:可靠性与成本:什么时候该重试,什么时候该放弃
- 第 7 篇:人机边界:什么时候该问人,什么时候该放心让它做
新手系列入口(偏入门,建议先跑通第一个 Agent):先听懂:AI、LLM、Prompt、Agent、RAG、Tool、Memory 到底是什么
