Structured output : parser du JSON

Les LLM renvoient du texte brut. Mais ton application a besoin de donnees structurees : un dictionnaire avec des cles precises, des types specifiques. Le "structured output", c'est forcer le LLM a repondre dans un format JSON precis, puis valider ce JSON cote serveur.

Le probleme : le LLM peut renvoyer du JSON invalide, oublier des champs, ou mettre le mauvais type. Par exemple, tu attends un prix en float et il renvoie "vingt euros". Il faut donc un systeme de validation robuste.

Tu vas ecrire une fonction valider_sortie(texte_json, schema) qui prend :
- texte_json : une chaine de caracteres censee contenir du JSON
- schema : un dictionnaire decrivant les champs attendus

Le schema a cette forme :
{"nom": {"type": "str", "obligatoire": True}, "age": {"type": "int", "obligatoire": False}}

Les types possibles sont : "str", "int", "float", "bool", "list".

La fonction doit :
1. Tenter de parser le JSON. Si ca echoue, renvoyer {"valide": False, "erreur": "JSON invalide"}
2. Verifier que tous les champs obligatoires sont presents. Si non, renvoyer {"valide": False, "erreur": "Champs manquants: [liste]"}
3. Verifier les types de chaque champ present. Si un type est mauvais, renvoyer {"valide": False, "erreur": "Type incorrect pour <champ>: attendu <type>, recu <type>"}
4. Si tout est bon, renvoyer {"valide": True, "donnees": le_dictionnaire_parse}

Exemple :

schema = {"nom": {"type": "str", "obligatoire": True}, "age": {"type": "int", "obligatoire": True}}
valider_sortie('{"nom": "Alice", "age": 30}', schema) renvoie {"valide": True, "donnees": {"nom": "Alice", "age": 30}}
valider_sortie('pas du json', schema) renvoie {"valide": False, "erreur": "JSON invalide"}

Tests (4/5)

JSON valide et conforme

import json
schema = {'nom': {'type': 'str', 'obligatoire': True}, 'age': {'type': 'int', 'obligatoire': True}}
r = valider_sortie('{"nom": "Alice", "age": 30}', schema)
assert r['valide'] == True
assert r['donnees'] == {'nom': 'Alice', 'age': 30}

JSON invalide

r = valider_sortie('pas du json {', {'x': {'type': 'str', 'obligatoire': True}})
assert r['valide'] == False
assert r['erreur'] == 'JSON invalide'

Champ obligatoire manquant

import json
schema = {'nom': {'type': 'str', 'obligatoire': True}, 'email': {'type': 'str', 'obligatoire': True}}
r = valider_sortie('{"nom": "Bob"}', schema)
assert r['valide'] == False
assert 'email' in r['erreur']

Type incorrect

import json
schema = {'prix': {'type': 'float', 'obligatoire': True}}
r = valider_sortie('{"prix": "cher"}', schema)
assert r['valide'] == False
assert 'Type incorrect' in r['erreur']

+ 0 tests cachés

Indices (3 disponibles)

Solution officielle

import json


TYPE_MAP = {"str": str, "int": int, "float": (int, float), "bool": bool, "list": list}


def valider_sortie(texte_json, schema):
    try:
        donnees = json.loads(texte_json)
    except (json.JSONDecodeError, TypeError):
        return {"valide": False, "erreur": "JSON invalide"}

    # Champs obligatoires
    manquants = [champ for champ, spec in schema.items()
                 if spec.get("obligatoire", False) and champ not in donnees]
    if manquants:
        return {"valide": False, "erreur": f"Champs manquants: {manquants}"}

    # Types
    for champ, spec in schema.items():
        if champ in donnees:
            type_attendu = spec["type"]
            type_python = TYPE_MAP.get(type_attendu)
            if type_python and not isinstance(donnees[champ], type_python):
                type_recu = type(donnees[champ]).__name__
                return {"valide": False, "erreur": f"Type incorrect pour {champ}: attendu {type_attendu}, recu {type_recu}"}

    return {"valide": True, "donnees": donnees}

← Evaluer une reponse LLM Guardrails : filtrer entrees et … →

solution.py

Bravo!

Structured output : parser du JSON

Tests (4/5)

Indices (3 disponibles)

Solution officielle