🎯 今日核心问题

  1. 哪些任务值得用最强模型,哪些任务用最小模型就够?拿什么作为路由依据?
  2. 语义缓存的命中率能到多少,误命中的代价是什么,阈值怎么定?
  3. System Prompt 从 1800 token 压到 600 token,是靠删字,还是靠换结构?

📖 精读提纲

【一】降级的正确形态是「分级路由」,不是「降级兜底」

很多人把模型降级理解成「主模型挂了才换便宜模型」,这是错的——那是故障转移,省钱效果几乎为零。真正的省法叫分级路由(tiered routing):请求进来先判定复杂度,直接派给对应档位的模型,一档不够再往上抬。

路由依据不应该是「让模型自己判断难度」(又一次模型调用,还未必准),而应该是廉价可判定的信号:意图分类器(小模型或规则,10ms 内出结果)、历史平均步数、Prompt 长度、是否命中已知模板、是否涉及金额/权限类工具。经验上 70% 的流量是可模板化的简单任务,20% 是标准多步任务,10% 才是需要强推理的硬骨头。

【二】具体策略表:什么任务用什么档位

还有一个反直觉的点: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 个点就回滚。

🔖 明日预告

成本压下来了,接下来保证它不会悄悄失控:哪些异常必须立刻知道(连续失败、步数暴涨、成本越界、缓存命中率崩塌),以及告警怎么设计才不被忽略。