想象你在经营一家小镇酒馆。过去你雇的伙计只会背三句固定台词，客人问什么都回“欢迎光临”；如今你请来一位藏在后厨的“幕后智囊”——大语言模型（LLM）。他能听懂客人说的任何话，还能张口就来一段合乎身份的回答。可光有智囊还不够：你得给他一张角色卡，告诉他是谁、什么性格、有什么往事（人设 Prompt）；给他一本记事本，记下与每位客人的过往（对话记忆）；排一张作息表，决定何时开口、何时干活（行为树）；一边记着柴米油盐的账（成本控制），一边盯着上菜别太慢、话别说秃噜（体验与安全）。这篇文章，就带你亲手开起这样一家“AI 酒馆”。

岗位关联

掌握 LLM 接入、人设注入、记忆管理与成本控制，是游戏 AI 工程师的核心技能——它让 NPC 从“复读机”进化成真正“活着的角色”。

目录
  1. 可视化演示
  2. 接入方案对比
  3. 人设Prompt设计
  4. 对话记忆管理
  5. 行为树融合
  6. 体验优化策略
  7. 成本控制方案
  8. 挑战与展望
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

展示玩家行为树LLM NPC对话架构、角色人设Prompt四维约束、短期长期对话记忆管理与滑动窗口、Token预算缓存复用本地降级成本控制策略，含粒子场背景动画。

本节配有交互动效（进入视口后自动加载，约 3KB）。

接入方案对比

请智囊上岗，先得选“厨房模式”。第一条路是包给中央厨房：云端大模型 API，按用量付费、无需自建，像点外卖一样省心。第二条路是自建后厨：本地部署开源模型，数据不出门，但光买灶台（显卡）、付电费就够呛。第三条路是混合架构：招牌大菜交给中央厨房，日常小炒自己掌勺。

对游戏项目而言，三条路各有取舍。云端 API 接入快、模型强，适合原型验证和中小团队；本地部署延迟稳定、隐私可控，适合单机或硬核叙事游戏；混合架构则把高频低危请求留在本地、把复杂生成交给云端，是商业大作的主流选择。

无论选哪条路，都要守住一条“实时感”红线——从玩家开口到 NPC 回复的端到端延迟必须够低。工程上常用三段式拆解：

去中央厨房点菜要等配送，自家后厨拼的是手速，混合架构则是把菜单劈成两半。选哪条路，得看你的酒馆开在闹市口还是深山——接入方案要跟着游戏类型、玩家规模与预算走。

Ltotal=Lnetwork+Linference+Lrender<200 ms\displaystyle L_{\text{total}} = L_{\text{network}} + L_{\text{inference}} + L_{\text{render}} < 200\,\text{ms}
这条公式是说：总延迟 = 网络传送时间 + 模型思考时间 + 画面播放时间，三者加起来要小于 0.2 秒，玩家才觉得 NPC“接得住话”。
  1. 总延迟 \(L_{\text{total}}\)玩家从开口到看到 NPC 回复的完整耗时，由三段组成。
    Ltotal=Lnetwork+Linference+LrenderL_{\text{total}} = L_{\text{network}} + L_{\text{inference}} + L_{\text{render}}
  2. 网络耗时 \(L_{\text{network}}\)台词与回复在玩家设备和服务器之间往返传输的时间。
    Lnetwork=T上行+T下行L_{\text{network}} = T_{\text{上行}} + T_{\text{下行}}
  3. 推理耗时 \(L_{\text{inference}}\)模型读完上下文并逐个生成回复 token（可以理解为“字词计费单元”）的时间，通常是延迟大头。
    Linference=Tprefill+TdecodeL_{\text{inference}} = T_{\text{prefill}} + T_{\text{decode}}
  4. 渲染耗时 \(L_{\text{render}}\)文本回传后，字幕与口型动画播放所花的时间。
    Lrender=T解析+T播放L_{\text{render}} = T_{\text{解析}} + T_{\text{播放}}
  5. 实时感阈值 200ms行业经验认为端到端总延迟低于 200 毫秒，玩家才会觉得 NPC“接得住话”。
    Ltotal<200 msL_{\text{total}} < 200\,\text{ms}

人设Prompt设计

