快速上手一个 API Key 调用所有主流大模型

AINative软件工程
7 阅读6分钟

现状：每个模型厂商一套体系，乱得很

做 AI 开发久了，你会接触到每家厂商：

  • 独立的 SDK 或 API 格式
  • 独立的计费体系，余额分散在各处
  • 独立的限流策略，触发了自己去查文档
  • 代码耦合严重：换个模型要改很多地方

TheRouter：一个入口，所有模型

TheRouter 是一个 AI 模型路由网关，把所有主流大模型统一在一个接口后面：

  • 一个 API Key：Claude、GPT、DeepSeek、Qwen 全用同一个 key
  • 完全兼容 GPT 格式：用 GPT 库，只改 base_url 和 model 参数
  • 直连：不需要代理，稳定可用
  • 统一计费：一个余额，所有模型都扣这里
  • 切换零成本：换模型只改一个字符串

注册地址：therouter.ai，支持邮箱注册，微信、支付宝充值。

5 分钟上手

安装 SDK

# Python
pip install xxx

# Node.js
npm install xxx

初始化客户端

from xxx import xxx

# 只需要改这两个参数
client = xxx(
    base_url="https://api.therouter.ai/v1",
    api_key="你的 TheRouter API Key",  # 从 therouter.ai 控制台获取
)

模型 ID 格式

TheRouter 用 品牌/模型名 的格式来标识模型：

deepseek/deepseek-chat
qwen/qwen-max

格式规律：斜杠前是模型原始品牌，斜杠后是模型名称。一看就知道是哪家的模型。

核心演示：同一段代码，切换任意模型

这是 TheRouter 最大的价值：只改 model 参数，其余代码一行不动。

from xxx import xxx

client = xxx(
    base_url="https://api.therouter.ai/v1",
    api_key="你的 TheRouter API Key",
)

# 问题固定不变
question = "用 Python 写一个二分查找算法，加上详细注释"

# 用不同模型回答同一个问题——只改 model 参数
models = [
    "其他类似"
    "deepseek/deepseek-chat",     # DeepSeek
]

for model in models:
    print(f"\n{'='*50}")
    print(f"模型：{model}")
    print('='*50)

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": question}],
        max_tokens=512,
    )
    print(response.choices[0].message.content)

实际应用中，你可以把 model 做成配置项，业务代码完全不感知底层用的是哪家模型。

流式输出（Stream）

流式对话是标配需求，所有模型的流式接口完全一致：

from xxx import xxx

client = xxx(
    base_url="https://api.therouter.ai/v1",
    api_key="你的 TheRouter API Key",
)

def stream_chat(model: str, prompt: str):
    """流式调用任意模型"""
    stream = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        stream=True,  # 开启流式输出
        max_tokens=1024,
    )

    print(f"[{model}] ", end="", flush=True)
    for chunk in stream:
        content = chunk.choices[0].delta.content
        if content is not None:
            print(content, end="", flush=True)
    print()  # 换行

# 流式调用 Claude
stream_chat(
    "xxxx/claude-sonnet-4",
    "解释一下 Python 的 GIL 是什么，以及它的影响"
)

# 流式调用 GPT-4o，代码完全相同
stream_chat(
    "xxx/gpt-4o",
    "解释一下 Python 的 GIL 是什么，以及它的影响"
)

Function Calling（工具调用）

Function Calling 也是统一接口，定义一次工具，所有支持工具调用的模型都能用：

from xxx import xxx
import json

client = xxx(
    base_url="https://api.therouter.ai/v1",
    api_key="你的 TheRouter 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 call_with_tools(model: str):
    """用工具调用测试不同模型"""
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": "北京今天天气怎么样？"}],
        tools=tools,
        tool_choice="auto",  # 让模型自己决定是否调用工具
    )

    message = response.choices[0].message

    # 检查是否触发了工具调用
    if message.tool_calls:
        for tool_call in message.tool_calls:
            func_name = tool_call.function.name
            func_args = json.loads(tool_call.function.arguments)
            print(f"[{model}] 调用工具: {func_name}({func_args})")
    else:
        print(f"[{model}] 直接回复: {message.content}")

# 同样的工具定义，用于不同模型
call_with_tools("xxx/claude-sonnet-4")
call_with_tools("xxx/gpt-4o")

Vision（图像理解）

支持多模态的模型，传图方式也完全一致：

from xxx import xxx
import base64

client = xxx(
    base_url="https://api.therouter.ai/v1",
    api_key="你的 TheRouter API Key",
)

def analyze_image(model: str, image_url: str, question: str):
    """用多模态模型分析图片"""
    response = client.chat.completions.create(
        model=model,
        messages=[
            {
                "role": "user",
                "content": [
                    {
                        "type": "image_url",
                        "image_url": {"url": image_url},
                    },
                    {
                        "type": "text",
                        "text": question,
                    },
                ],
            }
        ],
        max_tokens=512,
    )
    return response.choices[0].message.content

