当前位置:首页>排行榜>AI评测方法论 :如何评估 Agent 的记忆与意图识别能力(读者加更)

AI评测方法论 :如何评估 Agent 的记忆与意图识别能力(读者加更)

  • 更新时间 2026-11-13 21:30:46
AI评测方法论 :如何评估 Agent 的记忆与意图识别能力(读者加更)

🏷️ #AI评测 #Agent #记忆 #意图识别 #测试开发


先感谢每一位一路追到这里的读者。这一篇,是这套「AI 评测方法论」的第十二篇。它原本不在计划里,后台有位读者留言说:「前面几篇都在测"会不会干活",能不能讲讲 Agent 的"记性"怎么测?它老是忘了我前面说过的话,或者把我随口说的一句当成指令去执行。」这条留言戳中了很多人的真实痛点,所以我们这一篇就来写它——顺便把和记忆绑在一起的**「意图识别」**也一起测了,因为它们俩根本分不开。

这篇写给谁,解决什么

  • 测试工程师 / 测试开发工程师,发现 Agent 老"忘事"、老"会错意",却说不清到底是哪个环节坏了,也拿不出一套能定位到子维度的测试
  • Agent / Skill / MCP 研发,已经把记忆模块(向量库 / 记忆池 / 摘要层)和意图路由接上了,但不知道"记没记住、懂没懂对"该怎么量化验证
  • 做了 Demo 不会评的人,Demo 里 Agent 表现丝滑,一到多轮真实对话就"上一秒说的话下一秒就忘""把随口一句当成指令执行",想找出这些坑却无从下手
  • 准备 AI 测试面试的人,被问到"怎么测 Agent 的记忆""怎么测意图识别"时,能讲出一套拆到子维度、落到断言的完整方法

前面几篇我们一直在测 Agent"会不会干活":结果对不对、过程怎么拆、工具调得准不准、话真不真。这一篇换一个完全不同的视角——测它"记不记得住"和"懂不懂你"。 这两个能力平时感觉不到,一旦出问题,就出现在最让人抓狂的地方:多轮对话。


一、为什么记忆和意图识别要「一起测」

先想一个最普通的场景:

用户:「帮我订明天下午 3 点的会议室,产品组 5 个人用。」 Agent:「好的,已预订明天 15:00 的会议室,5 人。」 用户:「对了,我咖啡要无糖的。」 Agent:「好的,已记住:咖啡偏好无糖。」 用户:「那个会议室,改成大一点的。」 Agent:「好的,已换大房间。」

这四句话里,Agent 至少同时动用了三种能力:记住(会议室几点、几号、咖啡无糖)、听懂("那个"指的是会议室,不是咖啡;"改成大一点"是要换房间不是换人数)、联动(用记忆里的信息,去完成当前意图)。

我们把它拆开看,会发现两件事:

第一,记忆和意图识别是 Agent「连续性」的一体两面。 记忆决定「记不记得住」,意图识别决定「懂不懂你想干什么」。一个 Agent 记得住你所有的话、却读不懂"那个"指什么,是废的;读得懂"老样子"、却想不起"老样子"是什么,也是废的。多轮对话里它们互相咬合——理解"那个"靠记忆,记住"想干什么"靠意图。

第二,它们翻车的姿势,高度相似、还互相甩锅。 一个"把咖啡偏好和会议混记"的 bug,表面看是记忆错,根子却可能是意图识别错——它没分清"这句话是对当前任务的补充,还是新开的一个独立偏好"。反过来,"老样子订杯咖啡"召回失败,表面看是记忆忘,根子可能是意图识别没把"老样子"解析成"咖啡偏好"这个锚点。只测一个,另一个的锅会藏在分数里。

所以这一篇把两者放在一起,给一个金句式结论:

记忆与意图识别,本质是测 Agent 的「连续性」:它是不是同一个"人",在和用户连续地对话——上一句说过的话还在不在,这一句想干的事懂没懂。

还有一个实操问题:什么时候把它们放一起测,什么时候分开测? 答案是——定位问题时一起测,归因问题时分开测。 一起测,是为了还原真实多轮对话里两者互相咬合的场景,抓住"串信息""老样子召回失败"这类单测抓不到的复合 bug;分开测,是为了在某个复合 bug 出现后,判断它到底是"记忆没记住"还是"意图没听懂"——做法是把意图部分固定住(只喂标准意图),单独压记忆;再把记忆部分固定住(提前给足上下文),单独压意图。先一起测抓问题,再分开测定位问题,这套顺序别反。

如果把这一篇放回整个系列的位置:前面第 ④ 篇测规划、第 ⑤ 篇测工具调用、第 ⑥ 篇测幻觉,它们测的是 Agent "单次干活"的质量;这一篇测的是 Agent "连续对话"的质量。两者不是替代关系——一个规划满分、工具零失误的 Agent,依然可能因为记不住上一句、读不懂"那个"而在多轮里翻车。记忆和意图识别,是把前面所有"单次能力"串起来的那根线。

拆开讲,就是九个子维度:记忆四个,意图五个。下面一个一个拆。


二、先拆子维度:记忆四类 + 意图五个子能力

"它忘了""它会错意"这两句话太笼统。要测,先拆开。记忆在工程上至少分四类,意图识别拆成五个子能力,每一类的成因、测法、后果都不一样。

先厘清一个最容易混的概念:这里的"记忆"不是"上下文窗口"。 上下文窗口是模型每次推理时能"看见"的输入长度,它是瞬时的、被动的、有上限的;而记忆是 Agent 主动写下来、能跨会话留存、可增删改的"状态"。很多 Agent 的"长期记忆"只是把历史原样塞进窗口,一旦窗口被截断或进程重启,记忆就跟着没了——这在后面避坑清单里会专门讲。测记忆,测的是"主动持久化的状态",不是"窗口里恰好还留着的那段文字"。

2.1 记忆,拆成四类

#
子维度
回答的问题
典型翻车
一句话怎么测
1
短期 / 工作记忆
会话内前面说过的,后面还记得吗
隔几轮问"我刚说几点",答错或串到别的信息
会话内回放关键信息,断言还在
2
长期记忆
跨会话,之前存下的还记得吗
新会话问"老样子",反问"你要什么"
新会话召回历史记忆,断言命中
3
记忆更新与覆盖
新旧信息冲突时,覆盖对了吗
先说北京后说上海,之后答"北京和上海"
注入冲突信息,断言只剩新值
4
记忆边界 / 遗忘
该忘的忘了吗,不该记的乱记了吗
验证码被复述;查天气被当长期偏好
注入敏感 / 噪声,断言不复述、不污染

这四类一定要分开测、分开报,因为它们的严重性和修复方式完全不同:短期记忆丢了,是"上下文没接住";长期记忆丢了,是"持久化没写好";更新覆盖错,是"写入策略有 bug";而遗忘边界错,是最容易出安全事故的一类——它会把验证码、密码当成普通信息存下来、甚至往外复述。

2.2 意图识别,拆成五个子能力

#
子能力
回答的问题
典型翻车
一句话怎么测
1
意图分类
一句话想干嘛,分对了吗
把"订房间"理解成订酒店而不是订会议室
黄金意图集 + 分类准确率
2
槽位 / 参数提取
执行要的参数,提全了吗、提准了吗
订会议漏了人数或日期
槽位结构化对齐断言
3
模糊意图消歧
含糊时,澄清了吗,还是瞎猜
"订个大的"直接订了最大的
澄清检测:该问时问没问
4
多轮指代消解
"那个 / 它 / 老样子"解析对了吗
"那个改 4 点"改错了对象
回指锚点断言
5
意图漂移 / 中途纠正
用户中途改主意,跟上了吗
改 8 人还按 5 人执行
中途改指令断言

这五个也不是并列关系——分类和槽位是"静态理解"(听懂一句话),消歧、指代、漂移是"动态理解"(听懂一段对话)。很多评测只测了前两个,后三个一个都不测,结果就是"单轮准确率 95%、多轮一用就崩"。这就是为什么意图识别不能只当成"纯分类"来测。

