FR ▾
Obtenir une clé API

Tests de migration d'API pour les applications LLM : un plan pratique

Le test de migration d'API pour une application LLM diffère du test d'une API REST classique, car le même prompt ne retourne jamais exactement le même texte. Vous testez les propriétés de la réponse, pas les chaînes exactes.

Dernière mise à jour

Deux ballons en verre versant de la lumière sur des balances identiques pour illustrer la comparaison des sorties de l'ancien et du nouveau fournisseur

Résumé

  • Créez un ensemble de référence de 50 à 200 prompts réels avec des vérifications basées sur des règles, pas des attentes de correspondance exacte.
  • Fixez la température et la graine pour réduire le bruit, mais n'attendez jamais un texte identique.
  • Enregistrez les percentiles de latence et le coût par requête sur l'ancien et le nouveau chemin.
  • Notez les déclencheurs de retour en arrière avant le début du déploiement.

Ce que vous testez réellement

Avec une API classique, vous comparez les réponses octet par octet. Avec un modèle de langage, cela échoue immédiatement. Décidez plutôt quelles propriétés de la réponse votre produit nécessite, et testez-les.

  • Forme. JSON valide, clés requises, un appel d'outil avec les bons arguments.
  • Contenu. Mentionne les faits requis, respecte le format, reste dans le rôle.
  • Sûreté du produit. Pas de refus là où une réponse est attendue, pas de fuite du prompt système.
  • Opérations. Latence, taux d'erreur, comportement de la limite de débit, coût.

Si vous avez encore besoin des étapes de basculement elles-mêmes, le plan est dans le guide de migration sur ce site, et les erreurs rencontrées en cours de route sont couvertes dans erreurs courantes d'intégration LLM. Cet article couvre la vérification.

Construisez l'ensemble de prompts de référence