# 图片 URL
image_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/4/47/PNG_transparency_demonstration_1.png/280px-PNG_transparency_demonstration_1.png"

# 用 Claude 分析
result = analyze_image(
    "xxx/claude-sonnet-4",
    image_url,
    "描述一下这张图片里有什么"
)
print("Claude:", result)

# 用 GPT-4o 分析（代码完全相同）
result = analyze_image(
    "xxx/gpt-4o",
    image_url,
    "描述一下这张图片里有什么"
)
print("GPT-4o:", result)

Structured Outputs（结构化输出）

让模型返回 JSON 格式，方便程序解析：

from xxx import xxx
from pydantic import BaseModel
from typing import List

client = xxx(
    base_url="https://api.therouter.ai/v1",
    api_key="你的 TheRouter API Key",
)

# 定义期望的输出结构
class CodeReview(BaseModel):
    issues: List[str]       # 代码问题列表
    suggestions: List[str]  # 改进建议列表
    score: int              # 代码质量评分（1-10）
    summary: str            # 总结

code_to_review = """
def get_user(id):
    db = connect_db()
    result = db.query(f"SELECT * FROM users WHERE id = {id}")
    return result
"""

# 使用 response_format 获取结构化输出
response = client.beta.chat.completions.parse(
    model="xxx/claude-sonnet-4",
    messages=[
        {
            "role": "system",
            "content": "你是代码审查专家，请审查代码并输出结构化结果。",
        },
        {
            "role": "user",
            "content": f"请审查以下 Python 代码：\n\n```python\n{code_to_review}\n```",
        },
    ],
    response_format=CodeReview,  # 指定输出格式
)

review: CodeReview = response.choices[0].message.parsed
print(f"评分：{review.score}/10")
print(f"问题：{review.issues}")
print(f"建议：{review.suggestions}")
print(f"总结：{review.summary}")

支持的模型一览

完整模型列表见 therouter.ai/models，也可以调 /v1/models 接口实时查询：

curl https://api.therouter.ai/v1/models \
  -H "Authorization: Bearer 你的API Key"

实际项目中的最佳实践

把模型名做成配置，不要硬编码

import os
from xxx import xxx

client = xxx(
    base_url="https://api.therouter.ai/v1",
    api_key=os.environ["THEROUTER_API_KEY"],
)

# 从环境变量读取模型名，方便切换
MODEL = os.environ.get("AI_MODEL", "xxx/claude-sonnet-4")

response = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "你好"}],
)

这样切换模型只需改环境变量，代码不用动：

# 用 Claude
AI_MODEL=xxx/claude-sonnet-4 python app.py

# 换成 GPT-4o
AI_MODEL=xxx/gpt-4o python app.py

# 换成 DeepSeek（更便宜）
AI_MODEL=deepseek/deepseek-chat python app.py

Node.js / TypeScript 版本

import xxx from "xxx";

const client = new xxx({
  baseURL: "https://api.therouter.ai/v1",
  apiKey: process.env.THEROUTER_API_KEY!,
});

// 模型可配置
const MODEL = process.env.AI_MODEL ?? "xxx/claude-sonnet-4";

async function chat(userMessage: string): Promise<string> {
  const response = await client.chat.completions.create({
    model: MODEL,
    messages: [{ role: "user", content: userMessage }],
    max_tokens: 1024,
  });

  return response.choices[0].message.content ?? "";
}

// 使用
chat("用 TypeScript 写一个简单的 HTTP 服务器").then(console.log);

从现有 GPT 项目迁移

如果你已经在用 GPT SDK，迁移到 TheRouter 接入所有模型的成本几乎为零：

改动清单（共 2 处）：

  1. 初始化时加 base_url
  2. 需要用其他模型时改 model 参数
# 改之前（只能用 GPT 模型）
client = xx(api_key=os.environ["API_KEY"])
response = client.chat.completions.create(model="gpt-4o", ...)

# 改之后（可以用所有模型）
client = xxx(
    base_url="https://api.therouter.ai/v1",
    api_key=os.environ["THEROUTER_API_KEY"],
)
response = client.chat.completions.create(model="xxxx/claude-sonnet-4", ...)
# 或者保持用 GPT-4o：model="xxx/gpt-4o"

写在最后

一个 key，所有模型，统一计费，国内直连。TheRouter 解决的核心问题很简单：让你专注于用 AI，而不是管 AI 账号。

如果你做的产品需要同时评测多个模型，或者想随时切换最适合当前任务的模型，TheRouter 是目前我找到的最低成本方案。

立即体验：therouter.ai

注册后就能拿到 API Key.

avatar
文章
阅读
粉丝