Aller au contenu
TokIQ
Sortie

Obtenir du JSON fiable d'un LLM : schéma, validation

Obtenir un JSON valide d'un LLM ne se résume pas à demander poliment : schémas, sorties structurées, validation, nouvelles tentatives et pannes classiques.

TokIQ Editorial6 min de lecture
Dans cet article
  1. Pourquoi les modèles cassent-ils le JSON ?
  2. Étape 1 : décrire précisément la sortie dans le prompt
  3. Étape 2 : utiliser la sortie structurée de l'API
  4. Étape 3 : tout valider, même avec un schéma imposé
  5. Étape 4 : relancer avec l'erreur, pas à l'aveugle
  6. Où placer le raisonnement dans une réponse JSON ?
  7. Erreurs courantes de conception des schémas de sortie
  8. Le prompt seul suffit-il parfois ?

Pour obtenir un JSON fiable d'un modèle de langage, définissez la structure sous forme de JSON Schema, utilisez la fonction de sortie structurée du fournisseur quand elle existe, validez chaque réponse dans votre code et relancez avec l'erreur de validation en cas d'échec. La formulation du prompt vous mène presque au bout du chemin ; les derniers points de fiabilité viennent de l'API et de votre propre validation.

La distinction compte, car « presque au bout » ne suffit pas pour du code. Un parseur qui échoue sur 2 % des réponses, c'est une fonctionnalité cassée pour quelqu'un toutes les quelques minutes à grande échelle.

Pourquoi les modèles cassent-ils le JSON ?

Avant de corriger, il faut savoir ce qui se passe vraiment. À peu près dans l'ordre où vous les rencontrerez :

  1. Les blocs de code markdown. Le modèle renvoie ```json ... ``` parce que les modèles de chat sont entraînés à bien présenter le code.
  2. Les préambules bavards. « Bien sûr ! Voici le JSON demandé : », suivi de l'objet.
  3. Les clés fausses ou inventées. customerName au lieu de customer_name, ou un champ notes en plus que vous n'aviez pas demandé.
  4. Les mauvais types. "price": "19.99" sous forme de chaîne, "count": "three", un objet seul là où vous attendiez un tableau.
  5. La troncature. La réponse atteint la limite maximale de tokens et s'arrête au milieu d'un objet.
  6. Le non-sens syntaxiquement valide. Un JSON parfait au contenu faux : une date au mauvais format, un numéro de téléphone halluciné, null alors que la valeur figurait dans le texte d'entrée.

Les fonctions de sortie structurée éliminent les cinq premiers, pour l'essentiel. Rien n'élimine le sixième, sauf un bon prompt, l'ancrage dans les sources et des contrôles.

Étape 1 : décrire précisément la sortie dans le prompt

Même avec un schéma imposé, c'est dans le prompt que vous expliquez ce que signifie chaque champ. Un schéma dit que due_date est une chaîne ; seul le prompt peut dire qu'elle doit suivre la norme ISO 8601 et que les dates relatives doivent être résolues par rapport à la date d'envoi de l'e-mail.

Un prompt faible :

Extrais les informations de la facture de cet e-mail au format JSON.

Un prompt plus solide :

Extrais les informations de la facture à partir de l'e-mail ci-dessous.

Renvoie un seul objet JSON avec exactement ces clés :
- "vendor" : chaîne, l'entreprise qui a émis la facture
- "invoice_number" : chaîne, telle qu'écrite (conserve les zéros initiaux)
- "total" : nombre, dans la devise de la facture, sans symbole monétaire
- "currency" : chaîne, code ISO 4217 comme "USD" ou "EUR"
- "due_date" : chaîne au format YYYY-MM-DD, ou null si elle n'est pas indiquée

Si une valeur ne figure pas dans l'e-mail, utilise null. Ne devine pas.
Renvoie uniquement l'objet JSON, sans markdown et sans explication.

<email>
{{email_text}}
</email>

Deux détails pèsent lourd ici. « Conserve les zéros initiaux » empêche le modèle de transformer « utilement » 00417 en 417. Et « utilise null, ne devine pas » lui offre une sortie légitime. Sans option null explicite, un modèle soumis à un champ obligatoire inventera une valeur plausible plutôt que de laisser le champ vide.

