8341TokenFactory
LLM APIAPI GatewayAggregation

L'usine de tokens 8341 : quatre modèles pour une seule fonctionnalité — GPT-4o en secours, DeepSeek en principal, Qwen pour le chinois, Doubao pour le service client

SiCore TokenWorks Team·2026-11-08

Pour une même fonctionnalité, le frontend doit appeler quatre modèles : GPT-4o assure le secours, DeepSeek exécute l'inférence principale, Qwen traite les longs textes en chinois, et Doubao prend en charge les scripts du service client. Quatre SDK, quatre systèmes d'authentification, quatre documentations. La première semaine de mise en production, rien que l'alignement de ces différences nous a coûté deux jours-homme.

Ce n'est pas exagéré. Nous avons fait le calcul : après l'intégration de quatre fournisseurs de modèles, la partie du code métier liée aux appels de modèles avait gonflé de près de trois fois. À chaque changement de modèle, il fallait reprendre la méthode d'appel, la logique de parsing et la gestion des erreurs. Plus pénible encore : à chaque mise à jour du SDK par un fournisseur, il fallait tout retester. Cet article retrace de manière complète les pièges que nous avons rencontrés et la solution de passerelle que nous avons finalement mise en place, en espérant aider les équipes qui se débattent elles aussi entre plusieurs modèles.

I. Authentification : quatre systèmes, quatre façons de faire

L'authentification est le premier obstacle. La famille OpenAI utilise un Bearer Token, il suffit de mettre Authorization: Bearer sk-xxx dans l'en-tête de la requête. Qwen exige une signature AccessKey : chaque requête doit calculer un HMAC avec l'AK/SK, en assemblant un horodatage et une chaîne aléatoire. Doubao utilise AK/SK plus horodatage, mais l'algorithme de signature diffère de celui de Qwen. Quant à DeepSeek, bien qu'il soit compatible avec le format OpenAI, il a son propre base_url et son propre mapping de noms de modèles, et sa méthode d'initialisation ne correspond pas tout à fait au SDK officiel.

Résultat : le code est truffé de if-else. Une instance de client par fournisseur, un jeu de configuration par instance. La gestion des clés est encore plus pénible — les clés des quatre fournisseurs sont stockées à quatre endroits, et lors d'une rotation il faut modifier quatre endroits ; en oublier un provoque un incident en production.

Nous avons ensuite unifié les choses au niveau de la couche d'accès : à l'extérieur, on n'expose qu'une seule API Key, et en interne on fait de la traduction de protocole. Concrètement, la couche d'accès maintient une table de routage des fournisseurs, chaque fournisseur ayant son propre adaptateur d'authentification. Le côté métier ne détient qu'une seule Key, la requête arrive à la couche d'accès, qui identifie le fournisseur correspondant d'après le nom du modèle et utilise l'adaptateur pour effectuer la signature et le transfert.

Nous avons ensuite essayé d'unifier le base_url sur token8341 : une seule Key permet d'appeler GPT-4o, Claude, Gemini, DeepSeek, Qwen, ERNIE et Doubao, compatible avec le SDK OpenAI, et il suffit de changer une ligne de base_url pour basculer. Le sale boulot de l'authentification est relégué derrière la couche d'accès, et le code métier est devenu bien plus propre. La rotation des clés est aussi devenue une opération unique, et le coût d'exploitation a chuté d'un ordre de grandeur.

II. Streaming SSE par chunks : quatre formats, un seul rendu

Le streaming SSE par chunks est le deuxième piège, et il est plus insidieux que l'authentification. Dans le chunk de GPT-4o, delta.content peut être null, en particulier dans le premier et le dernier chunk ; si le frontend ne vérifie pas la nullité avant de rendre, il fait apparaître un undefined. DeepSeek inclut l'usage dans le dernier chunk, et la structure de son champ usage n'est pas tout à fait identique à celle d'OpenAI. Les types d'événements de Qwen sont plus finement découpés, avec plusieurs types comme add, finish, error, et la structure du payload diffère pour chacun. Le marqueur de fin de Doubao est encore différent : il utilise un champ finish_reason spécial pour signaler la fin du flux.

