Anti-modèles d'API
Šajā lapā
- Les erreurs qui coûtent cher en production
- Traiter une réponse tronquée comme complète
- Laisser l’historique de conversation grandir sans limites
- Supposer que le réseau répond toujours
- Demander au modèle de faire ce qu’il ne peut pas faire
- Déployer sans laisser de trace
- Une routine de débogage
- Galvenās atziņas
Les erreurs qui coûtent cher en production
Après avoir couvert les bonnes pratiques, il est temps de voir l’envers du décor. Les anti-modèles ci-dessous sont les pièges les plus courants lors de l’utilisation de l’API Chat Completions, et ils partagent un trait désagréable : ils n’apparaissent pas lors du développement. Sur dix requêtes de test, tout fonctionne bien. C’est en production qu’ils explosent, causant des coûts inattendus, des réponses incohérentes, une latence élevée, ou pire — des fuites de données sensibles.
Traiter une réponse tronquée comme complète
L’erreur la plus courante est d’ignorer finish_reason. Tu demandes un contrat, tu reçois du texte en retour, tu l’enregistres dans la base de données : sauf que max_tokens=100 a coupé la génération au milieu d’une clause, et personne ne s’en rend compte jusqu’à ce que le client signe. La correction prend trois lignes de code et doit devenir un réflexe.
# MAUVAIS — aucune vérification
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Draft a complete contract."}],
max_tokens=100 # Trop court pour un contrat !
)
contract = response.choices[0].message.content # Potentiellement tronqué !
# BON — vérification systématique
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Draft a complete contract."}],
max_tokens=4000
)
if response.choices[0].finish_reason == "length":
print("WARNING: Response truncated, increase max_tokens")
else:
contract = response.choices[0].message.content
Laisser l’historique de conversation grandir sans limites
Le deuxième piège se déclenche lentement. Une boucle de chat qui envoie tout l’historique de la conversation à chaque tour fonctionne parfaitement pour les dix premiers échanges, coûte le double au vingtième, et finit par dépasser la fenêtre de contexte au centième — avec une facture suivant la même courbe. La solution consiste à conserver le prompt système (non négociable) et à ne garder que les N derniers messages.
# MAUVAIS — l'historique grandit indéfiniment
conversation = []
while True:
user_input = input("You: ")
conversation.append({"role": "user", "content": user_input})
response = client.chat.complete(
model="mistral-large-latest",
messages=conversation # 100 tours = des milliers de tokens !
)
reply = response.choices[0].message.content
conversation.append({"role": "assistant", "content": reply})
# BON — fenêtre glissante avec élagage
MAX_MESSAGES = 20
def trim_conversation(messages: list, max_messages: int = MAX_MESSAGES) -> list:
"""Conserve le prompt système + les N derniers messages."""
system = [m for m in messages if m["role"] == "system"]
history = [m for m in messages if m["role"] != "system"]
if len(history) > max_messages:
history = history[-max_messages:]
return system + history
Supposer que le réseau répond toujours
Un appel API nu suppose que rien ne peut mal tourner : pas de délais d’attente, pas de 429, pas de 500. En production, les trois arrivent, et le troisième survient au pire moment. Note la distinction dans le code : un 429 justifie un backoff exponentiel, une erreur serveur mérite une seconde de patience, mais une erreur client comme un 400 ou un 401 ne doit jamais être réessayée — ta clé ne deviendra pas valide à la troisième tentative ; tu ne feras que retarder le diagnostic.
# MAUVAIS — aucune gestion d'erreur
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Hello"}]
)
# Plante en cas de timeout, 429, 500...
# BON — réessai avec backoff
from mistralai.client.errors import SDKError
import time
def safe_complete(client, messages, max_retries=3, **kwargs):
"""Appel API avec réessai et backoff exponentiel."""
for attempt in range(max_retries):
try:
return client.chat.complete(messages=messages, **kwargs)
except SDKError as e:
if e.status_code == 429:
wait = 2 ** attempt
print(f"Rate limit hit, waiting {wait}s...")
time.sleep(wait)
elif e.status_code >= 500:
time.sleep(1)
else:
raise # Erreur client (400, 401) — ne pas réessayer
raise Exception("Failed after 3 attempts")
Demander au modèle de faire ce qu’il ne peut pas faire
Trois anti-modèles convergent ici. Le premier est le langage subjectif : „court”, „beaucoup”, „intéressant” ne renvoient à rien de vérifiable, et le modèle décidera différemment d’un appel à l’autre. Remplace chaque adjectif par un nombre ou un critère observable.
# MAUVAIS — subjectif, non mesurable
"Write a short summary." # Court = 1 phrase ? 1 paragraphe ?
"Give many examples." # Beaucoup = 3 ? 10 ? 50 ?
"Answer in an interesting way." # Intéressant selon quels critères ?
# BON — critères objectifs
"Write a summary of 50 to 80 words."
"Give exactly 5 examples, one per line."
"Start every response with a relevant statistic."
Le deuxième est de laisser le modèle compter. Les LLM sont notoirement mauvais pour compter les mots, les caractères et les éléments : demander „exactement 280 caractères” produira un texte de 240 ou 310. Le comptage appartient à ton application, pas au modèle.
# MAUVAIS — le modèle ne peut pas compter précisément
"Write exactly 280 characters for a tweet."
# BON — compter côté application
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Write a tweet about AI in France."}],
max_tokens=100
)
tweet = response.choices[0].message.content
if len(tweet) > 280:
tweet = tweet[:277] + "..."
print(f"Tweet ({len(tweet)} chars): {tweet}")
Le troisième tombe dans la même famille : les échelles numériques. „Note de 1 à 5” suppose que le modèle a une représentation stable de l’écart entre 3 et 4, ce qui n’est pas le cas. Une échelle verbale où chaque étape est définie par un critère donne des notes beaucoup plus reproductibles.
# MAUVAIS — les modèles interprètent mal les échelles numériques
"Rate the quality of this text from 1 to 5."
# BON — échelle verbale avec définitions
"""Rate the quality of this text according to the following scale:
- EXCELLENT: Clear, well-structured, no errors
- GOOD: Generally correct, minor improvements possible
- AVERAGE: Understandable but lacks structure or contains errors
- POOR: Difficult to understand, significant errors
- VERY POOR: Incomprehensible or off-topic
Respond only with the label in uppercase."""
Déployer sans laisser de trace
Le dernier anti-modèle est le plus discret : appeler l’API, renvoyer le contenu, et ne rien garder. Le jour où un utilisateur signale une réponse aberrante, tu n’as ni l’ID de requête, ni le modèle réellement servi, ni la consommation de tokens. La journalisation structurée par appel coûte quelques millisecondes et rend l’enquête possible.
# MAUVAIS — aucune trace
response = client.chat.complete(
model="mistral-large-latest",
messages=messages
)
return response.choices[0].message.content
# BON — journalisation structurée
import logging
import json
logger = logging.getLogger("mistral_api")
def logged_complete(client, messages, **kwargs):
"""Appel API avec journalisation structurée."""
response = client.chat.complete(messages=messages, **kwargs)
logger.info(json.dumps({
"request_id": response.id,
"model": response.model,
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens,
"finish_reason": response.choices[0].finish_reason
}))
return response
Une routine de débogage
Lorsqu’une réponse ne répond pas à tes attentes, la tentation est de réécrire le prompt. Commence plutôt par cinq vérifications mécaniques, dans l’ordre : la réponse est-elle complète ? Le bon modèle a-t-il répondu ? Combien de tokens ont été consommés ? La réponse est-elle vide ? Le ratio sortie/entrée est-il plausible ? Un ratio inférieur à 1 % sur un grand prompt signale presque toujours que le modèle a refusé de traiter la requête plutôt que de la mal gérer.
def debug_response(response):
"""Liste de contrôle de débogage pour les réponses inattendues."""
choice = response.choices[0]
# 1. La réponse est-elle complète ?
if choice.finish_reason == "length":
print("ISSUE: Response truncated — increase max_tokens")
# 2. Le bon modèle a-t-il été utilisé ?
print(f"Model: {response.model}")
# 3. Combien de tokens consommés ?
print(f"Input tokens: {response.usage.prompt_tokens}")
print(f"Output tokens: {response.usage.completion_tokens}")
# 4. La réponse est-elle vide ?
if not choice.message.content or not choice.message.content.strip():
print("ISSUE: Empty response")
# 5. Ratio entrée/sortie suspect ?
ratio = response.usage.completion_tokens / max(response.usage.prompt_tokens, 1)
if ratio < 0.01:
print(f"WARNING: Very low output/input ratio ({ratio:.4f})")
Galvenās atziņas
- Vérifie toujours
finish_reasonpour détecter les troncatures - Limite l’historique de conversation avec une fenêtre glissante
- Implémente un réessai avec backoff exponentiel pour les erreurs réseau
- Utilise des critères objectifs et mesurables dans tes prompts
- Ne laisse jamais le modèle compter — valide côté application
- Journalise chaque appel API en production pour le débogage et le suivi des coûts