0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

@syu999

不想分别折腾 GPT、Claude、Grok、Gemini API？用一个平台统一接入，附 Python 实战代码

0
Posted at

不想分别折腾 GPT、Claude、Grok、Gemini API？用一个平台统一接入，附 Python 实战代码

现在做 AI 开发，一个越来越明显的问题是：模型越来越多，API 也越来越多。

你可能今天要用 GPT，明天想测试 Claude，后天又想接 Grok、Gemini，做 AI Coding 的时候还会用到 Codex、Claude Code 这类工具。

如果每一家都单独申请账号、充值、管理 API Key、修改代码，项目很快就会变得很乱。

我最近在用的一个平台是：

https://ai.chongplus.plus/

它的思路很简单：把不同 AI 模型的 API 统一到一个入口，通过 Token 调用不同模型。

对于开发者来说，最直接的好处就是：

以前：

GPT API
Claude API
Grok API
Gemini API
    ↓
分别注册
分别充值
分别保存 Key
分别适配 SDK

现在：

ai.chongplus.plus
    ↓
一个统一 API 入口
    ↓
通过 model 切换不同模型

这对于经常测试不同大模型、做 Agent、AI Coding、自动化工具的人来说，会方便很多。

需要说明一点：Codex、Claude Code 更准确地说属于 AI Coding 客户端或 Agent 工具，而 GPT、Claude、Grok、Gemini 属于模型或模型生态。实际能够调用哪些模型、对应的模型 ID 是什么，建议直接以平台控制台里的模型列表为准。

一、为什么我更喜欢统一 API

假设现在要写一个简单的 AI 应用。

如果直接对接不同厂商，代码可能会逐渐变成：

if provider == "openai":
    call_openai()

elif provider == "anthropic":
    call_claude()

elif provider == "google":
    call_gemini()

elif provider == "xai":
    call_grok()

再继续做下去，还会出现：

不同 API Key
不同 Base URL
不同请求参数
不同 SDK
不同错误处理
不同计费方式

如果只是偶尔测试一次还好。

但是如果你正在开发：

AI Agent
AI 客服
AI Coding 工具
内容生成平台
模型对比工具
工作流自动化
AI SaaS

这种维护成本会越来越高。

统一 API 网关的价值就在这里。

业务代码尽量不动，只修改：

model="你的模型ID"

就可以切换模型。

二、先准备 API Token

进入：

https://ai.chongplus.plus/

注册并登录以后，在平台中创建自己的 API Token。

例如：

sk-xxxxxxxxxxxxxxxx

注意，不要把真实 Token 直接写进 GitHub 项目。

错误写法：

API_KEY = "sk-真实密钥"

更推荐放到环境变量里。

Mac / Linux：

export AI_API_KEY="sk-xxxxxxxxxxxxxxxx"

Windows PowerShell：

$env:AI_API_KEY="sk-xxxxxxxxxxxxxxxx"

Python 中读取：

import os

api_key = os.getenv("AI_API_KEY")

三、最简单的 Python 调用

如果平台接口兼容 OpenAI API，那么 Python 接入会非常简单。

先安装 SDK：

pip install openai

然后创建一个文件：

demo.py

写入：

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AI_API_KEY"),
    base_url="https://ai.chongplus.plus/v1"
)

response = client.chat.completions.create(
    model="你的模型ID",
    messages=[
        {
            "role": "user",
            "content": "用一句话解释什么是 Docker"
        }
    ]
)

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

运行：

python demo.py

正常情况下，就可以拿到模型返回结果。

真正需要关注的核心其实只有三个参数：

api_key
base_url
model

也就是：

API Token
+
统一接口地址
+
模型 ID

四、切换 GPT、Claude、Grok、Gemini

统一 API 最大的方便之处，就是业务代码可以保持不变。

例如：

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AI_API_KEY"),
    base_url="https://ai.chongplus.plus/v1"
)

def ask_ai(model, prompt):
    response = client.chat.completions.create(
        model=model,
        messages=[
            {
                "role": "user",
                "content": prompt
            }
        ]
    )

    return response.choices[0].message.content


