← Blog
Un porte-bloc lavande avec une feuille crème vierge sous une pince orange.
Publié le
2026-11-13

Sorties structurées de LLM : valider le résultat

Une sortie structurée de LLM donne à l'application une forme prévisible pour la réponse du modèle, par exemple un objet JSON avec des champs définis. Cela facilite l'intégration, mais un enregistrement bien formé peut encore contenir des preuves inventées, mal interpréter une demande ou décrire une action qui n'a jamais eu lieu.

Commencez par le contrat attendu par l'application. Vérifiez ensuite sa prise en charge par le système d'inférence, validez chaque réponse terminée et définissez le traitement des résultats non acceptables. Le schéma constitue une partie de ce processus.

Séparer quatre contrôles avant d'utiliser le résultat

ContrôleQuestion traitéeCe qu'il ne prouve pas
Analyse JSONLa réponse peut-elle être lue comme du JSON ?La présence des champs requis ou de valeurs autorisées
Validation du schémaL'enregistrement respecte-t-il la structure déclarée ?La justification de ses affirmations par l'entrée
Validation applicativeLes identifiants, preuves et règles métier permettent-ils d'accepter ce résultat ?L'autorisation de l'appelant à effectuer une action
Autorisation et exécutionL'opération peut-elle être exécutée, et quel est son résultat réel ?La réalisation préalable d'un résultat proposé par le modèle

Demander du JSON au modèle, activer le mode JSON d'un fournisseur et utiliser une génération contrainte par schéma sont des choix différents. Lisez les garanties de l'endpoint précis. Un JSON lisible n'impose pas vos champs ; même une génération contrainte nécessite un contrôle d'acceptation côté application.

Notre guide des API compatibles OpenAI explique pourquoi un format familier constitue seulement le point de départ des tests de compatibilité.

Définir un petit contrat pour les tickets de support

Prenons un assistant fictif qui prépare des tickets pour vérification. Son message source en anglais, identifié par msg-1, indique : « I was charged twice for order A-104. » Le client déclare donc avoir été débité deux fois pour cette commande. L'assistant peut résumer ce signalement et proposer une catégorie. Il ne peut pas confirmer l'historique des paiements ni approuver un remboursement.

Voici un exemple d'enregistrement, avec les valeurs de démonstration en anglais :

{
  "category": "billing",
  "order_id": "A-104",
  "source_ids": [
    "msg-1"
  ],
  "summary": "Customer reports two charges for order A-104."
}

L'application conserve la maîtrise de l'identité du ticket et des messages sources autorisés. Le modèle fournit seulement quatre champs : une catégorie, une référence de commande si elle est connue, des références aux sources et un court résumé. Utilisez la catégorie explicite unknown lorsque l'entrée ne permet pas de déterminer la demande.

Ce schéma applicatif d'exemple utilise JSON Schema Draft 2020-12 :

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "type": "object",
  "additionalProperties": false,
  "required": [
    "category",
    "order_id",
    "source_ids",
    "summary"
  ],
  "properties": {
    "category": {
      "type": "string",
      "enum": [
        "billing",
        "technical",
        "unknown"
      ]
    },
    "order_id": {
      "type": [
        "string",
        "null"
      ],
      "minLength": 1
    },
    "source_ids": {
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1
      },
      "uniqueItems": true
    },
    "summary": {
      "type": "string",
      "minLength": 1,
      "maxLength": 240
    }
  }
}

La documentation des objets JSON Schema explique les propriétés requises et le contrôle des propriétés supplémentaires. Ici, les quatre champs sont obligatoires et tout champ supplémentaire est refusé. Un champ inventé approve_refund échoue donc à la validation.

Un champ obligatoire peut autoriser null. Dans ce contrat, order_id: null signifie que la référence de commande n'est pas disponible ; l'absence du champ est un autre résultat. La référence JSON Schema sur null explicite cette différence. N'obligez pas le modèle à inventer une valeur pour remplir une chaîne obligatoire.

Stabilisez le sens des champs et versionnez le contrat. Si les catégories autorisées ou le sens d'une liste de preuves vide changent, mettez à jour les applications consommatrices et les tests ensemble. Ce schéma sert à la validation locale ; il ne garantit pas que chaque endpoint d'inférence accepte tous ses mots-clés.

Vérifier le modèle et le parcours d'inférence

La prise en charge dépend du moteur, de sa version, du moteur de décodage, de la configuration du modèle et du parcours de la requête. La documentation vLLM sur les sorties structurées décrit la génération contrainte par schéma et des options dépendant de la version. Utilisez des exemples adaptés à votre version plutôt que de reprendre d'anciens champs sans les vérifier.

Testez le schéma réel sur l'endpoint prévu. Relevez les contraintes acceptées, les éventuelles erreurs explicites pour les contraintes non prises en charge, le signalement d'une sortie incomplète et l'emplacement du contenu final. Le streaming, le raisonnement et les outils peuvent nécessiter un traitement des réponses qu'un simple appel textuel ne teste pas.

Si plusieurs serveurs peuvent recevoir la requête, testez chacun d'eux. Un serveur de repli qui renvoie du texte libre ou interprète un champ autrement peut rompre le contrat malgré la réussite de la requête HTTP. Le guide du routage de modèles avec Hivenet Router présente les règles et contrôles de capacités ; ils ne remplacent pas la validation de l'enregistrement retourné.

