AI工具

OpenRouter API 深度调研：多模型统一接入方案

2026年2月1日|花叔

OpenRouterAPIAI模型LLM开发工具

OpenRouter API 深度调研报告

调研日期：2026-02-08 信息来源：OpenRouter 官方文档、社区指南、第三方评测

1. API 基础配置

Base URL

https://openrouter.ai/api/v1

完全兼容 OpenAI API 格式，可以直接用 openai Python SDK 调用。

认证方式

Authorization: Bearer sk-or-v1-xxxxxxxxxxxxxxxx

API Key 在 https://openrouter.ai/settings/keys 创建。

可选 Headers（推荐加上）

Header	用途	示例
`HTTP-Referer`	标识你的应用，用于 OpenRouter 排行榜	`https://your-app.com`
`X-Title`	应用名称，显示在排行榜	`My AI App`

主要 Endpoint

方法	路径	用途
POST	`/chat/completions`	聊天补全（核心）
GET	`/models`	获取所有可用模型
GET	`/generation?id={ID}`	查询生成记录和费用
GET	`/key`	查询 API Key 余额和用量

2. 2026年初热门模型与价格

价格单位：$/百万 tokens（输入/输出）

顶级模型

模型 ID	输入价格	输出价格	上下文	特点
`openai/gpt-5.3-codex`	$3	$12	-	OpenAI 最强编码模型，自我改进
`anthropic/claude-opus-4.6`	$5	$25	-	Anthropic 旗舰，agentic 能力增强
`openai/gpt-5.2`	$1.75	$14	400K	自适应推理
`anthropic/claude-sonnet-4`	$3	$15	200K	性价比高的智能模型

性价比之选

模型 ID	输入价格	输出价格	上下文	特点
`google/gemini-3-flash-preview`	$0.50	$3	1M	超长上下文，接近 Pro 推理
`deepseek/deepseek-chat-v3-0324`	$0.25	$0.38	-	接近 GPT-4o 性能，极低价格
`minimax/minimax-m2.1`	$0.28	$1.20	-	SWE-Bench 72.5%，超低成本

免费模型

模型 ID	特点
`xiaomi/mimo-v2-flash`	309B MoE，匹配 Claude Sonnet 4.5
`mistralai/devstral-2-2512`	开源 agentic 编码，256K 上下文
`nvidia/nemotron-3-nano`	30B MoE，256K 上下文
`deepseek/deepseek-v3.1-nex-n1`	Agent 优化，131K 上下文

价格区间总览

层级	价格范围	代表模型
免费	$0	MiMo, Devstral 2, Nemotron
超低	$0.05-$0.50	DeepSeek, ByteDance Seed
预算	$0.50-$5	Gemini Flash, GPT-4o Mini
标准	$5-$25	GPT-5.2, Claude Sonnet
旗舰	$12-$200+	GPT-5.3 Codex, Claude Opus

3. Python 调用完整示例

3.1 基础调用

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.getenv("OPENROUTER_API_KEY"),
    default_headers={
        "HTTP-Referer": "https://your-app.com",
        "X-Title": "Your App Name",
    }
)

completion = client.chat.completions.create(
    model="google/gemini-3-flash-preview",
    messages=[
        {"role": "system", "content": "你是一个有帮助的助手。"},
        {"role": "user", "content": "解释一下什么是 Transformer 架构？"},
    ],
    max_tokens=2048,
    temperature=0.7,
)

print(completion.choices[0].message.content)

3.2 流式输出

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.getenv("OPENROUTER_API_KEY"),
)

stream = client.chat.completions.create(
    model="anthropic/claude-sonnet-4",
    messages=[
        {"role": "user", "content": "写一首关于编程的短诗"},
    ],
    stream=True,
)

for chunk in stream:
    content = chunk.choices[0].delta.content
    if content:
        print(content, end="", flush=True)
print()  # 换行

3.3 多模态：图片输入

import os
import base64
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.getenv("OPENROUTER_API_KEY"),
)

# 方法1：URL 图片
completion = client.chat.completions.create(
    model="google/gemini-3-flash-preview",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "描述这张图片的内容"},
            {
                "type": "image_url",
                "image_url": {"url": "https://example.com/photo.jpg"}
            }
        ]
    }],
)

