返回专栏
· 25 分钟阅读

多模型接入与模型路由:构建统一、灵活、可扩展的大模型服务架构


一、为什么需要多模型接入与模型路由?

大模型应用早期通常只接入一个模型服务。

例如,应用通过一个 API 调用 GPT 或其他模型,完成文本生成、问答和内容处理。

这种方式实现简单,但随着业务发展,会逐渐暴露出一些问题:

  • 模型能力差异:不同模型在推理、编码、数学、长文本和多模态任务上的表现不同。
  • 供应商依赖:单一模型供应商出现故障,可能导致整个应用不可用。
  • 成本差异:不同模型的输入、输出 Token 价格存在差异。
  • 延迟差异:不同模型的响应速度、排队时间和吞吐能力不同。
  • 上下文窗口差异:不同模型支持的最大输入长度不同。
  • 协议差异:不同供应商的 API 参数、消息格式、工具调用和流式事件并不完全一致。
  • 模型更新频繁:模型版本、能力、价格和服务状态可能发生变化。

因此,生产级 AI 应用通常不会将业务代码直接绑定到某一个模型 API,而是构建统一的模型接入层,并通过模型路由管理不同模型。

整体架构可以分为两个核心部分:

模块 主要职责
多模型接入 Multi-Model Integration 统一接入不同供应商和自部署模型
模型路由 Model Routing 根据请求特征和运行状态选择合适模型

两者的关系是:多模型接入解决模型如何被调用,模型路由解决应该调用哪个模型。

二、多模型接入:统一不同模型的调用方式

2.1 什么是多模型接入?

多模型接入是指在同一个应用或平台中,接入多个不同来源、不同架构、不同能力的大模型,并通过统一接口进行管理和调用。

模型来源通常包括:

类型 代表模型或平台 接入方式
商业模型 API OpenAI、Anthropic、Google 云端 API
国内模型 API Qwen、DeepSeek、豆包等 云端 API
云厂商模型平台 AWS Bedrock、Azure AI 等 云平台统一接口
开源模型 Llama、Qwen、DeepSeek 等开放权重模型 自行部署或托管推理
企业私有模型 企业内部微调模型 私有化推理服务

这里需要区分模型与模型服务:

  • 模型是提供推理能力的参数化模型。
  • 模型服务是将模型部署并通过接口提供调用能力的系统。
  • 模型供应商负责提供模型 API 或托管推理服务。
  • 模型网关负责统一管理多个模型服务的接入与调用。

例如,Qwen 既可以通过云端 API 调用,也可以使用开放权重版本自行部署。两种方式使用的模型可能相关,但服务地址、运行环境、权限管理和运维责任不同。

2.2 多模型接入的基本架构

典型架构如下:

