《AI Agent 游戏产品开发》5.1 跨局记忆:记住什么、忘掉什么

跨局记忆不是把聊天记录存下来:记什么、记多久、什么不该记,三件事各有判据。本节用准入、淘汰、折叠三步把记忆范围写成可复算规则,对照消消的 7 天短记忆与方舟的 180 天跨赛季记忆,并说清敏感信息、过期记录、重复事件与三种纠正手段的处理边界。

以下人物、公司与数字均为教学假设,不构成对任何真实产品的评价。规模与记忆窗口来自附录 B 双案例唯一事实表 ,记忆条数与折叠阈值是教学设定值。

给 NPC 加记忆,最常见的做法是把最近若干轮对话拼进提示词。这个做法在单局里看着有效,跨局就会暴露三个问题:拼进去的内容越来越长、模型开始引用早已过期的偏好、玩家发现角色记得不该记得的事。记忆系统的难点从来不是「存」,而是「存什么」和「什么时候删」。

这一节把记忆范围拆成三步:准入、淘汰、折叠。三步都在服务端执行,结果是确定性的,可以回放、可以解释、也可以按玩家的删除请求整体清空。

记忆不是聊天日志

聊天日志是原始记录,记忆是从记录里提炼出的、会被再次使用的结论。两者的生命周期完全不同:

类型例子生命周期误用的后果
偏好玩家偏爱夜间关卡数天到数月推荐老化,角色反复提旧喜好
单局事件这一局在第 12 关失败数小时到数天记成永久标签,玩家被一次失误定义
事实玩家已解锁第三个家园区域与进度同寿说错进度,直接破坏叙事可信度
关系角色对玩家的信任档位跨赛季关系跳变,前后台词自相矛盾

把这四类混成一锅「上下文」,就会出现典型的错配:一次失败被当成长期偏好,一个赛季前的关系被当成昨天。分类不是为了整齐,而是因为四类的保留期、敏感度和淘汰方式都不同。

三类内容不该进模型

不是所有相关信息都值得进提示词。有三类内容即使技术上能存,也应该在准入阶段拒绝:

  1. 敏感信息。 健康、住址、支付片段这类内容,除非玩家明确同意且用途明确,否则不进记忆。消消的陪伴型 Agent 直接关闭敏感类别,方舟只在剧情需要且玩家授权时保留。
  2. 过期记录。 超过该类别的保留期就不再参与决策。留着不是「万一有用」,而是「一定会被模型翻出来用」。
  3. 不可归因的记录。 来源不明、时间不明、无法对应到具体事件的内容,不能作为记忆。它无法被纠正,也无法在回放里解释。

第三条最容易被忽略。运营在后台手改一条记忆、客服补录一句玩家反馈,这些记录没有观察时间,也没有来源,进了记忆库就变成了永久事实。记忆必须带时间戳与来源,否则它连「过期」都无法判断。

准入、淘汰、折叠

三步的顺序固定,每一步都有明确的输入输出:

  • 准入:判断一条记录是否允许进入记忆,看类别、敏感度、时间窗口。被拒绝的记录直接丢弃,不进入后续排序。
  • 淘汰:在准入通过的记录里,按显著度与新鲜度排序,截断到条数上限。上限是硬约束,不是建议值。
  • 折叠:同一键的重复单局事件累积到阈值后,合并成一条偏好。折叠发生在淘汰之前还是之后,会得到不同结果,本书固定为「先准入、再折叠、最后淘汰」。

折叠放在淘汰之前,是因为折叠会减少条数。先淘汰会把同一键的早期记录挤掉,剩下的记录数量不足阈值,永远折叠不成偏好;玩家会看到角色反复提「你上次失败了」,而不是「你最近在某个关卡上不太顺」。

把三步写成可运行规则

下面的实现把保留期、准入、加权淘汰与折叠写成纯函数,不依赖存储层,也不依赖模型。

// file: src/memory/memory-scope.ts
// tier: L1
// verify: node --test test/memory/memory-scope.test.ts

// 跨局记忆的存与忘:按类别定保留期,按显著度淘汰,按条数上限截断。
// 记忆不是越多越好:记错的东西比不记更贵。

export type MemoryKind = "preference" | "episode" | "fact" | "relationship";

export type MemoryRecord = {
  readonly id: string;
  readonly kind: MemoryKind;
  readonly key: string;
  readonly value: string;
  readonly observedDay: number;
  readonly salience: number;
  readonly sensitive: boolean;
};

export type MemoryPolicy = {
  readonly product: "match3" | "ark";
  readonly horizonDays: number;
  readonly maxEntries: number;
  readonly allowedKinds: readonly MemoryKind[];
  readonly allowSensitive: boolean;
  readonly foldThreshold: number;
};

