> **摘要**: 简单 FAQ 用 hunyuan-pro 太贵(¥0.02/千Token),复杂推理用 hunyuan-lite 又不够。本文实现 SpringAI 多模型路由,按意图复杂度自动选择模型档位(pro/standard/lite),混元异常时降级到备用模型。路由后日均 Token 成本降低 64%,同时复杂问题解决率不降。

**适用版本**: SpringBoot 3.3.x / SpringAI 1.0.x / 混元 hunyuan-pro/standard/lite / JDK 17+


## 一、背景:单一模型的成本与能力矛盾

第 7 篇用 `hunyuan-pro` 实现了 Function Calling,但全量切到 pro 后账单吓人——pro 的价格是 lite 的 10 倍:

| 模型 | 价格(每千Token) | 能力 | 适用场景 |
|------|----------------|------|---------|
| hunyuan-pro | ¥0.02 | 最强,支持 Function Calling | 复杂推理、工具调用 |
| hunyuan-standard | ¥0.008 | 通用对话 | 常规客服对话 |
| hunyuan-lite | ¥0.002 | 基础问答 | 简单 FAQ、高频调用 |

日均 12000 轮对话,如果全用 pro,月成本 ¥7200;全用 lite,月成本 ¥720。但 lite 扛不住复杂问题,pro 又浪费在简单问题上。

需求明确:**按问题复杂度路由到合适的模型档位,兼顾成本和能力**。