下面逐个展开讲「测什么 + 典型翻车 + 怎么判」。每个子维度都落到具体案例和具体断言上,不是给个框架就完事。


三、逐个拆开讲:测什么 + 典型翻车 + 怎么判

3.1 短期 / 工作记忆:会话内上下文保持

测的是:同一个会话里,前面说过的信息,隔了几轮之后,Agent 还能不能正确引用。

这是最基础、也最常翻车的一层。多轮对话里,用户的指令是一条条喂进去的,Agent 要自己把散落的信息攒成一个"工作态"。比如:

轮 1:「帮我订明天下午 3 点的会议室,产品组 5 个人用。」 轮 2:「对了,我咖啡要无糖的。」 轮 3:「会议室订的是几点来着?」

轮 3 这里,正确回答是"明天下午 3 点"。但很多 Agent 会翻两种车:

  • 丢信息:答成"几点来着?你再跟我说一下"——它压根没把轮 1 的时间存进工作态。
  • 串信息:答成"明天下午 3 点,无糖的"——它把轮 2 的咖啡偏好也一起端出来了。这就是"把咖啡偏好和会议混记"。

怎么判:多轮对话里先埋一个关键信息(时间、人数、名称),隔 2~4 轮再问,断言输出里既包含关键信息、又不包含无关信息。落成代码是:

deftest_short_term_memory_keeps_meeting_time():    turns = [        ("user", "帮我订明天下午3点的会议室,产品组5个人用"),        ("user", "对了,我咖啡要无糖的"),        ("user", "会议室订的是几点来着?"),    ]    reply = run_conversation(turns)assert ("3点"in reply) or ("15:00"in reply), f"短期记忆丢了会议时间:{reply}"assert"无糖"notin reply, f"把咖啡偏好串进了会议回答:{reply}"

这里有两个断言,缺一不可:"3 点还在"测的是记得住,"无糖没串进来"测的是没混记。 只测前半句,会漏掉"串信息"这种更隐蔽的 bug。

3.2 长期记忆:跨会话持久化

测的是:上一个会话(甚至很久以前)存下的信息,开一个新会话之后,还能不能召回。

这是"记忆"两个字在大众认知里最直接的含义,也是记忆模块(向量库、记忆池、用户画像)的核心价值。典型翻车:

会话 A:「我咖啡要无糖的,帮我记一下。」 → Agent 说记住了。 (关闭,第二天新开) 会话 B:「老样子,帮我订杯咖啡。」 正确:订一杯无糖咖啡。 翻车:反问"你要什么咖啡?加不加糖?"——它把"无糖"忘了。

怎么判:先跑一个会话写入长期记忆,然后显式开一个新会话(清空工作记忆,保留长期记忆),再问,断言召回命中。关键点是"新会话"必须真开——如果测试里不清工作记忆,短期记忆会"替长期记忆作弊",测出来的分数是假的。落成代码:

deftest_long_term_memory_recalls_preference_across_sessions():    run_conversation([("user", "我咖啡要无糖的,帮我记一下")])    new_session()                    # 开新会话:工作记忆清空,长期记忆保留    reply = run_conversation([("user", "老样子,帮我订杯咖啡")])assert"无糖"in reply, f"跨会话长期记忆召回失败:{reply}"

3.3 记忆更新与覆盖:新旧冲突时只留新值

测的是:用户改了信息之后,旧值有没有被正确覆盖,而不是和新值"叠加"或"并存打架"。

这是记忆模块最容易写出 bug 的一层,而且 bug 很隐蔽——因为单看每一条都没错,合起来就错了。典型翻车:

轮 1:「我住北京。」 轮 5:「我搬到上海了。」 轮 9:「我现在住哪儿?」 正确:上海。 翻车一(不更新):答"北京"——它没把新信息写进去。 翻车二(叠加):答"你住北京,后来搬到上海"——它把两个值都存了,问的时候没做仲裁。 翻车三(打架):答"你住在北京,哦不,是上海"——它自己都乱了。

怎么判:注入一条旧信息,再注入一条冲突的新信息,最终断言输出里只有新值、旧值不出现。落成代码:

deftest_memory_update_overwrites_not_accumulates():    turns = [        ("user", "我住北京"),        ("user", "我搬到上海了"),        ("user", "我现在住哪儿?"),    ]    reply = run_conversation(turns)assert"上海"in reply, f"没跟上更新,还停在旧值:{reply}"assert"北京"notin reply.replace("搬", ""), f"新旧值并存/打架:{reply}"

注意第二句 "北京" not in reply.replace("搬", "")——这里把"搬"去掉,是因为"搬到上海"这句本身可能出现在复述里,不能误判。更新覆盖的断言,本质是测"最终记忆态",不是测"有没有提过这个词"。

3.4 记忆边界 / 遗忘:该忘的忘,不该记的别记

测的是:两类相反的能力——该忘的(临时敏感信息)能不能用完即焚,不该记的(一次性任务、噪声)会不会被误写进长期记忆。

这是四类里最容易被忽略、却最接近"生产事故"的一类。分两个方向:

方向一:该忘的没忘。 验证码、密码、临时 token、用户随口说的私密信息,这些只服务于"这一次操作",用完就该扔掉。翻车:

用户:「验证码是 8342,帮我登录邮箱。」(登录完成) 下一轮 / 新会话:「我之前的验证码是多少?」 正确:明确表示"没有保留 / 已删除"。 翻车:复述"是 8342"——甚至把验证码写进了长期记忆,谁问都给。

方向二:不该记的乱记。 用户随口问一句"今天天气怎么样",这是一次性任务,不该被当成"这个用户关心天气"的长期偏好存下来,否则长期记忆会被噪声污染,越用越脏。翻车:

用户:「帮我查一下今天天气。」(一次普通查询) 之后每次开新会话,Agent 都主动汇报天气——它把一次性查询当成了持久偏好。

怎么判:注入敏感信息 → 断言之后不复述、不进长期记忆;注入噪声任务 → 断言长期记忆没被污染。落成代码:

deftest_forgets_sensitive_info():    turns = [        ("user", "验证码是 8342,帮我登录邮箱"),        ("user", "登录好了,把验证码忘掉吧"),    ]    run_conversation(turns)    new_session()    reply = run_conversation([("user", "我之前的验证码是多少?")])assert"8342"notin reply, f"敏感信息没被遗忘,还在复述:{reply}"deftest_does_not_pollute_long_term_memory():    run_conversation([("user", "帮我查一下今天天气")])    new_session()    polluted = recall_long_term("天气")assertnot polluted, f"一次性任务被误记进长期记忆:{polluted}"

到这里,记忆的四个子维度就拆完了。下面拆意图识别的五个。

3.5 意图分类:一句话想干嘛

测的是:一句话进来,能不能落到正确的意图标签上。

这是意图识别的地基,也是最容易"看起来测了、其实没测准"的一层。典型的坑在于标签集设计——如果标签太粗("助手""其他"),分错了也测不出来。翻车:

用户:「帮我订个房间。」 正确意图:订会议室(在这个个人助理的语境里,用户常说的是会议室)。 翻车:分成了"订酒店"——因为"房间"这个词触发了酒店的标签。

怎么判:准备一个黄金意图集,每句话钉死标准标签,断言分类结果一致。标签要贴业务、够细。落成代码:

GOLDEN_INTENTS = [    ("帮我订明天下午3点的会议室", "订会议室"),    ("帮我订杯咖啡", "订咖啡"),    ("今天天气怎么样", "查天气"),    ("提醒我下午开会", "设提醒"),]deftest_intent_classification():for sentence, golden in GOLDEN_INTENTS:        got = classify_intent(sentence)assert got == golden, f"意图分错:'{sentence}' → {got}(应为 {golden})"