智囊再聪明，不知道自己是谁就会胡言乱语。就像新来的伙计必须熟记“我是酒馆老板老约翰，在枫叶镇开了三十年店，最爱讲故事”，LLM 也需要一张角色卡——这就是人设 Prompt。

Prompt 是写给大模型的“角色说明书”。实践表明，结构化、精炼的短卡远比长篇小说有效。标准模板通常包含四个槽位：身份与角色、性格标签、背景故事、语气风格；游戏运行时把玩家发言实时填入模板，组成一次完整的请求。

为什么结构如此重要？因为回复质量可以看成三个维度的加权打分：

一张写满性格标签的短卡，客人一眼就能认出这是老约翰；若把五百页传记塞给他，模型反而抓不住重点，还白白多花 token 和延迟。好的人设卡，讲究“少而准”。

S=w1×Match性格+w2×Consist背景+w3×Style语气\displaystyle S = w_1 \times \text{Match}_{\text{性格}} + w_2 \times \text{Consist}_{\text{背景}} + w_3 \times \text{Style}_{\text{语气}}
这句公式的意思是：一句回复好不好，要看它“性格贴不贴、背景合不合、语气像不像”三个项，各自乘以权重再相加。
  1. 综合匹配分 \(S\)候选回复与角色人设的总体贴合度，分数越高越像“这个角色”。
    S=w1×Match性格+w2×Consist背景+w3×Style语气S = w_1 \times \text{Match}_{\text{性格}} + w_2 \times \text{Consist}_{\text{背景}} + w_3 \times \text{Style}_{\text{语气}}
  2. 性格匹配度 \(\text{Match}_{\text{性格}}\)回复用词与句式是否符合预设的性格标签（如热情、阴郁、毒舌）。
    Match性格=相似度(回复,性格标签)\text{Match}_{\text{性格}} = \text{相似度}(\text{回复}, \text{性格标签})
  3. 背景一致性 \(\text{Consist}_{\text{背景}}\)回复是否违背角色的过往经历与世界观设定。
    Consist背景=1−矛盾程度\text{Consist}_{\text{背景}} = 1 - \text{矛盾程度}
  4. 语气风格 \(\text{Style}_{\text{语气}}\)回复是否贴合角色的口头禅、腔调与用词习惯。
    Style语气∈[0,1]\text{Style}_{\text{语气}} \in [0, 1]
  5. 权重关系 \(w_1, w_2, w_3\)三个维度的相对重要性由策划调参，通常归一化。
    w1+w2+w3=1w_1 + w_2 + w_3 = 1

对话记忆管理

好老板不会转头就忘客人，也不会把十年流水账全背下来。短期记忆像眼前这桌的对话，随聊随记；长期记忆像老主顾的偏好本，关键信息沉淀下来；打烊后把今日见闻写成两三句日记——这便是摘要压缩。

若把全部历史对话原封不动塞进上下文，token 账单爆炸、窗口溢出、延迟飙升。工程惯例是“滑动窗口 + 摘要”：最近几轮原样保留，超出窗口的旧对话定期交给模型提炼成要点，作为长期记忆持久保存。

记忆如何随时间“变淡”，可以用指数衰减来建模：

遗忘系数 λ 就是老板的记性——λ 大的人三天就忘，λ 小的人记你一辈子。好的记忆系统既不忘本，也不背着沉重的包袱走路。

W(t)=W0×e−λt\displaystyle W(t) = W_0 \times e^{-\lambda t}
这条公式是说：一段记忆的“可调用强度”会随时间推移指数级衰减，衰减的快慢由遗忘系数 λ 控制。
  1. 记忆权重 \(W(t)\)某个记忆在 \(t\) 时刻的可调用强度，值越高越容易被模型采用。
    W(t)=W0×e−λtW(t) = W_0 \times e^{-\lambda t}
  2. 初始权重 \(W_0\)记忆刚产生时的强度，通常归一化为 1。
    W0=1W_0 = 1
  3. 遗忘速率 \(\lambda\)控制记忆衰减快慢的系数，越大忘得越快。
    λ>0\lambda > 0
  4. 自然底数 \(e\)自然常数，约等于 2.718，描述连续指数衰减。
    e≈2.718e \approx 2.718
  5. 时间间隔 \(t\)从记忆产生到当前时刻的经过时长。
    t=t当前−t产生t = t_{\text{当前}} - t_{\text{产生}}

行为树融合