![008-springai-multi-model-routing 图 1](https://developer.qcloudimg.com/http-save/yehe-2059497/9945caaf900cfb70ff16abbaab8d190a.png)


## 二、多 ChatModel 配置

### 2.1 三个模型档位配置

**【为什么需要这段配置】** SpringAI 的 OpenAI starter 默认只配一个 ChatModel,多模型需要用 `@Bean` 注册多个 `OpenAiChatModel`,每个指向不同模型档位。`@Qualifier` 按名称注入对应模型。

```java
@Configuration
public class MultiModelConfig {

    @Bean
    @Qualifier("proModel")
    public ChatModel proChatModel(
            @Value("${spring.ai.openai.chat.options.api-key}") String apiKey) {
        var api = OpenAiApi.builder()
            .baseUrl("https://api.hunyuan.cloud.tencent.com/v1")
            .apiKey(apiKey)
            .build();
        return OpenAiChatModel.builder()
            .openAiApi(api)
            .defaultOptions(OpenAiChatOptions.builder()
                .model("hunyuan-pro")
                .temperature(0.3)
                .maxTokens(1024)
                .build())
            .build();
    }

    @Bean
    @Qualifier("standardModel")
    public ChatModel standardChatModel(
            @Value("${spring.ai.openai.chat.options.api-key}") String apiKey) {
        var api = OpenAiApi.builder()
            .baseUrl("https://api.hunyuan.cloud.tencent.com/v1")
            .apiKey(apiKey)
            .build();
        return OpenAiChatModel.builder()
            .openAiApi(api)
            .defaultOptions(OpenAiChatOptions.builder()
                .model("hunyuan-standard")
                .temperature(0.3)
                .maxTokens(1024)
                .build())
            .build();
    }

    @Bean
    @Qualifier("liteModel")
    public ChatModel liteChatModel(
            @Value("${spring.ai.openai.chat.options.api-key}") String apiKey) {
        var api = OpenAiApi.builder()
            .baseUrl("https://api.hunyuan.cloud.tencent.com/v1")
            .apiKey(apiKey)
            .build();
        return OpenAiChatModel.builder()
            .openAiApi(api)
            .defaultOptions(OpenAiChatOptions.builder()
                .model("hunyuan-lite")
                .temperature(0.3)
                .maxTokens(512)
                .build())
            .build();
    }
}
```


## 三、复杂度评估与模型路由

### 3.1 复杂度评估 Service

**【为什么需要这段代码】** 用 lite 模型做复杂度评估(它便宜且快),输出 SIMPLE/MEDIUM/COMPLEX 三个等级。评估本身只消耗几十 Token,成本可忽略。也可以用第 2 篇的意图分类结果做路由依据。

```java
@Service
public class ComplexityRouterService {

    private final ChatModel liteModel; // 用 lite 做评估,最便宜
    private final ChatModel standardModel;
    private final ChatModel proModel;

    public ComplexityRouterService(
            @Qualifier("liteModel") ChatModel liteModel,
            @Qualifier("standardModel") ChatModel standardModel,
            @Qualifier("proModel") ChatModel proModel) {
        this.liteModel = liteModel;
        this.standardModel = standardModel;
        this.proModel = proModel;
    }

    /**
     * 评估问题复杂度,返回对应模型
     */
    public ChatModel routeModel(String userMessage) {
        String evalPrompt = """
            判断以下客服问题的复杂度,只输出一个词:
            - SIMPLE: 简单FAQ,如"退货政策""运费多少"
            - MEDIUM: 需要理解上下文,如"空调不制冷怎么办"
            - COMPLEX: 需要推理或调用工具,如"查订单CS001并退款"

            问题: %s
            """.formatted(userMessage);

        ChatClient evalClient = ChatClient.create(liteModel);
        String level = evalClient.prompt()
            .user(evalPrompt)
            .call()
            .content()
            .trim()
            .toUpperCase();

        return switch (level) {
            case "SIMPLE" -> liteModel;
            case "MEDIUM" -> standardModel;
            case "COMPLEX" -> proModel;
            default -> standardModel; // 评估失败用默认
        };
    }
}
```

### 3.2 路由对话 Controller

**【为什么需要这段代码】** 路由的核心:先评估复杂度,选对应模型,再用该模型构建 ChatClient 调用。Function Calling 场景强制用 pro(只有 pro 支持)。异常时降级到 standard。

```java
@RestController
@RequestMapping("/api/route")
public class ModelRouterController {

    private final ComplexityRouterService routerService;
    private final ChatModel standardModel; // 降级用

    public ModelRouterController(ComplexityRouterService routerService,
                                  @Qualifier("standardModel") ChatModel standardModel) {
        this.routerService = routerService;
        this.standardModel = standardModel;
    }

    @PostMapping("/chat")
    public ChatResponse routedChat(@RequestBody ChatRequest request) {
        // 1. 评估复杂度,选择模型
        ChatModel selectedModel = routerService.routeModel(request.message());

        // 2. 用选中的模型构建 ChatClient
        ChatClient chatClient = ChatClient.create(selectedModel);

        try {
            String response = chatClient.prompt()
                .system("你是电商客服,回答简洁友好。")
                .user(request.message())
                .call()
                .content();

            return new ChatResponse(response, getModelName(selectedModel));

        } catch (Exception e) {
            // 3. 主模型异常,降级到 standard
            ChatClient fallback = ChatClient.create(standardModel);
            String response = fallback.prompt()
                .system("你是电商客服,回答简洁友好。")
                .user(request.message())
                .call()
                .content();

            return new ChatResponse(response, "hunyuan-standard(fallback)");
        }
    }

    private String getModelName(ChatModel model) {
        // 从模型获取名称(用于日志和响应)
        return model.getDefaultOptions().getModel();
    }
}

record ChatResponse(String reply, String modelUsed) {}
```

![008-springai-multi-model-routing 图 2](https://developer.qcloudimg.com/http-save/yehe-2059497/7ac8620725017f658b1c47c29f73e0ee.png)


## 四、降级策略

### 4.1 三级降级链

**【为什么需要这段代码】** 生产环境不能只有一个降级目标。pro 挂了降 standard,standard 也挂了降 lite,lite 都挂了返回兜底话术。`RetryTemplate` 加重试,避免偶发抖动直接触发降级。

```java
@Service
public class FallbackChatService {

    private final ChatModel proModel;
    private final ChatModel standardModel;
    private final ChatModel liteModel;

    private static final String SYSTEM = "你是电商客服,回答简洁友好。";
    private static final String FALLBACK_REPLY = "系统暂时繁忙,请稍后再试或拨打客服热线 400-xxx-xxxx";

    /**
     * 三级降级: pro → standard → lite → 兜底话术
     */
    public ChatResult chatWithFallback(String userMessage) {
        // 1. 尝试 pro
        try {
            String reply = chat(proModel, userMessage);
            return new ChatResult(reply, "hunyuan-pro", true);
        } catch (Exception e) {
            log.warn("pro 调用失败,降级到 standard", e);
        }

        // 2. 尝试 standard
        try {
            String reply = chat(standardModel, userMessage);
            return new ChatResult(reply, "hunyuan-standard", true);
        } catch (Exception e) {
            log.warn("standard 调用失败,降级到 lite", e);
        }

        // 3. 尝试 lite
        try {
            String reply = chat(liteModel, userMessage);
            return new ChatResult(reply, "hunyuan-lite", true);
        } catch (Exception e) {
            log.error("所有模型均不可用", e);
        }

        // 4. 兜底话术
        return new ChatResult(FALLBACK_REPLY, "fallback", false);
    }

    private String chat(ChatModel model, String message) {
        return ChatClient.create(model).prompt()
            .system(SYSTEM)
            .user(message)
            .call()
            .content();
    }
}
```


## 五、成本对比

### 路由前后成本对比

日均 12000 轮对话,按复杂度分布:

| 复杂度 | 占比 | 轮数 | 路由前(全 pro) | 路由后(分档) | 节省 |
|--------|------|------|---------------|-------------|------|
| SIMPLE | 50% | 6000 | ¥0.02 × 6000 = ¥120 | ¥0.002 × 6000 = ¥12 | ¥108 |
| MEDIUM | 35% | 4200 | ¥0.02 × 4200 = ¥84 | ¥0.008 × 4200 = ¥33.6 | ¥50.4 |
| COMPLEX | 15% | 1800 | ¥0.02 × 1800 = ¥36 | ¥0.02 × 1800 = ¥36 | ¥0 |
| **日均** | — | 12000 | **¥240** | **¥81.6** | **¥158.4(↓66%)** |
| **月均** | — | — | **¥7200** | **¥2448** | **¥4752** |

路由后月成本从 ¥7200 降到 ¥2448,节省 ¥4752,降幅 66%。复杂问题仍用 pro,解决率不降。

![008-springai-multi-model-routing 图 3](https://developer.qcloudimg.com/http-save/yehe-2059497/c845ea420ead7ad8c8d7a3a5f32c4057.png)


## 六、踩坑实录

### 1:复杂度评估本身消耗大量 Token

**现象**: 路由后总 Token 消耗没降多少,因为每次都要调 lite 评估复杂度。

**定位**: 评估 Prompt 太长(200+ Token),每轮对话额外消耗 200 Token。

> **解决**: 精简评估 Prompt 到 50 Token 内;或用第 2 篇的意图分类结果做路由依据(意图分类本来就要做,不额外消耗)。最优方案:Function Calling 意图 → pro,咨询意图 → standard,简单 FAQ 关键词 → lite,用规则预筛掉 50% 的简单问题不走评估。

### 2:降级后 Function Calling 丢失

**现象**: pro 异常降级到 standard,但 standard 不支持 Function Calling,用户说"查订单CS001"得到编造回复。

**定位**: 降级时没考虑能力差异,standard 不支持 @Tool。

> **解决**: 降级到 standard 时,如果是工具调用场景,改为回复"系统暂时繁忙,您的请求已记录,客服将人工处理",而非让 standard 尝试回答。

### 3:多 ChatModel Bean 注入冲突

**现象**: 启动报 `NoUniqueBeanDefinitionException`,多个 ChatModel Bean 冲突。

**定位**: SpringAI 的自动配置也会注册一个 ChatModel,和自定义的 3 个 Bean 冲突。

> **解决**: 在启动类排除 SpringAI 的自动配置:`@SpringBootApplication(exclude = {OpenAiChatAutoConfiguration.class})`,完全用手动配置的 3 个 Bean。


## 七、总结与下一篇预告

### 本文核心

1. **多模型路由**按复杂度选 pro/standard/lite,月成本降低 66%
2. **三级降级链** pro → standard → lite → 兜底话术,保证可用性
3. **复杂度评估**用 lite 模型(最便宜)或复用意图分类结果
4. 降级时注意能力差异(standard 不支持 Function Calling)

### 下一篇预告

下一篇《SpringAI Token 成本治理:用量统计 + 缓存 + CLS 监控告警》解决"Token 账单看不懂、异常消耗无告警"的问题:

- Token 用量统计与 CLS 推送
- 语义缓存(相似问题不重复调混元)
- Token 成本告警规则
- 缓存命中率与成本对比


> **真实性声明**: 本文基于混元 hunyuan-pro/standard/lite 三档模型实测。成本数据按混元官方定价计算,复杂度分布来自 12000 轮真实客服对话统计。


> 👍 如果本文对你有帮助,欢迎点赞、收藏、转发!
> 💬 有任何问题或建议,请在评论区留言交流~

**专栏导航**:

- 📖 **上一篇**: [SpringAI Function Calling:工单系统](https://cloud.tencent.com/developer/article/2755035)
- 📖 **下一篇**: SpringAI Token 成本治理

摘要: 简单 FAQ 用 hunyuan-pro 太贵(¥0.02/千Token),复杂推理用 hunyuan-lite 又不够。本文实现 SpringAI 多模型路由,按意图复杂度自动选择模型档位(pro/standard/lite),混元异常时降级到备用模型。路由后日均 Token 成本降低 64%,同时复杂问题解决率不降。

SpringAI 多模型路由:混元主模型与备用降级策略实战

简单 FAQ 用 hunyuan-pro 太贵(¥0.02/千Token),复杂推理用 hunyuan-lite 又不够。本文实现 SpringAI 多模型路由,按意图复杂度自动选择模型档位(pro/standard/lite),混元异常时降级到备用模型。路由后日均 Token 成本降低 64%,同时复杂问题解决率不降。

算法

本文介绍SpringAI多模型路由方案，按问题复杂度自动选择hunyuan-pro/standard/lite三档模型，混元异常时降级备用。经实测，月成本降低66%，复杂问题解决率不降。附带三级降级链与踩坑实录，适用于SpringBoot3.3.x及JDK17+。

代码解释

路由

2026上云采购 | AI焕新·智启新局

tclm

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

SpringAI 多模型路由:混元主模型与备用降级策略实战-腾讯云开发者社区-腾讯云

SpringAI 多模型路由:混元主模型与备用降级策略实战

SpringAI 多模型路由:混元主模型与备用降级策略实战

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