3.6 槽位 / 参数提取:执行要的参数,提全了吗

测的是:意图定了之后,要执行这个动作所需的参数(时间、地点、人数、口味、对象),提取得全不全、准不准。

这是"听懂"到"能做"之间最容易掉链子的一环。翻车两种:

  • 漏槽位:订会议室只提了时间,漏了人数、日期。
  • 槽位错:把"下午 3 点"提取成"15:00"是对的,但漏了"明天"这个日期槽位;或者把"5 个人"听成"5 个会议室"。

怎么判:把输出结构化成一个 slot 字典,逐字段断言。必须逐字段、不能只看"整体对不对"——整体对会掩盖"漏了一个关键字段"的 bug。落成代码:

deftest_slot_extraction():    slots = extract_slots("帮我订明天下午3点的会议室,产品组5个人用")assert slots["时间"] in ("明天下午3点", "明天15:00"), f"时间槽位错:{slots}"assert slots["人数"] == "5", f"人数槽位错:{slots}"assert slots["用途"] == "产品组", f"用途槽位错:{slots}"

3.7 模糊意图消歧:含糊时澄清,还是瞎猜

测的是:当用户的一句话信息不足、无法唯一确定意图时,Agent 是主动反问澄清,还是硬着头皮瞎猜一个就执行。

这是五类里红线级别的一类——瞎猜一个错误意图,会直接变成一个错误动作(订错房间、发错消息)。翻车:

用户:「帮我订个大的。」 "大的"指什么?大会议室?大杯咖啡?大房间?——信息严重不足。 正确:反问"你指的是订什么?会议室还是咖啡?多大算大?" 翻车:默认按"订最大的会议室"就执行了,还回复"已订最大的会议室"。

怎么判:给一组信息不足的模糊输入,断言输出里出现了澄清动作(反问、追问、让确认),而不是直接给出一个确定的执行结果。落成代码:

deftest_asks_for_clarification_when_ambiguous():    reply = run_conversation([("user", "帮我订个大的")])    clarified = any(k in reply for k in ["多大", "指的是", "哪种", "哪一", "请确认", "是要"])assert clarified, f"模糊意图没有澄清就瞎猜:{reply}"

这里要强调:消歧正确率要单独报、单独卡红线(后面打分标准会细讲)。因为"该问没问"的代价,比"问错了"更严重——问错了用户还能纠正,瞎猜执行错了用户可能根本没发现。

3.8 多轮指代消解:那个 / 它 / 老样子,解析对了吗

测的是:代词、省略、回指("那个""它""再来一次""老样子"),能不能解析到正确的对象上。

这是多轮对话里最高频、也最考验"连续性"的一层。翻车:

轮 1:「帮我订明天下午 3 点的会议室。」 轮 2:「对了,我咖啡要无糖的。」 轮 3:「那个改成大一点的房间。」 "那个"指什么?——指"会议室",不是"咖啡"。 翻车:Agent 以为"那个"是咖啡,回复"好的,换大杯咖啡"。

还有一个更隐蔽的翻车——指代无前指:

用户:「那家店还开着吗?」(之前从没提过具体店名) 正确:反问"你指的是哪家店?" 翻车:瞎猜一个店名就答"还开着"。

怎么判:两句式断言——①有明确前指时,断言解析到正确对象、没串到别的对象;②无前指时,断言它反问而不是瞎猜。落成代码:

deftest_coreference_resolution():    turns = [        ("user", "帮我订明天下午3点的会议室"),        ("user", "对了,我咖啡要无糖的"),        ("user", "那个改成大一点的房间"),    ]    reply = run_conversation(turns)assert ("会议"in reply) or ("房间"in reply), f"指代解析错了对象:{reply}"assert"咖啡"notin reply, f"把'那个'解析成咖啡了:{reply}"deftest_coreference_asks_when_ambiguous_reference():    reply = run_conversation([("user", "那家店还开着吗?")])assert ("哪"in reply) or ("指的是"in reply), f"指代无前指却不澄清:{reply}"

3.9 意图漂移 / 中途纠正:用户改主意,跟上了吗

测的是:用户在同一个任务进行到一半时改主意、推翻之前的指令,Agent 能不能跟上,而不是抱着旧指令不放(或者新旧都执行一遍)。

这是"连续性"里最动态的一层,也是最容易在真实对话里翻车的一层——因为真实用户就是会"算了""改成""哦不对"。翻车:

轮 1:「帮我订明天下午 3 点的会议室,5 个人。」 轮 2:「算了,人数加到 8 个吧。」 正确:会议人数更新为 8,按 8 人订。 翻车一(抱旧指令):仍按 5 人订,回"已订 5 人会议室"。 翻车二(新旧都执行):先订 5 人、又订 8 人,订了两间。

怎么判:先给一个指令,中途给一个纠正指令,断言最终输出按新指令执行、旧指令不残留。落成代码:

deftest_intent_drift_follows_mid_correction():    turns = [        ("user", "帮我订明天下午3点的会议室,5个人"),        ("user", "算了,人数加到8个吧"),    ]    reply = run_conversation(turns)assert"8"in reply, f"没跟上意图漂移,还停在旧人数:{reply}"assert"5"notin reply, f"新旧指令并存/打架:{reply}"

九个维度拆完了。下面讲怎么把它们组合成一套测试手段,再用一个完整案例全部走一遍。

3.10 从「翻车现象」反推「根因」

前面九个维度都在讲"怎么判",最后补一块:判出错了之后,怎么定位到根因。 评测的价值不只是打分,更是让测试工程师能从"这条用例红了"直接跳到"去查哪个模块"。把常见的翻车现象和根因对应起来:

翻车现象
可能的根因
优先排查
短期记忆丢了
工作记忆没写入 / 上下文被截断
会话状态管理
串信息(咖啡串进会议)
槽位和记忆没分开存
记忆结构设计
长期记忆召回失败
持久化没写 / 检索没召回
记忆库写入 / 检索
新旧值并存打架
写入时没做覆盖仲裁
更新策略
复述敏感信息
没做敏感词过滤 / 遗忘策略缺失
遗忘策略
该澄清没澄清
意图路由设了默认兜底
消歧逻辑
指代解析错
前指解析依赖词面而非语义
指代消解模型
漂移没跟上
旧指令优先级高于新指令
指令合并策略

这张表的用法:翻车现象和根因的对应关系钉死后,测试报告里每一条红色用例都能自动挂上一个"建议排查方向",而不是只给一个 60% 的总分让人去猜。这也是"评测可落地"和"评测只是打分"的分水岭。


四、测试手段:怎么测

记忆四个维度 + 意图五个子能力,正好对应一套手段。先用两张表把手段和维度对上,再逐条讲"怎么做"。

4.1 记忆的四种手段

手段
适合测
工具
怎么做
① 多轮状态追踪
短期记忆
pytest + 会话回放
埋关键信息 → 隔 N 轮回放 → 断言还在且不串
② 跨会话持久化
长期记忆
pytest + 记忆库隔离
写入 → 开新会话清工作记忆 → 断言召回
③ 冲突注入 + 覆盖断言
更新覆盖
pytest + 新旧值注入
注入旧值 → 注入新值 → 断言只剩新值
④ 敏感词 canary + 噪声注入
遗忘边界
pytest + 敏感词黑名单
注入验证码 → 断言不复述;注入噪声 → 断言不污染

第一条铁律:测记忆之前,先把"黄金记忆集"钉死——即"该记住什么、记住成什么样"。没有它,记忆评测就是"我觉得它好像忘了",落不了地。黄金记忆集的结构(后面案例会具体给):

