Als je voor het eerst met Large Language Models (LLM's) werkt, begin je meestal met het schrijven van een prompt. Je stelt een vraag en het model geeft een antwoord. Deze interactie voelt magisch, maar stuit al snel op grenzen. Wat als het model toegang moet hebben tot bedrijfsdocumenten? Wat als het moet weten wat er tien minuten geleden is besproken? Of wat als het bepaalde taken moet kunnen uitvoeren, zoals het raadplegen van een API?
Hier eindigt de rol van simpele prompt engineering en begint het domein van context-engineering. Context-engineering is de kunst en wetenschap van het dynamisch opbouwen van de werkomgeving van een AI-model. In dit artikel leggen we uit waarom de complete context—instructies, documenten, gespreksgeschiedenis en tools—bepaalt wat een model kan, en waarom meer context paradoxaal genoeg niet altijd resulteert in betere antwoorden.
Het onderscheid tussen beide termen wordt vaak niet scherp getrokken, maar in de ontwikkeling van AI-applicaties is het cruciaal.
Prompt engineering richt zich op de exacte formulering van de vraag. Het gaat over het kiezen van de juiste woorden, het toevoegen van voorbeelden (few-shot prompting) en het structureren van de taak zodat het model precies snapt wat de bedoeling is. Je bent bezig met de input van de gebruiker.
Context-engineering daarentegen gaat over de architectuur van de informatie die samen met de prompt naar het model wordt gestuurd. Het model zelf is 'statisch'; het weet niets na de datum waarop de training is gestopt (de zogeheten kennis-cut-off). Om het model slim en relevant te maken voor een specifieke taak, moet je het voorzien van een actuele, gestructureerde en gefilterde set gegevens. Deze totale set noemen we het context window.
Stel, je vraagt een chef-kok om een taart te bakken. Prompt engineering is zeggen: "Bak een luchtige chocoladetaart in de vorm van een ster." Context-engineering is zorgen dat de chef in de keuken staat, dat de ingrediënten afgewogen klaarliggen, dat er een recept naast de oven ligt en dat de chef een lijst heeft van ingrediënten waar jij allergisch voor bent. Zonder die context kan de chef de perfecte instructie simpelweg niet uitvoeren.
Wanneer een ontwikkelaar een API-verzoek naar een model stuurt (zoals OpenAI's GPT-4, Google's Gemini of Anthropic's Claude), bestaat de payload niet uit één zinnetje. Het is een complex JSON-object dat zorgvuldig in elkaar is gezet. We kunnen deze context grofweg opdelen in vier bouwstenen.
De fundering van je context is de systeeminstructie. Dit is een onzichtbare instructie voor de eindgebruiker, die het basale gedrag, de tone-of-voice en de veiligheidsrestricties van de AI vastlegt. In de context-hiërarchie weegt deze instructie zeer zwaar. Een systeeminstructie stelt bijvoorbeeld de kaders: "Je bent een behulpzame klantenservice-bot voor een webshop. Antwoord altijd in het Nederlands. Geef nooit medisch advies. Als je het antwoord niet weet, verwijs dan door naar een menselijke collega."
LLM's hebben standaard geen intern geheugen; ze zijn stateless. Elk verzoek aan een API is een volledig nieuwe interactie. Om de illusie van een vloeiend gesprek te creëren, moet de applicatie de vorige vragen en antwoorden opslaan en deze bij elk nieuw verzoek opnieuw meesturen. Dit vereist actief beheer, zoals we uitgebreider bespreken in ons artikel over geheugen in LLM-apps. Als de geschiedenis te lang wordt, moet je oude berichten samenvatten of weglaten om binnen de limieten te blijven.
Misschien wel het belangrijkste onderdeel van moderne context-engineering is Retrieval-Augmented Generation, oftewel het dynamisch ophalen van informatie. In plaats van alle bedrijfsinformatie in het model te proppen (wat onmogelijk is), bouw je een systeem dat eerst de gebruikersvraag analyseert, vervolgens relevante documenten opzoekt in een database, en alleen die specifieke paragrafen toevoegt aan de context. Wil je hier zelf mee aan de slag? Lees dan onze gids over RAG voor beginners.
Tegenwoordig kun je in de context ook beschrijvingen van externe tools of API's meesturen (vaak in JSON-schema's). Je vertelt het model bijvoorbeeld: "Hier is een functie om de actuele weersverwachting op te halen." Het model leert hierdoor dat het niet zelf hoeft te gokken naar het weer, maar dat het een signaal kan teruggeven aan jouw applicatie met de vraag: "Voer deze functie voor mij uit en geef me de uitkomst terug."
Nieuwere modellen bieden gigantische context windows. Waar de eerste generaties maximaal 4.000 tokens aankonden (ongeveer 3.000 woorden), zien we nu modellen met context windows van 1 tot zelfs 2 miljoen tokens (gelijk aan duizenden pagina's tekst). Dit klinkt als de perfecte oplossing: je stuurt gewoon je hele archief mee en het model zoekt het wel uit. Dit blijkt in de praktijk echter vaak een slechte strategie. Dit noemen we de Context Paradox.
Net als mensen hebben taalmodellen moeite om hun aandacht gelijkmatig over een enorme hoeveelheid tekst te verdelen. Onderzoekers hebben een fenomeen geïdentificeerd dat Lost in the Middle wordt genoemd. Modellen zijn extreem goed in het onthouden en gebruiken van informatie die helemaal aan het begin of helemaal aan het einde van de context staat. Informatie die halverwege een enorm document verborgen zit, wordt echter vaak over het hoofd gezien of verkeerd geïnterpreteerd. Om beter te snappen hoe modellen informatie prioriteren, is kennis van het onderliggende attention-mechanisme essentieel.
Als je te veel irrelevante informatie aan de context toevoegt, ontstaat er 'ruis'. Stel dat de gebruiker vraagt naar de retourvoorwaarden van 2024, en je stuurt in de context documenten mee uit 2022, 2023 én 2024. Het model moet nu actief de tegenstrijdigheden oplossen. Hoe meer ruis er in de context zit, hoe groter de kans dat het model de mist in gaat en zaken gaat verzinnen. Meer inzicht in hoe en waarom modellen dingen verzinnen vind je in ons overzicht over het begrijpen van hallucinaties.
Het verwerken van tokens kost rekenkracht, tijd en geld. De kosten van LLM-API's worden vrijwel altijd berekend per verwerkt token. Als je bij elke vraag onnodig honderdduizend tokens aan achtergrondinformatie meestuurt, schieten je operationele kosten omhoog. Daarnaast zal de wachttijd (latency) voor de gebruiker toenemen. Het model heeft domweg meer tijd nodig om een massaal tekstblok te lezen voordat het überhaupt kan beginnen met typen.
Succesvolle AI-applicaties onderscheiden zich door efficiënte context-engineering. Ze proppen niet alles in de prompt, maar gebruiken geavanceerde technieken om de context zo rijk maar beknopt mogelijk te houden.
| Techniek | Doel | Werking |
|---|---|---|
| Reranking | Relevantie verhogen | Na het ophalen van documenten (via vector search), gebruikt men een gespecialiseerd 'reranker' model om de documenten opnieuw te sorteren. Alleen de top 3 meest relevante stukken gaan daadwerkelijk de context in. |
| Prompt Compression | Tokens besparen | Overbodige stopwoorden, whitespace of irrelevante zinnen uit ruwe data filteren voordat deze aan het model wordt gepresenteerd. |
| Context Caching | Kosten & snelheid | Veel API-providers bieden tegenwoordig 'Prompt Caching'. Als je steeds hetzelfde grote document meestuurt (bijvoorbeeld een enorm wetboek), slaat de server de analyse daarvan tijdelijk op. Je betaalt dan minder en het model reageert veel sneller op vervolgvragen over dit document. |
Om context-engineering tastbaar te maken, is het nuttig om te zien hoe een applicatie onder de motorkap communiceert met een taalmodel. In plaats van een simpele string (tekenreeks), is het verzoek meestal opgebouwd uit een array (een lijst) van berichten, elk met een specifieke rol. We kijken hier naar een sterk vereenvoudigd JSON-formaat, zoals je dat in veel frameworks ziet (voor het bouwen van zulke architecturen met Python kun je terecht op onze externe gids over LangChain basics).
[
{
"role": "system",
"content": "Je bent een behulpzame assistent. Beantwoord vragen uitsluitend op basis van de meegeleverde documenten."
},
{
"role": "user",
"content": "Hallo, kun je me vertellen hoe ik mijn wachtwoord kan resetten?"
},
{
"role": "assistant",
"content": "Natuurlijk! Om je wachtwoord te resetten, ga je naar de instellingen..."
},
{
"role": "user",
"content": "En hoe lang duurt het voordat ik de reset-link ontvang?\n\n[CONTEXT-DOCUMENT-1]: De reset-mail wordt doorgaans binnen 2 minuten verstuurd."
}
]In bovenstaand voorbeeld zie je de samenkomst van de drie belangrijkste rollen:
De taak van de context-engineer is om te bepalen hoeveel van die oude 'user' en 'assistant' berichten er bewaard blijven, hoe zwaar de 'system' prompt mag zijn, en hoeveel '[CONTEXT-DOCUMENTEN]' er veilig kunnen worden toegevoegd zonder dat het model in de war raakt.
Prompt engineering is als het sturen van een e-mail naar een medewerker met een specifieke vraag. Context-engineering is het inwerken van die medewerker: je geeft ze een bureau, een archiefkast, een handleiding en een set met bedrijfsregels. De kwaliteit van je AI-applicatie valt of staat bij dit proces.
In plaats van te vertrouwen op modellen met een steeds groter, onbeperkt context window, loont het om de context strak en gecontroleerd te houden. Een model dat precies de juiste, schone en relevante informatie voorgekauwd krijgt, levert snellere, goedkopere en betrouwbaardere antwoorden dan een model dat moet zoeken naar een naald in een hooiberg van miljoenen tokens.
Wil je zelf aan de slag met het ontwerpen van slimme systemen rondom LLM's? Bekijk dan ons externe overzicht waar je verschillende modellen en hun context limieten kunt vergelijken of duik verder in onze documentatie voor ontwikkelaars.