Le mois dernier, quand la comptable m'a envoyé la facture, j'ai cru qu'elle s'était trompée. Le volume d'appels avait augmenté de 40 % d'un mois sur l'autre, mais la facture était passée d'un peu plus de six chiffres à presque le triple. En calcul linéaire, on aurait dû payer au maximum quarante pour cent de plus : d'où sortait donc le reste ?
J'ai récupéré les logs d'appels des trente derniers jours et je les ai découpés par modèle, par interface et par nombre de tentatives. Le problème ne venait pas du « volume », mais de la « structure ». Quatre points de fuite cachés, chacun plus discret que le précédent.
Commençons par le plus flagrant : le modèle phare effectuait des tâches grossières. Nous avons un module de reconnaissance d'intention qui aurait très bien pu tourner sur un modèle léger, mais au début, pour aller plus vite, il avait été branché directement sur le modèle phare le plus cher, et personne n'y avait touché depuis. Ce type de trafic représentait plus de soixante pour cent du total des requêtes, mais apportait très peu de valeur métier. En relançant avec une stratification par modèle, en déléguant la classification, l'extraction et la validation de format à de petits modèles, et en ne réservant au modèle phare que les requêtes nécessitant réellement du raisonnement, on peut ramener ce coût au tiers ou à la moitié de l'original. Ne sous-estimez pas ce geste : il ne demande aucune modification de la logique métier, seulement du routage.
Comment stratifier concrètement ? J'ai découpé en trois niveaux selon le type de tâche : le premier niveau, classification et reconnaissance d'intention, avec des entrées courtes, des sorties courtes et une logique simple, que les petits modèles supportent parfaitement ; le deuxième niveau, extraction d'informations et validation de format, qui demande un peu de compréhension sémantique mais pas de raisonnement multi-étapes, confié à des modèles intermédiaires ; le troisième niveau seulement, le raisonnement multi-étapes complexe, la génération de textes longs et la complétion de code, réservé au modèle phare. Après le découpage, j'ai comparé : sur les tâches du premier niveau, la précision des petits modèles n'a baissé que de moins de deux points, mais le coût par appel a chuté de près de quatre-vingt-dix pour cent. Le deuxième niveau est plus subtil : l'écart de F1 entre les modèles intermédiaires et le modèle phare sur les tâches d'extraction est inférieur à 0,03, alors que le coût diffère d'un facteur cinq. Le calcul est vite fait : l'argent dépensé en trop venait purement et simplement de la paresse.
Le deuxième piège est plus sournois. La tempête de tentatives. Le seuil de timeout d'une interface en amont était réglé trop serré : au moindre hoquet du réseau, le client réessayait, la tentative expirait à nouveau, puis une nouvelle tentative. Dans les logs, on voyait la même requête frappée quatre ou cinq fois, brûlant des Tokens à chaque fois, alors que l'utilisateur ne voyait qu'un seul échec. Cette consommation inutile ne se voit pas dans la facture, mais elle peut en représenter environ vingt pour cent. L'action est simple : remplacer les tentatives par des tentatives idempotentes avec backoff, assouplir le seuil de timeout et faire de la déduplication côté serveur. Après cela, on élimine la majeure partie des Tokens inutiles.
Détaillons quelques paramètres clés. Nous avons assoupli le seuil de timeout de 3 secondes à 15 secondes, limité le nombre de tentatives à deux au maximum au lieu d'un nombre illimité, et adopté une stratégie de backoff exponentiel avec jitter : une seconde d'attente à la première tentative, deux à la seconde, avec un jitter aléatoire pour éviter l'effet de troupeau. Côté serveur, nous avons ajouté une empreinte de requête : une même empreinte n'est traitée qu'une fois en 60 secondes, les requêtes suivantes recevant directement le résultat en cache. Après la modification, j'ai surveillé pendant une semaine : le taux de tentatives est passé de 18 % à moins de 4 %, et la consommation de Tokens inutiles a chuté de plus de soixante-dix pour cent. Bénéfice inattendu : les plaintes des utilisateurs pour timeout ont aussi diminué, car en assouplissant le seuil, les requêtes qui auraient pu aboutir mais étaient coupées trop tôt renvoient désormais normalement.
Troisième point : le contexte long n'était pas tronqué. Notre interface de dialogue injectait par défaut tout l'historique, si bien qu'au vingtième tour, les Tokens d'entrée représentaient plus de dix fois ceux du premier tour. Or, dans les faits, la majeure partie de l'historique est inutile pour la réponse en cours. Avec une fenêtre glissante plus compression par résumé, en ne gardant que les derniers tours en texte brut et un résumé roulant, on réduit l'entrée de quarante à soixante pour cent. Un détail : le résumé lui-même coûte des Tokens, donc il ne faut pas compresser la fenêtre trop fort ; il faut trouver le point d'inflexion.
Nous avons testé plusieurs jeux de paramètres et retenu la combinaison « cinq derniers tours en texte brut + résumé roulant ». Le résumé roulant n'est pas régénéré à chaque tour, mais mis à jour tous les trois tours, en compressant les dialogues plus anciens en un résumé de moins de deux cents caractères. Ainsi, le volume de Tokens en entrée est passé de plus de huit mille au vingtième tour à un peu plus de trois mille, soit une baisse de plus de soixante pour cent. J'ai aussi essayé de ne garder que les deux derniers tours, mais la qualité des réponses s'est nettement dégradée : quand l'utilisateur posait une question de suivi sur le contexte, le modèle répondait souvent à côté. Ce point d'inflexion existe donc bel et bien, et il faut le tester selon son propre scénario métier. Notre expérience : la taille de la fenêtre ne doit pas descendre en dessous des trois derniers tours, et la fréquence de mise à jour du résumé ne doit pas dépasser une fois tous les deux tours, sinon les Tokens économisés ne compenseront pas la perte d'expérience utilisateur.
Quatrième point : un faible taux de hit du cache. Des requêtes identiques ou très similaires arrivaient sans cesse, et nous relancions pourtant l'inférence à chaque fois. Les prompts système, les modèles fixes et les questions-réponses fréquentes, qui sont parfaitement cachables, avaient alors un taux de hit inférieur à dix pour cent. Après ajout d'une couche de cache sémantique, les requêtes répétées renvoient directement le résultat ; la proportion économisée dépend du taux de répétition métier, chez nous environ vingt à trente pour cent.
Le cache sémantique mérite quelques mots de plus. Le cache exact ne peut intercepter que des requêtes strictement identiques, mais dans la pratique, beaucoup de requêtes sont « à peu près pareilles mais formulées différemment ». Par exemple, l'utilisateur demande « comment obtenir un remboursement » et « quelle est la procédure de remboursement » : la correspondance exacte échoue, le cache sémantique réussit. Notre solution : vectoriser l'entrée, faire une recherche approximative des plus proches voisins dans la base de cache, et renvoyer directement le résultat en cache si la similarité dépasse le seuil. Le choix du seuil est crucial : trop élevé, le taux de hit ne décolle pas ; trop bas, on risque de renvoyer des réponses hors sujet. Nous l'avons finalement fixé à 0,92, ce qui a fait passer le taux de hit de moins de 10 % à 34 %, sans aucune plainte d'utilisateur pour réponse à côté. Pour les prompts système et les modèles fixes, c'est encore plus simple : un cache de préfixe suffit, avec un taux de hit proche de 100 %.
En combinant les quatre actions, nous avons ensuite relancé en facturation à l'usage avec stratification par modèle : la facture est retombée à environ 1,2 fois le niveau d'avant la croissance, alors que le volume d'appels avait toujours augmenté de 40 %. Au passage, nous avons essayé token8341 pour l'accès unifié multi-modèles : une seule clé pour basculer entre plusieurs fournisseurs, et une fois le routage et la facturation unifiés, le diagnostic de ce type de problème structurel est devenu bien plus simple.
Un autre point facile à négliger : la supervision et l'attribution. Si ces quatre problèmes ont mis si longtemps à être détectés, c'est fondamentalement parce que notre facture n'était ventilée que par modèle et par interface, et non par « type de tâche » et « empreinte de requête ». J'ai ensuite ajouté une couche d'étiquettes d'appel : chaque requête porte les étiquettes type de tâche, tentative ou non, hit de cache ou non, nombre de tours de contexte ; à la sortie de la facture, on voit d'un coup d'œil quel maillon brûle de l'argent. Ce système d'étiquettes ne fait pas économiser d'argent en soi, mais sans lui, on ne sait tout simplement pas où va l'argent.
Mise en garde : ne commencez pas par changer pour un modèle moins cher. Commencez par décomposer la structure des appels ; bien souvent, l'argent ne part pas dans le prix unitaire, mais dans les répétitions et redondances dont vous n'avez même pas conscience. L'optimisation du prix unitaire est la dernière étape, pas la première.
Auteur : Zhao Qiming
Date de publication : 9 novembre 2026