# 方法2：本地图片（Base64 编码）
def encode_image(image_path: str) -> str:
    with open(image_path, "rb") as f:
        return base64.b64encode(f.read()).decode("utf-8")

base64_image = encode_image("./screenshot.png")

completion = client.chat.completions.create(
    model="google/gemini-3-flash-preview",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "这张截图里有什么？"},
            {
                "type": "image_url",
                "image_url": {"url": f"data:image/png;base64,{base64_image}"}
            }
        ]
    }],
)

print(completion.choices[0].message.content)

支持的图片格式：image/png、image/jpeg、image/webp、image/gif

建议：先放文本 prompt，再放图片，效果更好。

3.4 多模态：视频输入

# 视频输入需要支持视频的模型（如 Gemini 3）
# 使用 video_url content type

completion = client.chat.completions.create(
    model="google/gemini-3-flash-preview",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "总结这个视频的内容"},
            {
                "type": "video_url",
                "video_url": {"url": "https://example.com/video.mp4"}
            }
        ]
    }],
)

注意：视频输入目前仅通过 API 支持，OpenRouter 聊天界面暂不支持。OpenRouter 只会将视频 URL 转发给明确支持视频的 provider。

3.5 工具调用（Function Calling）

import os
import json
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.getenv("OPENROUTER_API_KEY"),
)

# 定义工具
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称，如「北京」「上海」"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "温度单位"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

# 实际的工具实现
def get_weather(city: str, unit: str = "celsius") -> dict:
    # 这里替换成真实 API 调用
    return {"city": city, "temperature": 22, "unit": unit, "condition": "晴"}

TOOL_MAPPING = {
    "get_weather": get_weather,
}

# 第1轮：发送用户消息 + 工具定义
messages = [
    {"role": "user", "content": "北京今天天气怎么样？"}
]

response = client.chat.completions.create(
    model="google/gemini-3-flash-preview",
    messages=messages,
    tools=tools,
    tool_choice="auto",  # 让模型决定是否调用工具
)

assistant_message = response.choices[0].message

# 第2轮：如果模型要调用工具，执行工具并返回结果
if assistant_message.tool_calls:
    messages.append(assistant_message)

    for tool_call in assistant_message.tool_calls:
        tool_name = tool_call.function.name
        tool_args = json.loads(tool_call.function.arguments)

        # 执行工具
        tool_result = TOOL_MAPPING[tool_name](**tool_args)

        # 将工具结果添加到消息
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(tool_result, ensure_ascii=False),
        })

    # 第3轮：让模型基于工具结果生成最终回复
    final_response = client.chat.completions.create(
        model="google/gemini-3-flash-preview",
        messages=messages,
        tools=tools,
    )

    print(final_response.choices[0].message.content)
else:
    print(assistant_message.content)

tool_choice 选项

# 让模型自动决定（默认）
tool_choice="auto"

# 禁止调用工具
tool_choice="none"

# 强制调用指定工具
tool_choice={"type": "function", "function": {"name": "get_weather"}}

3.6 Agentic 循环（自动多轮工具调用）

def call_llm(messages: list, tools: list) -> dict:
    """调用 LLM 并将回复追加到消息列表"""
    resp = client.chat.completions.create(
        model="google/gemini-3-flash-preview",
        tools=tools,
        messages=messages,
    )
    messages.append(resp.choices[0].message)
    return resp


def execute_tool_calls(response, messages: list) -> None:
    """执行工具调用并将结果追加到消息列表"""
    for tool_call in response.choices[0].message.tool_calls:
        tool_name = tool_call.function.name
        tool_args = json.loads(tool_call.function.arguments)
        tool_result = TOOL_MAPPING[tool_name](**tool_args)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(tool_result, ensure_ascii=False),
        })


# Agentic 循环
MAX_ITERATIONS = 10
iteration = 0

while iteration < MAX_ITERATIONS:
    iteration += 1
    resp = call_llm(messages, tools)

    if resp.choices[0].message.tool_calls:
        execute_tool_calls(resp, messages)
    else:
        break