Étape 2 : utiliser la sortie structurée de l'API

La plupart des grands fournisseurs proposent désormais un moyen de contraindre la sortie à un schéma. Les noms et les détails varient et évoluent, donc vérifiez la documentation actuelle, mais les principales options ressemblent à ceci :

  • OpenAI propose un JSON mode de base qui garantit un JSON syntaxiquement valide, et les Structured Outputs, où l'on passe un JSON Schema avec le mode strict et où la sortie est contrainte de s'y conformer.
  • Google Gemini permet de définir le type MIME de la réponse sur JSON et de fournir un schéma de réponse.
  • Anthropic permet de définir un outil avec un schéma d'entrée et de faire appeler cet outil par Claude, ce qui donne des arguments conformes au schéma ; sa documentation décrit aussi une prise en charge native de la sortie structurée.

La distinction importante est JSON mode vs application du schéma. Le JSON mode promet seulement que le texte se parse. Vos clés peuvent rester fausses. L'application du schéma (souvent réalisée par décodage contraint, qui limite les tokens que le modèle a le droit de générer ensuite) promet la forme.

Un schéma pour l'exemple de la facture :

{
  "type": "object",
  "properties": {
    "vendor": { "type": ["string", "null"] },
    "invoice_number": { "type": ["string", "null"] },
    "total": { "type": ["number", "null"] },
    "currency": { "type": ["string", "null"], "enum": ["USD", "EUR", "GBP", null] },
    "due_date": { "type": ["string", "null"], "description": "YYYY-MM-DD" }
  },
  "required": ["vendor", "invoice_number", "total", "currency", "due_date"],
  "additionalProperties": false
}

Remarquez les types nullables. Dans les modes stricts, tous les champs sont généralement obligatoires : « facultatif » doit donc s'exprimer par « obligatoire mais pouvant valoir null ». Remarquez aussi additionalProperties: false, qui empêche les champs surprises. Les modes stricts ne prennent généralement en charge qu'un sous-ensemble de JSON Schema ; vérifiez donc quels mots-clés sont autorisés avant de construire quelque chose d'élaboré.

Si vous utilisez Python ou TypeScript, définissez le schéma comme un modèle Pydantic ou un schéma Zod et générez le JSON Schema à partir de lui. La même définition valide alors la réponse, et les deux ne peuvent pas diverger.

Étape 3 : tout valider, même avec un schéma imposé

L'application du schéma garantit la structure. Elle ne garantit pas :

  • que due_date soit une vraie date (le 30 février est une chaîne valide),
  • que total corresponde à la somme des lignes,
  • que vendor apparaisse quelque part dans l'e-mail d'origine,
  • que le modèle n'ait pas omis la troisième ligne sur cinq.

Écrivez les contrôles qui comptent pour votre domaine. Parsez les dates. Vérifiez que les totaux ne sont pas négatifs. Pour les tâches d'extraction, vérifiez que les chaînes extraites figurent bien dans l'entrée ; ce simple test attrape étonnamment d'hallucinations.

Étape 4 : relancer avec l'erreur, pas à l'aveugle

Quand la validation échoue, ne renvoyez pas simplement la même requête en espérant. Renvoyez l'erreur :

Ta réponse précédente a échoué à la validation :
- "due_date" : "3 mars" ne respecte pas le format YYYY-MM-DD
- "currency" : "dollars" n'est pas l'une des valeurs USD, EUR, GBP

Renvoie uniquement l'objet JSON corrigé.

Les modèles corrigent bien les erreurs précises et nommées. Limitez les relances à une ou deux, journalisez chaque échec et regardez les journaux chaque semaine. Des échecs répétés sur le même champ signalent généralement un prompt ou un schéma peu clair, pas un modèle capricieux. Des bibliothèques comme Instructor (Python) encapsulent cette boucle valider-relancer, mais le principe est assez simple pour l'écrire soi-même.

Pour une casse purement syntaxique chez les fournisseurs sans sortie imposée, un parseur tolérant qui retire les blocs de code et le texte final avant JSON.parse règle les cas les plus courants. C'est un filet de secours, pas une stratégie.

