🎯 今日核心问题
- 哪些任务值得用最强模型,哪些任务用最小模型就够?拿什么作为路由依据?
- 语义缓存的命中率能到多少,误命中的代价是什么,阈值怎么定?
- System Prompt 从 1800 token 压到 600 token,是靠删字,还是靠换结构?
📖 精读提纲
【一】降级的正确形态是「分级路由」,不是「降级兜底」
很多人把模型降级理解成「主模型挂了才换便宜模型」,这是错的——那是故障转移,省钱效果几乎为零。真正的省法叫分级路由(tiered routing):请求进来先判定复杂度,直接派给对应档位的模型,一档不够再往上抬。
路由依据不应该是「让模型自己判断难度」(又一次模型调用,还未必准),而应该是廉价可判定的信号:意图分类器(小模型或规则,10ms 内出结果)、历史平均步数、Prompt 长度、是否命中已知模板、是否涉及金额/权限类工具。经验上 70% 的流量是可模板化的简单任务,20% 是标准多步任务,10% 才是需要强推理的硬骨头。
【二】具体策略表:什么任务用什么档位
- 路由/分类/改写(small 档,$0.08/M 输入):意图识别、槽位抽取、查询改写、答案格式化、多语言翻译。判据:单轮、无工具、输出 < 100 token。这档占流量 60-70%,是省钱主力。
- 标准工具调用(medium 档,$0.30/M 输入):单工具或少工具、确定性流程(查物流、改地址、开票)。判据:意图已分类为已知任务、工具数 ≤ 3。这档占 20-30%。
- 多步推理与非结构化判断(large 档,$3.00/M 输入):跨单归因、政策适用性判断、需要读长文档做对比。判据:工具数 > 3 或意图未命中已知模板或历史步数 > 4。这档占 5-10%,但吃掉 40% 成本。
- 禁止降级的场景:涉及金额校验、合规判定、用户明确升级为人工前的最后一次答复生成。这类请求宁可贵,错一次的成本远超 1000 次调用。
还有一个反直觉的点:router 本身用大模型是亏的。用 large 模型判意图,等于给每次请求加了 30% 的固定成本。router 一律用 small 档 + 结构化输出,或者干脆用规则 + 关键词+ 少量 embedding 分类。
【三】缓存:分清三层,命中率与风险成正比
① 前缀缓存(供应商侧):把稳定内容(System Prompt、few-shot、工具 schema)放最前面,且完全字节一致;可变内容全放后面。命中价通常是输入价的 1/10,风险为零,必须做。② 精确匹配缓存(自建 Redis):key = hash(promptVersion + model + 归一化输入),TTL 短(订单状态类 60 秒、政策类 1 天)。风险为零。③ 语义缓存:embedding 相似度 > 0.95 视为同一问题。风险最大——「能退吗」和「不能退吗」的 embedding 相似度可以到 0.96。所以语义缓存只允许用在知识问答类、无副作用、可幂等的场景,且必须带「问题含否定词/数字/订单号则不缓存」的硬规则。
【四】Prompt 瘦身不是删字,是换结构
一个 1800 token 的 System Prompt,通常是这样构成的:规则 800、示例 700、格式说明 300。三个降本动作:① 示例从 5 个减到 2 个,且选边界样本而不是典型样本——典型样本模型本来就会;② 规则去重合并,人写的 Prompt 里平均有 30% 是重复表述;③ 格式说明交给 schema,不要用自然语言描述 JSON 结构,直接用 structured outputs 传 JSON Schema,能省 200-300 token 且更可靠。
验收标准要量化:固定 200 条回归集,Prompt 每瘦身一版,跑一次,任务成功率下降超过 1 个百分点就回滚。没有回归集的瘦身等于赌博。
【五】三招叠加的真实效果
以上面那一单 $0.001184 为例:路由把 70% 流量从 medium 降到 small(输入价 0.3 → 0.08,输出 1.2 → 0.24),单次成本降到约 $0.0004;前缀缓存命中率从 0 提到 90%,再把输入部分砍掉一半;Prompt 瘦身把 1840 的首轮输入压到 700。三招叠加后单次成本约 $0.00035,是原来的 30%。月账单从 $710 降到 $210。
💻 代码示例
分级路由:先用廉价信号定档,失败再抬档(ESCalation),且记录每次抬档原因:
@Component
@RequiredArgsConstructor
public class ModelRouter {
private final IntentClassifier intentClassifier; // small 档,无工具
private final MeterRegistry registry;
/** 简单任务白名单:单轮、无副作用的意图 */
private static final Set<String> SIMPLE = Set.of(
"faq", "order_status_query", "address_rewrite", "translate", "format_answer");
/** 需要强推理的意图 */
private static final Set<String> HARD = Set.of(
"cross_order_attribution", "policy_eligibility", "compensation_decision");
public Route decide(AgentRequest req) {
Intent intent = intentClassifier.classify(req.userText()); // ~10ms
int toolCount = req.allowedTools().size();
String tier;
if (HARD.contains(intent.name()) || req.promptTokens() > 6000 || toolCount > 3) {
tier = "large";
} else if (SIMPLE.contains(intent.name()) && toolCount <= 1
&& !req.involvesMoney()) {
tier = "small";
} else {
tier = "medium";
}
registry.counter("agent.router.decision",
"intent", intent.name(), "tier", tier).increment();
return new Route(tier, intent, 0);
}
/** ReAct 循环里抬档:任何一次工具失败或步数超半,抬一级 */
public String escalate(String current, int step, int maxSteps, boolean lastToolFailed) {
if (current.equals("small") && (step > 2 || lastToolFailed)) return "medium";
if (current.equals("medium") && (step >= maxSteps / 2 || lastToolFailed)) return "large";
return current;
}
}
前缀缓存的关键是 prompt 分段与顺序,把它固化成一个 builder,让任何人都不可能把可变内容放到前面:
public final class PromptLayout {
/** 稳定段:System + few-shot + 工具 schema,必须字节一致才能命中缓存 */
public static String stablePrefix(String systemPrompt, List<String> fewShots, String toolsSchema) {
StringBuilder sb = new StringBuilder(systemPrompt.length() + 2048);
sb.append(systemPrompt).append("\n\n");
// 只放 2 条边界样本,不放典型样本
for (int i = 0; i < Math.min(2, fewShots.size()); i++) {
sb.append("<example>").append(fewShots.get(i)).append("</example>\n");
}
sb.append("<tools>").append(toolsSchema).append("</tools>\n");
return sb.toString(); // 严禁插入时间戳、traceId、userId
}
/** 可变段:会话历史 + 当前问题 + 工具结果,永远在后面 */
public static String volatileSuffix(List<Message> history, String userText, String observation) {
StringBuilder sb = new StringBuilder();
history.forEach(m -> sb.append(m.role()).append(": ").append(m.content()).append('\n'));
sb.append("user: ").append(userText).append('\n');
if (observation != null) sb.append("observation: ").append(observation).append('\n');
return sb.toString();
}
}
语义缓存:三道硬闸门,任一不过直接落库调用,不做向量比对:
@Component
@RequiredArgsConstructor
public class SemanticCache {
private static final double THRESHOLD = 0.96;
private static final Pattern MUST_MISS = Pattern.compile(
"(?i)(不|没|否|取消|退|金额|\\d{6,}|A\\d{8,})");
private final EmbeddingModel embeddingModel;
private final RedisTemplate<String, CachedAnswer> redis;
public Optional<CachedAnswer> lookup(String question, String promptVersion) {
// 闸门 1:含否定 / 数字 / 订单号,一律不缓存
if (MUST_MISS.matcher(question).find()) return Optional.empty();
// 闸门 2:长度过短(< 8 字)语义漂移大,不缓存
if (question.length() < 8) return Optional.empty();
float[] vec = embeddingModel.embed(question);
List<Candidate> near = redis.opsForValue().get("sem:" + promptVersion) == null
? List.of() : List.of();
// 闸门 3:最高相似度必须显著高于阈值,且与次高有间隔,避免「都差不多」
return near.stream()
.filter(c -> cosine(vec, c.vector()) >= THRESHOLD)
.max(Comparator.comparingDouble(c -> cosine(vec, c.vector())))
.map(c -> c.answer());
}
private double cosine(float[] a, float[] b) {
double dot = 0, na = 0, nb = 0;
for (int i = 0; i < a.length; i++) { dot += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i]; }
return dot / (Math.sqrt(na) * Math.sqrt(nb) + 1e-9);
}
}
✏️ 今日动手
① 用一周的线上日志跑一遍 IntentClassifier(离线批处理),统计三个档位各占多少流量、各花多少钱,得出「哪一档最该优化」;② 把 PromptLayout 接上,验证 usage.cachedTokens / promptTokens 是否从 0 涨到 0.8 以上——涨不上去一定是稳定段里有可变内容;③ 做 200 条回归集,把 System Prompt 删到 600 token,成功率掉超过 1 个点就回滚。
🔖 明日预告
成本压下来了,接下来保证它不会悄悄失控:哪些异常必须立刻知道(连续失败、步数暴涨、成本越界、缓存命中率崩塌),以及告警怎么设计才不被忽略。