flowchart TB
    A["业务应用"] --> B["统一模型接入层"]
    B --> C["模型适配器"]
    C --> D["OpenAI API"]
    C --> E["Anthropic API"]
    C --> F["Google API"]
    C --> G["国内模型 API"]
    C --> H["自部署模型服务"]

    D --> I["模型服务"]
    E --> J["模型服务"]
    F --> K["模型服务"]
    G --> L["模型服务"]
    H --> M["推理引擎"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#EAF3EC,stroke:#83A995,color:#315D49
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#EAF3EC,stroke:#83A995,color:#315D49
    style M fill:#EAF3EC,stroke:#83A995,color:#315D49

业务应用不需要直接了解每个供应商的底层协议,而是通过统一接入层发起请求。

统一接入层负责:

  • 管理模型配置。
  • 维护供应商连接信息。
  • 转换请求和响应格式。
  • 处理认证和密钥。
  • 统一超时和错误处理。
  • 统一流式响应接口。
  • 管理模型能力与版本信息。
  • 提供调用日志和监控指标。

2.3 为什么不能只统一 API 地址?

不同模型供应商即使提供相似的 API,也不意味着它们完全兼容。

例如,常见的差异包括:

维度 可能存在的差异
Endpoint 请求地址不同
Authentication API Key、OAuth 或云平台凭证
Message Format 消息结构不同
Role 支持的角色和语义不同
Sampling Temperature、Top P 等参数支持范围不同
Tool Calling 工具定义、调用结果格式不同
Structured Output JSON Schema 支持程度不同
Streaming SSE 事件结构和结束标记不同
Multimodal 图片、音频和视频输入格式不同
Error 错误码和限流信息不同
Usage Token 使用量统计字段不同

因此,统一接入不应该只把不同供应商的 URL 替换成一个配置项。

真正的统一接入需要建立协议适配层。

三、模型适配器:屏蔽供应商协议差异

3.1 什么是 Model Adapter?

Model Adapter(模型适配器)是连接统一模型接口与具体模型供应商 API 的组件。

它负责将应用内部的标准请求转换成供应商所需的请求格式,并将供应商响应转换成统一格式。

典型结构:

flowchart TB
    A["统一模型请求"] --> B["模型适配器"]
    B --> C["供应商请求格式转换"]
    C --> D["调用供应商 API"]
    D --> E["接收原始响应"]
    E --> F["响应格式转换"]
    F --> G["统一模型响应"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style E fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#DCEFE5,stroke:#4F8B70,color:#24563F

适配器的核心目标是:

将供应商特定的协议差异限制在适配器内部,而不是让这些差异扩散到业务代码中。

3.2 统一请求模型

可以先定义一套应用内部的标准请求结构。

例如:

from dataclasses import dataclass, field
from typing import Any, Optional

@dataclass
class Message:
    role: str
    content: Any

@dataclass
class ModelRequest:
    model: str
    messages: list[Message]

    temperature: Optional[float] = None
    top_p: Optional[float] = None
    max_tokens: Optional[int] = None

    tools: list[dict] = field(default_factory=list)
    response_format: Optional[dict] = None

    stream: bool = False
    metadata: dict = field(default_factory=dict)

这里的 ModelRequest 是应用内部的数据模型,不代表所有供应商都支持其中的全部字段。

适配器需要根据目标模型的能力进行转换:

  • 支持的字段正常映射。
  • 不支持的字段明确拒绝、忽略或使用经过验证的兼容处理。
  • 不应该静默改变请求语义。
  • 对有损转换应当记录或返回明确状态。

例如,某个模型不支持指定的 JSON Schema 约束,就不能假装已经实现了同等结构化输出能力。

3.3 统一响应模型

不同模型 API 的响应结构不同,但应用可以抽象出统一的响应对象。

from dataclasses import dataclass, field
from typing import Any, Optional

@dataclass
class Usage:
    input_tokens: Optional[int] = None
    output_tokens: Optional[int] = None
    total_tokens: Optional[int] = None

@dataclass
class ModelResponse:
    model: str
    content: Any

    finish_reason: Optional[str] = None
    usage: Optional[Usage] = None

    tool_calls: list[dict] = field(default_factory=list)
    provider_request_id: Optional[str] = None
    metadata: dict = field(default_factory=dict)

其中:

  • model:实际使用的模型标识。
  • content:模型生成的内容。
  • finish_reason:生成结束原因。
  • usage:Token 使用情况。
  • tool_calls:工具调用请求。
  • provider_request_id:供应商请求追踪标识。
  • metadata:供应商特定的扩展信息。

统一响应不意味着必须丢弃所有供应商信息。

生产系统应保留必要的原始响应或扩展字段,以便排查问题和使用供应商特有能力。

3.4 适配器接口设计

可以定义统一的模型接口:

from abc import ABC, abstractmethod

class ModelAdapter(ABC):

    @abstractmethod
    def generate(self, request):
        pass

    @abstractmethod
    def stream(self, request):
        pass

    @abstractmethod
    def get_capabilities(self):
        pass

不同供应商分别实现:

class OpenAIAdapter(ModelAdapter):

    def generate(self, request):
        # 转换为对应供应商的请求格式
        # 调用模型 API
        # 将响应转换为统一格式
        pass

    def stream(self, request):
        # 处理供应商流式事件
        # 转换为统一事件
        pass

    def get_capabilities(self):
        return {
            "streaming": True,
            "tool_calling": True,
            "structured_output": True
        }

其他供应商实现相同接口:

class AnthropicAdapter(ModelAdapter):
    pass


class GeminiAdapter(ModelAdapter):
    pass


class LocalModelAdapter(ModelAdapter):
    pass

示例中的能力值只是接口设计示意,真实能力必须根据具体模型、版本和部署配置确定。

3.5 不要过度抽象供应商差异

统一接口有价值,但过度抽象也会产生问题。

例如:

  • 把不同模型的工具调用格式强行压缩成过于简单的数据结构。
  • 把不同的多模态输入统一成无法表达差异的字符串。
  • 忽略供应商特有的缓存控制参数。
  • 将不同的推理参数统一成语义不明确的字段。
  • 将不同流式事件直接拼接成文本。

更合理的设计是采用两层结构:

  1. 公共能力层:统一大多数业务都会使用的功能。
  2. 供应商扩展层:保留特定模型的高级参数和特殊能力。

例如:

request = ModelRequest(
    model="provider-a/model-x",
    messages=[],
    metadata={
        "provider_options": {
            "specific_parameter": "value"
        }
    }
)

扩展字段应经过适配器白名单校验,避免随意传入不受控制的参数。

四、模型注册中心:统一管理可用模型

4.1 什么是 Model Registry?

Model Registry(模型注册中心)是用于管理模型元数据、供应商配置、能力信息和运行状态的组件。

它回答几个关键问题:

  • 系统接入了哪些模型?
  • 每个模型属于哪个供应商?
  • 模型对应哪个 API Endpoint?
  • 模型支持哪些能力?
  • 模型价格是多少?
  • 模型上下文窗口多大?
  • 模型当前是否可用?
  • 模型是否允许某类业务调用?

4.2 模型元数据

一个模型注册记录可以包含:

{
  "model_id": "provider-a/model-x",
  "provider": "provider-a",
  "provider_model_id": "model-x",
  "endpoint": "https://api.example.com/v1",
  "capabilities": {
    "text_generation": true,
    "streaming": true,
    "tool_calling": true,
    "structured_output": true,
    "vision": false
  },
  "context_window": 128000,
  "status": "active",
  "priority": 10
}

这是一个内部配置示例,并非任何真实供应商的标准格式。

常见元数据可以分为以下几类:

分类 字段
基础信息 Model ID、名称、供应商、版本
接入信息 Endpoint、认证方式、适配器类型
能力信息 工具调用、结构化输出、多模态、流式
性能信息 上下文窗口、最大输出长度、吞吐能力
成本信息 输入价格、输出价格、缓存价格
运行状态 可用状态、健康状态、错误率
路由配置 优先级、权重、业务标签
安全配置 数据区域、权限等级、合规要求

价格、能力和上下文窗口都可能发生变化,因此不应该只在代码中写死。

4.3 模型能力矩阵

模型路由不能只根据模型名称进行判断。

应该维护能力矩阵:

能力 模型 A 模型 B 模型 C
文本生成 支持 支持 支持
流式响应 支持 支持 支持
工具调用 支持 支持 不支持
JSON Schema 支持 部分支持 不支持
图片理解 支持 支持 不支持
音频输入 支持 部分支持 不支持
长上下文 支持 支持 有限制
高级推理 支持 支持 有限制

这里的 A、B、C 是抽象模型。具体能力应按实际模型版本进行验证。

能力矩阵的价值在于:

路由器可以先排除不满足任务要求的模型,再从候选模型中进行成本和性能优化。

例如,用户上传图片要求分析时,不应该将请求路由到只支持纯文本的模型。

五、模型路由:根据任务选择合适的模型

5.1 什么是 Model Routing?

模型路由(Model Routing)是指根据请求特征、模型能力、成本、延迟和服务状态,动态选择一个或多个模型执行任务的机制。

可以将其理解为 AI 应用中的智能调度层。

传统业务路由主要根据 URL、请求参数或服务地址选择后端。

模型路由则需要额外理解:

  • 用户任务是什么。
  • 请求复杂度有多高。
  • 需要什么模型能力。
  • 允许多少推理成本。
  • 对响应时间有什么要求。
  • 哪些模型当前可用。
  • 是否需要满足特定数据安全要求。

5.2 模型路由的基本流程

flowchart TD
    A["接收用户请求"] --> B["解析请求特征"]
    B --> C["识别任务类型"]
    C --> D["获取模型候选列表"]
    D --> E["能力过滤"]
    E --> F["可用性过滤"]
    F --> G["成本与延迟评估"]
    G --> H["选择目标模型"]
    H --> I["调用模型适配器"]
    I --> J["返回模型结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style F fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F

路由过程通常分为四个阶段:

  1. 请求理解:提取任务类型、输入长度、输出要求和业务约束。
  2. 候选筛选:根据能力、权限和服务状态排除不合适的模型。
  3. 模型评分:计算候选模型的综合适配程度。
  4. 模型选择:选择目标模型,并通过对应适配器调用。

六、模型路由策略

不同业务对成本、质量和延迟的要求不同,因此需要采用不同的路由策略。

6.1 固定路由 Static Routing

固定路由是最简单的方式。

通过配置指定某类业务始终使用某个模型。

例如:

MODEL_ROUTING = {
    "classification": "model-small",
    "chat": "model-medium",
    "reasoning": "model-large",
    "code": "model-code"
}

优点:

  • 实现简单。
  • 行为可预测。
  • 便于测试和排查。
  • 不需要复杂的模型评估逻辑。

缺点:

  • 无法根据实时服务状态动态调整。
  • 不能充分利用不同模型的价格和性能差异。
  • 模型升级后需要调整配置。

适用场景:

  • 业务类型明确。
  • 模型数量较少。
  • 对可预测性要求较高。
  • 初期系统建设。

6.2 基于任务类型的路由

不同任务适合不同模型。

例如:

任务类型 路由目标
简单分类 低成本模型
文本摘要 通用文本模型
代码生成 编程能力较强的模型
数学推理 推理能力较强的模型
图片理解 支持视觉输入的模型
音频转写 支持音频输入的模型
长文档分析 支持长上下文的模型
工具调用 工具调用能力符合要求的模型

任务路由通常需要先进行任务分类。

例如:

flowchart TD
    A["用户请求"] --> B["任务分类"]
    B --> C{"任务类型"}
    C -->|"简单分类"| D["轻量模型"]
    C -->|"代码生成"| E["代码模型"]
    C -->|"复杂推理"| F["推理模型"]
    C -->|"图片理解"| G["视觉模型"]
    C -->|"长文档分析"| H["长上下文模型"]
    D --> I["统一响应"]
    E --> I
    F --> I
    G --> I
    H --> I

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#EAF3EC,stroke:#83A995,color:#315D49
    style G fill:#EAF3EC,stroke:#83A995,color:#315D49
    style H fill:#EAF3EC,stroke:#83A995,color:#315D49
    style I fill:#DCEFE5,stroke:#4F8B70,color:#24563F

需要注意,任务分类本身也可能使用模型。

如果为了选择模型,先调用一个高成本模型进行分类,路由带来的成本收益可能被抵消。

可以考虑:

  • 规则分类。
  • 轻量模型分类。
  • 基于请求元数据分类。
  • 业务系统显式指定任务类型。
  • 多种方法组合。

6.3 基于成本的路由

不同模型的价格可能相差很大。

假设系统有三个候选模型:

模型 输入价格(示意) 输出价格(示意) 能力定位
Model A 低 低 简单任务
Model B 中 中 通用任务
Model C 高 高 复杂推理

对于简单问题,使用 Model C 可能没有必要。

可以设置成本预算:

def select_model(task, candidates):
    if task.complexity == "simple":
        return candidates["low_cost"]

    if task.complexity == "complex":
        return candidates["high_capability"]

    return candidates["balanced"]

成本路由的关键不是永远选择最便宜的模型,而是在满足质量要求的前提下,选择成本更低的模型。

需要考虑:

  • 输入 Token 价格。
  • 输出 Token 价格。
  • 缓存 Token 价格。
  • 预期输出长度。
  • 重试成本。
  • 工具调用成本。
  • 模型调用次数。

一次请求的模型成本可以近似表示为:

C = \frac{T_{in}}{10^6}P_{in} + \frac{T_{out}}{10^6}P_{out}

其中:

  • T_{in}:输入 Token 数量。
  • T_{out}:输出 Token 数量。
  • P_{in}:每百万输入 Token 的价格。
  • P_{out}:每百万输出 Token 的价格。

实际费用还可能包含缓存、图片、音频、视频等额外计费项,应以供应商实际计费规则为准。

6.4 基于延迟的路由

某些场景对响应时间非常敏感。

例如:

  • 实时语音交互。
  • 在线客服。
  • 代码补全。
  • 实时推荐。
  • 用户界面中的即时问答。

可以根据模型的历史延迟选择模型。

常见指标:

指标 含义
TTFT 首个输出 Token 的等待时间
TPOT 每个输出 Token 的平均生成时间
Total Latency 整体响应时间
Queue Latency 排队等待时间
P50 中位延迟
P95 95 分位延迟
P99 99 分位延迟

不要只使用平均延迟。

平均值可能掩盖长尾请求。例如,绝大多数请求很快,但少量请求非常慢,依然会严重影响用户体验。

更合理的路由策略可以根据 P95 或 P99 延迟判断模型服务是否满足 SLA。

6.5 基于质量的路由

不同模型在不同任务上的表现并不一致。

例如:

  • 模型 A 的代码生成能力较强。
  • 模型 B 的中文表达更自然。
  • 模型 C 的数学推理表现更好。
  • 模型 D 的结构化输出更稳定。

可以通过离线评估建立任务与模型的质量映射。

例如:

任务 评估指标
文本分类 Accuracy、Precision、Recall、F1
信息抽取 字段准确率、完整率
代码生成 单元测试通过率
数学推理 最终答案准确率
RAG 问答 Context Recall、Faithfulness
JSON 输出 Schema 合规率
工具调用 参数准确率、任务成功率

质量路由不能仅依赖模型排行榜。

真正重要的是模型在目标业务数据集上的表现。

6.6 基于规则的组合路由

生产系统通常会综合多种条件。

例如:

def route(request, models):

    candidates = [
        model for model in models
        if model.enabled
        and model.supports(request.required_capabilities)
        and model.context_window >= request.input_tokens
        and model.health_status == "healthy"
    ]

    if not candidates:
        raise RuntimeError("没有符合要求的可用模型")

    if request.priority == "low_cost":
        candidates.sort(key=lambda m: m.estimated_cost)

    elif request.priority == "low_latency":
        candidates.sort(key=lambda m: m.p95_latency)

    elif request.priority == "high_quality":
        candidates.sort(
            key=lambda m: m.quality_score,
            reverse=True
        )

    return candidates[0]

这是简化的路由示例。

生产系统还需要考虑:

  • 多目标约束。
  • 数据区域限制。
  • 模型并发配额。
  • 供应商健康状态。
  • 价格变化。
  • 请求超时预算。
  • 模型能力验证。
  • 候选模型评分数据的时效性。

七、模型评分与多目标优化

7.1 为什么需要综合评分?

模型路由经常需要同时考虑:

  • 模型质量。
  • 调用成本。
  • 响应延迟。
  • 服务可用性。
  • 任务匹配程度。

这些指标之间存在冲突。

例如:

  • 高质量模型可能更贵。
  • 低成本模型可能推理能力较弱。
  • 低延迟模型可能上下文窗口较小。
  • 某个模型效果很好,但当前服务不可用。

因此,可以建立综合评分机制。

7.2 加权评分模型

假设将各项指标归一化到 0 到 1:

Score(m)= w_q Q(m) + w_c C(m) + w_l L(m) + w_a A(m)

其中:

  • Q(m):模型质量得分。
  • C(m):成本得分。
  • L(m):延迟得分。
  • A(m):可用性得分。
  • w_q,w_c,w_l,w_a:各指标权重。

权重需要满足:

w_q+w_c+w_l+w_a=1

例如:

weights = {
    "quality": 0.4,
    "cost": 0.2,
    "latency": 0.2,
    "availability": 0.2
}

这只是示意配置,不代表通用最佳权重。

还需要注意,原始成本和延迟是越低越好,不能直接与质量分数相加。

需要先进行归一化,例如:

C(m)=1-\frac{Cost(m)}{Cost_{\max}}
L(m)=1-\frac{Latency(m)}{Latency_{\max}}

并对超出约束的模型直接排除,避免归一化后仍然被错误选中。

7.3 先约束,再评分

生产环境中更推荐两阶段决策:

第一阶段:硬约束过滤。

  • 模型必须支持所需能力。
  • 输入不能超过上下文窗口。
  • 必须满足数据区域要求。
  • 模型必须处于可用状态。
  • 预计成本不能超过预算。
  • 延迟不能超过业务上限。

第二阶段:软目标评分。

  • 质量越高越好。
  • 成本越低越好。
  • 延迟越低越好。
  • 可用性越高越好。

这种方式比直接给所有模型计算一个分数更安全。

八、智能模型路由:让模型参与模型选择

8.1 什么是 LLM-based Routing?

传统路由通常依赖规则和固定配置。

智能模型路由则可以使用一个轻量级模型分析用户请求,判断任务类型和复杂度,再选择适合的目标模型。

例如:

用户请求:
请分析这段 Rust 代码中的并发安全问题。

路由模型输出:
{
  "task": "code_analysis",
  "complexity": "high",
  "required_capabilities": [
    "code_reasoning"
  ],
  "priority": "quality"
}

路由系统根据这些信息选择合适的模型。

8.2 智能路由架构

flowchart TD
    A["用户请求"] --> B["轻量路由模型"]
    B --> C["任务类型识别"]
    C --> D["复杂度评估"]
    D --> E["能力需求提取"]
    E --> F["生成路由决策"]
    F --> G["模型注册中心"]
    G --> H["候选模型筛选"]
    H --> I["成本与性能评估"]
    I --> J["选择目标模型"]
    J --> K["执行实际任务"]
    K --> L["返回结果"]

    style A fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style B fill:#EAF3EC,stroke:#83A995,color:#315D49
    style C fill:#EAF3EC,stroke:#83A995,color:#315D49
    style D fill:#EAF3EC,stroke:#83A995,color:#315D49
    style E fill:#EAF3EC,stroke:#83A995,color:#315D49
    style F fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style G fill:#F5F8F4,stroke:#B5CBBB,color:#40594A
    style H fill:#F7F4E8,stroke:#C7B77A,color:#675A2D
    style I fill:#EAF3EC,stroke:#83A995,color:#315D49
    style J fill:#DCEFE5,stroke:#4F8B70,color:#24563F
    style K fill:#EAF3EC,stroke:#83A995,color:#315D49
    style L fill:#DCEFE5,stroke:#4F8B70,color:#24563F

8.3 智能路由的优点

  • 可以理解自然语言请求。
  • 能够识别复杂任务和多种能力需求。
  • 能够适应不同表达方式。
  • 可以根据任务类型动态选择模型。
  • 可以将复杂请求拆分成不同子任务。

8.4 智能路由的风险

第一,路由本身也有成本。

如果每个请求都需要先调用一个模型分类,可能增加 Token 消耗和延迟。

第二,路由模型也可能判断错误。

例如,将复杂代码审查错误识别为简单文本问答,导致选择能力不足的模型。

第三,路由模型可能受到 Prompt Injection 影响。

用户可以在请求中加入诱导内容,试图影响模型选择。

第四,路由结果不应该拥有无限权限。

模型可以提出路由建议,但最终选择必须受到服务端能力白名单、成本预算、权限和可用性约束。

因此,生产系统通常采用:

  • 规则预筛选。
  • 轻量模型分类。
  • 服务端约束校验。
  • 确定性模型选择。

不能完全依赖路由模型自由决定调用哪个外部服务。

九、Fallback Routing:主模型故障时自动切换

9.1 什么是 Fallback Routing?

Fallback Routing(备用路由)是指当首选模型无法正常提供服务时,自动选择其他符合条件的模型继续处理请求。

可能触发切换的原因:

  • 连接超时。
  • HTTP 429 限流。
  • HTTP 500、502、503 等服务异常。
  • 模型服务不可用。
  • 当前模型超过延迟预算。
  • 模型能力不满足实际请求。
  • 供应商区域故障。