Avec quatre formats reçus côté frontend, la logique de rendu explose littéralement. Notre première approche consistait à adapter côté frontend, en écrivant quatre fonctions de parsing ; résultat : à chaque ajout d'un nouveau modèle, il fallait modifier le frontend. Nous sommes ensuite passés à une normalisation au niveau de la passerelle : tout est unifié sur la structure de chunk d'OpenAI, les delta vides sont directement filtrés, et l'usage est extrait séparément pour être cumulé. La règle concrète est la suivante — toutes les réponses en streaming des fournisseurs sont converties au format data: {"choices":[{"delta":{"content":"..."}}]}, la fin est uniformément marquée par data: [DONE], et l'usage est renvoyé au format OpenAI dans le dernier chunk.

Le frontend ne reconnaît qu'un seul format et n'a pas à se soucier de qui est branché derrière. Cette modification a fait passer le code lié aux modèles côté frontend d'environ 400 lignes à environ 80 lignes, et l'ajout d'un nouveau modèle ne nécessite aucune modification côté frontend.

III. Codes d'erreur : des erreurs cachées dans un HTTP 200

La confusion des codes d'erreur dépasse les attentes. Pour une même limitation de débit, OpenAI renvoie un 429 avec rate_limit_exceeded, Qwen renvoie une erreur métier avec un champ code, et Doubao glisse carrément l'erreur dans le corps d'un HTTP 200 — le code de statut est 200, mais le corps contient un champ error. DeepSeek est la plupart du temps cohérent avec OpenAI, mais renvoie parfois des structures d'erreur personnalisées.

Impossible d'unifier la surveillance et les alertes. On ne peut pas écrire une règle disant « alerter sur 429 », car certains fournisseurs ne renvoient pas de 429 en cas de limitation. On ne peut pas non plus se contenter de regarder le code de statut HTTP, car le 200 de Doubao peut être une erreur.

Nous avons construit dans la couche d'accès une table de mapping qui ramène les codes d'erreur de chaque fournisseur à un système d'erreurs internes unifié : limitation de débit, timeout, échec d'authentification, modération de contenu, service indisponible. La logique de mapping concrète est la suivante — on regarde d'abord le code de statut HTTP, puis le code d'erreur dans le corps, et on combine les deux pour décider. Par exemple, si Doubao renvoie 200 mais avec un error dans le corps, on mappe selon le code d'erreur ; si Qwen renvoie 400 avec un code métier, on mappe selon ce code. Les règles d'alerte ne sont écrites qu'une seule fois, et lors du diagnostic on regarde ensuite le code d'erreur d'origine.

Nous avons maintenu cette table de mapping avec environ 60 règles, couvrant les scénarios d'erreur courants des quatre fournisseurs. Après la mise en production, le taux d'exactitude des alertes est passé d'environ 60 % à plus de 95 %, et les faux positifs ont pratiquement disparu.

IV. Statistiques d'usage : quatre chiffres qui ne concordent pas

Les différences de méthode de comptage d'usage sont ce qu'on néglige le plus facilement, mais elles finissent toujours par se révéler lors du rapprochement comptable. Le comptage de tokens de GPT-4o inclut le system prompt, les tokens dont le cache est touché chez DeepSeek sont facturés séparément, Qwen calcule séparément l'entrée et la sortie, et l'unité de facturation de Doubao est encore différente. Au moment du rapprochement comptable, les quatre chiffres ne concordent pas, et impossible de calculer clairement le coût réel de chaque modèle.

La solution de consolidation consiste à enregistrer au niveau de la passerelle, pour chaque requête, le model, input_tokens, output_tokens, cache_hit, et à les stocker en base selon une norme de facturation unifiée au token. Concrètement, la passerelle enregistre l'heure de début et de fin de la requête lors du transfert, extrait le champ usage de chaque fournisseur depuis la réponse, et le convertit dans un format standard. Pour les fournisseurs dont l'unité de facturation diffère, une conversion est effectuée au niveau de la passerelle, tout étant ramené à un coût par token.