if iteration >= MAX_ITERATIONS:
    print("警告：达到最大迭代次数")

print(messages[-1].content)

4. 特殊功能

4.1 模型路由与 Fallback

OpenRouter 最强大的特性之一：你可以指定多个模型，自动故障转移。

# 使用 extra_body 传递 OpenRouter 特有参数
completion = client.chat.completions.create(
    model="anthropic/claude-sonnet-4",  # 主模型
    messages=[{"role": "user", "content": "Hello"}],
    extra_body={
        "models": [
            "anthropic/claude-sonnet-4",
            "openai/gpt-5.2",
            "google/gemini-3-flash-preview",
        ],
        "route": "fallback",  # 启用 fallback 模式
    },
)

# 检查实际使用的模型
print(f"实际使用模型: {completion.model}")

触发 Fallback 的条件：

上下文长度超限
内容审核过滤
速率限制
Provider 宕机
5xx 错误

费用按实际使用的模型计价。

4.2 Provider 路由控制

精细控制请求路由到哪些 Provider。

completion = client.chat.completions.create(
    model="anthropic/claude-sonnet-4",
    messages=[{"role": "user", "content": "Hello"}],
    extra_body={
        "provider": {
            # 指定 provider 优先顺序
            "order": ["anthropic", "aws-bedrock", "gcp-vertex"],

            # 允许 fallback 到其他 provider（默认 true）
            "allow_fallbacks": True,

            # 只路由到支持请求中所有参数的 provider
            "require_parameters": True,

            # 数据隐私：只用不保留数据的 provider
            "data_collection": "deny",

            # 零数据保留
            "zdr": True,

            # 按价格/吞吐量/延迟排序
            "sort": "price",  # 或 "throughput" 或 "latency"

            # 量化过滤
            "quantizations": ["fp16", "bf16"],

            # 最低吞吐量要求（tokens/秒）
            "preferred_min_throughput": {"p90": 50},

            # 最大延迟要求
            "preferred_max_latency": {"p90": 1000},

            # 最高价格限制（$/百万 tokens）
            "max_price": {"prompt": 5, "completion": 15},
        }
    },
)

快捷方式：在模型 ID 后面加后缀

anthropic/claude-sonnet-4:nitro — 优先吞吐量
anthropic/claude-sonnet-4:floor — 优先最低价格

4.3 Plugins（插件系统）

# Web 搜索插件 — 让任何模型都能联网搜索
completion = client.chat.completions.create(
    model="anthropic/claude-sonnet-4",
    messages=[{"role": "user", "content": "2026年春节是哪天？"}],
    extra_body={
        "plugins": [{"id": "web"}]
    },
)

# 或者直接在模型名加 :online
completion = client.chat.completions.create(
    model="anthropic/claude-sonnet-4:online",
    messages=[{"role": "user", "content": "2026年春节是哪天？"}],
)

可用插件：

插件	用途
`web`	联网搜索（Anthropic/OpenAI 用原生搜索，其他用 Exa）
`file-parser`	PDF 文件解析
`response-healing`	自动修复 JSON 格式错误（非流式请求有效）

4.4 结构化输出

completion = client.chat.completions.create(
    model="openai/gpt-5.2",
    messages=[{"role": "user", "content": "列出3种编程语言的特点"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "languages",
            "schema": {
                "type": "object",
                "properties": {
                    "languages": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {"type": "string"},
                                "features": {
                                    "type": "array",
                                    "items": {"type": "string"}
                                }
                            }
                        }
                    }
                }
            }
        }
    },
    extra_body={
        "plugins": [{"id": "response-healing"}]  # 自动修复 JSON 错误
    },
)

4.5 调试模式

# 流式请求中查看发送给 provider 的实际参数
stream = client.chat.completions.create(
    model="anthropic/claude-sonnet-4",
    messages=[{"role": "user", "content": "test"}],
    stream=True,
    extra_body={
        "debug": {"echo_upstream_body": True}
    },
)

注意：仅在 stream=True 时生效，不要在生产环境使用。

5. 错误处理与最佳实践

5.1 错误码速查

