知序
返回
保存草稿
发布
H1
H2
H3
1
2
3
Excalidraw 图
AI 写作
AI 优化
目录
输入内容后显示目录
Markdown
# 语义缓存与 Token 成本治理 > 导读:本文从"功能上线一个月,账单比预估高了十倍,但 QPS 几乎没变"这个具体痛点出发,把 LLM 应用的费用构成、精确缓存与语义缓存的分工、语义缓存的落地要点、提示词前缀缓存、模型分级路由与成本可观测逐项讲透,最后给出工程实践与踩坑清单。适合正在把大模型能力做成线上服务、既要效果又要控成本的后端与算法同学。 ## 一、先建立全局认知 ### Q:LLM 应用的费用到底花在哪? A:结论先行——**LLM 应用的成本几乎全部由 Token(词元,模型处理文本的最小计量单位)用量决定,而 Token 用量 ≈ 调用次数 × 单次输入长度 × 单次输出长度,再乘以对应模型的单价**。所以"贵"很少是单点问题,而是"次数 / 长度 / 单价"三个乘数里至少有一个失控,且通常是三个一起失控。 把一次典型调用的账单拆开看: | 费用项 | 说明 | 常见失控原因 | | --- | --- | --- | | 输入 Token | System Prompt、多轮历史、RAG 召回片段、用户问题 | 历史不做裁剪、召回 TopN 过大、System Prompt 越写越长 | | 输出 Token | 模型生成的正文 | 要求"详细展开"、未设置最大输出长度、无效兜底话术很长 | | 缓存命中价 | 提示词前缀命中缓存后的折扣输入价 | 没做前缀缓存,白付全价 | | 重试费用 | 超时/429 后的重试 | 无退避的暴力重试,一次问题付费多次 | | 额外能力费 | 向量化、OCR、Web 搜索等 | 与主流程混算,归因不清 | 关键认知点有三个: 1. **输入和输出的单价结构不同。** 同一模型档位下,输出 Token 单价通常显著高于输入 Token 单价。具体倍率随厂商、模型、版本变化,**不要背数字,要以官方价目表按实际单价核算**。 2. **模型分档,价差是数量级而非百分比。** 大模型、中模型、小模型之间的价差往往达到一个数量级。也就是说,"用哪个模型"这一个决策,对成本的影响远大于"把 Prompt 优化 10%"。 3. **缓存命中价改变了优化方向。** 当某些厂商对前缀命中缓存给出明显折扣时,"把稳定不变的内容放到 Prompt 最前面"就从"代码洁癖"变成了"真金白银"。 ### Q:为什么成本会失控? A:结论先行——**成本失控几乎都来自"放大器"而不是"单价",即某个业务动作把调用次数或上下文长度成倍放大,而系统里没有任何地方做闸门**。 四个最常见的放大器: **放大器一:多轮会话的上下文无界增长。** 每轮都把完整历史重新发一遍,那么第 N 轮的输入长度近似为 O(N)。20 轮对话下来,总输入 Token 近似是 O(N²) 增长。用户聊得越久,单次越贵,而用户体验上看不出任何异常。 ```text 轮次: 1 2 3 4 ... N 输入长度: L 2L 3L 4L ... N*L 累计开销: L + 2L + 3L + 4L + ... + N*L ≈ O(N^2) ``` **放大器二:RAG 召回片段过多且不去重。** "宁多勿少"的心态让 TopN 从 3 调到 10,单次输入直接涨两三倍;再叠加相邻切片重叠(overlap),同一段文字被算了好几遍。 **放大器三:失败重试。** 超时重试、429 重试、前端重试、SDK 内置重试叠加在一起,一次用户提问实际扣费 N 次,日志里却只有一个请求。 **放大器四:无缓存 + 无路由。** "你好""怎么退货""帮我写个摘要"这类高频低难度请求,全部走最贵的大模型,且每次都重新计算。这是投产初期最普遍的一笔冤枉钱。 一个用来做定性判断的计算模型(**系数需按自身实际单价与流量结构核算**): ```text 月成本 ≈ Σ_over_模型档位 [ 月调用次数 × (平均输入长度×输入单价 + 平均输出长度×输出单价) ] + 重试放大系数 × 上述金额 × 重试率 - 缓存节省(命中率 × 命中部分金额 × 折扣比例) ``` 把这张表写出来就会发现:**优先动"路由"和"缓存",其次动"长度",最后才动"Prompt 措辞"。** 顺序反了,就是花大力气省小钱。 ## 二、缓存机制:精确缓存、语义缓存与语义缓存实现 ### Q:精确缓存和语义缓存到底差在哪? A:结论先行——**精确缓存按"请求内容完全相同"命中,零风险但命中率低;语义缓存按"语义相似"命中,命中率高但引入了答非所问与时效性风险。两者不是替代关系,而是分层关系。** 对照表: | 维度 | 精确缓存 | 语义缓存 | | --- | --- | --- | | 命中判据 | 请求规范化后的哈希完全相等 | Embedding 向量相似度 ≥ 阈值 | | 命中率 | 低(用户措辞极少完全一致) | 高(同义改写可命中) | | 正确性风险 | 接近零 | 存在误命中:语义相近但答案不同 | | 时效性风险 | 低(键里带版本即可控制) | 高(语义相近的旧答案更容易被复用) | | 实现复杂度 | 低(Redis GET/SET) | 中高(向量化 + 向量检索 + 阈值调参) | | 适用场景 | FAQ、固定指令、幂等重试、相同机器请求 | 客服问答、知识问答、多用户同质提问 | | 隔离难度 | 低 | 高(必须做租户/权限隔离) | **精确缓存的关键在"规范化"。** 如果直接把原始请求体做哈希,命中率会极低,因为 JSON 字段顺序、空白、时间戳、traceId 都会变。正确做法是先构造一个"缓存键素材": ```text cacheKey = hash( tenantId + userId + modelId + promptVersion + systemPromptHash + normalizedMessages + temperature==0 ) ``` 其中 `normalizedMessages` 要去掉 traceId、时间戳、无意义的空白与字段顺序;只有 `temperature` 为 0(或极低)时才认为输出可复现,才能缓存。 ### Q:语义缓存的命中率为什么会"虚高"?风险具体是什么? A:结论先行——**因为"向量相似"不等于"答案相同"。相似度只衡量语义接近程度,不衡量意图与约束是否一致,所以阈值一放松,命中率曲线会漂亮地上升,同时正确率会悄悄下降。** 典型误命中场景: | 用户 A 的问题 | 用户 B 的问题 | 相似度 | 复用 A 的答案后果 | | --- | --- | --- | --- | | "订单 12345 什么时候到?" | "订单 67890 什么时候到?" | 极高 | 报错单号,用户收到错误物流 | | "怎么退货?" | "怎么换货?" | 高 | 答非所问 | | "2023 年的报销标准是多少?" | "报销标准是多少?" | 高 | 用了过期年度口径 | | "iPhone 15 有什么优惠?" | "iPhone 16 有什么优惠?" | 高 | 商品错位 | | "我们公司年假多少天?" | "我们公司年假多少天?"(不同租户) | 极高 | 跨租户数据泄露 | 因此有一条工程铁律:**任何携带"实体变量"(订单号、用户 ID、日期、金额、商品 ID)的问题,必须先做实体抽取并纳入缓存键,不允许只靠向量相似度决定命中。** 另一条铁律:**语义缓存的命中率必须与"命中后人工/自动评测的满意率"一起看。** 只看命中率,等于只看省钱不看赔钱。 ### Q:一套可落地的语义缓存需要哪些组件? A:结论先行——**语义缓存 = 请求规范化 + 实体隔离 + Embedding 向量化 + 向量检索 + 阈值判定 + TTL + 租户/权限隔离 + 回写策略,缺任何一环都会在生产上出事。** 组件与职责:  *图:语义缓存流程——精确缓存、向量检索与阈值判定* ```text ┌──────────────── 语义缓存流程 ────────────────┐ 用户请求 ──▶ 1. 规范化 + 实体抽取(订单号/用户/日期/租户) │ ├─▶ 2. 精确缓存查一次(命中即返回,零风险) │ ├─▶ 3. Embedding 向量化 │ ├─▶ 4. 向量检索 TopK(按租户/权限分区) │ ├─▶ 5. 相似度 ≥ 阈值 且 实体一致 且 未过期? │ ├─ 是 ─▶ 返回缓存答案(标记 cache=semantic) │ └─ 否 ─▶ 6. 调用 LLM,回写缓存 └──────────────────────────────────────────────┘ ``` **阈值怎么定?** 结论先行——**用你自己的数据回归,不要抄别人的数字。** 做法:取一批真实问答对,人工标注"哪些问题应该共享答案",然后扫一遍阈值区间,观察精确率(precision)与命中率(recall)的权衡曲线,选一个"精确率优先"的点。因为语义缓存误命中的代价(给出错误答案、泄露数据)远高于少省一点钱的收益。 **TTL 怎么定?** 结论先行——**按"答案的半衰期"分层设定,而不是全局一个值。** | 内容类型 | 建议 TTL 思路 | 理由 | | --- | --- | --- | | 常识/概念解释 | 长(天级或更长) | 答案几乎不变 | | 产品 FAQ/政策 | 中(小时到天) | 会随版本更新 | | 价格/库存/活动 | 短(分钟到小时)或禁用 | 强时效,误用代价高 | | 个性化/账户数据 | 禁用语义缓存 | 一眼错就是事故 | **隔离怎么做?** 结论先行——**分区键必须是"租户 + 权限域 + 模型版本 + Prompt 版本"的组合,做在向量检索的过滤条件里,而不是取回结果后再过滤。** 先取回再过滤会把别的租户的向量捞进内存,既是性能浪费,也是泄露隐患。Redis 侧的向量检索支持在查询时带过滤条件(具体语法与能力**需结合 Redis 版本 / Redis Stack 确认**)。 推荐的 Key 设计(示意,**具体命令能力需按实际 Redis 版本确认**): ```redis # 1) 精确缓存:值就是答案,TTL 由内容类型决定 SET sc:exact:{tenant}:{sha256(user|normQuestion|entity)} "<answer>" EX 86400 # 2) 语义缓存索引:隔离维度直接写进 key,天然分区 # field = 向量指纹, value = 答案Id HSET sc:sem:{tenant}:{scope}:{promptVer} <vecHex> <answerId> EXPIRE sc:sem:{tenant}:{scope}:{promptVer} 86400 # 3) 答案体:与向量分开存,便于单独失效和审计 HSET sc:ans:{answerId} answer "<answer>" entityKey "<orderId>" expiresAt "<ms>" EXPIRE sc:ans:{answerId} 86400 # 4) 反向索引:知识更新时按文档Id批量失效(避免全量清空) SADD sc:ansidx:doc:{docId} <answerId> # 5) 单飞锁:防热点键击穿,同一问题只回源一次 SET sc:lock:{tenant}:{sha256(normQuestion)} <requestId> NX EX 10 ``` 这套 Key 设计的三个要点:**答案体与向量分离**(便于答案级失效与审计)、**反向索引支撑精准失效**(知识更新只清相关答案,不用 `FLUSHDB`)、**单飞锁控制回源并发**(避免缓存失效瞬间的流量风暴)。 ### Q:语义缓存和 RAG 缓存是一回事吗? A:结论先行——**不是。它们缓存的对象不同:语义缓存缓存"最终答案",RAG 缓存缓存"检索结果";前者省的是整次 LLM 调用,后者省的是检索与文档处理的重复开销。** 对照: | 维度 | 语义缓存(答案缓存) | RAG 检索缓存 | | --- | --- | --- | | 缓存对象 | 最终答案文本 | 召回文档片段列表 | | 键 | 问题向量 + 隔离维度 | 问题向量 + 索引版本 + 过滤条件 | | 失效条件 | 答案过期、知识更新 | 文档库变更、切分策略变更、Embedding 模型变更 | | 省下什么 | 整次生成调用(最大头) | 向量检索 + 重排(往往是次要头) | | 风险 | 答非所问、跨权限 | 召回了过时/无权限的片段 | | 优先级 | 高(省得多) | 中(省得少、但能降延迟) | 实践建议:**两者可以叠加,但必须共用同一套"索引/知识版本号"。** 知识库更新时,通过版本号让两边的缓存一起失效,否则会出现"检索到新文档、却返回旧答案"的诡异现象。 ### Q:Java 侧怎么实现一个最小可用的语义缓存? A:结论先行——**核心是三件事:一个规范的缓存键、一次向量近邻查询、一个带隔离与 TTL 的判定;先用最朴素的结构跑通,再谈优化。** 下面这个示例解决的问题是:**在 Java 服务里用 Redis 保存"问题向量 → 答案",并在新问题到来时找出语义最相似且同租户、未过期的一条,相似度达标则直接复用。** 为便于理解,这里把向量以二进制形式存在 Redis Hash 中,相似度在应用侧计算;生产上更推荐使用 Redis 的原生向量索引(能力与命令**需结合 Redis 版本 / Redis Stack 确认**)以把计算下推到存储层。 ```java import redis.clients.jedis.Jedis; import redis.clients.jedis.Pipeline; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.charset.StandardCharsets; import java.security.MessageDigest; import java.util.*; /** * 最小可用语义缓存: * - 精确缓存:key = sc:exact:{tenant}:{hash} * - 语义缓存:key = sc:sem:{tenant} (Hash:field = 向量指纹, value = 答案Id) * - 答案体:key = sc:ans:{id} (Hash:answer / expiresAt / entityKey) */ public class SemanticCache { private final Jedis jedis; private final EmbeddingClient embedding; // 自行封装,返回归一化向量 private final double threshold; // 由离线评测得出,不硬编码"通用值" public SemanticCache(Jedis jedis, EmbeddingClient embedding, double threshold) { this.jedis = jedis; this.embedding = embedding; this.threshold = threshold; } /** 入口:命中返回答案,未命中返回 empty */ public Optional<String> get(String tenantId, String userId, String question, String entityKey, long ttlSeconds) { String norm = normalize(question); String exactKey = "sc:exact:" + tenantId + ":" + sha256(userId + "|" + norm + "|" + entityKey); // 1) 精确缓存:零风险,先查 String exact = jedis.get(exactKey); if (exact != null) { return Optional.of(exact); } // 2) 语义缓存:先按租户分区,避免跨租户串号 float[] q = embedding.embed(norm); Map<String, String> candidates = jedis.hgetAll("sc:sem:" + tenantId); if (candidates.isEmpty()) { return Optional.empty(); } String bestId = null; double bestScore = -1; for (Map.Entry<String, String> e : candidates.entrySet()) { float[] v = decode(e.getKey()); double score = cosine(q, v); if (score > bestScore) { bestScore = score; bestId = e.getValue(); } } if (bestId == null || bestScore < threshold) { return Optional.empty(); } // 3) 实体必须一致,否则相似度再高也不复用(订单号/日期类问题) Map<String, String> ans = jedis.hgetAll("sc:ans:" + bestId); long expiresAt = Long.parseLong(ans.getOrDefault("expiresAt", "0")); if (expiresAt < System.currentTimeMillis()) { return Optional.empty(); } if (!Objects.equals(entityKey, ans.getOrDefault("entityKey", ""))) { return Optional.empty(); } return Optional.ofNullable(ans.get("answer")); } /** 回写:只在温度极低、答案确定性高的场景调用 */ public void put(String tenantId, String userId, String question, String entityKey, String answer, long ttlSeconds) { String norm = normalize(question); float[] v = embedding.embed(norm); String id = UUID.randomUUID().toString(); Pipeline p = jedis.pipelined(); p.hset("sc:ans:" + id, Map.of( "answer", answer, "entityKey", entityKey == null ? "" : entityKey, "expiresAt", String.valueOf(System.currentTimeMillis() + ttlSeconds * 1000) )); p.expire("sc:ans:" + id, ttlSeconds); // 向量指纹用十六进制,便于作为 Hash 的 field p.hset("sc:sem:" + tenantId, encodeHex(v), id); p.expire("sc:sem:" + tenantId, ttlSeconds); p.setex("sc:exact:" + tenantId + ":" + sha256(userId + "|" + norm + "|" + entityKey), ttlSeconds, answer); p.sync(); } // ===== 工具方法 ===== private static String normalize(String q) { return q == null ? "" : q.trim().replaceAll("\\s+", "").toLowerCase(Locale.ROOT); } private static double cosine(float[] a, float[] b) { double dot = 0, na = 0, nb = 0; int n = Math.min(a.length, b.length); for (int i = 0; i < n; i++) { dot += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i]; } if (na == 0 || nb == 0) return -1; return dot / (Math.sqrt(na) * Math.sqrt(nb)); } private static String encodeHex(float[] v) { ByteBuffer bb = ByteBuffer.allocate(v.length * 4).order(ByteOrder.BIG_ENDIAN); for (float f : v) bb.putFloat(f); StringBuilder sb = new StringBuilder(bb.capacity() * 2); for (byte x : bb.array()) sb.append(String.format("%02x", x)); return sb.toString(); } private static float[] decode(String hex) { byte[] raw = new byte[hex.length() / 2]; for (int i = 0; i < raw.length; i++) { raw[i] = (byte) Integer.parseInt(hex.substring(i * 2, i * 2 + 2), 16); } ByteBuffer bb = ByteBuffer.wrap(raw).order(ByteOrder.BIG_ENDIAN); float[] v = new float[raw.length / 4]; for (int i = 0; i < v.length; i++) v[i] = bb.getFloat(); return v; } private static String sha256(String s) { try { MessageDigest md = MessageDigest.getInstance("SHA-256"); byte[] d = md.digest(s.getBytes(StandardCharsets.UTF_8)); StringBuilder sb = new StringBuilder(); for (byte b : d) sb.append(String.format("%02x", b)); return sb.toString(); } catch (Exception e) { throw new IllegalStateException(e); } } } ``` 关键点与边界: - **分区键 `sc:sem:{tenantId}`** 是隔离的第一道闸门;如果还有"部门/角色"级别的权限差异,分区键要扩展成 `sc:sem:{tenantId}:{scopeId}`。 - **实体比对(`entityKey`)** 是防"订单号错位"这类事故的兜底;没有实体的问题传空串即可。 - **相似度阈值来自离线评测**,不是抄来的;示例刻意不写死数字,就是为了避免把别人的经验值当默认值。 - **`HGETALL` 把整个租户的向量捞回内存**,在候选量小的时候可接受,量一大就必须换成原生向量索引或 ANN(近似最近邻)检索;这一步是"教学实现 → 生产实现"的分水岭。 - **TTL 逐键设置**,避免"一个租户下所有答案一起过期"的缓存雪崩。 - **写缓存的前提是答案可复现**(温度接近 0、无随机性、无实时数据),否则等于把随机结果固化成"标准答案"。 ### Q:命中缓存之后,成本就一定降了吗? A:结论先行——**不一定。语义缓存会额外产生 Embedding 调用与向量检索开销,只有当"省的生成费用 > 多花的向量化费用"时才真正省钱。** 所以要做一次明确的投入产出判断: ```text 净收益 = 命中次数 × 单次生成费用 - 全部请求次数 × 单次 Embedding 费用 - 向量存储与检索成本 - 误命中的业务损失(人工兜底、投诉、返工) ``` 注意后两项:**误命中的损失往往不可忽略,而且难以直接量化**。一个常见做法是给语义缓存设置一个"影子模式"阶段——只记录"如果命中会返回什么",人工抽查一段时间,确认误命中率可接受后再真正放开。 ## 三、提示词缓存与成本治理 ### Q:提示词缓存的原理是什么? A:结论先行——**提示词缓存(Prompt Caching)也叫前缀缓存,指的是把 Prompt 中"前面一段完全不变的内容"在供应商侧缓存下来,后续请求若前缀一致,这段内容按缓存价计费,从而降低输入成本与首字延迟。** 原理示意:  *图:一次请求的 Prompt 结构与可缓存前缀* ```text 一次请求的 Prompt 结构: [ System Prompt(很长,几乎不变) ][ 工具定义(不变) ][ 少样本示例(不变) ] [ 检索到的文档(每次不同) ][ 历史对话(增长) ][ 用户当前问题(每次不同) ] └──────────── 可缓存前缀 ────────────┘└────────── 必须每次重传 ──────────┘ 第二次请求: [ 命中缓存,按缓存价计费 ] [ 正常按输入价计费 ] ``` 命中前提是**前缀逐字节一致**,所以任何"看起来无关紧要"的变动都会导致缓存失效: | 破坏缓存的常见操作 | 后果 | | --- | --- | | 在 System Prompt 前拼接当前时间戳 | 每次都不同,永不命中 | | 把用户信息插到 System Prompt 中间 | 前缀被打断,后半段全部失效 | | 工具定义顺序随机(如 HashMap 序列化) | 前缀不稳定 | | 少样本示例动态拼装 | 前缀不稳定 | | 多轮对话把历史放在文档之前 | 缓存边界被冲掉 | ### Q:哪些场景最值得上前缀缓存? A:结论先行——**"长且稳定"的内容才值得缓存,最典型的是长 System Prompt、固定工具/函数定义、固定的少样本示例,以及"文档在前、问题在后"的 RAG 长上下文。** | 场景 | 前缀长度特征 | 收益判断 | | --- | --- | --- | | 长 System Prompt + 大量规则 | 长且稳定 | 高 | | Agent 的工具/函数定义 | 长且稳定 | 高 | | RAG:同一批文档被多问题反复问 | 长且相对稳定 | 高(把文档放前、问题放后) | | 多轮会话 | 前缀随轮次增长 | 中到高(历史天然是前缀) | | 短 Prompt(几十 Token) | 短 | 低,收益有限 | | 每次都换 System Prompt | 不稳定 | 无 | 实践要点: 1. **按"变化频率"排序拼接**:最不变的排最前,最易变的排最后。这是前缀缓存的唯一核心原则。 2. **不要为了缓存牺牲可读性**:把时间戳等动态信息放到最后一段或用户消息里,而不是删掉。 3. **缓存有生命周期**:供应商侧的缓存通常有存活时间,**具体时长与计费规则需结合厂商版本与文档确认**;低频请求可能"还没命中就过期了"。 4. **前缀缓存与语义缓存叠加**:前者省"每次都一样的部分",后者省"整个请求",两者互不冲突。 ### Q:除了缓存,还有哪些真正有效的降本手段? A:结论先行——**按收益从高到低依次是:模型分级路由 > 结果复用(缓存)> Token 预算与截断 > 批量合并 > 流式提前终止 > Prompt 瘦身。** 顺序不要乱。 **手段一:模型分级路由。** 核心思想是"简单问题给小模型,复杂问题给大模型"。判定依据可以是规则(意图分类、问题长度、是否命中 FAQ)、小模型自评(先让小模型试答并给出置信度),或历史统计(该意图的模型效果对比)。  *图:用户请求的路由与降级链* ```text 用户请求 │ ├─ 规则命中(FAQ/固定指令)──▶ 直接走缓存或小模型 │ ├─ 意图分类(小模型/轻量分类器) │ ├─ 简单 ─▶ 小模型;结果不达标再升级 │ └─ 复杂 ─▶ 大模型 │ └─ 降级链:主模型不可用 ─▶ 备用供应商 ─▶ 小模型兜底 ─▶ 固定话术 ``` 注意"**小模型兜底 + 大模型兜底**"是两件事: - **小模型兜底**:绝大多数请求由小模型承接,成本基础盘立刻下降。 - **大模型兜底**:当小模型结果被判定为不合格(自评低、格式校验失败、答案过短)时,升级到大模型重试一次,保证质量下限。 路由规则建议做成**配置驱动**,而不是写死在代码里,这样调参不需要发版: ```yaml # 模型分级路由配置(示意) route: - name: faq-exact when: "intent in ('greeting','faq_lookup')" action: cache_or_template # 最省:命中缓存/模板,不调模型 - name: simple-qa when: "tokenEstimate < 800 and intent in ('summary','rewrite')" model: small maxOutputTokens: 512 escalateOn: [lowConfidence, formatInvalid] # 不达标自动升级 - name: complex-qa when: "intent in ('reasoning','code','analysis')" model: large maxOutputTokens: 2048 - name: fallback when: "providerUnavailable or budgetExceeded" action: degrade # 按场景决定降级到哪个备用供应商或固定话术 ``` 配置驱动的好处是:**成本策略可以按租户、按场景灰度**,出问题时能一键回滚,而不是回滚代码发布。 **手段二:结果复用(缓存)。** 见前文,精确缓存 + 语义缓存 + 前缀缓存三层叠加。 **手段三:Token 预算与截断。** 为核心链路设定硬预算: | 预算项 | 控制方式 | | --- | --- | | 单次输入上限 | 超长则裁剪历史、减少召回片段 | | 单次输出上限 | 设置最大输出长度,避免无限生成 | | 单会话累计上限 | 超过阈值后降级为摘要 + 短上下文 | | 单用户/单租户日预算 | 超预算后限流或降级模型 | 多轮会话的截断必须"保头保尾":保留 System Prompt 与最早的目标设定,保留最近若干轮,中间历史压缩成摘要。直接砍掉中间会让模型丢失关键约束。 **手段四:批量(Batch)。** 把非实时任务(离线标注、数据清洗、批量摘要)合并提交,部分供应商对批量通道有折扣。**是否支持、折扣多少需结合厂商确认**。适用边界:**只适合非交互场景**,用户等待的请求不要走批量。 **手段五:流式提前终止。** 在流式输出中,一旦检测到已满足业务需求(例如已输出完整 JSON、已命中关键词、已生成足够长度的摘要),就主动断开连接,避免为"多余的礼貌用语"付费。前提是用的流式接口本身支持中断且计费按实际生成量,**具体计费口径需确认**。 **手段六:Prompt 瘦身。** 排在最后,因为它的收益是百分比级,而前几项是数量级。做法:去掉冗余示例、用结构化短指令替代长段自然语言、把重复规则抽成一次性的工具定义。 ### Q:降本和降质怎么平衡? A:结论先行——**用"分层质量目标"来平衡:不同场景允许不同下限,贵的资源只花在真正需要它的场景上。** | 场景类型 | 质量下限 | 允许的降本手段 | | --- | --- | --- | | 闲聊/引导语 | 低 | 小模型、模板、缓存全开 | | 内部工具(草稿、摘要) | 中 | 小模型优先,差评后再升级 | | 面向客户的问答 | 高 | 大模型为主,缓存 + 前缀缓存 | | 合规/法务/财务 | 最高 | 不做语义缓存,禁用降级链的"模板兜底" | **关键原则:降级链的终点不能是"胡说八道的模板"。** 宁可明确说"当前无法回答,请稍后重试",也不要给一个看起来像答案的错误答案。 ## 四、成本可观测 ### Q:成本怎么归因和告警? A:结论先行——**成本可观测的前提是"每一次调用都带得走归因维度",即每条 LLM 调用记录里必须有租户、用户、业务场景、模型、Prompt 版本、输入/输出 Token 数。缺任何一个维度,都只能看总账单,无法优化。** 推荐埋点字段: | 字段 | 用途 | | --- | --- | | `traceId` | 串联一次请求内的多次模型调用 | | `tenantId` / `userId` | 按租户、用户归因 | | `bizScene` | 按业务场景归因(客服/摘要/推荐…) | | `modelId` / `modelVersion` | 模型档位与版本,成本与质量对比的基准 | | `promptVersion` | Prompt 变更的影响面 | | `inputTokens` / `outputTokens` | 计费基础与异常检测 | | `cachedTokens` | 前缀命中量,验证缓存是否真的生效 | | `cacheHit` / `cacheType` | 精确/语义/前缀命中标记 | | `latencyMs` / `firstTokenMs` | 延迟与首字延迟 | | `retryCount` | 重试放大系数 | | `status` / `errorCode` | 失败率与失败类型 | 告警阈值建议按"相对变化"设,而不是拍绝对值:  *图:成本、token、租户、缓存、重试、首字延迟六项告警* ```text 1) 单位时间总成本环比昨日同时段涨幅 > X% → 成本告警 2) 单请求平均 token 数环比涨幅 > X% → 上下文失控信号 3) 某租户成本占比 > X%(与其流量占比严重不匹配) → 资源倾斜排查 4) 缓存命中率环比下降 > X% → 缓存失效/Prompt 改动 5) 重试率 > X% → 供应商不稳或超时过短 6) 首字延迟 P95 环比涨幅 > X% → 供应商或链路问题 ``` 阈值里的 X 必须用自己业务的历史波动定,**不要照搬任何"业界值"**。 看板建议分三层:**总览(今日成本/预算百分比/趋势)→ 归因(按租户/场景/模型下钻)→ 明细(单请求成本与 Token 明细,可跳日志)**。没有下钻能力的看板等于没有看板。 ## 五、工程实践与踩坑 **坑 1:缓存污染(Cache Poisoning)。** 第一种是被错误答案污染:某次模型抽风返回了乱码,被写进语义缓存,之后所有相似问题都返回这个乱码。防护:**回写前做格式/长度/敏感词校验,拒绝写入低质量答案**;对写入的答案打上模型版本,版本升级后按需失效。 第二种是被人为污染:攻击者构造大量相似问题,把缓存"占满"或植入错误答案。防护:**缓存键带租户,写入频率限流,对异常写入模式告警**。 **坑 2:权限串号。** 最严重的一类事故:A 租户问"我们公司年假多少天",缓存命中 B 租户的答案。根因通常是**向量检索没做租户过滤,或过滤发生在取回之后**。防护:分区键前置、实体比对、上线前的跨租户用例回归。**这条必须在设计阶段解决,事后补救成本极高。** **坑 3:命中率虚高。** 只看命中了多少次,不看答得对不对。防护:**命中率必须与"命中后满意度/人工抽检通过率"配对监控**;一旦发现"命中率上升但投诉率也上升",立即收紧阈值。 **坑 4:缓存与多轮会话冲突。** 语义缓存本质是"无状态"的,而多轮会话是"有状态"的。如果第 3 轮的问题恰好与某条历史单轮问题相似,命中后直接返回了单轮答案,就会丢失前文语境。防护:**会话内不做跨轮语义缓存**,或者缓存键里带上"会话摘要指纹",只允许语义相同且上下文等价时命中。 **坑 5:缓存雪崩与击穿。** 批量设置的 TTL 同时到期,大量请求同时打向模型;或热点键失效瞬间所有请求穿透。防护:**TTL 加随机抖动**;热点问题用单飞(singleflight / 分布式锁)保证只回源一次,其余请求等待结果。 **坑 6:把"省钱"做到了用户体验上。** 把最大输出长度设得过小,导致答案被截断;或把语义缓存阈值放松到命中即答,用户拿到"看起来像但不是"的答案。防护:**成本优化的每一个开关都要有"体验护栏指标"(截断率、追问率、差评率)陪跑。** **坑 7:重试放大成本。** 超时时间设得过短 → 大量超时重试 → 成本翻倍 + 供应商压力翻倍。防护:**超时时间按 P99 设定并留余量;重试必须有退避与上限;重试请求不要重复计费到用户账单口径**。 **坑 8:成本归因缺失,最后只能砍功能。** 没有按场景归因时,唯一的降本手段就是"砍功能"。防护:**在第一个版本就把归因字段埋好**,成本可观测的投入是复利。 **坑 9:前缀缓存被"顺手"破坏。** 某次迭代在 System Prompt 开头加了一行"当前时间",命中率瞬间归零,且没有任何告警。防护:**把 Prompt 结构纳入版本管理与回归,缓存命中率作为发布门禁指标之一。** ## 小结 - 成本 = 次数 × 长度 × 单价;失控来自放大器(多轮上下文膨胀、召回过多、重试叠加),不是单价本身。 - 精确缓存零风险低命中,语义缓存高命中高风险,二者分层叠加,且语义缓存必须配实体抽取与租户隔离。 - 前缀缓存只认"逐字节一致的最长前缀",拼接顺序按"变化频率升序",是把长 System Prompt 与 RAG 长上下文变便宜的最直接手段。 - 降本优先序:模型分级路由 → 结果复用 → Token 预算 → 批量 → 流式提前终止 → Prompt 瘦身。顺序反了就是花大力气省小钱。 - 成本可观测的关键是"每次调用都带得走归因维度",并把缓存命中率与"命中后满意度"配对监控。 - 所有涉及成本/命中率的阈值、TTL、相似度门槛,都必须用自己业务的数据回归得出;不要抄数字,也不要写死默认值。 ## 思考题 1. 你的业务里,"多轮上下文"占输入 Token 的比例大概是多少?如果对它做"保头保尾 + 中间摘要",你预计能省多少(写出计算模型)? 2. 语义缓存的相似度阈值如何用离线评测确定?请描述你需要的正负样本与评估指标。 3. 如果供应商不支持提示词前缀缓存,你会怎么在应用层模拟"前缀稳定"带来的收益? 4. 设计一套"成本告警",要求既能发现总成本异常,也能定位到具体租户/场景/模型版本,请列出你要监控的指标与下钻路径。 5. 语义缓存与多轮会话天然冲突,你会选择"禁用跨轮语义缓存"还是"把上下文指纹写进缓存键"?各自的代价是什么? 6. 降级链的终点如果是固定话术,什么样的场景可以接受、什么样的场景绝对不能接受?请给出判断标准。
预览
发布文章
添加摘要让读者更快了解文章内容
取消
确认发布
AI 写作助手
输入一个主题,AI 将为你生成一篇 Markdown 博客文章
AI 正在写作中...
取消
开始生成
AI 优化助手
描述你的修改需求,AI 将在原文基础上进行补充或微调
AI 正在优化中...
取消
开始优化
画布
从已有图里选
✕
图名
保存后生成 /images/excalidraw/<图名>.svg(只能用字母、数字、短横线、下划线、点)
取消
保存并插入