Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Anti-motifs d'API

Lektion 12 av 16 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Les erreurs qui coûtent cher en production
  2. Traiter une réponse tronquée comme complète
  3. Laisser l’historique de conversation grandir sans limite
  4. Supposer que le réseau répond toujours
  5. Demander au modèle de faire ce qu’il ne peut pas faire
  6. Déployer sans laisser de trace
  7. Une routine de débogage
  8. Viktiga punkter

Les erreurs qui coûtent cher en production

Après avoir vu les bonnes pratiques, il est temps d’examiner l’envers du décor. Les anti-motifs 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 parfaitement. C’est en production qu’ils explosent, entraînant des coûts imprévus, 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 fréquente consiste à ignorer finish_reason. Tu demandes un contrat, tu reçois du texte, 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’à la signature du client. La correction tient en 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 limite

Le deuxième piège se déclenche lentement. Une boucle de chat qui envoie l’intégralité de l’historique de 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 — la 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 brut suppose que rien ne peut mal tourner : pas de délai d’attente, pas d’erreur 429, pas d’erreur 500. En production, les trois se produisent, et le troisième arrive au pire moment. Note la distinction dans le code : une erreur 429 justifie un backoff exponentiel, une erreur serveur mérite une seconde de patience, mais une erreur client comme une 400 ou 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-motifs convergent ici. Le premier est le langage subjectif : « court », « nombreux », « 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."              # Nombreux = 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 consiste à 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 bien 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-motif 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’investigation 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})")

Viktiga punkter

  • Vérifie toujours finish_reason pour 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