老板再能聊，也得先看现在是营业还是打烊、灶上有没有火、门口有没有客人。行为树就是这张作息表：什么条件下允许开口，说完话该去干什么活。

在工程里，LLM 负责“说什么”，行为树负责“何时说、说完做什么”。标准做法是把 LLM 调用封装成行为树的一个“对话”叶子节点：节点被选中时发起请求，返回后驱动口型、字幕与动画。

对话能否触发，可以看成多个条件的逻辑与：

行为树像导演，LLM 像演员：导演决定这场戏演不演、怎么走位，演员负责把台词说活。两者各司其职，NPC 才能既有章法又有灵魂。

P(对话触发)=P(玩家靠近)×P(事件空闲)×P(剧情解锁)\displaystyle P(\text{对话触发}) = P(\text{玩家靠近}) \times P(\text{事件空闲}) \times P(\text{剧情解锁})
这条公式是说：玩家靠近、NPC 手头没急事、剧情进度满足，三个条件同时成立，对话分支才会被行为树选中。
  1. 触发概率 \(P(\text{对话触发})\)行为树选择对话分支的倾向强度，取 1 表示必然触发。
    P(对话触发)=P(玩家靠近)×P(事件空闲)×P(剧情解锁)P(\text{对话触发}) = P(\text{玩家靠近}) \times P(\text{事件空闲}) \times P(\text{剧情解锁})
  2. 玩家靠近条件玩家是否进入 NPC 的交互半径。
    P(玩家靠近)∈{0,1}P(\text{玩家靠近}) \in \{0, 1\}
  3. 事件空闲条件NPC 当前是否没有更高优先级的行动（如战斗、巡逻、工作）。
    P(事件空闲)∈{0,1}P(\text{事件空闲}) \in \{0, 1\}
  4. 剧情解锁条件相关任务或剧情进度是否满足对话的前提要求。
    P(剧情解锁)∈{0,1}P(\text{剧情解锁}) \in \{0, 1\}
  5. 逻辑与关系三者必须同时为 1，对话分支才会被选中，任何一个为 0 则不触发。
    P(对话触发)=1  ⟺  三条件皆为 1P(\text{对话触发}) = 1 \iff \text{三条件皆为 } 1

体验优化策略

客人等太久会摔杯子。LLM 生成完整一句话可能要一两秒，但“边想边说”能让第一个字几乎瞬间蹦出来——就像老板先远远喊一嗓子“来啦！”，再转身去忙。

流式输出只是第一步。沉浸感还依赖内容审核（守酒馆规矩，辱骂、剧透、违规内容要拦下）、情境感知（根据天气、剧情、玩家声望调整话术）、打断处理（玩家插话时能即时切换话题）。

玩家对“快不快”的感知，集中体现在首字等待时间：

把一句完整回答拆成“先应声、再细说”，只快了零点几秒，玩家却觉得这位老板反应快、够机灵——游戏体验的差别，往往就藏在这几百毫秒里。

T首字=T请求+T首token\displaystyle T_{\text{首字}} = T_{\text{请求}} + T_{\text{首token}}
这条公式是说：玩家看到第一个字的时间 = 请求发出去的时间 + 模型吐出第一个字的时间，流式输出就是让后者尽可能早发生。
  1. 首字时间 \(T_{\text{首字}}\)从玩家发出发言到屏幕上出现第一个字的等待时长。
    T首字=T请求+T首tokenT_{\text{首字}} = T_{\text{请求}} + T_{\text{首token}}
  2. 请求时延 \(T_{\text{请求}}\)客户端组包、网络上行与服务器排队处理的总时间。
    T请求=T组包+T上行+T排队T_{\text{请求}} = T_{\text{组包}} + T_{\text{上行}} + T_{\text{排队}}
  3. 首 token 时延 \(T_{\text{首token}}\)模型消化完输入并输出第一个 token 的时间。
    T首token=Tprefill+T首个解码T_{\text{首token}} = T_{\text{prefill}} + T_{\text{首个解码}}
  4. 优化目标流式输出把“首字”提前送回，玩家立刻看到回应，等待感大幅下降。
    T首字流式≪T首字整句等待T_{\text{首字}}^{\text{流式}} \ll T_{\text{首字}}^{\text{整句等待}}

成本控制方案