Récupérez 50 à 200 prompts réels depuis vos logs (supprimez les données personnelles d'abord). Couvrez le chemin commun, les cas délicats et les cas qui ont échoué auparavant. Stockez chaque cas comme un enregistrement avec ses messages, paramètres et les vérifications qu'il doit passer.

{
  "id": "invoice-json-03",
  "messages": [
    {"role": "system", "content": "Extract fields. Reply with JSON only."},
    {"role": "user", "content": "Invoice 4471 from Acme, total 1,250 EUR, due 2025-03-01"}
  ],
  "json": true,
  "required_keys": ["number", "vendor", "total"],
  "must_contain": ["4471"]
}

Étiquetez les cas par risque : appels de fonctions, contexte long, streaming, non-anglais, réponses très courtes et très longues. Lorsqu'un bug apparaît en production plus tard, ajoutez-le à l'ensemble. L'ensemble devient votre suite de régression.

Écrivez un cadre de test qui enregistre tout

Un script doit exécuter l'ensemble complet contre un chemin, appliquer les vérifications et enregistrer les chiffres. Utilisez temperature=0 et une graine fixe pour réduire la variation. Les deux sont transmis par cette API, mais considérez-les comme une réduction de bruit, pas une garantie.

import json, time
from openai import OpenAI

client = OpenAI(base_url="https://api.apimigration.com/v1", api_key="YOUR_KEY")
PRICE_IN, PRICE_OUT = 0.15, 0.50  # USD per 1M tokens

def run(case):
    t0 = time.perf_counter()
    raw = client.chat.completions.with_raw_response.create(
        model="uncensored",
        messages=case["messages"],
        temperature=0,
        seed=42,
    )
    elapsed = time.perf_counter() - t0
    resp = raw.parse()
    text = resp.choices[0].message.content or ""
    u = resp.usage
    return {
        "id": case["id"],
        "text": text,
        "seconds": elapsed,
        "cost": (u.prompt_tokens * PRICE_IN + u.completion_tokens * PRICE_OUT) / 1e6,
        "balance": raw.headers.get("X-Balance-USD"),
        "request_id": raw.headers.get("X-Request-Id"),
    }

Conservez l'ID X-Request-Id pour chaque cas échoué. C'est ce que vous citez lorsque vous demandez du support concernant une requête spécifique.

Différez par règles, pas par chaînes

Appliquez les vérifications de chaque enregistrement. Tout ce qui échoue va dans une courte liste pour une lecture humaine.

def check(case, text):
    problems = []
    if case.get("json"):
        try:
            obj = json.loads(text)
        except ValueError:
            return ["invalid json"]
        for key in case.get("required_keys", []):
            if key not in obj:
                problems.append("missing key " + key)
    for needle in case.get("must_contain", []):
        if needle.lower() not in text.lower():
            problems.append("missing text " + needle)
    if len(text.strip()) < case.get("min_chars", 1):
        problems.append("answer too short")
    return problems

Pour les réponses libres, ajoutez une bande de longueur peu coûteuse (par exemple entre la moitié et le double de l'ancienne réponse) et une courte liste de phrases de refus pour signaler. Ensuite, lisez 20 sorties côte à côte à l'œil. Les règles détectent les régressions ; la lecture détecte le ton. Faites les deux.

Pour les sorties JSON, définissez response_format sur {"type":"json_object"} et validez toujours, car les vérifications ci-dessus sont peu coûteuses.

Testez les chemins d'échec intentionnellement

Les prompts happy-path passent sur presque tous les fournisseurs. Les échecs sont là où les migrations font mal, donc provoquez-les délibérément avant que les utilisateurs ne le fassent.

  • Mauvaise clé. Envoyez une requête avec une clé incorrecte et confirmez que votre application affiche un message raisonnable et ne réessaie pas en boucle.
  • Limites de débit. Envoyez plus de 8 requêtes à la fois avec une clé complète (2 avec une clé d'essai) et confirmez que votre code gère le HTTP 429 avec le code concurrency, puis le code rate_limited si vous dépassez le plafond par minute.
  • Surcharge temporaire. Un 429 avec Retry-After: 5 doit entraîner une attente de cinq secondes, pas une tentative de réessai immédiate.
  • Entrée surdimensionnée. Envoyez un prompt proche de la fenêtre de 100 000 tokens et un au-delà. Votre application doit tronquer ou résumer, et non planter.
  • Gros corps. La limite est de 8 Mo. Confirmez que vous rejetez les charges utiles plus grandes vous-même.
  • Flux interrompus. Coupez la connexion en plein streaming et confirmez que le créneau de concurrence revient.

Chacun de ces cas doit avoir un test automatisé qui s'exécute en CI contre un serveur factice, plus un passage manuel contre le vrai.

Vérifiez le streaming et les appels de fonctions

Le streaming et les outils changent la forme de la réponse, donc un ensemble de référence construit sur du texte brut les manque. Ajoutez un cas pour chacun.

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up an order by id",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

r = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Where is order A-1042?"}],
    tools=tools,
    tool_choice="auto",
)
calls = r.choices[0].message.tool_calls or []
assert calls and calls[0].function.name == "get_order_status"
print(calls[0].function.arguments)

L'assertion vérifie que l'appel existe et que les arguments s'analysent comme le JSON attendu. Ajoutez une vérification que le second tour, avec le résultat renvoyé comme un message avec role: "tool", produit une réponse normale. Pour les streams, vérifiez que les morceaux arrivent, que l'utilisation finale apparaît et que votre code arrête de lire à la fin du stream.

Suivez latence et coût par route

Exécutez l'ensemble sur l'ancienne et la nouvelle route et comparez les mêmes colonnes : médiane et 95e percentile en secondes, nombre d'erreurs, tokens, coût. Cet article ne donne aucun chiffre de latence pour aucun fournisseur, car le vôtre dépendra de vos prompts et du réseau. Mesurez le vôtre.

Le coût pour la nouvelle route est le nombre de tokens multiplié par les tarifs, $0,15 par 1M d'entrée et $0,50 par 1M de sortie. Exemple : 200 prompts de référence moyennant 1 200 tokens d'entrée et 300 tokens de sortie.

  • Entrée : 240 000 tokens x $0,15 / 1 000 000 = $0,036.
  • Sortie : 60 000 tokens x 0,50 $ / 1 000 000 = 0,03 $.
  • Une exécution complète : $0,066.

Le crédit d'essai de $0,50 couvre environ sept exécutions de ce type. Une clé d'essai permet 2 requêtes simultanées et 60 par minute, donc 200 prompts prennent au moins trois minutes et demie. Les requêtes échouées ou refusées ne sont pas facturées. Vous pouvez aussi lire le solde depuis l'en-tête X-Balance-USD après chaque appel pour confirmer vos propres calculs.

Trafic fantôme et déploiement progressif

Une fois que l'ensemble de référence passe, copiez les requêtes réelles vers la nouvelle route sans afficher les réponses. Enregistrez les résultats et comparez-les aux réponses réelles avec les mêmes vérifications. Les exécutions fantômes nécessitent un plafond de concurrence : une clé complète permet 8 requêtes à la fois, donc mettez en file d'attente les appels miroirs au lieu de les envoyer tous ensemble.

Puis déplacez les vrais utilisateurs par étapes, comme 5 %, 25 %, 50 % et 100 %. Maintenez chaque étape jusqu'à ce que le taux d'erreur, les vérifications échouées et les plaintes restent stables.

Définissez les règles de retour en arrière à l'avance

Écrivez les seuils avant de déplacer le premier utilisateur, afin que la décision en temps réel soit mécanique.

SignalExemple de déclencheur
Échecs de vérification sur le trafic réelPlus que votre part convenue échoue aux vérifications de règles
Taux HTTP 429 ou 5xxMaintenu au-dessus de la base de l'ancienne route
Latence p95Au-dessus du budget de temps mort de votre produit
Coût par requêteAu-dessus de l'estimation d'une marge définie
Signalements utilisateursUn cluster sur le même comportement

Le rollback doit être un changement de configuration, pas un déploiement. Gardez l'ancienne route financée et configurée pendant au moins quelques jours après 100 %. Lorsque vous êtes prêt à lancer les tests, obtenez une clé API et réclamez l'essai, vérifiez les tarifs pour les exécutions plus importantes, et utilisez la documentation pour les détails de l'endpoint.

Questions fréquentes

Combien de prompts de référence avez-vous besoin ?

Cinquante à deux cents prompts réels couvrent la plupart des applications. La qualité compte plus que le nombre, donc incluez les cas difficiles et ceux qui ont échoué précédemment.

Puis-je comparer les sorties avec une différence exacte ?

Pas de manière fiable. Même à température 0 avec une graine fixe, considérez les sorties comme variables et testez des règles telles que JSON valide, faits requis et longueur.

Comment suivre les coûts pendant les tests ?

Multipliez les tokens d'utilisation par 0,15 $ par 1 M d'entrée et 0,50 $ par 1 M de sortie, et surveillez l'en-tête X-Balance-USD pour le solde réel.

Qu'est-ce qui doit déclencher un retour en arrière ?

Définissez d'abord les seuils : échecs des vérifications, taux 429 ou 5xx, latence par rapport à votre délai d'attente, et coût par rapport à l'estimation.

Obtenez votre clé API

Inscrivez-vous, copiez la clé, mettez à jour l'URL de base. L'installation est terminée.

Obtenir une clé API