任务类型	建议模型	理由
简单意图识别、关键词提取	小模型（Haiku、mini 系列）	任务简单，便宜就够
文档摘要、格式化处理	中等模型	需要一定理解能力
复杂分析、多步推理	大模型	需要最强能力
代码生成	专门代码模型	专业模型效果更好

实际项目中，大约 60-70% 的请求可以用便宜的小模型处理，只有 20-30% 需要大模型。这样整体成本可以降低 50-70%。

缓存策略

对于重复性高的查询，做查询缓存：

@Service
public class CachedLLMService {

    private final ChatClient chatClient;
    private final RedisTemplate<String, String> redisTemplate;

    // 缓存时间：24小时（知识类内容变化不频繁）
    private static final long CACHE_TTL_SECONDS = 24 * 60 * 60;

    // 相似度阈值：用于语义缓存（相似问题复用缓存）
    private final VectorStore cacheIndexStore;

    /**
     * 带缓存的LLM调用
     * 精确缓存：完全相同的问题直接返回缓存
     * 语义缓存：相似度足够高的问题复用缓存（可选）
     */
    public String cachedCall(String prompt, String cacheKey) {
        // 1. 精确缓存查找
        String exactCacheKey = "llm:exact:" + DigestUtils.md5Hex(prompt);
        String cachedResponse = redisTemplate.opsForValue().get(exactCacheKey);
        if (cachedResponse != null) {
            log.debug("Cache hit (exact) for key: {}", cacheKey);
            return cachedResponse;
        }

        // 2. 语义缓存查找（相似度 > 0.95 才复用）
        List<Document> semanticCacheHits = cacheIndexStore.similaritySearch(
            SearchRequest.query(prompt)
                .withTopK(1)
                .withSimilarityThreshold(0.95)
        );
        
        if (!semanticCacheHits.isEmpty()) {
            String semanticCachedResponse = semanticCacheHits.get(0)
                .getMetadata().get("response").toString();
            log.debug("Cache hit (semantic) for key: {}", cacheKey);
            return semanticCachedResponse;
        }

        // 3. 缓存未命中：调用LLM
        String response = chatClient.prompt()
            .user(prompt)
            .call()
            .content();

        // 4. 写入精确缓存
        redisTemplate.opsForValue().set(exactCacheKey, response, 
            CACHE_TTL_SECONDS, TimeUnit.SECONDS);
        
        // 5. 更新语义缓存索引
        Document cacheDoc = new Document(prompt, 
            Map.of("response", response, "cache_key", cacheKey));
        cacheIndexStore.add(List.of(cacheDoc));

        return response;
    }

    /**
     * 批量处理：多个文档合并成一次LLM调用
     * 适合批量摘要、批量分类等场景
     */
    public List<String> batchProcess(List<String> items, String instruction) {
        // 把多个小任务合并成一次调用
        // 适合 token 少的任务，能减少调用次数（降低成本）
        if (items.size() <= 5) {
            String batchPrompt = buildBatchPrompt(items, instruction);
            String batchResponse = chatClient.prompt()
                .user(batchPrompt)
                .call()
                .content();
            return parseBatchResponse(batchResponse, items.size());
        } else {
            // 超过5个，分批处理
            List<List<String>> batches = Lists.partition(items, 5);
            return batches.stream()
                .flatMap(batch -> batchProcess(batch, instruction).stream())
                .collect(Collectors.toList());
        }
    }

    private String buildBatchPrompt(List<String> items, String instruction) {
        StringBuilder sb = new StringBuilder();
        sb.append(instruction).append("\n\n");
        sb.append("请按顺序处理以下").append(items.size()).append("条内容，");
        sb.append("每条用「---」分隔：\n\n");
        for (int i = 0; i < items.size(); i++) {
            sb.append("【").append(i + 1).append("】\n");
            sb.append(items.get(i)).append("\n---\n");
        }
        return sb.toString();
    }
}

缓存策略的效果：在知识库问答场景里，相同或相似的问题占总查询量的 30-40%，缓存后这部分成本降为零。整体成本通常可以降低 20-35%。

Prompt 优化降低 Token 消耗

系统提示词要精简：系统提示词每次调用都要计费，200 字和 2000 字，成本差 10 倍。把系统提示词压缩到最精简，删掉冗余说明。

上下文窗口控制：RAG 检索到的文档，不是越多越好，多了不仅成本高，反而可能降低质量（上下文太长，LLM 注意力分散）。控制在 4-8 个文档片段，而不是 15-20 个。

输出长度控制：明确告诉 LLM「输出不超过 200 字」，避免生成冗长的不必要内容。

什么场景适合轻量化本地模型

本地小模型有一个根本性的劣势：能力不如大模型。但有些场景，能力要求不高，本地模型完全够用：

适合本地小模型的场景

文本分类和意图识别：判断一段文本属于哪个类别（比如客服问题分类），对模型能力要求不高，1-3B 的小模型完全可以胜任。

简单信息提取：从非结构化文本中提取特定字段（日期、金额、地名），这类任务模式规律，小模型效果不错。

批量文本处理：大量文档的格式化、清洗、摘要，对单条质量要求不极端高，但量大，本地处理更经济。

敏感数据场景：涉及员工数据、客户隐私、商业机密的场景，不方便走外网，本地模型是唯一选项。

轻量化部署方案

不需要 GPU，一台配置较好的服务器（16-32GB 内存，多核 CPU）就可以跑小型量化模型：

Ollama：最简单的本地模型部署方案，安装后一条命令就能跑常见模型：

# 安装后直接拉取并运行
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama serve

量化模型：选择 Q4 量化版本，大幅减少内存需求。Qwen2.5-7B 原始版本需要 14GB 显存，Q4 量化后只需要约 5GB 内存，普通 CPU 服务器可以运行（慢一些，但能用）。

Spring AI 集成本地模型：

@Configuration
public class LocalModelConfig {

    @Bean
    public ChatClient localChatClient() {
        // 连接本地 Ollama 服务
        OllamaChatModel ollamaModel = OllamaChatModel.builder()
            .baseUrl("http://localhost:11434")
            .model("qwen2.5:7b-instruct-q4_K_M")
            .options(OllamaOptions.builder()
                .temperature(0.1)   // 低温度，输出更稳定
                .numCtx(4096)       // 上下文窗口
                .build())
            .build();
        
        return ChatClient.builder(ollamaModel).build();
    }
}