Claude Architect · Les

Een JSON-schema ontwerpen

Vorm de uitvoer precies naar wat u nodig hebt

Les 2 van 413 stappen

Een JSON-schema ontwerpen is een gratis Claude Architect-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Claude Architect. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Claude Architect bevat in totaal 4 lessen.

Waarom uitvoer in de vorm van een schema

Wanneer je Claude's antwoord in een precieze structuur nodig hebt, moet je geen vrije tekst parseren in de hoop dat het goed gaat. Combineer tool_use met een JSON Schema: Claude vult de input_schema van een tool in en de API garandeert geldige JSON waarin de vereiste velden aanwezig zijn.

Hiermee schakel je twee volledige soorten fouten uit: syntaxisfouten (ontbrekende komma's, niet-geëscape'te aanhalingstekens) en ontbrekende velden. Het schema IS het contract — ontwerp het goed en code verderop hoeft nooit te controleren op verkeerd gevormde structuren.

De tool is het schema

Een "tool" voor gestructureerde uitvoer hoeft niets aan te roepen. Het is gewoon een benoemde container waarvan input_schema de gewenste vorm van de uitvoer beschrijft. Je definieert de tool en leest vervolgens wat Claude in de toolaanroep heeft gezet.

Geef de tool een duidelijke naam en beschrijving — die bepalen nog steeds de selectie — maar het echte werk zit in de properties en de lijst required van het schema.

extract_invoice = {
    "name": "extract_invoice",
    "description": "Record the structured fields parsed from an invoice document.",
    "input_schema": {
        "type": "object",
        "properties": {
            "invoice_number": {"type": "string"},
            "total": {"type": "number"},
        },
        "required": ["invoice_number", "total"],
    },
}

Dwing de structuur af met tool_choice

Als je gegarandeerd gestructureerde uitvoer wilt, laat dat dan niet aan het toeval over. Stel tool_choice in om een toolaanroep af te dwingen:

  • "auto" — het model kiest tekst of een tool
  • "any" — het model MOET een tool aanroepen (garandeert gestructureerde uitvoer)
  • {"type":"tool","name":"X"} — dwingt één specifieke tool af

Voor extractie met één schema is het afdwingen van de exacte tool op naam de meest eenvoudige weg naar een deterministische structuur.

resp = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    tools=[extract_invoice],
    tool_choice={"type": "tool", "name": "extract_invoice"},
    messages=[{"role": "user", "content": invoice_text}],
)

Required betekent altijd aanwezig

De belangrijkste schemaregel: markeer een veld ALLEEN als required wanneer het altijd in de bron aanwezig is. Maak een veld nooit verplicht als het kan ontbreken.

Waarom? Een verplicht veld dwingt het model om een waarde te produceren. Als de gegevens er niet zijn, zal Claude er één verzinnen om aan het contract te voldoen. Optioneel en afwezig is eerlijk; verplicht maar ontbrekend leidt tot hallucinaties.

Optionele velden goed gebruiken

Voor velden die wel of niet kunnen voorkomen — een kortingsregel, een tweede contactpersoon, een vervaldatum — laat je ze WEG uit required. Beschrijf ze duidelijk, zodat Claude ze alleen invult wanneer de gegevens echt aanwezig zijn.

Een goede beschrijving vertelt het model in welk formaat de invoer staat en wanneer het veld moet ontbreken, zodat het het veld weglaat in plaats van iets te verzinnen.

"properties": {
    "invoice_number": {"type": "string"},
    "total": {"type": "number"},
    "due_date": {
        "type": "string",
        "description": "ISO 8601 date (YYYY-MM-DD). Omit entirely if no due date is stated."
    },
},
"required": ["invoice_number", "total"]

Enumwaarden beperken de uitvoer

Wanneer een veld een vaste woordenschat heeft — status, categorie, prioriteit — gebruik je een enum. Daarmee breng je rommelige vrije tekst ("paid", "PAID", "settled") terug tot één canonieke waarde waarop je code kan schakelen.

Enumwaarden verminderen ook hallucinaties: het model moet kiezen uit de opgegeven reeks in plaats van een label te verzinnen.

"status": {
    "type": "string",
    "enum": ["draft", "sent", "paid", "overdue", "void"],
    "description": "Current invoice status."
}

Enumwaarden ontwerpen voor uitbreidbaarheid

Strikte enumwaarden breken wanneer de werkelijkheid een nieuw geval oplevert. Het patroon van een architect: voeg een waarde "other" toe aan de enum EN een vrij tekstveld detail om vast te leggen wat "other" precies was.

Zo blijft je schema geldig voor onvoorziene invoer, verlies je geen informatie en kun je het detailveld analyseren om te bepalen of een nieuwe enumwaarde gerechtvaardigd is.

"category": {
    "type": "string",
    "enum": ["hardware", "software", "services", "other"]
},
"category_detail": {
    "type": "string",
    "description": "If category is 'other', describe it here. Omit otherwise."
}

Beschrijvingen geven uitleg

