Faire passer une application d’OpenAI à un fournisseur compatible OpenAI est une petite modification de code si vous utilisez Chat Completions, et une réécriture si vous utilisez la Responses API. Cet article montre les diffs exacts en Python, Node et cURL, ce qu’il faut faire pour Responses, les outils, la sortie structurée et les embeddings, et un test de fumée à lancer avant de déplacer le moindre trafic. Les exemples utilisent BroadNet Inference à l’adresse https://inference.broadnet.ai/v1 ; les mêmes étapes valent pour n’importe quel fournisseur.
C’est le pendant en code de la checklist de migration, qui couvre les limites de débit, les erreurs et la planification de la bascule. Pour les URL de base d’autres fournisseurs, voir les URL de base compatibles OpenAI, vérifiées.
Qu’est-ce qui change dans la configuration du client ?
Trois valeurs : l’URL de base, la clé d’API et l’identifiant du modèle.
Python
import os
from openai import OpenAI
# before: client = OpenAI() # reads OPENAI_API_KEY, calls api.openai.com
client = OpenAI(
base_url="https://inference.broadnet.ai/v1",
api_key=os.environ["BROADNET_API_KEY"],
)
r = client.chat.completions.create(
model="broadnet/gemma-4-26b-a4b", # was e.g. "gpt-..."
messages=[{"role": "user", "content": "Reply with one short sentence."}],
)
print(r.choices[0].message.content)
Node
import OpenAI from "openai";
const client = new OpenAI({
baseURL: "https://inference.broadnet.ai/v1",
apiKey: process.env.BROADNET_API_KEY,
});
const r = await client.chat.completions.create({
model: "broadnet/gemma-4-26b-a4b",
messages: [{ role: "user", content: "Reply with one short sentence." }],
});
console.log(r.choices[0].message.content);
cURL
curl https://inference.broadnet.ai/v1/chat/completions \
-H "Authorization: Bearer $BROADNET_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model":"broadnet/gemma-4-26b-a4b","messages":[{"role":"user","content":"Reply with one short sentence."}]}'
Attention au chemin : l’URL de base se termine déjà par /v1, et le SDK ajoute /chat/completions. Doubler /v1 est la première erreur la plus fréquente.
Peut-on changer sans toucher au code ?
Oui, pour du code Chat Completions. Le SDK Python lit OPENAI_BASE_URL quand aucune base_url n’est passée, et le client Node prend par défaut baseURL dans process.env['OPENAI_BASE_URL']. Les deux lisent OPENAI_API_KEY. Définir deux variables d’environnement déplace tous les appels.
C’est aussi le risque. Tous les appels partent, y compris les embeddings, la modération, les envois de fichiers et tout ce que le nouveau fournisseur n’a peut-être pas. N’utilisez la bascule par l’environnement que si votre application ne fait que des appels de chat.
Et si mon code utilise la Responses API ?
Les README des SDK d’OpenAI présentent désormais la Responses API comme l’API principale ; le README Python qualifie Chat Completions de « the previous standard (supported indefinitely) » (traduction : « l’ancien standard (pris en charge sans limite de durée) »). Beaucoup de fournisseurs compatibles n’implémentent que Chat Completions. BroadNet documente POST /v1/chat/completions et POST /v1/audio/transcriptions : les appels Responses doivent donc être réécrits. La correspondance :
| Responses API | Chat Completions |
|---|---|
client.responses.create(...) |
client.chat.completions.create(...) |
instructions="..." |
Premier message {"role": "system", "content": "..."} |
input="..." ou une liste d’éléments |
messages=[...] |
response.output_text |
response.choices[0].message.content |
max_output_tokens |
max_tokens (documentation de BroadNet) ou max_completion_tokens |
text={"format": {...}} |
response_format={...} |
previous_response_id, conversations |
Renvoyer vous-même tout l’historique des messages |
Outil {"type": "function", "name": ...} |
Outil {"type": "function", "function": {"name": ...}} |
Élément de sortie function_call, réponse avec function_call_output et call_id |
message.tool_calls, réponse avec le rôle tool et tool_call_id |
| Outils intégrés (recherche web, recherche de fichiers) | Non disponibles ; faites tourner votre propre outil |
L’avant et l’après pour un appel simple :
# Before: Responses API
r = client.responses.create(model="gpt-...", instructions="Be brief.", input="What is RAG?")
text = r.output_text
# After: Chat Completions
r = client.chat.completions.create(
model="broadnet/gemma-4-26b-a4b",
messages=[{"role": "system", "content": "Be brief."},
{"role": "user", "content": "What is RAG?"}],
)
text = r.choices[0].message.content
Le plus gros changement de structure concerne l’état. Responses peut garder l’état de la conversation côté OpenAI avec previous_response_id. Chat Completions n’a pas d’état côté serveur : votre code stocke la liste des messages et l’envoie en entier à chaque tour. Prévoyez-le dans votre budget : tout l’historique compte en tokens d’entrée à chaque appel.
Comment changent les appels d’outils ?
Dans Chat Completions, une définition d’outil imbrique la fonction sous une clé function, et la réponse revient sous forme de message tool :
import json
tools = [{
"type": "function",
"function": {
"name": "get_order",
"description": "Look up an order by ID.",
"parameters": {"type": "object",
"properties": {"order_id": {"type": "string"}},
"required": ["order_id"]},
},
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
msg = r.choices[0].message
if msg.tool_calls:
messages.append(msg) # keep the assistant turn
for call in msg.tool_calls:
args = json.loads(call.function.arguments) # a JSON string: parse and validate it
messages.append({"role": "tool", "tool_call_id": call.id,
"content": json.dumps(lookup_order(args["order_id"]))})
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
Le modèle compte plus que la forme. La documentation de BroadNet n’indique les outils que pour GLM 5.3 et Qwen3.8 27B. Ne branchez pas une boucle d’outils sur un modèle dont la documentation ne mentionne pas les outils, et validez les arguments avant d’exécuter quoi que ce soit. L’appel d’outils avec des modèles ouverts contient une boucle complète avec validation.
Et la sortie structurée ?
client.chat.completions.parse(..., response_format=MyPydanticModel) et zodResponseFormat côté Node envoient tous deux response_format avec un JSON Schema. Ils ne fonctionnent que si le fournisseur accepte cette forme sur ce modèle. BroadNet indique la sortie structurée pour GLM 5.3 et Qwen3.8 27B mais ne nomme pas le paramètre de requête. Faites le test en quatre étapes de mode JSON ou json_schema une fois par modèle, et continuez à valider le résultat parsé, quoi que promette le fournisseur.
Que deviennent les embeddings ?
Si vous changez l’URL de base d’un client partagé et que le fournisseur n’a pas d’endpoint d’embeddings, chaque appel à client.embeddings.create échoue. BroadNet ne vend pas d’embeddings. Gardez deux clients :
chat = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
embed = OpenAI(api_key=os.environ["OPENAI_API_KEY"]) # or any embeddings provider
vec = embed.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding
answer = chat.chat.completions.create(model="broadnet/glm-5.3", messages=build_prompt(query, search(vec)))
Ne mélangez jamais dans un même index des vecteurs issus de deux modèles d’embeddings. Si vous changez aussi de fournisseur d’embeddings, recalculez les embeddings de tout le corpus. Le calculateur de coûts d’embeddings en chiffre le coût.
Il en va de même pour tout ce qui n’est pas du chat : génération d’images, synthèse vocale, modération, Batch API et stockage de fichiers. BroadNet ne propose rien de tout cela. Le speech-to-text, lui, suit : client.audio.transcriptions.create fonctionne avec /v1/audio/transcriptions, en WAV ou MP3, avec un champ language (guide speech-to-text pour l’arabe).
Comment change le code de streaming ?
La Responses API diffuse des événements typés, comme response.output_text.delta et response.completed. Chat Completions diffuse des chunks, et le texte se trouve dans choices[0].delta.content. L’usage n’est envoyé que si vous le demandez, et il arrive alors dans un dernier chunk avec une liste choices vide.
// Before (Responses): for await (const e of stream) if (e.type === "response.output_text.delta") out(e.delta);
const stream = await client.chat.completions.create({
model: "broadnet/gemma-4-26b-a4b",
messages: [{ role: "user", content: "Count from one to three." }],
stream: true,
stream_options: { include_usage: true },
});
for await (const chunk of stream) {
const text = chunk.choices[0]?.delta?.content;
if (text) process.stdout.write(text);
if (chunk.usage) console.log("\ntokens:", chunk.usage.total_tokens); // last chunk
}
Deux habitudes sécurisent le code de streaming après la bascule. Protégez l’accès à choices[0], car le chunk d’usage n’a pas de choices. Et traitez comme incomplet un flux qui se termine avant la ligne finale data: [DONE] ; la documentation de BroadNet demande alors de noter le X-Request-ID et de décider si une nouvelle requête est sans risque. Le streaming des chat completions présente le schéma complet en Python.
La gestion des erreurs et les retries changent-ils ?
Les classes d’erreur du SDK restent les mêmes : AuthenticationError pour 401, RateLimitError pour 429, APIStatusError pour le reste. Ce qui change, c’est la signification de chaque statut chez le nouveau fournisseur. Chez BroadNet, une 401 peut signifier un quota de paiement à l’usage épuisé, et pas seulement une mauvaise clé, et 402 signifie un solde insuffisant pour un achat. Aucune ne se règle par un retry. Une 429 peut venir de la limite de débit, de simultanéité, de débit de tokens ou de dépense. Relancez les 429 et 5xx avec backoff, et corrigez tout le reste. Le guide des erreurs et des retries contient le tableau complet.
Le SDK relance par défaut deux fois les erreurs de connexion, 408, 409, 429 et 5xx. Si vous ajoutez votre propre boucle de retry, réglez max_retries=0 sur le client pour que les deux ne s’additionnent pas.
Quels paramètres se comportent différemment ?
| Paramètre | Ce qu’il faut vérifier |
|---|---|
max_tokens / max_completion_tokens |
OpenAI rend max_tokens obsolète ; la documentation de BroadNet l’utilise. Sur les modèles de raisonnement, il inclut la réflexion, donc de petites valeurs renvoient des réponses vides (pourquoi) |
reasoning_effort |
BroadNet documente low ; testez les autres valeurs avant de compter dessus |
stream_options: {"include_usage": true} |
Documenté par BroadNet ; l’usage arrive dans le dernier chunk |
n, logprobs, seed, logit_bias |
Absents de la documentation de BroadNet ; testez-les ou supprimez-les |
store, metadata |
Fonctionnalités de stockage d’OpenAI ; supprimez-les |
Parties de contenu image_url |
Uniquement sur les modèles indiqués avec images : DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B |
Comment tester la bascule ?
Lancez un court test de fumée contre le nouveau fournisseur avant de déplacer le moindre trafic. Celui-ci vérifie le chat simple, l’usage en streaming, le budget de raisonnement et l’authentification. Ajoutez un cas d’appel d’outil si vous utilisez des outils.
import os, openai
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)
FAST, REASONING = "broadnet/gemma-4-26b-a4b", "broadnet/qwen3.8-27b"
msg = [{"role": "user", "content": "Reply with the word ok."}]
# 1. Plain chat returns text and usage
r = client.chat.completions.create(model=FAST, messages=msg)
assert r.choices[0].message.content and r.usage.prompt_tokens > 0
# 2. Streaming reports usage in the last chunk
chunks = list(client.chat.completions.create(model=FAST, messages=msg, stream=True,
stream_options={"include_usage": True}))
assert chunks[-1].usage is not None
# 3. A reasoning model needs room: a tiny budget can come back empty
r = client.chat.completions.create(model=REASONING, messages=msg, max_tokens=2000)
assert r.choices[0].finish_reason == "stop" and r.choices[0].message.content
# 4. A bad key raises AuthenticationError (401), which you should not retry
bad = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key="invalid", max_retries=0)
try:
bad.chat.completions.create(model=FAST, messages=msg)
raise AssertionError("expected 401")
except openai.AuthenticationError:
pass
print("smoke test passed")
Comparez ensuite la qualité, pas seulement la forme. Rejouez un échantillon de vrais prompts chez les deux fournisseurs et notez les réponses ; évaluer un LLM avant de changer montre comment. L’outil de migration d’OpenAI vers BroadNet vous aide à réécrire un extrait de code et liste les fonctionnalités qu’il utilise.
Qu’est-ce qui casse le plus souvent ?
- Une URL de base globale qui déplace aussi les appels d’embeddings et de fichiers.
- Des helpers propres à Responses comme
output_text, laissés dans du code qui appelle désormais Chat Completions. - Les identifiants de modèles. Les noms
gpt-...n’existent pas ailleurs. Chez BroadNet, ils ressemblent àbroadnet/glm-5.3. - Des réponses vides des modèles de raisonnement avec un petit
max_tokens. - Les limites de débit. Une clé BroadNet en paiement à l’usage autorise 30 requêtes par minute et 4 en cours. Les traitements en masse ont besoin d’une file d’attente (gérer les 429).
La place de BroadNet Inference
BroadNet Inference convient aux applications dont l’usage d’OpenAI se résume au chat et à la transcription : assistants, extraction, résumé, traduction et parole en arabe. Il convient aussi aux applications qui veulent des forfaits DeepSeek V4.1 Flash pour leurs agents. Ce n’est pas la bonne cible si vous dépendez de l’état côté serveur de la Responses API, des outils intégrés, des embeddings, de la génération d’images, de la synthèse vocale, de la voix en temps réel ou de la Batch API. Déplacez ces usages vers des fournisseurs qui les proposent, ou gardez-les chez OpenAI et ne déplacez que les appels de chat. Gemma 4 VL 26B et les deux modèles de transcription fonctionnent avec le crédit de départ de $5 ; GLM 5.3, Qwen3.8 27B et DeepSeek V4.1 Flash nécessitent d’abord une recharge.