HTTP 状态码	含义	处理方式
400	参数错误 / CORS	检查请求参数
401	认证失败	检查 API Key
402	余额不足	充值
403	内容被审核过滤	修改内容
408	超时	重试或换模型
429	速率限制	指数退避重试
502	Provider 不可用	自动 fallback 或重试
503	无可用 Provider	放宽路由条件

5.2 速率限制

用户类型	限制
免费用户	20 RPM
付费用户	$1 余额 = 1 RPS，最高 500 RPS
免费模型（无充值）	每日请求数有限
免费模型（有充值）	每日请求数提升

关键点：

速率限制是全局的，多个 API Key 不能增加额度
不同模型的限制独立，可以分散负载
余额过低会触发更激进的缓存过期，增加延迟

5.3 完整的错误处理示例

import os
import time
from openai import OpenAI, APIError, RateLimitError, APIConnectionError
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.getenv("OPENROUTER_API_KEY"),
)


def chat_with_retry(
    messages: list,
    model: str = "google/gemini-3-flash-preview",
    max_retries: int = 3,
    initial_delay: float = 1.0,
) -> str:
    """带指数退避重试的聊天函数"""
    delay = initial_delay

    for attempt in range(max_retries):
        try:
            completion = client.chat.completions.create(
                model=model,
                messages=messages,
                extra_body={
                    # 启用 fallback，增加可靠性
                    "models": [
                        model,
                        "openai/gpt-5.2",
                        "google/gemini-3-flash-preview",
                    ],
                    "route": "fallback",
                },
            )
            return completion.choices[0].message.content

        except RateLimitError as e:
            if attempt < max_retries - 1:
                print(f"速率限制，{delay}秒后重试... (第{attempt + 1}次)")
                time.sleep(delay)
                delay *= 2  # 指数退避
            else:
                raise

        except APIError as e:
            if e.status_code in (502, 503) and attempt < max_retries - 1:
                print(f"服务暂时不可用，{delay}秒后重试...")
                time.sleep(delay)
                delay *= 2
            else:
                raise

        except APIConnectionError as e:
            if attempt < max_retries - 1:
                print(f"连接错误，{delay}秒后重试...")
                time.sleep(delay)
                delay *= 2
            else:
                raise

    return ""


# 使用
result = chat_with_retry(
    messages=[{"role": "user", "content": "Hello!"}],
    model="anthropic/claude-sonnet-4",
)
print(result)

5.4 流式输出的错误处理

def stream_with_error_handling(messages: list, model: str):
    """流式输出并处理中途错误"""
    try:
        stream = client.chat.completions.create(
            model=model,
            messages=messages,
            stream=True,
        )

        full_content = ""
        for chunk in stream:
            choice = chunk.choices[0]

            # 检查是否是错误
            if choice.finish_reason == "error":
                print(f"\n[流式传输中断] 模型返回错误")
                break

            content = choice.delta.content
            if content:
                print(content, end="", flush=True)
                full_content += content

        print()
        return full_content

    except Exception as e:
        print(f"\n[错误] {e}")
        return ""

6. 和直接调用的区别

6.1 价格

对比项	OpenRouter	直接调用
推理价格	和原始 provider 相同，不加价	原价
充值手续费	Stripe 约 5.5%（最低 $0.80），加密支付 5%	无
BYOK 费用	月度免费额度后收取小比例费用	无

实际上，OpenRouter 的核心商业模式是在充值环节收费，推理本身不加价。

6.2 延迟

场景	OpenRouter 额外延迟
理想条件	~25ms
典型生产环境	~40ms
含路由和 fallback	200-500ms

对于大多数文本生成场景，这个延迟可以忽略不计。但实时语音、高频交易等场景需要考虑。

6.3 功能差异

特性	OpenRouter	直接调用
模型切换	改一个字符串	重新集成 SDK
自动 Fallback	内置	需自己实现
多 Provider 路由	内置	需自己实现
统一计费	一个账户	每个 Provider 分别计费
Fine-tuning	有限支持	完整支持
最新功能可用性	可能略有延迟	第一时间
企业级 SLA	有限	各 Provider 提供
数据隐私控制	可通过 provider 参数控制	直接和 Provider 签协议