print(
    ask_ai(
        "你的GPT模型ID",
        "写一个 Python 快速排序"
    )
)

想换成 Claude，只需要修改：

model="你的Claude模型ID"

想测试 Grok：

model="你的Grok模型ID"

想测试 Gemini：

model="你的Gemini模型ID"

程序主体不需要重新写。

模型 ID 不建议直接照抄网上文章，因为平台支持的模型会更新，直接从控制台的模型列表复制最稳妥。

五、用 requests 调用，不依赖 SDK

如果不想安装 OpenAI SDK，也可以直接使用 HTTP 请求。

安装 requests：

pip install requests

代码：

import os
import requests

API_KEY = os.getenv("AI_API_KEY")

url = "https://ai.chongplus.plus/v1/chat/completions"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

data = {
    "model": "你的模型ID",
    "messages": [
        {
            "role": "system",
            "content": "你是一名资深 Python 工程师"
        },
        {
            "role": "user",
            "content": "写一个 FastAPI Hello World"
        }
    ]
}

response = requests.post(
    url,
    headers=headers,
    json=data,
    timeout=120
)

response.raise_for_status()

result = response.json()

print(result["choices"][0]["message"]["content"])

这也是我比较推荐大家理解的一种方式。

因为不管上层 SDK 怎么封装，最终本质上还是：

Python
  ↓
HTTP Request
  ↓
AI API Gateway
  ↓
具体模型
  ↓
返回 JSON

六、做成一个通用 AI Client

如果项目里会频繁调用模型，可以再封装一层。

例如创建：

ai_client.py

代码：

import os
from openai import OpenAI


class AIClient:

    def __init__(
        self,
        api_key=None,
        base_url="https://ai.chongplus.plus/v1"
    ):
        self.client = OpenAI(
            api_key=api_key or os.getenv("AI_API_KEY"),
            base_url=base_url
        )

    def chat(
        self,
        model,
        prompt,
        system_prompt="你是一个专业的 AI 助手"
    ):
        response = self.client.chat.completions.create(
            model=model,
            messages=[
                {
                    "role": "system",
                    "content": system_prompt
                },
                {
                    "role": "user",
                    "content": prompt
                }
            ]
        )

        return response.choices[0].message.content

然后在业务代码中：

from ai_client import AIClient

ai = AIClient()

result = ai.chat(
    model="你的模型ID",
    prompt="帮我设计一个用户登录接口"
)

print(result)

以后切换模型：

result = ai.chat(
    model="另一个模型ID",
    prompt="帮我设计一个用户登录接口"
)

就可以直接对比两个模型的效果。

七、再进一步：一次对比多个模型

统一 API 还有一个很适合开发者的玩法，就是做模型横向测试。

例如：

from ai_client import AIClient

ai = AIClient()

models = [
    "GPT模型ID",
    "Claude模型ID",
    "Grok模型ID",
    "Gemini模型ID"
]

prompt = """
用 Python 写一个生产者消费者模型，
要求使用 asyncio，并解释代码。
"""

for model in models:

    print("=" * 60)
    print("MODEL:", model)
    print("=" * 60)

    try:
        result = ai.chat(
            model=model,
            prompt=prompt
        )

        print(result)

    except Exception as e:
        print("调用失败：", e)

这样一段代码，就可以直接观察：

谁写代码更好
谁解释更清楚
谁速度更快
谁更适合长文本
谁更适合 Agent

这比每次打开几个网页分别复制提示词方便很多。

八、流式输出

做聊天机器人时，一般不会等模型全部生成完成以后再一次性显示，而是边生成边显示。

可以开启 stream：

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AI_API_KEY"),
    base_url="https://ai.chongplus.plus/v1"
)

stream = client.chat.completions.create(
    model="你的模型ID",
    messages=[
        {
            "role": "user",
            "content": "详细解释 Python asyncio"
        }
    ],
    stream=True
)

for chunk in stream:

    if not chunk.choices:
        continue

    content = chunk.choices[0].delta.content

    if content:
        print(
            content,
            end="",
            flush=True
        )

运行以后，就会看到类似 ChatGPT 的逐字输出效果。

