Programma Les 138 van 250 · Gestructureerde Outputs & Function/Tool Calling
Gestructureerde Outputs & Function/Tool Calling

Beperkte / Schema-afgedwongen outputs

Je hebt het model JSON in de laatste lessen handmatig gevalideerd. Moderne praktijk gaat een stap eerder: zorg dat het model helemaal geen slecht JSON uitstoot. Dit is constrained decoding (ook wel structured outputs genoemd). Je geeft de API een schema, en de decoder mag alleen tokens samplen die de output geldig houden volgens dat schema. Het model kan letterlijk geen ontbrekend veld of een verkeerd getypeerde waarde produceren.

Met de OpenAI-stijl API geef je een response_format door met een JSON Schema en strict: true (alleen ter illustratie -> we roepen hier geen model aan):

resp = client.chat.completions.create(
    model="...",
    messages=[...],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
                "required": ["name", "age"],
            },
        },
    },
)

De rest van deze cursus noemt Anthropic, die dezelfde garantie biedt via output_config voor gegarandeerde-JSON-responses en strict tool gebruik voor schema-perfecte tool inputs:

resp = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[...],
    output_config={"format": {
        "type": "json_schema",
        "schema": {
            "type": "object",
            "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
            "required": ["name", "age"],
        },
    }},
)

In beide gevallen doet de provider de beperking. Maar constrained decoding kan nog steeds niet je bedrijfsregels controleren (is de leeftijd aannemelijk? is de valuta een die je ondersteunt?), en niet elk model of gateway ondersteunt het. Je valideert dus toch aan jouw eigen kant. Die validator is wat je nu bouwt.

Aan de Python kant is de de-facto standaard voor het declareren en valideren van die vorm Pydantic. Je schrijft een model klasse en de bibliotheek analyseert, dwingt af en valideert voor je:

from pydantic import BaseModel

class Person(BaseModel):
    name: str
    age: int

record = Person.model_validate_json(text)   # raises if it does not fit

Pydantic is niet beschikbaar in deze sandbox in de browser, dus je bouwt hetzelfde idee handmatig met de standaardbibliotheek. Dat is precies wat deze bibliotheken onder de motorkap doen, en het maakt de regels onmogelijk om weg te wuiven. Je schrijft validate_against_schema(obj, schema).

De schema is een dictionary. Elke waarde is een type naam string ("int", "float", "str", "bool", "list", "dict") of een kleine spec dictionary zoals {"type": "int", "default": 0}. Je functie geeft een result dictionary {"ok": bool, "value": dict, "errors": list} terug:

  • Als obj geen dict is, retourneer ok=False met één root error en een lege value.
  • Voor elk veld: als het missing is en de spec heeft een "default", vul de standaard in (de coerce/default pass). Als het ontbreekt zonder standaard, registreer een fout.
  • Als het aanwezig is, controleer je de type. Bij een mismatch noteer je een fout met de naam van het veld.
  • Coerce een plain int naar een float wanneer een float wordt gewild (dat is zonder verlies en veilig), maar dwing niets anders af.
  • Als er fouten zijn, retourneer ok=False met de verzamelde errors en een lege value; anders retourneer ok=True met de geverifieerde value.

De bool-is-int valkuil. In Python bool is een subclass van int, dus isinstance(True, int) is True en JSON true decodeert naar Python True. Een simpele typecheck laat "age": true door een int veld glippen. Wees expliciet streng bij een bool overal waar een int of een float vereist is:

if expected is int and isinstance(value, bool):
    errors.append(field + ": expected int, got bool")

Bouw het zo dat twee verschillende goed gevormde payloads beide slagen, een ontbrekend veld en een verkeerd type landen elk in errors, een standaardwaarde wordt ingevuld, een int wordt omgezet naar een float, en een sluipende bool wordt geweigerd waar een getal vereist is.

Jij bent aan de beurt

Schrijf validate_against_schema(obj, schema) die {"ok", "value", "errors"} teruggeeft. schema koppelt elk veld aan een type-naam string ("int"/"float"/"str"/"bool"/"list"/"dict") of een spec dict {"type": ..., "default": ...}. Wees afwijzend tegen een niet-dict obj, noteer een fout voor elk ontbrekend (geen-standaard) of verkeerd getype veld, vul een standaard in wanneer er een gegeven is, dwing een gewone int naar float af, en wees afwijzend tegen een bool waar een int of float vereist is (de bool-is-int valkuil). Geef ok=True met de geverifieerde value alleen terug wanneer er geen fouten zijn.

Een probleem ontdekt in deze les? Meld het · Vraag naar deze les

Deze oefening opent binnenkort

Maak de les ervoor af voordat deze wordt ontgrendeld. De hele cursus is gratis, geen account nodig, en je kunt deze les nu lezen.