Claude Architect · Les

Gestructureerde foutcontext

Fouttype, uitgeprobeerde query, gedeeltelijke resultaten en alternatieven

Les 3 van 413 stappen

Gestructureerde foutcontext is een gratis Claude Architect-les op CoddyKit. Dit is les 3 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 fouten structuur nodig hebben

In een systeem met meerdere agents loopt een subagent uiteindelijk tegen een fout aan: een database is niet beschikbaar, een query levert niets op of een machtiging wordt geweigerd. De manier waarop die fout wordt gemeld, bepaalt of de coördinator intelligent kan herstellen of het simpelweg opgeeft.

Een algemene status zoals "Operation failed" blokkeert herstel — de coördinator heeft geen idee wat de volgende stap is. Een gestructureerde foutcontext verandert een doodlopende weg in een routeringsbeslissing.

In deze les behandelen we de vier pijlers van een goede foutcontext: fouttype, uitgevoerde query, gedeeltelijke resultaten en alternatieven.

Het antipatroon van de algemene fout

Vergelijk twee foutpayloads die terugkomen van een subagent of tool.

De generieke versie vertelt de coördinator niets waarmee die iets kan doen. Die kan niet beslissen of er opnieuw moet worden geprobeerd, of de gebruiker om meer invoer moet worden gevraagd, of dat het probleem moet worden geëscaleerd. Stil onderdrukken is nog erger: de workflow gaat verder alsof de gegevens bestaan, terwijl dat niet zo is.

De gestructureerde versie benoemt wat er is mislukt en waarom. Dat is de eerste stap naar een intelligente volgende actie.

# Anti-pattern: opaque, un-actionable
return {"isError": True, "message": "Operation failed"}

# Better: structured, routable
return {
    "isError": True,
    "errorCategory": "transient",
    "isRetryable": True,
    "message": "Connection to orders DB timed out after 5s",
}

Pijler 1 — Fouttype

De eerste taak van een foutcontext is het classificeren van de fout. Gestructureerde MCP-fouten bevatten een veld errorCategory met een kleine, vaste woordenschat:

  • transient — een tijdelijke fout in de infrastructuur (time-out, snelheidslimiet). Vaak opnieuw uitvoerbaar.
  • validation — de invoer had een ongeldige indeling.
  • business — een domeinregel blokkeerde de actie.
  • permission — de toegang werd geweigerd.

De bijbehorende booleaanse waarde isRetryable neemt het giswerk weg: de coördinator leest deze rechtstreeks uit in plaats van de bedoeling af te leiden uit een vrijetekstbericht.

{
  "isError": true,
  "errorCategory": "transient",
  "isRetryable": true,
  "message": "Rate limit hit on inventory service"
}

Fout tegenover leeg resultaat

Een onderscheid brengt architecten voortdurend in verwarring: een toegangsprobleem is niet hetzelfde als een geldig leeg resultaat.

  • Fout: de opzoekactie kon niet worden uitgevoerd — de database is onbereikbaar of de toegang is geweigerd. Opnieuw proberen kan zinvol zijn.
  • Leeg: de opzoekactie is succesvol uitgevoerd en leverde nul overeenkomsten op. Opnieuw proberen verandert niets — het antwoord is echt „geen resultaten”.

Als je deze twee door elkaar haalt, ontstaan zinloze herhaallussen voor lege resultaten, of wordt een echte storing behandeld als „geen gegevens gevonden”. Modelleer ze altijd als afzonderlijke toestanden.

def classify(result):
    if result.connection_error:
        return {"isError": True, "errorCategory": "transient",
                "isRetryable": True}
    if not result.rows:                 # ran fine, found nothing
        return {"isError": False, "empty": True, "matches": 0}
    return {"isError": False, "matches": len(result.rows)}

Pijler 2 — Uitgevoerde zoekopdracht

De coördinator heeft de mislukte bewerking niet zelf uitgevoerd en kan dus niet zien wat er is geprobeerd. Neem attempted_query letterlijk op in de foutcontext.