智囊按字收费，就像菜价按盘算。精明的老板会提前备好常客的拿手菜（缓存），小菜让学徒做（模型分级），点单时合并同类项（请求优化），大厨请假还有 B 计划（降级脚本）。

LLM 按输入输出 token 计费，NPC 对话一多账单就吓人。成本控制不是砍掉功能，而是把钱花在刀刃上：高频台词走缓存，简单闲聊用小模型，关键剧情才惊动大模型。

单次对话的花费可以精确记账：

账本平衡了，酒馆才能长久开下去。把“贵”的算力用在玩家真正在意的地方，NPC 的鲜活才不会变成财务危机。

C=cprompt×Nprompt+ccompletion×Ncompletion−ccache×Nhit\displaystyle C = c_{\text{prompt}} \times N_{\text{prompt}} + c_{\text{completion}} \times N_{\text{completion}} - c_{\text{cache}} \times N_{\text{hit}}
这条公式是说：一次对话成本 = 输入 token 费用 + 输出 token 费用，再减去命中缓存省下的钱。
  1. 单次成本 \(C\)一次 NPC 对话调用的总花费，由输入、输出与缓存节省共同决定。
    C=cprompt×Nprompt+ccompletion×Ncompletion−ccache×NhitC = c_{\text{prompt}} \times N_{\text{prompt}} + c_{\text{completion}} \times N_{\text{completion}} - c_{\text{cache}} \times N_{\text{hit}}
  2. 输入侧费用输入 token 数量乘以其单价（通常更便宜）。
    cprompt×Npromptc_{\text{prompt}} \times N_{\text{prompt}}
  3. 输出侧费用输出 token 数量乘以其单价（通常更贵）。
    ccompletion×Ncompletionc_{\text{completion}} \times N_{\text{completion}}
  4. 缓存节省额命中缓存的 token 数乘以可节省的单价，从总成本中扣除。
    ccache×Nhitc_{\text{cache}} \times N_{\text{hit}}
  5. 总 token 数输入与输出的 token 之和，是计价的原始依据。
    Ntotal=Nprompt+NcompletionN_{\text{total}} = N_{\text{prompt}} + N_{\text{completion}}

挑战与展望

再好的酒馆也有难处：晚高峰上菜慢（延迟瓶颈）、客人多了记性乱（一致性）、有人借酒闹事得拦（安全对齐）、外地客人讲方言怎么办（多语言）。

LLM 驱动 NPC 的工程化挑战集中在四个方面。延迟靠接入方案与流式输出缓解；一致性靠人设卡、记忆与规则校验兜底；安全靠模型对齐 + 规则过滤器组合出招；多语言则依赖模型能力与本地化测试。

一致性是可以度量与改进的，最简单的指标是一致性比率：

通往“活着的 NPC”的路还很长，但方向已经清晰：把 LLM 的开放性与行为树的纪律、记忆的温度、账本的理性组合在一起，下一个让玩家念念不忘的酒馆老板，也许就出自你的代码。

Rconsistency=N一致N总\displaystyle R_{\text{consistency}} = \frac{N_{\text{一致}}}{N_{\text{总}}}
这条公式是说：抽一批对话样本，数一数其中不违背角色设定、不前后矛盾的比例，就是一致性比率。
  1. 一致性比率 \(R_{\text{consistency}}\)抽样回复中与角色设定保持一致的比例。
    Rconsistency=N一致N总R_{\text{consistency}} = \frac{N_{\text{一致}}}{N_{\text{总}}}
  2. 一致回复数 \(N_{\text{一致}}\)不违背人设、不前后矛盾的回复条数。
    N一致=N总−N矛盾N_{\text{一致}} = N_{\text{总}} - N_{\text{矛盾}}
  3. 总回复数 \(N_{\text{总}}\)测试样本中全部回复的条数。
    N总=N一致+N矛盾N_{\text{总}} = N_{\text{一致}} + N_{\text{矛盾}}
  4. 评估方式定期抽样对话、人工或规则评判，统计该比率。
    Rconsistency=N总−N矛盾N总R_{\text{consistency}} = \frac{N_{\text{总}} - N_{\text{矛盾}}}{N_{\text{总}}}
  5. 工程目标通过人设卡、记忆管理和规则校验，让比率逐渐逼近 1。
    Rconsistency→1R_{\text{consistency}} \to 1

AI 应用场景

开放世界 RPG 的村民闲聊系统

