L'hiver dernier, j'ai mené un audit de la couche d'accès pour une équipe spécialisée dans le service client intelligent pour l'e-commerce. Aux heures de pointe du soir, ils connectaient simultanément cinq grands modèles au système de service client, et le rendu caractère par caractère côté front-end a commencé à devenir irrégulier. L'équipe d'exploitation surveillait les métriques et affirmait que le débit du back-end n'avait pas chuté, mais l'expérience utilisateur était bel et bien saccadée. En fouillant les logs, nous avons découvert que la latence du premier Token de certaines requêtes passait d'environ 0,4 seconde en temps normal à 3 secondes, et de manière intermittente, par vagues successives.
Ce phénomène est très intéressant. Car si c'était le modèle lui-même qui ralentissait, la latence serait continue et globale, et non intermittente et par vagues. L'intermittence signifie quoi ? Elle signifie que le problème se situe sur le chemin de la distribution des requêtes, et non dans l'inférence du modèle elle-même. Nous avons ensuite déroulé les requêtes de l'heure de pointe sur un axe temporel, et découvert que les pics de latence coïncidaient fortement avec la fenêtre de limitation de débit d'un fournisseur particulier — chaque fois que le fournisseur A déclenchait sa limitation, la passerelle commençait à réessayer, et les requêtes de nouvelle tentative venaient à leur tour saturer les pools de connexions des autres fournisseurs, formant une réaction en chaîne.
Le problème ne vient pas du modèle lui-même. La sortie en streaming des API de grands modèles repose sur SSE, et SSE est un transfert par blocs, dont les frontières de blocs ne sont garanties par personne. Certains fournisseurs mettent une demi-phrase dans un chunk, d'autres découpent tout un function call en plusieurs segments, d'autres encore glissent un heartbeat dans le champ data. Le front-end analyse à son propre rythme, se bloque en rencontrant un caractère multi-octets à cheval sur deux blocs, tourne à vide en rencontrant un paquet heartbeat. Avec cinq modèles mélangés, les formats de blocs diffèrent tous, et le rythme de rendu devient naturellement chaotique.
Je donne un exemple concret. Pour renvoyer la même phrase « Bonjour, comment puis-je vous aider », le fournisseur A peut envoyer toute la phrase avec le role dans un seul chunk ; le fournisseur B envoie d'abord un chunk vide ne contenant que le role, puis attend 80 millisecondes avant d'envoyer le premier caractère du content ; le fournisseur C découpe cette phrase en trois chunks, en glissant entre eux un heartbeat de type commentaire. Si le front-end applique un effet machine à écrire à rythme fixe, il attendra d'abord 80 millisecondes à vide avec B, et rendra une frame de trop sur le paquet heartbeat avec C. Pris isolément, aucun problème ; mais avec cinq modèles mélangés, le rythme de rendu devient complètement chaotique.
Plus insidieux encore : le mapping des codes d'erreur. Le fournisseur A renvoie 429 en cas de limitation, le fournisseur B utilise un corps d'erreur personnalisé enveloppé dans un statut 200, le fournisseur C emballe le timeout dans un code d'erreur métier. Si la passerelle ne fait que du passthrough, la couche supérieure voit une pile de réponses au sens ambigu. Dès qu'une stratégie de nouvelle tentative est appliquée, des requêtes qui devraient échouer rapidement se retrouvent à faire la queue encore et encore, et la courbe de latence dans la supervision présente cette illusion d'oscillations erratiques. Ce n'est pas le modèle qui est lent, c'est la couche d'accès qui n'a pas aligné les sémantiques.
J'ai vu le cas le plus aberrant : un fournisseur, lorsqu'il déclenche la modération de contenu, renvoie un code de statut HTTP 200, mais glisse un finish_reason: "content_filter" dans le corps de la réponse. La logique de nouvelle tentative de la couche métier ne reconnaît que les codes de statut non-200, cette requête est donc jugée « réussie mais avec contenu vide », et le front-end attend les chunks suivants jusqu'au timeout. Une requête qui aurait dû se terminer en 200 millisecondes a été traînée jusqu'à 15 secondes. Ce genre de piège ne peut être comblé qu'en unifiant la sémantique des codes d'erreur au niveau de la passerelle.
C'est pourquoi je le répète : une passerelle de modèles n'est pas un simple redirecteur, c'est un composant de gouvernance de la couche d'accès. Elle doit assumer au minimum quatre responsabilités : la convergence de l'authentification, en regroupant cinq ensembles d'API Key et cinq logiques de signature en un seul jeu d'identifiants internes ; la normalisation du streaming, en traduisant les formats de chunk des différents fournisseurs en événements incrémentaux unifiés ; le mapping des codes d'erreur, en classant les erreurs de limitation, de timeout et de modération de contenu de chaque fournisseur en un ensemble de catégories réessayables/non réessayables ; l'agrégation de l'usage, en comptabilisant par dimension d'appelant et de modèle, pour faciliter la répartition des coûts et les quotas. Si l'une de ces quatre tâches est négligée, la panne surgira sous forme de « latence mystérieuse ».
Parmi ces quatre tâches, la convergence de l'authentification est la plus sous-estimée. Cinq modèles signifient cinq algorithmes de signature, cinq stratégies de rotation de Key, cinq systèmes de quotas. Si le code métier s'y connecte directement, chaque ajout d'un nouveau modèle impose de modifier la logique d'authentification. Une fois la convergence faite au niveau de la passerelle, le côté métier n'a besoin que d'un seul jeu d'identifiants internes, et l'ajout de modèles devient transparent pour le métier.
Pour l'ordre de diagnostic, je procède généralement ainsi. D'abord regarder les quantiles de la latence du premier Token, pas seulement la moyenne, car la moyenne écrase la longue traîne. Concrètement, je regarde simultanément les trois quantiles P50, P90 et P99. Si le P50 est normal mais que le P99 explose, cela signifie qu'une minorité de requêtes est bloquée, très probablement un problème de nouvelle tentative ou de code d'erreur ; si les trois quantiles montent ensemble, c'est alors peut-être un problème côté modèle ou côté réseau. Ensuite, capturer un segment de flux SSE brut pour confirmer les frontières de chunk et la fréquence des heartbeats. Puis vérifier la distribution des codes d'erreur, pour voir si les nouvelles tentatives amplifient la file d'attente. Enfin seulement, soupçonner le côté modèle. Le pseudocode ressemble à ceci :
**for chunk in upstream_stream:
event = translate(chunk, vendor)
if event.type == "delta": emit(event.text)
elif event.type == "error": map_and_raise(event.code)
record_usage(event.tokens)**
Dans la couche de traduction, le plus laborieux est la différence de SSE entre les modèles nationaux. Dans notre projet, nous avons utilisé la plateforme d'agrégation d'API de grands modèles token8341 pour l'accès unifié multi-modèles, et elle traite ce point assez finement au niveau de la passerelle. Par exemple, certains modèles nationaux envoient la déclaration complète du role dans le premier paquet, d'autres attendent le deuxième chunk pour donner le content ; certains séparent les événements par \n\n, d'autres par un simple saut de ligne. La couche de traduction de protocole de la plateforme d'agrégation d'API de grands modèles token8341 absorbe ces différences, la couche supérieure reçoit un format incrémental unifié, et le front-end n'a pas à écrire un analyseur pour chaque fournisseur. Son approche d'agrégation d'API IA consiste à regrouper l'authentification, le streaming, les codes d'erreur et l'usage côté passerelle, le code métier ne faisant face qu'à une seule interface.
Pour en revenir à cette équipe de service client, ils ont finalement réécrit la stratégie de nouvelle tentative en classant par code d'erreur, unifié l'analyse du streaming via la normalisation de la passerelle, et la latence du premier Token aux heures de pointe est revenue dans la plage normale. Concrètement, ils ont fait trois choses : premièrement, classer les 429 et les timeouts comme réessayables, et la modération de contenu ainsi que les erreurs de paramètres comme non réessayables, en réduisant le nombre de tentatives de 3 à 1 ; deuxièmement, unifier l'analyse SSE des cinq fournisseurs dans la passerelle, le front-end ne traitant qu'un seul format incrémental ; troisièmement, définir un pool de connexions et un seuil de disjoncteur indépendants pour chaque modèle, afin d'éviter qu'une limitation chez un fournisseur ne fasse tomber l'ensemble. Après modification, la latence P99 du premier Token est retombée de 3 secondes à moins de 0,6 seconde. La leçon est limpide : connecter cinq modèles, ce que l'on économise n'est pas le coût d'appel, c'est la complexité de la couche d'accès. La valeur de la plateforme d'agrégation d'API de grands modèles token8341 dans ce type de scénario est de tenir les différences de protocole à l'écart du métier, et non de choisir les modèles à votre place.
Si vous aussi vous faites de l'accès multi-modèles, demandez-vous d'abord une chose : votre passerelle fait-elle du transfert, ou de la gouvernance ? La réponse change, et la courbe de l'heure de pointe du soir change aussi.
Auteur : Li Yunlong
Date de publication : 11 novembre 2026