Dit heeft twee doelen:

  • De coördinator kan beslissen of die dezelfde zoekopdracht opnieuw uitvoert of deze herformuleert (bijvoorbeeld door een te smal filter te verruimen).
  • Bij escalatie krijgt de menselijke beoordelaar het exacte geval om te reproduceren, in plaats van een vaag bericht als „zoeken mislukt”.
return {
    "isError": True,
    "errorCategory": "transient",
    "isRetryable": True,
    "attempted_query": {
        "endpoint": "GET /orders",
        "filters": {"customer_id": "C-4821", "status": "shipped"},
    },
    "message": "Orders service returned 503",
}

Pijler 3 — Gedeeltelijke resultaten

Een fout betekent zelden dat er geen werk is verricht. Een onderzoeks-subagent kan 6 van de 10 bronnen hebben verzameld voordat een aanbieder de toegang wegens een snelheidslimiet blokkeerde. Dat allemaal weggooien — of de hele workflow afbreken — verspilt echte voortgang.

Voeg alles wat succesvol is verzameld toe als partial_results. De coördinator kan dan de beschikbare gegevens samenvoegen, het ontbrekende deel markeren en beslissen of het resterende werk een nieuwe poging waard is.

Onderdruk de fout nooit stilzwijgend en presenteer gedeeltelijke resultaten niet alsof ze volledig zijn.

return {
    "isError": True,
    "errorCategory": "transient",
    "isRetryable": True,
    "attempted_query": "fetch 10 sources on 'EU AI Act timelines'",
    "partial_results": collected_sources,   # 6 of 10 gathered
    "message": "Provider rate-limited after 6 sources",
}

Pijler 4 — Alternatieven

De nuttigste foutcontexten beschrijven niet alleen de blokkade, maar wijzen ook een uitweg aan. Het veld alternatives stelt concrete volgende acties voor die de coördinator of een mens kan uitvoeren.

Voorbeelden: „probeer het opnieuw via de leesreplica”, „verruim het datumfilter”, „vraag de gebruiker om een ordernummer”, „escaleer naar een mens en voeg de gedeeltelijke resultaten toe”.

Hierdoor wordt een gestructureerde fout een routeringsinstructie in plaats van alleen een rapport.

return {
    "isError": True,
    "errorCategory": "business",
    "isRetryable": False,
    "attempted_query": "process_refund(order='O-77', amount=620)",
    "partial_results": {"order_total": 620, "customer_verified": True},
    "alternatives": [
        "Refund exceeds $500 policy cap — escalate to human",
        "Offer store credit within auto-approve limit",
    ],
    "message": "Refund blocked by policy threshold",
}

Lokaal herstellen, niet-herstelbare fouten escaleren

Gestructureerde context leidt tot een duidelijk beleid. Handel transient-fouten binnen de subagent af — probeer de time-out opnieuw en wacht langer na het bereiken van een snelheidslimiet — zodat de coördinator een herstelbare hapering nooit te zien krijgt.

Pas wanneer een fout echt niet-herstelbaar is (beleidslimiet bereikt, toegang geweigerd, alle nieuwe pogingen uitgeput), escaleer je deze naar boven — en wel met de gedeeltelijke resultaten en alternatieven erbij, niet als een kale melding „mislukt”.

Het doel: breek niet de hele workflow af omdat één vertakking is mislukt.

for attempt in range(3):          # local recovery for transient faults
    res = run_query()
    if not res.get("isError"):
        return res
    if not res.get("isRetryable"):
        break                     # non-recoverable: stop retrying

# escalate upward WITH context, never a bare failure
return escalate(res)

De structuur afdwingen met een schema

Vrije foutwoordenboeken wijken na verloop van tijd af. Leg het contract vast met een JSON Schema via een tool of gestructureerde uitvoer, zodat de subagent de juiste velden moet invullen.

Een belangrijke regel bij het ontwerpen van gestructureerde uitvoer: markeer een veld alleen als verplicht als het altijd aanwezig is. errorCategory en message zijn altijd aanwezig — maak ze verplicht. partial_results en alternatives kunnen ontbreken — laat ze optioneel, anders gaat het model ze verzinnen om aan het schema te voldoen.