6.4 适用场景建议

用 OpenRouter 的场景：

需要快速测试多个模型
A/B 测试不同模型效果
需要自动 fallback 保证可用性
用量不大，便利性优先
需要统一管理多模型费用

直接调用的场景：

高频调用，延迟敏感
需要 Fine-tuning
有严格的合规/数据驻留要求
预算量大，需要企业级 SLA
需要第一时间使用新功能

7. 环境变量配置

.env 文件

# OpenRouter API
OPENROUTER_API_KEY=sk-or-v1-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# 可选：你的应用信息（用于 OpenRouter 排行榜）
OPENROUTER_REFERER=https://your-app.com
OPENROUTER_APP_NAME=Your App Name

Python 中使用

import os
from dotenv import load_dotenv

load_dotenv()

OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY")
OPENROUTER_REFERER = os.getenv("OPENROUTER_REFERER", "")
OPENROUTER_APP_NAME = os.getenv("OPENROUTER_APP_NAME", "")

查询 API Key 余额

import requests
import os
from dotenv import load_dotenv

load_dotenv()

headers = {
    "Authorization": f"Bearer {os.getenv('OPENROUTER_API_KEY')}"
}

response = requests.get(
    "https://openrouter.ai/api/v1/key",
    headers=headers,
)

key_info = response.json()
print(f"余额: {key_info}")

8. 完整的生产级封装

"""
OpenRouter 客户端封装
用法：
    from openrouter_client import OpenRouterClient
    client = OpenRouterClient()
    result = client.chat("你好")
"""

import os
import json
import time
import base64
from typing import Generator
from openai import OpenAI, APIError, RateLimitError, APIConnectionError
from dotenv import load_dotenv

load_dotenv()