Veldbeschrijvingen zijn miniprompts. Vage sleutels leveren vage uitvoer op. Vermeld het formaat, geef een voorbeeld en beschrijf hoe je met randgevallen omgaat, rechtstreeks in het schema.

Dit is voor gestructureerde uitvoer het equivalent van expliciete criteria die beter werken dan vage instructies: "ISO 8601-datum, weglaten als deze ontbreekt" werkt elke keer beter dan een kale due_date: string.

"line_items": {
    "type": "array",
    "description": "One object per billed line. Empty array if none.",
    "items": {
        "type": "object",
        "properties": {
            "sku": {"type": "string", "description": "e.g. 'ABC-1024'"},
            "qty": {"type": "integer"},
            "unit_price": {"type": "number"}
        },
        "required": ["qty", "unit_price"]
    }
}

Ingebouwde zelfcontrole

Goede schema's helpen je fouten op te sporen. Om berekeningen te controleren, extraheer je zowel een berekende als een vermelde waarde en vergelijk je die vervolgens in code.

Leg bijvoorbeeld stated_total vast (afgedrukt op het document), naast de regelitems die je zelf kunt optellen. Een verschil markeert een extractie- of documentfout voordat die verderop gevolgen heeft.

"stated_total": {
    "type": "number",
    "description": "The grand total exactly as printed on the invoice."
}
# In code:
# calc = sum(li['qty'] * li['unit_price'] for li in items)
# if abs(calc - data['stated_total']) > 0.01: flag_discrepancy()

Valideer en probeer daarna opnieuw met feedback

Het schema garandeert de JSON-structuur, niet de juistheid volgens de bedrijfsregels. Voeg validatie in Pydantic-stijl toe. Wanneer die faalt door een formaat-, structurele of rekenkundige fout, probeer je het opnieuw — maar geef het model door wat er misging.

Stuur het oorspronkelijke document, de verkeerde uitvoer en de exacte validatiefout. Dat is opnieuw proberen met feedback. Let op: opnieuw proberen helpt NIET wanneer informatie simpelweg ontbreekt in de bron — hoe vaak je het ook opnieuw vraagt, ontbrekende gegevens verschijnen niet ineens.

messages = [
    {"role": "user", "content": original_doc},
    {"role": "assistant", "content": wrong_output},
    {"role": "user", "content":
        f"Validation failed: {error}. Re-emit corrected JSON."},
]
# Retry fixes format/arithmetic bugs, not missing facts.

Herkomst vastleggen in het schema

Voor extracties die je later moet kunnen verdedigen, ontwerp je velden die de herkomst bewaren: waar elke bewering vandaan komt. Houd koppelingen tussen beweringen en bronnen bij — bronnaam, citaat, pagina of datum.

Zo wordt een extractie uit een zwarte doos controleerbaar en kun je tegenstrijdige waarden (vaak een datumverschil) annoteren in plaats van stilzwijgend één waarde te kiezen.

"items": {
    "type": "array",
    "items": {
        "type": "object",
        "properties": {
            "value": {"type": "string"},
            "source_quote": {"type": "string",
                "description": "Verbatim text supporting this value."},
            "source_page": {"type": "integer"}
        },
        "required": ["value", "source_quote"]
    }
}

Korte controle: optioneel veld

Je extraheert inkooporders. Sommige inkooporders bevatten een discount_code, maar de meeste niet. Hoe moet het schema discount_code behandelen?

Samenvatting: de uitvoer vormgeven

Belangrijkste lessen voor het ontwerpen van een JSON Schema:

  • tool_use + JSON Schema voorkomt syntaxisfouten en dwingt vereiste velden af.
  • Dwing de structuur af met tool_choice: "any" voor een willekeurige tool, {"type":"tool","name":"X"} voor een specifieke tool.
  • Markeer required ALLEEN voor velden die altijd aanwezig zijn — een ontbrekend veld verplicht maken leidt tot verzinning.
  • Gebruik enumwaarden voor vaste woordenschatten; voeg "other" en een detailveld toe voor uitbreidbaarheid.
  • Beschrijvingen leggen formaat, voorbeelden en randgevallen uit.
  • Extraheer zowel berekende als vermelde waarden voor zelfcontrole; valideer en probeer daarna opnieuw met feedback bij forma atfouten (niet bij ontbrekende informatie).
  • Leg de herkomst vast voor controleerbare en verdedigbare extracties.
Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
26
Lessen
104

Veelgestelde vragen

Is de les “Een JSON-schema ontwerpen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Claude Architect, waaronder “Een JSON-schema ontwerpen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Claude Architect bevat in totaal 4 lessen.

Wat leer ik in “Een JSON-schema ontwerpen”?

Vorm de uitvoer precies naar wat u nodig hebt Je oefent met Claude Architect door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Claude Architect te beginnen?

Ervaring vooraf is niet nodig. Claude Architect op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Een JSON-schema ontwerpen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Claude Architect?

Ja. Elke les over Claude Architect bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. tool_use voor gegarandeerde structuur
  2. Een JSON-schema ontwerpen
  3. Verplichte versus optionele/nullable velden
  4. Enums met 'other' voor uitbreidbaarheid
← Terug naar Claude Architect