Tester le validateur avec des enregistrements acceptables et incorrects

Nous avons vérifié le schéma localement avec Python jsonschema 4.26.0 et son validateur Draft 2020-12. La documentation du validateur explique la vérification des schémas et des instances. Les 12 cas ont testé uniquement l'analyse JSON et les règles du schéma ; aucun modèle, moteur d'inférence ou endpoint Router n'a été appelé.

Groupe de casRésultat local observéDécision applicative suivante
Enregistrement ordinaire ; catégorie unknown avec référence de commande nulleLes deux respectent le schémaVérifier le premier ; envoyer le cas inconnu en vérification humaine
Champ manquant, mauvais type de commande, catégorie interdite, action supplémentaire, résumé nul, résumé vide, référence source en doubleLes sept sont refusés par le schémaLes exclure du traitement en aval
JSON tronquéÉchec de l'analyseTraiter comme une réponse incomplète
Identifiant source inventé ; résumé affirmant qu'un remboursement a été approuvé et payéLes deux respectent le schémaRejeter les preuves ou affirmations non étayées par des contrôles applicatifs distincts

La dernière ligne montre la limite importante. Une chaîne peut respecter le schéma tout en désignant un message absent des entrées. Une affirmation de remboursement peut tenir dans la longueur autorisée et contredire la tâche. Ces exemples montrent la limite de la validation du schéma, pas la précision d'un modèle.

Dans ce traitement, vérifiez que chaque référence appartient aux sources autorisées et justifie réellement l'affirmation. Contrôlez la référence de commande dans le contexte permis et préservez la distinction entre « le client signale un débit » et « le débit est vérifié ». L'existence d'une référence ne suffit pas à en faire une preuve.

Prévoir les informations manquantes et les échecs

Distinguez les résultats inconnus, refusés, incomplets et invalides. Un refus ou une erreur au niveau de l'API peut arriver hors du schéma métier. Ne le transformez pas en enregistrement fabriqué avec des valeurs par défaut pour satisfaire un analyseur en aval.

Avec le streaming, rassemblez le contenu complet attendu et vérifiez l'état de fin documenté avant de l'accepter. Un enregistrement partiel peut sembler plausible avant la fin de la réponse. Si le flux s'interrompt ou atteint une limite de longueur, appliquez le parcours de réponse incomplète.

Limitez les nouvelles tentatives avec un budget global de temps et de coût. Une réponse mal formée peut justifier un nouvel essai ; un schéma non pris en charge ou un refus d'accès nécessite une autre solution. Répéter indéfiniment une requête incompatible augmente le coût sans résoudre la cause.

  • Conservez les identifiants de requête et de réponse d'origine pour suivre les tentatives.
  • Enregistrez les résultats de validation sans recopier inutilement des données sensibles dans les journaux.
  • Préservez les sources et la version du contrat utilisées pour décider.
  • Dirigez les enregistrements non résolus vers un état de vérification ou d'échec défini.
  • Séparez les enregistrements acceptés de l'exécution des actions, avec autorisation et protection contre les actions en double à cette frontière.

Un champ généré ne doit jamais prouver qu'un remboursement, une modification de compte ou une écriture externe a réussi. Le composant qui exécute l'action doit indiquer son résultat réel. Traitez les instructions contenues dans les messages clients comme des données, sans leur permettre de contourner ces contrôles.

Évaluer les résultats acceptés, la latence et le coût complet

Constituez un jeu étiqueté avec des demandes simples, des informations manquantes, des preuves contradictoires, des références invalides, des messages longs et des demandes non prises en charge. Séparez les tests finaux des exemples utilisés pour ajuster les prompts ou les règles d'acceptation.

Mesurez séparément le taux de conformité au schéma, la justesse de la tâche et la justification par les sources. Mesurez aussi les cas inconnus, la vérification humaine, les échecs après nouvelles tentatives, la latence de bout en bout et le coût total par enregistrement accepté. Incluez les générations rejetées, tentatives, validations et vérifications dans ce coût. Un taux élevé de JSON valide peut coexister avec une application inutilisable.

Répétez l'évaluation après une modification des modèles, prompts, schémas, moteurs de décodage ou règles de routage. Les cas locaux présentés restent utiles pour détecter les régressions du validateur, mais ne prouvent pas le comportement d'un déploiement d'inférence face à de vraies requêtes.

Préparer le traitement avec Hivenet

Compute avec Hivenet fournit une infrastructure pour les applications et moteurs d'inférence exploités par le client. Conservez la validation des sorties dans l'application même si le moteur choisi propose une génération contrainte. Si plusieurs serveurs auto-hébergés nécessitent du routage, vérifiez le contrat sur chaque parcours autorisé.

Pour un traitement sensible ou spécifique, Private AI avec Hivenet permet d'aborder les données, le modèle, l'endpoint et les besoins d'exploitation. Préparez le schéma, des entrées représentatives, les sorties inacceptables, les règles d'accès et les tests d'acceptation avant de discuter du traitement avec Hivenet. La première évaluation porte ainsi sur des enregistrements assez fiables pour être utilisés par l'application.

Votre prochaine charge de travail sur Hivenet.

Choisissez une charge de travail d’IA, de calcul ou de stockage à tester sur Hivenet, ou échangez avec notre équipe sur sa mise en production.