class OpenRouterClient:
    """OpenRouter API 客户端封装"""

    # 推荐的模型配置
    MODELS = {
        "fast": "google/gemini-3-flash-preview",
        "smart": "anthropic/claude-sonnet-4",
        "powerful": "anthropic/claude-opus-4.6",
        "cheap": "deepseek/deepseek-chat-v3-0324",
        "code": "openai/gpt-5.3-codex",
    }

    def __init__(
        self,
        api_key: str = None,
        default_model: str = "fast",
        max_retries: int = 3,
    ):
        self.api_key = api_key or os.getenv("OPENROUTER_API_KEY")
        if not self.api_key:
            raise ValueError("OPENROUTER_API_KEY 未设置")

        self.default_model = self.MODELS.get(default_model, default_model)
        self.max_retries = max_retries

        self.client = OpenAI(
            base_url="https://openrouter.ai/api/v1",
            api_key=self.api_key,
            default_headers={
                "HTTP-Referer": os.getenv("OPENROUTER_REFERER", ""),
                "X-Title": os.getenv("OPENROUTER_APP_NAME", ""),
            },
        )

    def chat(
        self,
        prompt: str,
        model: str = None,
        system: str = None,
        temperature: float = 0.7,
        max_tokens: int = 4096,
        fallback_models: list = None,
    ) -> str:
        """简单聊天，带自动重试"""
        model = self.MODELS.get(model, model) or self.default_model
        messages = []
        if system:
            messages.append({"role": "system", "content": system})
        messages.append({"role": "user", "content": prompt})

        extra_body = {}
        if fallback_models:
            extra_body["models"] = [model] + fallback_models
            extra_body["route"] = "fallback"

        return self._call_with_retry(
            model=model,
            messages=messages,
            temperature=temperature,
            max_tokens=max_tokens,
            extra_body=extra_body if extra_body else None,
        )

    def chat_stream(
        self,
        prompt: str,
        model: str = None,
        system: str = None,
    ) -> Generator[str, None, None]:
        """流式聊天"""
        model = self.MODELS.get(model, model) or self.default_model
        messages = []
        if system:
            messages.append({"role": "system", "content": system})
        messages.append({"role": "user", "content": prompt})

        stream = self.client.chat.completions.create(
            model=model,
            messages=messages,
            stream=True,
        )

        for chunk in stream:
            content = chunk.choices[0].delta.content
            if content:
                yield content

    def chat_with_image(
        self,
        prompt: str,
        image_path: str = None,
        image_url: str = None,
        model: str = None,
    ) -> str:
        """带图片的聊天"""
        model = self.MODELS.get(model, model) or self.default_model

        content = [{"type": "text", "text": prompt}]

        if image_path:
            with open(image_path, "rb") as f:
                b64 = base64.b64encode(f.read()).decode("utf-8")
            ext = image_path.rsplit(".", 1)[-1].lower()
            mime = {"png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg",
                    "webp": "image/webp", "gif": "image/gif"}.get(ext, "image/png")
            content.append({
                "type": "image_url",
                "image_url": {"url": f"data:{mime};base64,{b64}"}
            })
        elif image_url:
            content.append({
                "type": "image_url",
                "image_url": {"url": image_url}
            })

        messages = [{"role": "user", "content": content}]

        return self._call_with_retry(model=model, messages=messages)

    def chat_with_tools(
        self,
        messages: list,
        tools: list,
        tool_mapping: dict,
        model: str = None,
        max_iterations: int = 10,
    ) -> str:
        """工具调用循环"""
        model = self.MODELS.get(model, model) or self.default_model

        for _ in range(max_iterations):
            resp = self.client.chat.completions.create(
                model=model,
                messages=messages,
                tools=tools,
            )

            msg = resp.choices[0].message
            messages.append(msg)

            if not msg.tool_calls:
                return msg.content

            for tc in msg.tool_calls:
                fn_name = tc.function.name
                fn_args = json.loads(tc.function.arguments)
                result = tool_mapping[fn_name](**fn_args)
                messages.append({
                    "role": "tool",
                    "tool_call_id": tc.id,
                    "content": json.dumps(result, ensure_ascii=False),
                })

        return messages[-1].content if messages else ""

    def _call_with_retry(self, **kwargs) -> str:
        """带指数退避的重试逻辑"""
        delay = 1.0
        extra_body = kwargs.pop("extra_body", None)

        for attempt in range(self.max_retries):
            try:
                call_kwargs = {k: v for k, v in kwargs.items() if v is not None}
                if extra_body:
                    call_kwargs["extra_body"] = extra_body

                resp = self.client.chat.completions.create(**call_kwargs)
                return resp.choices[0].message.content

            except RateLimitError:
                if attempt < self.max_retries - 1:
                    time.sleep(delay)
                    delay *= 2
                else:
                    raise

            except (APIError, APIConnectionError) as e:
                if attempt < self.max_retries - 1:
                    time.sleep(delay)
                    delay *= 2
                else:
                    raise

        return ""


# ===== 使用示例 =====
if __name__ == "__main__":
    oc = OpenRouterClient(default_model="fast")

    # 基础聊天
    print(oc.chat("用一句话解释什么是 API"))

    # 流式输出
    for chunk in oc.chat_stream("写一首关于代码的俳句"):
        print(chunk, end="", flush=True)
    print()

    # 带 fallback
    print(oc.chat(
        "Hello",
        model="smart",
        fallback_models=[
            "openai/gpt-5.2",
            "google/gemini-3-flash-preview",
        ],
    ))

9. 模型选择策略速查

场景	推荐模型	理由
日常对话/快速问答	`google/gemini-3-flash-preview`	便宜、快、1M 上下文
写作/创意内容	`anthropic/claude-sonnet-4`	中文能力好、创意强
复杂推理/分析	`anthropic/claude-opus-4.6`	最强推理
编程/代码生成	`openai/gpt-5.3-codex`	专为编码优化
长文档处理	`google/gemini-3-flash-preview`	1M 上下文
预算有限	`deepseek/deepseek-chat-v3-0324`	极低价格
免费试用	`xiaomi/mimo-v2-flash`	免费且性能不错
图片理解	`google/gemini-3-flash-preview`	多模态支持好
视频理解	`google/gemini-3-flash-preview`	原生视频支持

参考链接

花叔｜AI进化论-花生

AI Native Coder / 独立开发者 / AI自媒体博主

小猫补光灯作者，《一本书玩转DeepSeek》作者