阶段：推理与对话生成

解决的问题：传统行为树加脚本只能输出预制台词，玩家反复对话后迅速审美疲劳。LLM 让每个村民拥有独立身份，可围绕传闻、任务、天气聊出千变万化的话题，且不违背角色设定。

具体案例：某开放世界手游里，酒馆老板“老约翰”配了 120 字人设卡、最近 6 轮对话记忆和村庄大事摘要。玩家每次进酒馆问“最近有什么新闻”，老板都会结合当天任务进度给出不同回答，仿佛真在过日子。

侦探游戏的自由审问

阶段：行为树决策 + 人设对话

解决的问题：传统分支选项看似自由实则局限，玩家想说的话系统接不住。行为树决定“何时可审问”，LLM 生成“审问时的应答”，让玩家用自然语言自由质询。

具体案例：审问嫌疑人时，玩家输入“你昨晚八点为什么出现在码头”，嫌疑人会结合自己的背景故事、不在场证明和记忆摘要进行辩解，前后逻辑一致，破案过程张力十足。

千人同服的成本控制

阶段：成本优化与降级

解决的问题：同服大量 NPC 同时被玩家搭话时，API 账单暴涨、并发超限。用缓存高频台词、小模型担纲日常闲聊、大模型负责关键剧情，再加上熔断降级到脚本，把单次对话成本压到可接受范围。

具体案例：MMO 节假日活动期间，全村 NPC 同时被玩家搭话。系统监控到调用量超过阈值后自动降级：闲聊走缓存，任务引导走小模型，只有主线关键对话走大模型，成本下降七成且玩家无感知。

Python 演示

python108 行
"""LLM driven NPC dialogue demo - persona card, memory, cost meter"""from collections import deque  class NPCProfile:    def __init__(self, name, role, personality, lore, tone):        self.name = name        self.role = role        self.personality = personality        self.lore = lore        self.tone = tone     def build_prompt(self, memory_text, player_name):        return (            "你是" + self.role + self.name + "，" + self.lore +            "。性格：" + self.personality +            "，说话" + self.tone + "。\n"            "最近的对话：\n" + memory_text +            "\n玩家" + player_name + "说："        )  class MemoryManager:    def __init__(self, max_turns=4):        self.turns = deque(maxlen=max_turns)        self.summary = ""     def add(self, role, text):        self.turns.append(role + "：" + text)     def build_context(self):        recent = "\n".join(self.turns)        if self.summary:            return "【旧事摘要】" + self.summary + "\n" + recent        return recent     def compress(self, llm_client):        if len(self.turns) < self.turns.maxlen:            return        history = "\n".join(self.turns)        self.summary = llm_client.chat(            "请用两句话总结这段对话的要点：\n" + history        )        self.turns.clear()  class CostMeter:    def __init__(self, price_per_1k=0.002):        self.total_tokens = 0        self.total_cost = 0.0        self.price = price_per_1k     def add(self, prompt_tokens, completion_tokens):        self.total_tokens += prompt_tokens + completion_tokens        self.total_cost += (            (prompt_tokens + completion_tokens) / 1000.0 * self.price        )  class MockLLM:    def __init__(self):        self.fallback = [            "嗯……这件事嘛，说来话长。",            "客人您稍等，容我慢慢讲。",            "哈哈，您问到点子上了！"        ]        self._idx = 0     def chat(self, prompt):        self._idx += 1        if "你好" in prompt:            return "欢迎光临我的小酒馆，远方的旅人！"        if "任务" in prompt:            return "我正缺人手，去村外采三株月光草回来吧。"        if "传说" in prompt:            return "相传东边的古堡里，住着一位会说话的幽灵。"        return self.fallback[self._idx % len(self.fallback)]  def main():    npc = NPCProfile(        name="老约翰",        role="酒馆老板",        personality="热情爽朗、爱讲故事",        lore="在枫叶镇开了三十年酒馆",        tone="带着乡音，幽默风趣"    )    memory = MemoryManager(max_turns=4)    llm = MockLLM()    cost = CostMeter(price_per_1k=0.002)    script = ["你好呀！", "有没有任务交给我？", "讲讲这里的传说吧！"]     for text in script:        prompt = npc.build_prompt(memory.build_context(), "阿明") + text        reply = llm.chat(prompt)        print("玩家：" + text)        print(npc.name + "：" + reply + "\n")        memory.add("玩家", text)        memory.add(npc.name, reply)        cost.add(120, 80)        memory.compress(llm)     print("本轮共用 token：" + str(cost.total_tokens))    print("预计花费：$" + str(round(cost.total_cost, 4)))  if __name__ == "__main__":    main()
目的：用模拟 LLM 跑通“人设卡 → 记忆管理 → 成本记账”的 NPC 对话流水线，展示工程上的核心环节如何协作。
  1. self.turns = deque(maxlen=max_turns)用定长双向队列当短期记忆，新对话进来、旧对话自动挤出窗口
  2. memory.compress(llm)队列满后把旧对话交给模型总结，压缩成两三句“长期记忆”再清空窗口
  3. build_context()拼 prompt 时把“旧事摘要”放在前面、近期对话放在后面，模型既记得老交情又不超窗口
  4. npc.build_prompt(...)把角色卡、记忆上下文与玩家发言拼成完整人设 prompt，正是正文讲的结构化模板
  5. cost.add(120, 80)模拟一次调用消耗 120 个输入 token 与 80 个输出 token，实时记入账本