这对于：

网页聊天
AI 客服
Agent
代码生成
长文章生成

都非常有用。

九、在实际项目中不要把模型写死

小 Demo 里这样写没有问题：

model="xxx"

但正式项目最好放进配置文件。

例如：

.env

写：

AI_API_KEY=sk-xxxxxxxxxxxxxxxx
AI_BASE_URL=https://ai.chongplus.plus/v1
AI_MODEL=你的模型ID

安装：

pip install python-dotenv

Python：

import os

from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()

client = OpenAI(
    api_key=os.getenv("AI_API_KEY"),
    base_url=os.getenv("AI_BASE_URL")
)

response = client.chat.completions.create(
    model=os.getenv("AI_MODEL"),
    messages=[
        {
            "role": "user",
            "content": "你好，介绍一下你自己"
        }
    ]
)

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

以后想换模型，只修改：

AI_MODEL=新的模型ID

代码完全不需要修改。

十、异常处理也要加上

正式项目里一定不要默认 API 永远成功。

例如：

import os

from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AI_API_KEY"),
    base_url="https://ai.chongplus.plus/v1"
)

try:

    response = client.chat.completions.create(
        model="你的模型ID",
        messages=[
            {
                "role": "user",
                "content": "Hello"
            }
        ]
    )

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

except Exception as e:

    print("AI API 调用失败：")
    print(e)

实际开发中比较常见的问题包括：

API Token 错误
余额不足
模型名称错误
模型暂时不可用
请求超时
并发过高
上游服务异常

所以生产环境最好再加：

重试
超时
日志
降级模型
错误监控

例如可以准备一个备用模型：

models = [
    "主模型ID",
    "备用模型ID"
]

for model in models:

    try:
        result = ai.chat(
            model=model,
            prompt="帮我分析这段代码"
        )

        print(result)
        break

    except Exception as e:
        print(
            model,
            "调用失败：",
            e
        )

主模型出现问题时，就可以自动切换备用模型。

十一、这种统一 API 最适合哪些人

如果只是偶尔和 AI 聊聊天，其实直接使用 ChatGPT、Claude、Gemini 官网就够了。

但是对于开发者来说，统一 API 的价值会明显很多。

尤其是下面这些场景：

1. 经常测试不同大模型

2. 开发 AI Agent

3. 开发 AI SaaS

4. 做 AI Coding

5. 做模型效果横向测试

6. 做自动化工作流

7. 一个项目需要同时使用多个模型

8. 不想维护一堆不同厂商的 API Key

例如一个 Agent 完全可以这样分工：

写代码
  ↓
GPT / Claude

搜索与分析
  ↓
Grok

长文本处理
  ↓
Gemini

最终汇总
  ↓
再交给另一个模型

业务层只调用自己的统一 AI Client。

至于底层到底使用哪个模型，可以随时调整。

十二、总结

我觉得 AI 开发接下来会越来越像现在的云计算。

开发者不会永远只使用一家模型。

很可能一个项目里同时存在：

GPT
Claude
Grok
Gemini
以及其他模型

模型会越来越多。

真正麻烦的反而不是怎么调用模型，而是：

怎么统一管理
怎么快速切换
怎么控制成本
怎么处理失败
怎么做模型路由

所以像：

https://ai.chongplus.plus/

这种统一 API Gateway 的价值，本质上不是简单地“多几个模型”。

而是把：

不同 AI 厂商
不同模型
不同接口

尽量收敛成：

一个 Base URL
+
一个 Token
+
一个 model 参数

对于 Python 开发者来说，最简单的接入甚至只有十几行代码：

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.getenv("AI_API_KEY"),
    base_url="https://ai.chongplus.plus/v1"
)

response = client.chat.completions.create(
    model="你的模型ID",
    messages=[
        {
            "role": "user",
            "content": "Hello AI"
        }
    ]
)

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

剩下的事情，就是选择适合自己业务的模型。

至于 GPT、Claude、Grok、Gemini 到底谁最好，我觉得没有一个固定答案。

最好的办法反而是：

同一个问题，直接用代码全部跑一遍。

0
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
0
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?