export const MEMORY_POLICY: Record<"match3" | "ark", MemoryPolicy> = {
  match3: {
    product: "match3",
    horizonDays: 7,
    maxEntries: 20,
    allowedKinds: ["preference", "episode"],
    allowSensitive: false,
    foldThreshold: 10,
  },
  ark: {
    product: "ark",
    horizonDays: 180,
    maxEntries: 200,
    allowedKinds: ["preference", "episode", "fact", "relationship"],
    allowSensitive: true,
    foldThreshold: 10,
  },
};

// 不同类别的保留期不同:一次对局比偏好先过期,关系状态要跨赛季。
const KIND_WEIGHT: Record<MemoryKind, number> = {
  preference: 1,
  episode: 0.25,
  fact: 1,
  relationship: 2,
};

export function retentionDays(policy: MemoryPolicy, kind: MemoryKind): number {
  return Math.round(policy.horizonDays * KIND_WEIGHT[kind]);
}

export type AdmitVerdict = { readonly keep: boolean; readonly reason: string };

// 准入先看类别与敏感度,再看时间:窗口外的记录连淘汰排序都不用参加。
export function admit(record: MemoryRecord, policy: MemoryPolicy, today: number): AdmitVerdict {
  if (!policy.allowedKinds.includes(record.kind)) {
    return { keep: false, reason: `kind not allowed: ${record.kind}` };
  }
  if (record.sensitive && !policy.allowSensitive) {
    return { keep: false, reason: "sensitive without consent" };
  }
  const age = today - record.observedDay;
  if (age < 0) {
    return { keep: false, reason: "observed in the future" };
  }
  const limit = retentionDays(policy, record.kind);
  if (age > limit) {
    return { keep: false, reason: `expired after ${limit} days` };
  }
  return { keep: true, reason: "admitted" };
}

// 淘汰分数 = 显著度 × 新鲜度。新鲜度按该类别的保留期归一,不能跨类别直接比。
export function weightedSalience(
  record: MemoryRecord,
  policy: MemoryPolicy,
  today: number,
): number {
  const limit = Math.max(1, retentionDays(policy, record.kind));
  const freshness = Math.max(0, 1 - (today - record.observedDay) / limit);
  return record.salience * (0.5 + 0.5 * freshness);
}

// 同分用 id 排序,保证同一批输入每次淘汰结果一致,否则回放对不上。
export function evict(
  records: readonly MemoryRecord[],
  policy: MemoryPolicy,
  today: number,
): MemoryRecord[] {
  const admitted = records.filter((record) => admit(record, policy, today).keep);
  const sorted = [...admitted].sort((a, b) => {
    const gap = weightedSalience(b, policy, today) - weightedSalience(a, policy, today);
    if (gap !== 0) return gap;
    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
  });
  return sorted.slice(0, policy.maxEntries);
}

// 重复出现的同类事件折叠成一条偏好,避免「最近输了三次」被记成三条独立记忆。
export function foldEpisodes(
  records: readonly MemoryRecord[],
  threshold: number,
): MemoryRecord[] {
  const groups = new Map<string, MemoryRecord[]>();
  for (const record of records) {
    if (record.kind !== "episode") continue;
    const list = groups.get(record.key) ?? [];
    list.push(record);
    groups.set(record.key, list);
  }
  const folded: MemoryRecord[] = [];
  const dropped = new Set<string>();
  for (const [key, list] of groups) {
    if (list.length < threshold) continue;
    const latest = list.reduce((a, b) => (b.observedDay > a.observedDay ? b : a));
    folded.push({
      id: `fold:${key}`,
      kind: "preference",
      key,
      value: `${list.length} 次:${latest.value}`,
      observedDay: latest.observedDay,
      salience: Math.min(1, latest.salience + 0.1),
      sensitive: list.some((record) => record.sensitive),
    });
    for (const record of list) dropped.add(record.id);
  }
  return [...records.filter((record) => !dropped.has(record.id)), ...folded];
}

retentionDays 让保留期按类别折算,而不是所有类别共用一个窗口。方舟的窗口是 180 天,单局事件的系数是 0.25,折算下来 45 天;关系状态系数是 2,折算 360 天,刚好跨两个赛季。这个折算不是精算,而是让「窗口」这个参数对每个类别都有意义。

admit 的顺序是刻意的:先判类别,再判敏感度,最后判时间。类别不合法时,即使记录新鲜也不该进;敏感内容没有同意时,时间再新也不该进。把时间检查放在最后,是为了让拒绝原因更具体,值班时能直接看出是哪一类问题。