Où placer le raisonnement dans une réponse JSON ?

Si la tâche demande du jugement (une classification avec justification, un score de risque), placez un champ de raisonnement avant le champ de décision :

{
  "evidence": "Le client mentionne un double prélèvement sur la facture de mars.",
  "category": "billing",
  "confidence": "high"
}

Les modèles génèrent les champs dans l'ordre. Une décision écrite en premier est justifiée après coup au lieu d'être éclairée par le raisonnement. Nous détaillons ce point dans le chain-of-thought prompting expliqué.

Revers de la médaille : les champs de raisonnement coûtent des tokens à chaque appel. Pour une extraction simple, laissez-les de côté.

Erreurs courantes de conception des schémas de sortie

Un niveau d'imbrication inutile. Trois niveaux d'objets là où une liste à plat suffirait. Chaque niveau est une occasion de plus pour le modèle de mal placer une valeur.

Des champs de texte libre qui devraient être des enums. Si le code en aval se ramifie selon status, faites-en un enum. Sinon vous obtiendrez « Pending », « pending », « In progress » et « awaiting review » pour la même chose.

Des noms de champs ambigus. Une date sur une facture peut être la date d'émission, d'échéance ou de paiement. Appelez-la due_date et décrivez-la.

En demander trop en un seul appel. Un schéma de quarante champs extraits d'un contrat de vingt pages invite aux omissions. Découpez : un appel par section, ou un appel pour localiser les passages pertinents et un autre pour en extraire les données.

Oublier le cas vide. Que doit renvoyer la sortie si l'e-mail n'est pas du tout une facture ? Ajoutez un booléen is_invoice ou autorisez un résultat vide, sinon le modèle extraira une facture d'une invitation à déjeuner.

Le prompt seul suffit-il parfois ?

Pour des prototypes, des scripts lancés à la main ou des modèles sans sortie structurée, oui. Une description précise du format, un exemple de la sortie exacte et un parseur défensif vous amènent à une fiabilité élevée. Pour tout ce qui est en contact avec les utilisateurs, imposez le schéma quand c'est possible et validez toujours.

La compétence de fond est la même dans tous les cas : décrire la sortie si précisément qu'il n'y a qu'une seule façon raisonnable de la remplir. Le thème sortie structurée travaille ces décisions, et si le JSON que vous produisez est un appel d'outil plutôt qu'une réponse finale, le tool calling et les agents IA prennent le relais. Pour une extraction ancrée dans des documents sources, voir ce qu'est la RAG.

Questions fréquentes

Comment forcer un LLM à renvoyer du JSON valide ?

Utilisez la fonction de sortie structurée du fournisseur avec un JSON Schema quand elle existe, car elle contraint la génération au schéma. Validez ensuite quand même le résultat dans votre code, et relancez ou réparez en cas d'échec de la validation.

Quelle différence entre le JSON mode et les structured outputs ?

Le JSON mode fait produire au modèle un JSON syntaxiquement valide, mais ne garantit ni vos clés ni vos types. Les structured outputs avec un schéma strict contraignent la sortie à respecter le schéma que vous fournissez.

Pourquoi mon LLM entoure-t-il le JSON de blocs de code markdown ?

Les modèles de chat sont entraînés à bien présenter le code pour les humains. Demandez au modèle de ne renvoyer que l'objet JSON brut, ou utilisez un mode de sortie structurée, et retirez les blocs de code par prudence dans votre parseur.

Faut-il valider le JSON d'un LLM même avec un schéma ?

Oui. Un schéma garantit la forme, pas la véracité. Le JSON peut être parfaitement valide et contenir quand même une date fausse, une valeur inventée ou un champ vide alors que la donnée existait.

  • #sortie structurée
  • #JSON
  • #JSON schema
  • #validation

À vous de jouer

TokIQ transforme le prompt engineering en courts quiz, avec une explication pour chaque réponse.

Bientôt surApp StoreDisponible surGoogle Play

Écrivez de meilleurs prompts, quelques questions par jour.

De courts quiz sur de vraies décisions de prompting, avec une explication pour chaque réponse. Gratuit pour commencer sur iPhone et Android.

Bientôt surApp StoreDisponible surGoogle Play