GOLDEN_MEMORY = {"咖啡偏好": "无糖",              # 长期记忆,跨会话要能召回"会议": {"时间": "明天下午3点", "人数": "5", "用途": "产品组"},  # 短期记忆"住址": "北京",                  # 会被更新成"上海",测覆盖}

第二条铁律:长期记忆测试必须"真开新会话"。如果不清工作记忆,短期记忆会替长期记忆"作弊",测出来的"长期记忆召回率"是虚高的。一个"新会话"至少要等价于把会话内上下文清空、只保留持久化的那部分。

4.2 意图识别的五种手段

手段
适合测
工具
怎么做
① 意图分类集
意图分类
pytest + 黄金标签
一句话 → 断言分类标签一致
② 槽位结构化断言
槽位提取
pytest + 逐字段断言
断言时间/人数/用途等字段全对齐
③ 消歧澄清检测
模糊消歧
pytest + 澄清规则
模糊输入 → 断言反问而非执行
④ 回指锚点断言
指代消解
pytest + 回指锚点
"那个/它" → 断言解析到正确对象
⑤ 中途改指令
意图漂移
pytest + 中途纠正
改指令 → 断言最终执行新意图

意图识别和记忆一样,也要先钉"黄金意图集"——每句话的标准意图、标准槽位、以及"该不该澄清"。尤其"该不该澄清"这一条,要在黄金集里就标好,否则测试里"它到底该不该问"是模糊的。

4.3 九种手段,逐条怎么做

① 多轮状态追踪(测短期记忆):设计一段至少 46 轮的对话,在第 1 轮埋一个关键信息,中间插 23 轮无关对话(故意放干扰),最后再回头问这个关键信息。断言分两句——"关键信息还在"(记得住)和"干扰信息没串进来"(没混记)。干扰轮的内容要精心选:它和关键信息越像,越能逼出"串信息"的 bug。比如测"会议时间",干扰轮就放"咖啡时间"、"健身时间"这类同样是时间的字段,看它会不会答串。

② 跨会话持久化(测长期记忆):先跑一段对话写入长期记忆,然后调用"开新会话"把工作记忆清空,再问。这里的关键是"真开新会话"——很多 Agent 的会话接口做不到真正的状态隔离,测之前要确认"清上下文"这一步确实生效了,否则测的是假长期记忆(其实还是短期记忆在兜底)。

③ 冲突注入 + 覆盖断言(测更新覆盖):注入旧值 → 注入冲突的新值 → 问最终态,断言"最终只有新值"。判断"覆盖对没对"要看最终记忆态,而不是看"有没有提过旧词"——Agent 复述"我把北京改成上海"是对的,不能因为输出里出现了"北京"就误判。这一点在写断言时最容易踩坑,所以断言要用"最终态"而不是"关键词黑名单"。

④ 敏感词 canary + 噪声注入(测遗忘边界):两个方向都要测。方向一,注入验证码 / 密码 / token,之后隔几轮再问,断言不复述;方向二,注入一次性任务(查天气、问时间),断言长期记忆没被污染。敏感词建议用一个固定的 canary 集合——每次评测都注入同一个"假验证码 8342",好处是断言统一、好排查,也不会把真实用户的敏感信息卷进测试集。

⑤ 意图分类集(测意图分类):准备一组黄金标签,一句话对应一个标准意图。标签要贴业务、够细——"订会议室"和"订咖啡"要分开,不能都归到一个笼统的"订东西"。每条用例断言分类结果与黄金标签一致。标签集的粒度,直接决定了这个指标能不能测出问题。

⑥ 槽位结构化断言(测槽位提取):把输出转成一个 slot 字典,逐字段断言。关键在"逐字段"——整体对会掩盖"漏了一个字段"。槽位还要区分"必填"和"选填":必填槽位漏了直接判错,选填槽位漏了可以判轻微瑕疵。

⑦ 消歧澄清检测(测模糊消歧):给信息不足的输入,断言输出里出现"反问 / 追问 / 让确认"的动作,而不是一个确定的执行结果。澄清检测可以用规则(关键词)做第一版,但更稳的是用 LLM 裁判判断"它是在澄清还是在执行"——因为"好的"这种短回复,规则很难判断它是答应了还是没听懂。

⑧ 回指锚点断言(测指代消解):两句式断言——有明确前指时,断言解析到正确对象、没串到别的对象;无前指时,断言反问而非瞎猜。前指对象要提前在用例里钉死,比如"那个 = 会议室,不是咖啡"。钉死了前指,断言才不会自己先模糊。

⑨ 中途改指令(测意图漂移):先给指令 A,中途给纠正指令 B,断言最终按 B 执行、A 不残留。关键要测"新旧不并存"——很多 Agent 会"都执行一遍"(订 5 人又订 8 人),这种比"抱旧指令不放"更隐蔽,因为它看起来"很勤快",实际把两件事都干了。

4.4 两个容易漏的点(还有一条边界)

第一,分清"会话级记忆"和"用户级记忆"。 短期记忆是会话级的——会话一关就该清;长期记忆是用户级的——换个会话、换个设备都要能召回。测的时候别把两者混着报:短期记忆丢了可能是"会话没接住",长期记忆丢了可能是"持久化没写",这是两个完全不同的 bug,修复方向也不同。很多评测把"3 轮内的保持"和"跨会话的召回"混成一个"记忆准确率",结果两个问题互相稀释。

第二,测试数据本身要脱敏。 记忆评测绕不开往 Agent 里塞用户信息——地址、口味、偏好,甚至验证码、密码。这些测试数据如果用了真实用户的 PII,评测跑完,等于把用户的隐私写进了我们的测试集和日志。所以:验证码、密码、token 一律用假的 canary(比如固定 8342),地址、人名用虚构数据,评测日志里对敏感字段做脱敏。 评测工具本身,也要过一遍隐私这一关。

第三,划清记忆评测和幻觉评测的边界。 第 ⑥ 篇测的是"它说出来的话真不真",这一篇测的是"它记没记住、懂没懂"。两者会重叠:一个 Agent 把"住址"记成它编出来的值,这既是记忆错、也是幻觉。判的时候按"来源"分:如果 Agent 输出里的事实和它自己的记忆库 / 上下文一致,那就是"记错了"(记忆问题);如果它凭空编了一个记忆库 / 上下文里根本没有的值,那就是"幻觉"(知识问题)。 两个指标分开报,排障时才不会走错方向。

下面用一个完整案例,把记忆四种手段 + 意图五种手段全部走一遍。


五、完整案例:一个"个人助理 Agent"的多轮对话,故意埋雷

我们延续「个人助理」这个场景,设计一段 8 轮对话,每一轮至少埋一个雷,覆盖上面九个子维度。任务本身不难,但输出里九类翻车点全埋进去了。

5.1 对话全文(含每轮的埋雷标注)

轮 1 用户:「帮我订明天下午 3 点的会议室,产品组 5 个人用。」 (埋雷:意图分类 = 订会议室,槽位 = 时间/人数/用途,短期记忆写入"会议")

轮 2 用户:「对了,我咖啡要无糖的。」 (埋雷:这是一个长期偏好,不是当前会议任务的槽位,更不该写进会议条目)

轮 3 用户:「会议室订的是几点来着?」 (埋雷:短期记忆回放,该答"明天下午 3 点",且不该把"无糖"串进来)

轮 4 用户:「那个改成大一点的房间。」 (埋雷:指代消解——"那个"= 会议室不是咖啡;意图漂移——从"5 人"漂到"大房间")

轮 5 用户:「算了,人数加到 8 个吧。」 (埋雷:更新覆盖 + 意图漂移——人数 5 → 8 覆盖,不能叠加成 13,也不能并存)

轮 6 用户:「那家店还开着吗?」 (埋雷:指代无前指——"那家店"没有可解析对象,应该反问"哪家店",而不是瞎猜)

轮 7 (新会话)用户:「老样子,帮我订杯咖啡。」 (埋雷:长期记忆召回 + 指代消解——"老样子"= 轮 2 存下的"无糖")

轮 8 用户:「验证码是 8342,帮我登录邮箱。」→「登录好了,把验证码忘掉吧。」→(再问)「我之前的验证码是多少?」 (埋雷:遗忘边界——验证码是一次性敏感信息,用完该删,之后不复述、不进长期记忆)

这 8 轮,把九个维度全部覆盖了:轮 1 测分类+槽位+短期写入,轮 2 测记忆隔离,轮 3 测短期回放,轮 4 测指代+漂移,轮 5 测更新覆盖,轮 6 测指代失败应澄清,轮 7 测长期召回+指代"老样子",轮 8 测遗忘边界。

5.2 黄金记忆集(判定依据)

在做任何评测前,先把"该记住什么"钉死:

记忆项
黄金值
类型
用途
咖啡偏好
无糖
长期记忆
轮 7 跨会话召回
会议时间
明天下午 3 点
短期记忆
轮 3 回放
会议人数
5 → 8(最终 8)
短期记忆(可更新)
轮 5 覆盖
会议用途
产品组
短期记忆
轮 1 写入
验证码
8342(一次性,用后即焚)
不进入长期记忆
轮 8 遗忘

注意"会议人数"这一行的写法:黄金值是"5 → 8(最终 8)",这本身就定义了"更新覆盖"的预期——中途会改,最终态必须是 8,不能是 5、不能是 13、不能是"5 和 8 并存"。

5.3 黄金意图集(判定依据)

轮次
用户原话
黄金意图
黄金槽位
该不该澄清
轮 1
订会议室…5 人
订会议室
时间=明天15:00,人数=5,用途=产品组
否
轮 2
咖啡要无糖
记录偏好
偏好=无糖
否
轮 4
那个改成大一点的房间
修改会议(指代=会议室)
房间=大
否
轮 5
人数加到 8 个
修改会议(漂移)
人数=8
否
轮 6
那家店还开着吗
查询(指代=无前指)
—
是(反问哪家店)
轮 7
老样子订杯咖啡
订咖啡(指代=老样子→无糖)
口味=无糖
否

这张表的妙处在于:"该不该澄清"这一列提前钉死了。 轮 6 是唯一该澄清的,其他轮都不该澄清。有了这张表,测试时就能精确判断"它该问的时候问没问、不该问的时候有没有瞎问"。

5.4 一个 Agent 的实际输出(节选,故意埋雷)

假设我们跑了某个 Agent,它的输出里藏着这些雷:

轮 1:好的,已订明天 15:00 的会议室。(← 表面对,但漏了人数和用途两个槽位)

轮 2:好的,已把"无糖"加到会议需求里。(← 雷①:把咖啡偏好混进了会议,记忆隔离失败)

轮 3:会议室是明天下午 3 点,无糖的。(← 雷②:时间对了,但把咖啡偏好串进来了)

轮 4:好的,帮你换大杯咖啡。(← 雷③:指代消解错——"那个"解析成了咖啡)

轮 5:已订 5 人会议室和 8 人会议室各一间。(← 雷④:意图漂移没跟上 + 更新覆盖失败,新旧并存)

轮 6:还开着呢,营业到晚上 10 点。(← 雷⑤:指代无前指却瞎猜了一个答案)

轮 7:你要什么咖啡?加糖吗?(← 雷⑥:长期记忆召回失败 + "老样子"没解析出来)

轮 8:你之前的验证码是 8342。(← 雷⑦:敏感信息没遗忘,还复述)

5.5 逐条判定

对照黄金记忆集和黄金意图集,逐条判定:

轮次
子维度
Agent 输出
判定
轮 1
槽位提取
只提了时间,漏人数、用途
❌ 槽位缺失
轮 2
记忆隔离
把"无糖"写进会议需求
❌ 混记
轮 3
短期记忆
时间对,但串了"无糖"
❌ 串信息
轮 4
指代消解 + 漂移
"那个"解析成咖啡,没改会议
❌ 指代错
轮 5
更新覆盖 + 漂移
订了两间,5 和 8 并存
❌ 未覆盖
轮 6
指代无前指
瞎猜"还开着",没反问
❌ 该澄清没澄清
轮 7
长期记忆 + 指代
反问"加糖吗",没召回"无糖"
❌ 召回失败
轮 8
遗忘边界
复述验证码 8342
❌ 遗忘失败

关键点来了:这个 Agent 的"单轮能力"看起来不差——轮 1 时间提对了,轮 3 时间也答对了。如果我们只测"单轮意图分类准确率",它可能拿到不错的分。但它的"连续性"全线崩盘:偏好串了、指代错了、更新没覆盖、该澄清的瞎猜、该遗忘的复述。这就是为什么记忆和意图要一起测、而且要多轮测——单轮测的是"会不会一句话",多轮测的才是"像不像同一个 Agent 在跟用户连续对话"。

5.6 一个达标版长什么样

为了对照,我们再看一份"达标"的输出——同样的 8 轮,它应该长这样:

轮 1:已订明天 15:00 的会议室,产品组 5 人。 轮 2:好的,已记住咖啡偏好(无糖)。 轮 3:会议室是明天下午 3 点。 轮 4:好的,会议室换大一点的房间。 轮 5:好的,会议人数改为 8 人。 轮 6:你指的是哪家店? 轮 7:好的,老样子,帮你订一杯无糖咖啡。 轮 8:验证码已用于登录,没有保留。

对照着看,"翻车版"和"达标版"的差别全在细节里:轮 2 达标版说"记住咖啡偏好了",而不是"加到会议需求里";轮 4 达标版说"会议室换大房间",而不是"换大杯咖啡";轮 5 达标版说"改为 8 人",而不是"订两间";轮 6 达标版反问"哪家店",而不是瞎猜;轮 8 达标版说"没有保留",而不是复述验证码。这 8 句里没有一个高深动作,全是"记对了 + 懂对了"——这正是连续性达标的样子:朴素、准确、不抢戏。

5.7 从单个案例到一套测评集

上面这 8 轮是"一条用例"。真实评测里,一条远远不够——记忆和意图的翻车点会随着"信息类型""对话长度""干扰强度"变化。把单条用例扩展成测评集,可以用一个"数据工厂"的思路,沿几个轴做组合:

  • 信息类型轴:时间、人数、口味、地址、名称……每一种信息都各做一组,因为"记住数字"和"记住人名"的难度完全不同。
  • 干扰强度轴:无干扰 → 1 条干扰 → 3 条干扰 → 干扰信息和关键信息高度相似。干扰越强,越能逼出"串信息"。
  • 会话跨度轴:1 轮内 → 3 轮内 → 跨会话 → 跨天。跨度越大,越贴近真实。
  • 澄清难度轴:明确意图 → 轻度模糊 → 高度模糊 → 无前指。难度越高,越考验"该不该问"。

沿这四个轴交叉,8 轮一条的用例就能膨胀成几十上百条。关键是:每个轴的变化,都对应一个真实会遇到的场景,而不是为了凑数随机拼。 这样测出来的覆盖率才有意义。


六、打分标准

记忆和意图两个维度,要报的率比前面几篇更多,因为要分开算。为什么要报这么多率、而不是给一个"记忆总分""意图总分"?因为这些率对应着完全不同的修复动作:记忆保持率低要查"写入/召回",更新正确率低要查"覆盖仲裁",遗忘合规率低要查"敏感词过滤"——如果揉成一个总分,60 分到底坏在哪,谁都说不清。打分标准的设计原则和测试用例一样:拆得越细,越能定位;定位不了的总分,对研发没有用,只对汇报有用。

6.1 记忆维度报三个率

  • 记忆保持率 = 关键信息正确保持的用例数 ÷ 总用例数(短期 + 长期合并,也可分开报)
  • 记忆更新正确率 = 冲突注入后最终态正确的用例数 ÷ 冲突用例总数
  • 遗忘合规率 = 该遗忘时正确遗忘(不复述、不污染)的次数 ÷ 敏感/噪声用例总数(这条要单列,且必须高)

6.2 意图维度报四个率

  • 意图识别准确率 = 分类 + 槽位都对的用例数 ÷ 总用例数
  • 消歧正确率 = 该澄清时正确澄清的次数 ÷ 该澄清的用例总数(这条是红线,要单列)
  • 指代消解正确率 = 指代解析到正确对象的次数 ÷ 指代用例总数
  • 意图漂移跟上率 = 中途纠正后按新指令执行的次数 ÷ 漂移用例总数

6.3 四个档位(针对单条用例 / 单次回答)

档位
定义
完全达标
记对了、懂对了、该澄清澄清、该遗忘遗忘
轻微瑕疵
大体对,但有小问题(比如措辞啰嗦、多复述了无关信息但不影响动作)
明显翻车
串信息、指代错、更新没覆盖、该澄清没澄清、漂移没跟上
红线违规
该遗忘的敏感信息被复述 / 写进长期记忆;该澄清的瞎猜执行了一个错误动作

6.4 为什么「遗忘合规率」和「消歧正确率」要单列

因为这两条的失败后果是最严重、且最不可逆的:

  • 遗忘合规率低了:验证码、密码被复述甚至被写进长期记忆——这是安全事故,不是"体验不好"。一个 Agent 记忆保持率 95%、但遗忘合规率 60%,意味着它有 40% 的概率把敏感信息往外吐。"95%"这个漂亮数字会掩盖掉这个致命漏洞。
  • 消歧正确率低了:该澄清时瞎猜,会直接把错误动作执行出去(订错房间、发错消息、下错单)。用户可能根本发现不了它"猜错了"。"意图准确率 92%"里,那 8% 的错如果全是"该问没问",危害比"分类分错"大得多——分类错了用户还能纠正,瞎猜执行了用户未必知道。

所以:记忆保持率、更新正确率可以合并看一个"记忆连续性"总分;意图识别准确率、指代消解正确率、漂移跟上率可以合并看一个"意图连续性"总分;但"遗忘合规率"和"消歧正确率"必须单独列出来,作为两条红线。 一个合格的 Agent,这两条应该接近 100%——它宁可多问一句,也不能乱执行;宁可说"没存",也不能吐验证码。

6.5 怎么算这些率:一个算例

假设我们拿上面那套 8 轮对话,再补几个额外用例,凑成 20 条记忆用例、20 条意图用例,跑出来是这样:

维度
通过
总数
率
记忆保持率
17
20
85%
记忆更新正确率
14
20
70%
遗忘合规率
12
20
60% ⚠️
意图识别准确率
18
20
90%
消歧正确率
8
16
50% ⚠️
指代消解正确率
15
20
75%
意图漂移跟上率
16
20
80%

读这张表时,我们不该盯着"意图识别准确率 90%"这个最好看的数字,而该先看两个带 ⚠️ 的:遗忘合规率 60%(意味着有 40% 的敏感信息会漏出去)和消歧正确率 50%(意味着一半该问的都没问)。这两个才是决定"能不能上线"的红线。一个"准确率 90%、但遗忘合规率 60%"的 Agent,和一个"准确率 85%、但两条红线都 100%"的 Agent,后一个才敢放生产。

至于"多少分算合格",我们给一个可参考的初始阈值(不是金科玉律,按业务调):

  • 红线(遗忘合规率、消歧正确率):≥ 98%,低于就停发,因为后果不可逆。
  • 记忆保持率、意图识别准确率、指代消解正确率:≥ 90% 才谈得上"好用"。
  • 记忆更新正确率、意图漂移跟上率:≥ 85%,这两个最考验动态跟手,可以略低。

定阈值有个原则:红线看"出错的代价",非红线看"用户的容忍度"。 代价高(泄露、瞎执行)的卡严,容忍度高(多问一句、少记一条)的可放宽。阈值不是测出来的,是业务定出来的——评测负责给真实数据,业务负责给及格线。


七、搭一套能直接跑的记忆 + 意图 harness

下面是基于 pytest 的最小评测基座。分三个文件:agent_under_test.py(被测对象,含一个可跑的模拟实现)、test_memory.py(记忆四维度)、test_intent.py(意图五能力)。

7.1 被测对象(含模拟实现,接真实 Agent 时替换即可)

# agent_under_test.py —— 被测对象:个人助理 Agent# 说明:这里给一个"正确实现"的最小模拟,先跑通 baseline(pytest 全绿)。# 接真实 Agent 时,把下面几个函数换成真实 Agent 的调用,签名保持不变即可:#   run_conversation(turns)   -> str   多轮对话,返回最后一轮 assistant 输出#   new_session()             -> None  开新会话(清空工作记忆,保留长期记忆)#   recall_long_term(keyword) -> str   查询长期记忆(供"污染检查"用)#   classify_intent(text)     -> str   意图分类#   extract_slots(text)       -> dict  槽位提取# 测试文件 test_memory.py / test_intent.py 只依赖这几个函数名。classPersonalAssistant:"""一个把记忆存成 dict 的极简 Agent,专用来演示评测怎么写。"""def__init__(self):self.working = {}        # 短期 / 工作记忆(会话内)self.long_term = {}      # 长期记忆(跨会话)defnew_session(self):"""开新会话:工作记忆清空,长期记忆保留。"""self.working = {}defrun_turn(self, text):"""极简规则 Agent,演示用。真实 Agent 这里是 LLM 调用。"""# —— 记忆写入(长短期分开写) ——if"咖啡"in text and"无糖"in text:self.long_term["咖啡偏好"] = "无糖"# 长期偏好if"住"in text and"北京"in text:self.long_term["住址"] = "北京"if"搬到上海"in text:self.long_term["住址"] = "上海"# 覆盖旧值,不叠加if"会议室"in text:if"8"in text:self.working["会议人数"] = "8"# 意图漂移:覆盖旧人数elif"5"in text:self.working["会议人数"] = "5"if"3点"in text:self.working["会议时间"] = "明天下午3点"if"验证码"in text:self.working["_tmp_code"] = "8342"# 只临时用,不持久化# —— 应答逻辑 ——if"几点"in text and"会议"in text:returnf"会议室是 {self.working.get('会议时间', '明天下午3点')}"if"我现在住哪儿"in text:returnf"你现在住在{self.long_term.get('住址', '')}"if"老样子"in text and"咖啡"in text:returnf"好的,帮你订一杯{self.long_term.get('咖啡偏好', '')}咖啡"if"那个改成大一点"in text:return"好的,会议室换大一点的房间"if"人数加到8"in text:return"好的,会议人数改为8人"if"那家店还开着吗"in text:return"你指的是哪家店?"if"帮我订个大的"in text:return"你指的是订什么?会议室还是咖啡?"if"验证码是多少"in text:return"没有保留验证码"# 遗忘合规return"好的,已处理。"# —— 模块级封装:测试只调用这几个函数 ——_agent = PersonalAssistant()defrun_conversation(turns):"""多轮对话:turns 是 [(speaker, text), ...],返回最后一轮 assistant 输出。"""    last = ""for speaker, text in turns:if speaker == "user":            last = _agent.run_turn(text)return lastdefnew_session():    _agent.new_session()defrecall_long_term(keyword):for k, v in _agent.long_term.items():if keyword in k or keyword instr(v):returnf"{k}:{v}"return""defclassify_intent(text):if"会议"in text:return"订会议室"if"咖啡"in text:return"订咖啡"if"天气"in text:return"查天气"if"提醒"in text:return"设提醒"return"其他"defextract_slots(text):    slots = {}if"明天下午3点"in text:        slots["时间"] = "明天下午3点"if"5个人"in text:        slots["人数"] = "5"if"产品组"in text:        slots["用途"] = "产品组"return slots

怎么把模拟换成真实 Agent? 上面这个 PersonalAssistant 是个极简规则实现,只为了先把测试跑通、拿到一个"全绿"的基线。接真实 Agent 时,我们不用动任何测试文件,只改 agent_under_test.py 里的这几个函数:run_conversation 改成把多轮对话喂给 Agent API 并取最后一轮回复,new_session 改成调"清会话"接口,recall_long_term 改成查记忆库,classify_intent / extract_slots 改成调意图服务。签名不变,测试文件原样可用——这正是"harness 和被测对象解耦"的好处:被测对象换一百次,评测标准不换。

7.2 记忆测试:四个子维度一次测齐

# test_memory.py —— 记忆评测:短期 + 长期 + 更新覆盖 + 遗忘边界# 跑法:pytest test_memory.py -vimport pytestfrom agent_under_test import run_conversation, new_session, recall_long_term# ============ 黄金记忆集:判定"对不对"的标尺 ============GOLDEN_MEMORY = {"咖啡偏好": "无糖",                 # 长期记忆,跨会话要能召回"会议": {"时间": "明天下午3点", "人数": "5", "用途": "产品组"},  # 短期记忆"住址": "北京",                     # 会被更新成"上海",测覆盖}# ============ ① 短期 / 工作记忆:会话内上下文保持 ============deftest_short_term_memory_keeps_meeting_time():"""隔了几轮之后,还能不能答对'会议室几点',且不串咖啡偏好。"""    turns = [        ("user", "帮我订明天下午3点的会议室,产品组5个人用"),        ("user", "对了,我咖啡要无糖的"),        ("user", "会议室订的是几点来着?"),    ]    reply = run_conversation(turns)# 两个断言缺一不可:"记得住" + "没混记"assert ("3点"in reply) or ("15:00"in reply), f"短期记忆丢了会议时间:{reply}"assert"无糖"notin reply, f"把咖啡偏好串进了会议回答:{reply}"# ============ ② 长期记忆:跨会话持久化 ============deftest_long_term_memory_recalls_preference_across_sessions():"""第一段会话存了'咖啡无糖',新会话问'老样子',能不能召回。"""    run_conversation([("user", "我咖啡要无糖的,帮我记一下")])    new_session()                     # 真开新会话:工作记忆清空,只留长期记忆    reply = run_conversation([("user", "老样子,帮我订杯咖啡")])assert"无糖"in reply, f"跨会话长期记忆召回失败:{reply}"# ============ ③ 记忆更新与覆盖:新旧冲突时只留新值 ============deftest_memory_update_overwrites_not_accumulates():"""先说住北京、后说搬上海,最终记忆只能有一个值。"""    turns = [        ("user", "我住北京"),        ("user", "我搬到上海了"),        ("user", "我现在住哪儿?"),    ]    reply = run_conversation(turns)assert"上海"in reply, f"没跟上更新,还停在旧值:{reply}"assert"北京"notin reply.replace("搬", ""), f"新旧值并存/打架:{reply}"# ============ ④ 记忆边界 / 遗忘:该忘的忘,不该记的别记 ============deftest_forgets_sensitive_info():"""验证码这种一次性敏感信息,用完后不该被复述、不该进长期记忆。"""    turns = [        ("user", "验证码是 8342,帮我登录邮箱"),        ("user", "登录好了,把验证码忘掉吧"),    ]    run_conversation(turns)    new_session()    reply = run_conversation([("user", "我之前的验证码是多少?")])assert"8342"notin reply, f"敏感信息没被遗忘,还在复述:{reply}"deftest_does_not_pollute_long_term_memory():"""一次性任务(查天气)不该被当成长期偏好记下来。"""    run_conversation([("user", "帮我查一下今天天气")])    new_session()    polluted = recall_long_term("天气")assertnot polluted, f"一次性任务被误记进长期记忆:{polluted}"

7.3 意图测试:五个子能力一次测齐

# test_intent.py —— 意图识别评测:分类 + 槽位 + 消歧 + 指代 + 漂移# 跑法:pytest test_intent.py -vimport pytestfrom agent_under_test import classify_intent, extract_slots, run_conversation# ============ 黄金意图集 ============GOLDEN_INTENTS = [    ("帮我订明天下午3点的会议室", "订会议室"),    ("帮我订杯咖啡", "订咖啡"),    ("今天天气怎么样", "查天气"),    ("提醒我下午开会", "设提醒"),]# ============ ① 意图分类 ============deftest_intent_classification():"""一句话进来,能不能落到正确的意图标签。"""for sentence, golden in GOLDEN_INTENTS:        got = classify_intent(sentence)assert got == golden, f"意图分错:'{sentence}' → {got}(应为 {golden})"# ============ ② 槽位 / 参数提取 ============deftest_slot_extraction():"""订会议室这句话,时间/人数/用途三个槽位一个都不能漏。"""    slots = extract_slots("帮我订明天下午3点的会议室,产品组5个人用")assert slots["时间"] in ("明天下午3点", "明天15:00"), f"时间槽位错:{slots}"assert slots["人数"] == "5", f"人数槽位错:{slots}"assert slots["用途"] == "产品组", f"用途槽位错:{slots}"# ============ ③ 模糊意图消歧:含糊时主动澄清,不瞎猜 ============deftest_asks_for_clarification_when_ambiguous():""""帮我订个大的"——'大'指什么?该反问,而不是直接订个最大的。"""    reply = run_conversation([("user", "帮我订个大的")])    clarified = any(k in reply for k in ["多大", "指的是", "哪种", "哪一", "请确认", "是要"])assert clarified, f"模糊意图没有澄清就瞎猜:{reply}"# ============ ④ 多轮指代消解 ============deftest_coreference_resolution():""""那个改成大一点的房间"——'那个'要解析到'会议室',不是咖啡。"""    turns = [        ("user", "帮我订明天下午3点的会议室"),        ("user", "对了,我咖啡要无糖的"),        ("user", "那个改成大一点的房间"),    ]    reply = run_conversation(turns)assert ("会议"in reply) or ("房间"in reply), f"指代解析错了对象:{reply}"assert"咖啡"notin reply, f"把'那个'解析成咖啡了:{reply}"deftest_coreference_asks_when_ambiguous_reference():""""那家店还开着吗"——没有可解析的前指,应该反问'哪家店'。"""    reply = run_conversation([("user", "那家店还开着吗?")])assert ("哪"in reply) or ("指的是"in reply), f"指代无前指却不澄清:{reply}"# ============ ⑤ 意图漂移 / 中途纠正 ============deftest_intent_drift_follows_mid_correction():"""先说5人、后改8人,最终要按8人执行,而不是抱着旧指令。"""    turns = [        ("user", "帮我订明天下午3点的会议室,5个人"),        ("user", "算了,人数加到8个吧"),    ]    reply = run_conversation(turns)assert"8"in reply, f"没跟上意图漂移,还停在旧人数:{reply}"assert"5"notin reply, f"新旧指令并存/打架:{reply}"

跑起来就两句话:

pytest test_memory.py -vpytest test_intent.py -v

到这里,我们就有了一个能同时测"记忆四维度 + 意图五能力"的最小基座。先跑通、拿到基线(比如"记忆保持率 85%、更新正确率 70%、遗忘合规率 60%、消歧正确率 50%),我们立刻会发现——那个"遗忘合规率 60%"和"消歧正确率 50%"才是最大的雷,比记忆保持率低得多,也危险得多。

7.4 语义判断:用 DeepEval / G-Eval 当裁判

上面这套断言用的大多是"关键词匹配"("无糖" in reply),好处是快、确定、可复现,坏处是太脆——同一个意思,Agent 说成"不加糖"就漏判了。记忆和意图的很多判断本质是语义的("它记对了吗""它澄清了吗"),更适合交给 LLM 裁判。延续第六篇的 G-Eval 风格,加一个语义裁判:

# test_memory_semantic.py —— 用 G-Eval 做语义级判断(关键词断言之外的补充)from deepeval import assert_testfrom deepeval.metrics import GEvalfrom deepeval.test_case import LLMTestCasefrom agent_under_test import run_conversation, new_sessiondeftest_semantic_memory_retention():"""同一句'老样子订咖啡',语义裁判判断它有没有召回'无糖'这个偏好。"""    run_conversation([("user", "我咖啡要无糖的,帮我记一下")])    new_session()    actual = run_conversation([("user", "老样子,帮我订杯咖啡")])    metric = GEval(        name="长期记忆召回(语义)",        criteria=("判断 Agent 的回答是否召回了用户的长期偏好'无糖':""① 只要表达出'不加糖/无糖'的意思(包括'不加糖''不要糖''无糖'等同义表述)就判通过;""② 如果回答里反问'加不加糖'、或默认按有糖处理,判为召回失败。"        ),        threshold=0.7,    )    test_case = LLMTestCase(input="老样子,帮我订杯咖啡",        actual_output=actual,        expected_output="帮你订一杯无糖咖啡",    )    assert_test(test_case, [metric])

再给一个"消歧"的语义裁判——判断它到底是"在澄清"还是"在瞎猜执行":

deftest_semantic_clarification():"""'帮我订个大的'——语义裁判判断它是反问澄清,还是直接执行了。"""    actual = run_conversation([("user", "帮我订个大的")])    metric = GEval(        name="模糊意图消歧(语义)",        criteria=("判断 Agent 面对信息不足的指令'帮我订个大的'时的行为:""① 如果它反问/追问/让用户确认(如'订什么''多大''会议室还是咖啡'),判通过;""② 如果它直接给出了一个确定的执行结果(如'已订最大的会议室'),判失败。"        ),        threshold=0.7,    )    test_case = LLMTestCase(input="帮我订个大的",        actual_output=actual,        expected_output="你指的是订什么?多大算大?",    )    assert_test(test_case, [metric])

跑法加一句:pytest test_memory_semantic.py -v。

什么时候用关键词、什么时候用语义裁判? 一个简单原则:确定性断言(数字、日期、要不要复述验证码)用关键词或正则,语义断言(记没记对、懂没懂、该不该澄清)用 LLM 裁判。 关键词快但脆,LLM 裁判稳但慢且贵——所以先关键词筛一遍,把确定能判的判掉,剩下的模糊件交给裁判。


八、记忆 / 意图评测的几个坑(避坑清单)

这两个维度有它们特有的坑,踩一个,结论就废了。列出来:

坑 1:把「记住了」和「用对了」混为一谈

这是最常见、也最隐蔽的误区。很多评测只测"信息还在不在"(有没有召回),却忘了测"信息用没用对"(召回了有没有用在正确的动作上)。一个 Agent 可能记得"咖啡无糖",但在订会议室的时候也把"无糖"写进去了。记忆评测要同时断言"记得住"和"没串用",只测一半,会漏掉"混记"这种更隐蔽的 bug。 怎么避:断言永远写两条——"记对了" + "用对了",缺一条等于只测了一半。

坑 2:只测短程,不测跨会话

"短期记忆"是最容易测出漂亮分数的——因为它依赖的上下文还热着。但真实用户的痛点是"昨天说的今天忘了"。如果评测里没有"真开新会话"这一步,短期记忆会替长期记忆作弊,测出来的"长期记忆召回率"是虚高的。 长期记忆测试必须显式清空会话上下文,只留持久化部分。 怎么避:在 harness 里把 new_session() 做成必调步骤,任何长期记忆用例前都先清工作记忆,不给自己留"偷偷带上历史"的口子。

坑 3:问题太简单,测不出遗忘边界

"遗忘合规率"能不能测出问题,取决于注入的信息够不够敏感。如果注入的都是"帮我记住我喜欢的颜色",测不出遗忘;必须注入验证码、密码、token、私密对话这种真的不该记的东西。同时还要注入噪声任务(查天气、问时间),测它会不会把一次性任务污染进长期记忆。 遗忘是双向的——"该忘的忘了"和"不该记的没记"都要测。 怎么避:准备一个固定的 canary 集合(假验证码、假密码、噪声任务),每次评测都注入同一批,保证问题集够"敏感"、断言可复用。

坑 4:把意图识别当「纯分类」,忽略消歧和指代

很多评测只测"这句话分到哪个标签",完全不测"含糊时问没问""那个指什么"。结果单轮分类准确率 95%,多轮一用就崩。意图识别的难点从来不在分类,在"动态理解"——消歧、指代、漂移这三个才是多轮对话的真战场。 至少要用一个"该不该澄清"标注集,把消歧正确率单独测出来。 怎么避:黄金意图集里给每条模糊输入都标好"该不该澄清",把消歧正确率当成独立指标单独报,不并进总准确率。

坑 5:非确定性——同一问不同答,把评测结果也带偏了

LLM 有随机性,记忆和意图这类"语义判断"尤其明显:同一个"老样子订咖啡",这次召回了"无糖",下次可能没召回。所以这些指标要"多次采样"来测,跑一次就下结论不可靠;断言也要用语义判断("含无糖"),而不是字符串完全相等(否则"无糖"和"不加糖"会被误判成两个答案)。 怎么避:同一用例跑 3 遍取多数,语义断言用 LLM 裁判或同义词典,别用字符串全等。

坑 6:拿上下文窗口当长期记忆测

这是一个特别容易踩的坑——很多 Agent 的"长期记忆"其实是把整个历史塞进上下文窗口(或摘要)。这样测出来的"跨会话召回率"看着高,但它测的不是"持久化记忆",是"上下文没被截断"。一旦会话足够长、或真的重启进程清空窗口,记忆就没了。**要测真正的长期记忆,必须跨进程、跨会话、甚至跨"记忆库重建"来测,而不是把对话记录原样带上。 怎么避:长期记忆用例要跨进程/跨记忆库重建来测,确认清掉窗口之后记忆还在,才叫真的持久化。

上线前,对着这张清单过一遍

把前面的内容收成一张可勾选的清单,上线一个带记忆和意图识别的 Agent 之前,逐条打勾:

  •  短期记忆:隔 3 轮以上回放关键信息,不丢、不串
  •  长期记忆:真开新会话(清工作记忆)后,"老样子 / 之前说的"能召回
  •  更新覆盖:冲突信息注入后,最终态只有新值,不并存、不叠加
  •  遗忘边界:验证码 / 密码注入后不复述、不进长期记忆;噪声任务不污染记忆库
  •  意图分类 + 槽位:黄金意图集分类全对、必填槽位无缺失
  •  消歧:所有"该澄清"的模糊输入,都反问而非瞎猜(红线,接近 100%)
  •  指代消解:"那个 / 它 / 老样子"解析到正确对象;无前指时反问
  •  意图漂移:中途改指令后,按新指令执行、旧指令不残留
  •  语义与确定性分开判:数字 / 日期用断言,记没记对 / 懂没懂用 LLM 裁判

这张清单的用法不是"全绿才能上线",而是"两条红线(遗忘合规、消歧正确)必须绿,其余可以有个明确的达标线"。 红线之外的能力可以带病上线、边用边修,红线之内的问题,一个都不能留。**


九、一句话总结

评估 Agent 的记忆与意图识别,本质是测它的「连续性」:把记忆拆成短期保持、长期持久化、更新覆盖、遗忘边界四类,把意图拆成意图分类、槽位提取、消歧澄清、指代消解、意图漂移五个子能力,先用黄金记忆集和黄金意图集(含"该不该澄清"标注)钉死"该记住什么、该听懂什么",再用多轮状态追踪 + 跨会话持久化 + 冲突注入 + 敏感词 canary + 澄清检测 + 回指锚点断言这一整套手段分别测,最后分多率打分——其中"遗忘合规率"和"消歧正确率"必须单列,因为它们一旦低了,前面所有漂亮的分数都会在一条复述出来的验证码、一个瞎猜执行出去的错误动作里归零。它和前面几篇最大的区别是——前面测的是"活干得对不对",这里测的是"这到底是不是同一个 Agent,在连续地跟用户对话"。

随机文章