常见误区

误区“大模型什么都会，NPC 想说什么说什么、想干什么干什么，行为树这种老掉牙的东西该淘汰了。”

正解LLM 只擅长“开口说话”，不擅长“行动的时机与规则”。酒馆老板再能聊，也得先判断现在是营业还是打烊、灶上有没有火。行为树负责决策“何时进入对话、说完去干什么”，LLM 负责生成“说什么”，两者是导演与演员的关系，缺一不可。

为何常见：LLM 的输出太像人，让人误以为它能接管游戏内全部逻辑，忽略了行动控制与物理规则的独立性。

误区“把角色的五百年家族史、三百条爱好全写进 prompt，AI 一定演得入木三分。”

正解过长的 prompt 会稀释关键指令、推高 token 成本、拉长延迟，还容易让模型“顾此失彼”。高效的人设卡是结构化短卡：身份、性格、背景、语气各一两句，像简历一样突出重点，模型反而更抓得住。

为何常见：人们常把“信息量大”等同于“效果好”，忽略了大模型注意力在超长上下文中的稀释效应。

误区“把玩家跟 NPC 聊过的所有话都堆进 prompt，模型自然什么都记得。”

正解上下文窗口有限且按 token 收费，全量塞入会爆窗、超时、烧钱。正确做法是滑动窗口保留近期对话，再定期把旧对话压缩成摘要，既保住长期一致性，又控制成本与延迟。

为何常见：不了解 token 计费机制，也低估了超长上下文对推理速度的影响。

误区“NPC 每句话都要过审、对齐、查重，有一点瑕疵就不能上线。”

正解游戏对话允许一定的随机与模糊，玩家对闲聊的容忍度很高。关键节点（任务交付、剧情推进）用规则校验兜底即可，普通闲聊放开生成，过度审核反而杀死开放性，还拖慢响应。

为何常见：把“内容安全”与“内容自由度”对立起来，忘了分级治理的思路。

误区“自己买显卡跑开源模型，一劳永逸，省下所有 API 费。”

正解本地部署要算显卡采购、机房电费、运维人力、并发扩容的成本。中小团队往往“云端 API + 缓存”更划算；只有在数据合规、离线运行或规模极大时，本地部署才体现优势。

为何常见：只盯着 API 单价，忽略了全链路成本与团队维护能力。

面试题

Q1. 在 AI NPC 对话系统中，行为树主要负责什么？

单选题 · easy

  • A.负责对话行为的时机与动作← 正确答案
  • B.负责生成 NPC 的对话台词
  • C.负责训练游戏大语言模型
  • D.负责压缩对话的记忆缓存

答案：A。行为树是“行动导演”，决定 NPC 何时进入对话、说完去干什么，答案 A 正确。B 是 LLM 的职责，C 与 D 与行为树无关。

Q2. LLM 接入游戏 NPC 的三种典型方案是？

单选题 · easy

  • A.云端 API、本地部署、混合架构← 正确答案
  • B.单机部署、局域网服务器、广域网连接
  • C.预训练、指令微调、强化学习
  • D.文本输入、语音识别、图像渲染

