
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.
| Contrôle | Question traitée | Ce qu'il ne prouve pas |
|---|---|---|
| Analyse JSON | La réponse peut-elle être lue comme du JSON ? | La présence des champs requis ou de valeurs autorisées |
| Validation du schéma | L'enregistrement respecte-t-il la structure déclarée ? | La justification de ses affirmations par l'entrée |
| Validation applicative | Les 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écution | L'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é.
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.
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é.
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 cas | Résultat local observé | Décision applicative suivante |
|---|---|---|
| Enregistrement ordinaire ; catégorie unknown avec référence de commande nulle | Les deux respectent le schéma | Vé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 double | Les sept sont refusés par le schéma | Les exclure du traitement en aval |
| JSON tronqué | Échec de l'analyse | Traiter 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éma | Rejeter 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.
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.
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.
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.
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.
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.