error_schema = {
    "type": "object",
    "properties": {
        "errorCategory": {"enum": ["transient", "validation",
                                    "business", "permission", "other"]},
        "isRetryable": {"type": "boolean"},
        "attempted_query": {"type": "string"},
        "partial_results": {"type": "array"},
        "alternatives": {"type": "array", "items": {"type": "string"}},
        "message": {"type": "string"},
    },
    "required": ["errorCategory", "isRetryable", "message"],
}

Context gaat niet vanzelf over agentgrenzen heen

Subagents erven de gespreksgeschiedenis van de coördinator niet. Wanneer een subagent dus mislukt, weet de coördinator alleen wat het foutpayload expliciet bevat.

Daarom moeten attempted_query en partial_results in de gestructureerde fout staan — er is geen gedeeld geheugen waarop de coördinator kan terugvallen. De foutcontext is de volledige brug tussen beide.

Beperk deze tot de relevante velden, maar verwijder nooit de vier pijlers.

# Coordinator delegates; subagent returns ONLY its payload.
# No shared history -> the error context must be self-contained.
results = await asyncio.gather(
    research_subagent("EU AI Act"),
    research_subagent("US AI policy"),
)
for r in results:
    if r.get("isError") and not r["isRetryable"]:
        annotate_coverage_gap(r["attempted_query"], r["partial_results"])

Alles samenbrengen

Dankzij een foutcontext van productiekwaliteit kan de coördinator handelen zonder zelf iets opnieuw uit te voeren:

  • fouttype + isRetryable → beslissing: opnieuw proberen of escaleren
  • uitgevoerde zoekopdracht → reproduceren of herformuleren
  • gedeeltelijke resultaten → voortgang benutten en het ontbrekende deel markeren
  • alternatieven → de concrete volgende actie

Dit is het verschil tussen een kwetsbare pijplijn die bij de eerste hapering stopt en een veerkrachtig systeem dat netjes terugvalt en om de schade heen routeert.

{
  "isError": true,
  "errorCategory": "permission",
  "isRetryable": false,
  "attempted_query": "SELECT * FROM payroll WHERE dept='ENG'",
  "partial_results": [],
  "alternatives": [
    "Request read grant on payroll schema",
    "Escalate to data-owner for approval"
  ],
  "message": "Access denied to payroll table"
}

Korte controle

Een onderzoeks-subagent kreeg de opdracht om 10 bronnen te verzamelen. Nadat er 6 waren verzameld, legde de nieuws-API een snelheidslimiet op (HTTP 429). Wat moet de subagent teruggeven aan de coördinator?

Samenvatting — Gestructureerde foutcontext

Belangrijkste punten:

  • Generieke fouten blokkeren herstel; gestructureerde fouten maken intelligente routering mogelijk.
  • Neem altijd de vier pijlers op: fouttype, uitgevoerde zoekopdracht, gedeeltelijke resultaten, alternatieven.
  • Gebruik errorCategory (transient / validation / business / permission) + isRetryable om de beslissing over opnieuw proberen of escaleren aan te sturen.
  • Maak onderscheid tussen een toegangsprobleem (opnieuw proberen kan zinvol zijn) en een geldig leeg resultaat (geen overeenkomsten — opnieuw proberen helpt niet).
  • Herstel transient-fouten lokaal in de subagent; escaleer niet-herstelbare fouten met de gedeeltelijke resultaten erbij.
  • Onderdruk fouten nooit stilzwijgend en breek de hele workflow niet af vanwege één fout.
  • Dwing de structuur af met een schema, maar maak alleen velden verplicht die altijd aanwezig zijn — optionele pijlers moeten optioneel blijven om verzinsels te voorkomen.
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 “Gestructureerde foutcontext” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Claude Architect, waaronder “Gestructureerde foutcontext”, 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 “Gestructureerde foutcontext”?

Fouttype, uitgeprobeerde query, gedeeltelijke resultaten en alternatieven 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 3 van 4.

Hoe lang duurt de les “Gestructureerde foutcontext”?

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. Duidelijke escalatietriggers
  2. Antipatroon: sentiment- en betrouwbaarheidsscores
  3. Gestructureerde foutcontext
  4. Lokaal herstel versus escalatie
← Terug naar Claude Architect