weightedSalience 把显著度与新鲜度相乘。新人偏好和旧的重要事实可以同台竞争,但跨类别比较时新鲜度已经做了归一,不会因为某类保留期长就永远占优。

evict 在排序里增加了 id 作为第二键。没有第二键时,同分记录的顺序取决于数组初始顺序,而数组顺序在并发写入下不稳定,回放就会出现两个不同结果。

foldEpisodes 只处理单局事件,折叠后的记录继承最新时间、略高的显著度与敏感标记。敏感标记用「任一」而不是「全部」,因为一条敏感事件被合并后,合并结果仍然是敏感的。

消消与方舟的范围完全不同

两款产品的记忆策略差异,不是同一套参数调大调小:

维度消消方舟
窗口7 天180 天(跨两个赛季)
条数上限20 条200 条
允许类别偏好、单局偏好、单局、事实、关系
敏感内容不接收需明确同意
主要用途赛后点评更贴合剧情与关系连续

消消的记忆窗口短,是因为它的陪伴发生在赛后,玩家三天后再上线时,一周前的失败已经没有参考价值。方舟需要跨赛季记忆,是因为关系与剧情是长线资产,玩家能明显察觉角色「忘了」上一季的事。

条数上限也要分开定。20 条对消消足够覆盖七天的偏好;方舟 200 条对应八个常驻 NPC 与多条剧情线,再高会让提示词装配变慢,也会让模型在无关记忆之间乱连线。

记忆出错时怎么纠正

记忆系统必须支持三种纠正方式,缺一不可:

  1. 单条纠正。 玩家或运营指出某条记忆错误,系统能定位到具体记录并删除,而不是重建全部记忆。
  2. 批量回滚。 一次版本升级导致批量写入错误时,能按写入批次回滚,不影响其他批次。
  3. 整体删除。 玩家提出删除请求时,按玩家维度清空,并给出完成时间。

第三种方式依赖记录必须带玩家标识与写入批次。没有这两个字段,删除就只能靠扫描内容猜,既慢又容易漏。

什么时候不该做记忆

记忆不是每个 Agent 形态都需要。对手型 Agent 按局计算,跨局记忆反而会让匹配失衡;导演型 Agent 的记忆应该落在关卡与节奏上,而不是玩家个人信息。只有陪伴型与剧情 NPC 需要长期记忆,且必须有明确的用途。

判断标准很直接:如果一条记忆无法指向一个具体的产品行为(推荐、台词、难度、活动),它就不该存在。存下来但没有消费方的记忆,只会增加泄露面与成本。

小结

  • 记忆不是聊天日志,是从记录里提炼出的、会被再次使用的结论。
  • 四类记忆的生命周期不同:偏好、单局事件、事实、关系不能共用一个窗口。
  • 敏感信息、过期记录、不可归因记录,三类都应在准入阶段拒绝。
  • 三步顺序固定:先准入、再折叠、最后淘汰;顺序换掉结果就不同。
  • 淘汰分数 = 显著度 × 新鲜度,同分用 id 排序,保证可复现。
  • 折叠只处理单局事件,合并后的记录按「任一敏感」继承敏感标记。
  • 消消 7 天 20 条,方舟 180 天 200 条,差异来自用途而不是风险偏好。
  • 记忆必须带玩家标识与写入批次,否则单条纠正、批量回滚、整体删除都做不了。
  • 无法指向具体产品行为的记忆不该存在。
  • 对手型与导演型 Agent 通常不需要跨局记忆,别把陪伴型的方案套过去。

阅读导航:上一节:4.3 Agent 与反作弊的边界 · 下一节:5.2 关系状态与叙事连续性 。

常见错误与边界

  1. 把对话历史当记忆。 原始记录会无限增长,模型会被过期内容带偏;记忆必须是提炼后的结论。
  2. 所有类别共用一个保留期。 单局事件与关系状态的生命周期差一个数量级,共用窗口必然出错。
  3. 先淘汰再折叠。 早期记录被挤掉后数量不足阈值,重复事件永远折叠不成偏好。
  4. 排序没有第二键。 同分记录的顺序随写入顺序变化,回放与线上对不上。
  5. 记录没有来源与时间。 这类记录无法判断过期,也无法解释为什么被使用。
  6. 给每个形态都加记忆。 对手型与导演型不需要玩家长期记忆,加了只会增加成本与风险。

记忆范围定下来之后,下一个问题是关系状态怎么在这条记忆上稳定演化:哪些维度可以变、一天能变多少、档位怎么决定台词。

继续阅读

探索更多技术文章

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

全部文章 返回首页

「books」更多文章

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