Extraire des données structurées

Demandez à Claude de générer du JSON, du Python ou une liste structurée, et vous recevrez presque toujours un supplément non commandé : du texte explicatif autour — « Voici la règle demandée : », des blocs markdown, une conclusion aimable. Charmant en conversation, rédhibitoire dans un programme qui veut parser la sortie. Pour obtenir uniquement les données brutes, on combine les deux techniques de la leçon précédente : le pré-remplissage et les séquences d’arrêt — chacune fermant une extrémité de la réponse.

Le problème

Donnons-lui un visage concret. Imaginez une application web qui génère des règles AWS EventBridge : l’utilisateur décrit ce qu’il veut, clique sur « générer », et s’attend à recevoir du JSON propre, prêt à copier dans sa console AWS. Si Claude enveloppe le JSON dans un bloc de code markdown précédé d’explications, l’application doit soit afficher ce fatras, soit écrire du code fragile pour découper la réponse — deux mauvaises options. Ce qu’il faut, c’est que la sortie du modèle soit la donnée, sans emballage.

La solution

Quatre lignes suffisent :

messages = []
add_user_message(messages, "Génère une regle EventBridge courte en JSON")
add_assistant_message(messages, "```json")

text = chat(messages, stop_sequences=["```"])

Le pré-remplissage "```json" ouvre un bloc de code à la place de Claude ; la séquence d’arrêt "```" guette la fermeture de ce même bloc. Entre les deux, il ne peut rien se glisser d’autre que le contenu.

Comment ça fonctionne

Décomposons le raisonnement que ces quatre lignes imposent au modèle :

1. Claude lit le message utilisateur et pense qu’il doit écrire une règle complète
2. Il voit le message assistant pré-rempli et suppose qu’il a déjà commencé le bloc JSON
3. Il génère directement le contenu JSON
4. Quand il essaie de fermer le bloc avec ```, la séquence d’arrêt coupe immédiatement la génération

Le pré-remplissage neutralise le préambule : impossible d’écrire « Voici la règle : » quand on a déjà, du point de vue du modèle, ouvert le bloc de code. La séquence d’arrêt neutralise la conclusion : la génération meurt au moment exact où le bloc se referme. Le résultat : tout ce qui se trouve entre le début pré-rempli et la séquence d’arrêt — soit exactement le contenu voulu, et rien d’autre.

Nettoyage

Reste un détail de finition avant l’usage programmatique :

import json

parsed_json = json.loads(text.strip())

Le strip() retire les éventuels sauts de ligne en bordure de la sortie, et json.loads fait d’une pierre deux coups : il convertit le texte en dictionnaire Python exploitable, et il valide au passage que la sortie est bien du JSON correct — si le modèle a produit une structure bancale, l’exception le signale immédiatement, au bon endroit, plutôt que plus loin dans l’application.

La technique n’a rien de spécifique au JSON : elle fonctionne pour tout format structuré — code Python (pré-remplir ```python), listes à puces, expressions régulières. Le principe reste invariant : ouvrir le format à la place du modèle, couper à la marque de fermeture.

Points clés à retenir

• Le texte d’accompagnement autour des données rend la sortie inutilisable par un programme
• Pré-remplissage ```json = pas de préambule possible ; stop sequence ``` = pas de conclusion possible
• La réponse est alors exactement le contenu du bloc, prêt à parser
• json.loads(text.strip()) convertit et valide — les malformations éclatent tôt et au bon endroit
• Le schéma se transpose à tout format : ouvrir le format pour le modèle, couper à sa fermeture