答案：A。接入方案的三种典型是云端 API（中央厨房）、本地部署（自家后厨）与混合架构（两者结合）。B 是网络拓扑，C 是模型训练阶段，D 是多模态技术，均不属于接入方案。

Q3. 设计角色人设 Prompt 时，最佳实践是？

单选题 · mid

  • A.写五千字人物传记最专业
  • B.结构化短卡含身份性格语气← 正确答案
  • C.必须用英文书写才有效果
  • D.只需要写上角色姓名即可

答案：B。人设卡宜“少而准”：身份、性格、背景、语气各一两句。A 过长易稀释关键指令并抬高成本；C 语言无必然关系；D 信息不足，模型无法演出角色。

Q4. 对话记忆管理中“摘要压缩”的主要作用是？

单选题 · mid

  • A.让模型拥有更强的理解能力
  • B.将旧对话提炼成要点节省成本← 正确答案
  • C.删除玩家的全部历史聊天记录
  • D.为 NPC 生成新的随机台词

答案：B。滑动窗口装不下全部历史，将旧对话定期压缩成摘要，可保留长期一致性、控制 token 成本与延迟。A 属于模型能力问题，C 会丢失记忆，D 与记忆无关。

Q5. 成本公式 C = c_prompt×N_prompt + c_completion×N_completion − c_cache×N_hit 中，N_hit 表示？

单选题 · mid

  • A.模型的单次调用命中准确率
  • B.命中缓存所节省的 Token 数← 正确答案
  • C.同一时刻游戏的玩家在线数
  • D.大语言模型的训练迭代次数

答案：B。N_hit 是命中缓存的 token 数量，乘以可节省单价后从总成本中扣减。A 指准确率，C 指并发量，D 指训练轮次，均不在公式语义内。

Q6. 下列哪些做法能有效控制 NPC 对话的 LLM 成本？

多选题 · mid

  • A.缓存玩家高频重复的对话← 正确答案
  • B.简单回复降级到便宜小模型← 正确答案
  • C.为输出设置 Token 数量上限← 正确答案
  • D.全部改用本地大模型推理

答案：ABC。缓存避免重复计费，模型分级让简单任务用便宜模型，输出上限防止生成失控——三者都直接省钱。D 看似省钱，实则把采购、运维和电费全背到自己身上，对中小团队反而更贵。

Q7. 流式输出主要解决的体验问题是？

单选题 · hard

  • A.扩大单次对话的网络带宽
  • B.缓解首字等待感提升沉浸感← 正确答案
  • C.提高模型答案的准确程度
  • D.减少每次调用的 Token 消耗

答案：B。流式输出把“第一个字”提前送回，显著缩短玩家感知等待，对应公式 T_首字 = T_请求 + T_首token。它不解决带宽、准确率，也不减少 token 消耗。

Q8. 关于 LLM 驱动 NPC 的工程挑战，下列说法正确的有？

多选题 · hard

  • A.延迟超标会破坏对话沉浸感← 正确答案
  • B.一致性可完全交给模型自觉
  • C.安全对齐需配合规则过滤器← 正确答案
  • D.记忆窗口可以无限地扩大

答案：AC。端到端延迟需控制在 200ms 内，否则玩家出戏；内容安全要“模型对齐 + 规则过滤”组合。B 错误，一致性没有外部兜底极易人设崩塌；D 错误，上下文窗口有限且成本随长度暴涨。

Q9. 记忆权重衰减公式 W(t)=W0×e^(−λt) 中，λ 越大表示？

单选题 · hard

  • A.记忆遗忘的速度就越快← 正确答案
  • B.记忆保持的时间越长久
  • C.对话生成的质量越高
  • D.对话服务的成本越高

答案：A。λ 是遗忘速率系数，位于指数衰减的负指数项中。λ 越大，W(t) 随 t 下降越剧烈，记忆淡出越快，所以选 A。它不直接决定质量或成本。

Q10. 当大模型 API 超时或不可用时，游戏端应如何降级？

单选题 · easy

  • A.回退到预设脚本或缓存回复← 正确答案
  • B.让游戏直接崩溃并退出
  • C.开启无限次数的重试循环
  • D.让角色永久保持沉默状态

答案：A。降级方案是成本控制的兜底一环——请求失败时回退到行为树预设脚本或缓存回复，保证对话不断线。B 和 D 破坏体验，C 会放大超时压力与账单。