← Alle blogs AI MET EEN BOUWHELM OP

Betrouwbare 'AI-functies'

“Imagine if an API failed 5% of the time. Most engineers would drop everything and fix it. Yet when LLMs fail at the same rate, we shrug it off and call it acceptable.” – Vaibhav Gupta (BAML)

Introductie

LLM’s zijn krachtig maar onvoorspelbaar. In de vorige blog kozen we daarom voor een beperkte scope: AI alleen waar het waarde toevoegt én je de controle kunt loslaten. De vervolgvraag is dan: hoe maak je die AI-functies betrouwbaar?

Dat is allesbehalve vanzelfsprekend. LLM’s zijn inherent probabilistisch en de nauwkeurigheid neemt snel af naarmate de context groeit (context rot). Drie concepten vormen het antwoord: routing, context engineering en evals.

Routing: het kleinste zinvolle begin

Routing is de eenvoudigste vorm van AI in een workflow: de LLM classificeert de input en bepaalt welke workflow wordt uitgevoerd. Er wordt dus niet gekeken hoe de berekening gemaakt wordt, maar welke. Zo behoud je maximale controle: “own your control flow”.

In het ari pakket zit een eenvoudige router voor geotechnische berekeningen. De gebruiker typt: “reken de draagkracht uit bij cpt001” en de LLM vertaalt dat naar PAALFUNDERING, STABILITEIT, ZETTINGEN of DAMWAND. Lukt dat niet, dan vraagt de LLM om verduidelijking. Meer AI komt er niet aan te pas.

Maar een goede router staat of valt met wat je het model meegeeft. Dat is context engineering.

Context engineering: schaven aan de LLM response

Wanneer je AI integreert, zijn er een boel knoppen waar je aan kunt draaien: de system prompt, gebruikersinput, relevante informatie en het output format. Dit geheel optimaliseren heet context engineering. Gebruik geen AI framework om dit te doen, want die maken het juist lastig om je context te beheersen. “Own your prompts”.

Een framework specifiek ontwikkeld voor dit probleem is BAML.

BAML

BAML is een DSL voor AI-functies. In plaats van losse promptstrings in je codebase, schrijf je functies met invoer, uitvoer en structuur. BAML regelt de koppeling met de LLM-provider, schema aligned parsing en testbaarheid.

Hieronder de geotechnische router functie in BAML, met:

  • de system prompt: tussen {{_.role("system")}} en {{_.role("user")}}
  • de user prompt: vanaf {{_.role("user")}}
  • het output format (Berekening en VerzoekVerduidelijking): {{ ctx.output_format }}
  • de prompt gebruiker: {{ input }}
enum Berekening {
    PAALFUNDERING
    STABILITEIT
    ZETTINGEN
    DAMWAND
}

class VerzoekVerduidelijking {
  intentie "Geef meer informatie"
  verzoek_tot_verduidelijking string
}

function ChooseWorkflow(input: string) -> Berekening | VerzoekVerduidelijking {
  client Claude4_5Haiku
  prompt #"
    {{ _.role("system") }}
    Classificeer welk werk er uitgevoerd moet worden.
    Als de input onduidelijk is, geef je deze feedback terug aan de gebruiker.
    {{ ctx.output_format }}

    {{ _.role("user") }}
    {{ input }}
  "#
}

BAML vertaalt dit vervolgens naar de volgende API call:

<system prompt>
  Classificeer welk werk er uitgevoerd moet worden.
  Als de input onduidelijk is, geef je deze feedback terug aan de gebruiker.

  Answer in JSON using any of these schemas:
    'PAALFUNDERING' or 'STABILITEIT' or 'ZETTINGEN' or 'DAMWAND' or {
      intentie: "Geef meer informatie",
      verzoek_tot_verduidelijking: string,
    }
</system prompt>

<user prompt>
  prompt van de gebruiker
</user prompt>

Of die context ook echt werkt, weet je pas als je het meet. Dat zijn evals.

Evals: vertrouwen kwantificeren

Evals zijn tests: een input, een verwachte output en een check. Bij een router is dat volledig te automatiseren, vergelijkbaar met een unit test. Bij complexere functies kun je LLM-as-judge inzetten, of een mens (liefst met meer dan alleen ‘vibes’).

Evals zijn onmisbaar omdat LLM’s probabilistisch zijn én soms significant afwijkend gedrag vertonen na een modelupdate.

En zonder evals zijn je gebruikers het proefkonijn!

BAML evals

Vijf gevallen die samen de grenzen aftasten: van eenduidige invoer tot vragen die te vaag zijn om een berekening mee te starten.

test TestChooseWorkflowPile {
    functions [ChooseWorkflow]
    args {
        input "Ik wil graag een heipaal uitrekenen bij cpt001"
    }
    @@assert({{ this == "PAALFUNDERING" }})
}

test TestChooseWorkflowZetting {
    functions [ChooseWorkflow]
    args {
        input "Reken de zettingen uit bij cpt001"
    }
    @@assert({{ this == "ZETTINGEN" }})
}

test TestChooseWorkflowZetting2 {
    functions [ChooseWorkflow]
    args {
        input "Wat is de zakking ter plaatse van km 23.5?"
    }
    @@assert({{ this.intentie == "Geef meer informatie" }})
}

test TestChooseWorkflowStabiliteit {
    functions [ChooseWorkflow]
    args {
        input "Reken de stbi uit bij de Dorpstraat in Krimpen aan de IJssel"
    }
    @@assert({{ this.intentie == "Geef meer informatie" }})
}

test TestChooseWorkflowStabiliteit2 {
    functions [ChooseWorkflow]
    args {
        input "Hoe stabiel is de Lekdijk?"
    }
    @@assert({{ this.intentie == "Geef meer informatie" }})
}

De cases testen de grenzen van de router: eenduidige invoer (“heipaal”, “zettingen”), ambigue termen (“zakking”), onvolledige context (“stbi” zonder locatiedata) en vragen die te vaag zijn om een berekening mee te starten.

Met een aanpak vergelijkbaar met TDD stel je eerst je testgevallen op, en vervolgens engineer je de context totdat alles klopt. Met de prompt fiddle van BAML kun je zo eenvoudig schaven aan je AI-functies.

Op weg naar betrouwbare AI-functies

Routing waar mogelijk, context zorgvuldig inrichten, evals als toetssteen. Zo bouw je stap voor stap aan AI-functies waar je op kunt bouwen. En als je fan bent van ‘prompt optimizers’, ga dan vooral los in de LinkedIn comments!

De volgende post gaat in op waarom (alleen) chat niet werkt.

P.S.: De codebase van ari is opensource.

Vertel ons waar je tegenaan loopt.