Donnees structurees

Le probleme

Quand vous demandez a Claude de generer du JSON, du code ou tout autre format structure, il a tendance a envelopper sa reponse dans du texte explicatif :

Voici la configuration JSON que vous avez demandee :

```json
{"server": "nginx", "port": 80}

N’hesitez pas a adapter les valeurs selon vos besoins !

C'est tres bien pour un humain qui lit la reponse. Mais c'est un cauchemar pour du code qui doit **parser** la sortie. Un `json.loads()` sur ce texte va echouer immediatement.

## La solution : prefill + stop sequence

En combinant les deux techniques vues dans la lecon precedente, on peut extraire **uniquement** le contenu structure :

1. **Prefill** : on commence la reponse avec le marqueur d'ouverture (ex: ` ```json\n`)
2. **Stop sequence** : on arrete Claude au marqueur de fermeture (ex: ` ``` `)

Claude ne peut plus ajouter de texte avant ou apres -- il est contraint de produire directement le contenu structure.

## Exemple concret : generer une regle EventBridge AWS

```python
import anthropic
import json

client = anthropic.Anthropic()

def generer_json(description):
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Genere une regle AWS EventBridge en JSON pour : {description}"
            },
            {
                "role": "assistant",
                "content": "```json\n"
            }
        ],
        stop_sequences=["```"]
    )

    texte_brut = response.content[0].text
    return json.loads(texte_brut.strip())


# Utilisation
regle = generer_json("Detecter les arrets d'instances EC2")
print(json.dumps(regle, indent=2))

Resultat :

{
  "source": ["aws.ec2"],
  "detail-type": ["EC2 Instance State-change Notification"],
  "detail": {
    "state": ["stopped", "stopping"]
  }
}

Pas de texte parasite. Du JSON pur, directement parseable.

Comment ca marche, etape par etape

1. L’utilisateur demande une regle EventBridge
2. Le prefill \“json\n` indique a Claude qu’il est deja dans un bloc de code JSON
3. Claude genere le contenu JSON
4. Des que Claude produit \“ ` pour fermer le bloc, la stop sequence l’arrete
5. On recupere uniquement le JSON, qu’on parse avec json.loads()

Le strip() est une precaution : il supprime les espaces ou sauts de ligne en debut/fin de chaine.

Au-dela du JSON

Cette technique fonctionne pour tout format structure. L’idee cle est toujours la meme : identifier ce que Claude utilise pour envelopper le contenu, puis utiliser ces enveloppes comme prefill et stop sequence.

Code Python

def generer_python(description):
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Ecris une fonction Python qui : {description}"
            },
            {
                "role": "assistant",
                "content": "```python\n"
            }
        ],
        stop_sequences=["```"]
    )
    return response.content[0].text.strip()

code = generer_python("calcule la suite de Fibonacci jusqu'a n")
print(code)

CSV

def generer_csv(description):
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Genere des donnees CSV : {description}"
            },
            {
                "role": "assistant",
                "content": "```csv\n"
            }
        ],
        stop_sequences=["```"]
    )
    return response.content[0].text.strip()

csv_data = generer_csv("5 villes francaises avec population et region")
print(csv_data)

Liste simple

def generer_liste(description, n=5):
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=1024,
        messages=[
            {
                "role": "user",
                "content": f"Donne une liste de {n} elements : {description}"
            },
            {
                "role": "assistant",
                "content": "1. "
            }
        ],
        stop_sequences=[f"{n + 1}. "]
    )
    return "1. " + response.content[0].text.strip()

liste = generer_liste("langages de programmation pour le web", 5)
print(liste)

L’idee cle a retenir

La technique repose sur une observation simple : Claude formate ses reponses de maniere previsible. Quand on lui demande du JSON, il ecrit ```json ... ```. Quand on lui demande du code, il ecrit ```python ... ```.

En utilisant ces marqueurs comme prefill (debut) et stop sequence (fin), on isole parfaitement le contenu structure du texte explicatif.

Attention

• Utilisez toujours strip() avant de parser, pour eliminer les espaces parasites
• Testez avec plusieurs inputs : Claude peut parfois generer du JSON invalide sur des requetes ambigues
• Pour des structures JSON complexes, ajoutez un exemple dans le prompt utilisateur