Ainsi, quel que soit le fournisseur branché en dessous, le coût peut être aligné dans un même tableau. Nous avons ensuite construit, sur la base de ce tableau, un tableau de bord des coûts, décomposable par modèle, par ligne métier et par jour. Une fois, nous avons constaté que le coût d'une ligne métier avait soudainement augmenté de 40 % ; après vérification, la stratégie de routage envoyait un grand nombre de requêtes vers GPT-4o, et après ajustement du routage, le coût a immédiatement baissé. Sans consolidation unifiée de l'usage, ce genre de problème serait tout simplement indétectable.

V. L'architecture en quatre couches de la passerelle de modèles

Quelles couches la passerelle de modèles doit-elle assumer ? Ma répartition est en quatre couches.

Première couche : traduction de protocole. Unifier les formats de requête et de réponse de chaque fournisseur en une interface compatible OpenAI. C'est la seule couche que le code métier touche directement ; elle est chargée de traduire les requêtes au format OpenAI standard vers le format de chaque fournisseur, puis de retraduire les réponses.

Deuxième couche : routage. Choisir le modèle selon le type de tâche, par exemple les longs textes en chinois vers Qwen, le code vers DeepSeek, le secours vers GPT-4o. La stratégie de routage peut être configurable, prenant en charge plusieurs dimensions comme le type de tâche, la priorité, le coût. Nous avons aussi ajouté une logique de dégradation — si le modèle principal tombe en timeout ou est limité en débit, bascule automatique vers le modèle de secours.

Troisième couche : consolidation de l'usage. Facturation et quotas unifiés. La consommation de tokens, les hits de cache et le temps de réponse de chaque requête sont enregistrés dans cette couche, qui expose une interface unifiée de consultation de l'usage.

Quatrième couche : observabilité. Logs, traçage de bout en bout, convergence des codes d'erreur. Chaque requête a un trace_id, traçable de bout en bout de l'entrée à la sortie. Les codes d'erreur sont uniformément mappés dans cette couche, et les règles d'alerte ne sont configurées que dans cette couche.

Le code métier n'appelle que l'interface de la première couche ; les trois couches suivantes lui sont transparentes. L'avantage est le suivant — changer de modèle sans modifier le code métier, ajouter un modèle sans modifier le code métier, ajuster la stratégie de routage sans modifier le code métier. L'équipe métier n'a qu'à se soucier de « je veux appeler un modèle », le reste est confié à la passerelle.

VI. Rappels pour éviter les pièges

N'importez pas directement les SDK de chaque fournisseur dans le code métier. Dès qu'un fournisseur met à jour son interface ou que vous voulez changer de modèle, la surface des modifications devient énorme. Nous avons vu des équipes appeler directement les SDK dans le code métier, et lors d'un changement de modèle, elles ont modifié plus de 30 fichiers et ont dû tester pendant une semaine avant de mettre en production.

Deux jours de plus sur la couche d'accès font gagner deux semaines par la suite. Ce rapport investissement/bénéfice a été vérifié chez nous de manière concrète — après la mise en production de la passerelle, ajouter un modèle ne demande que l'ajout d'un adaptateur dans la passerelle, sans aucune modification du code métier, et l'intégration plus les tests prennent une demi-journée.

Deux petits conseils supplémentaires : premièrement, faites la consolidation de l'usage le plus tôt possible, n'attendez pas le rapprochement comptable pour découvrir qu'on ne peut rien calculer ; deuxièmement, la table de mapping des codes d'erreur doit être maintenue en continu, et la première chose à faire lors de l'intégration d'un nouveau fournisseur est de compléter le mapping des codes d'erreur.

Auteur : Sun Haoran

Date de publication : 9 novembre 2026