Context window

Wat is een context window?

Het context window van een taalmodel is de maximale hoeveelheid tekst die het in één oproep kan verwerken. Alles wat je meegeeft (systeeminstructie, gebruikersvraag, opgehaalde documenten, gesprekshistoriek) plus alles wat het model genereert, moet samen in dat venster passen. De maat is meestal niet in woorden maar in tokens, de eenheid waarin het model tekst opsplitst.

Je kan het context window vergelijken met het korte termijngeheugen van een mens. Een mens kan ongeveer zeven dingen tegelijk onthouden. Een modern taalmodel kan er honderdduizenden onthouden, maar zelfs dat is eindig. Alles wat buiten het venster valt, is voor het model simpelweg niet meer zichtbaar.

Contextvensters zijn de afgelopen jaren snel gegroeid. GPT-3 startte in 2020 met 2.000 tokens. Vandaag draaien Claude, GPT-4.x en Gemini met windows van 200.000 tot 2 miljoen tokens. Dat lijkt oneindig, maar er zitten in de praktijk veel kanttekeningen bij.

Waarom is het context window belangrijk?

Het bepaalt wat je kan meegeven. Een contract van 80 pagina's past niet in een window van 4.000 tokens. Een hele codebase past niet in 32.000 tokens. Voor grote documenten heb je ofwel een groot window nodig, ofwel een slimme manier om selectief stukken mee te sturen.

Het bepaalt wat je betaalt. De meeste API's factureren per token, zowel voor input als output. Een prompt van 100.000 tokens bij elke oproep wordt snel duur. Cache-mechanismen en bewuste contextbesparing zijn geen luxe maar een vereiste voor productiesystemen.

Het beïnvloedt de kwaliteit. Hoe verder info in het window zit, hoe meer kans dat het model ze vergeet of slecht combineert. Het zogenaamde lost in the middle-effect: modellen onthouden het begin en het einde van een lange prompt beter dan het midden.

Tokens, niet woorden

Een token is ruwweg een half woord in het Nederlands of Engels, en korter voor talen als Chinees of Arabisch. Wat telt als één token hangt af van de tokenizer van het model. Enkele vuistregels voor het Engels en Nederlands:

• 100 tokens komt ongeveer overeen met 75 woorden of vijf korte zinnen.

• 1.000 tokens is ongeveer één pagina A4 tekst.

• 100.000 tokens is een korte roman van ongeveer 300 pagina's.

• 1 miljoen tokens is ruwweg vijf boeken of een middelgrote codebase.

Namen, getallen, URL's en afkortingen breken vaak in meer tokens dan je verwacht. Tel ze altijd na met een tokenizer van het model dat je gebruikt.

Hoe ga je om met een beperkt context window?

1. Retrieval-Augmented Generation
   In plaats van alle documenten mee te sturen, haal je via RAG enkel de relevante fragmenten op en stuur je die mee. Zo past een kennisbank van gigabytes in een window van een paar duizend tokens.

2. Samenvatten tussendoor
   Bij lange gesprekken laat je het model zelf periodiek samenvatten wat er besproken is en gooi je de oudste berichten weg. Hoe minder ruis, hoe beter het antwoord.

3. Chunking per taak
   Grote documenten opsplitsen en per stuk een deeltaak laten uitvoeren, dan de resultaten samenbrengen. Werkt goed voor samenvatten, extractie en vergelijking.

4. Prompt caching
   Bij API's die prompt caching aanbieden (Anthropic, OpenAI) betaal je maar één keer voor een grote systeeminstructie of document, ook al stuur je er duizenden oproepen overheen. Kan de kostprijs tot tien keer drukken.

Groter is niet altijd beter

Een window van een miljoen tokens klinkt indrukwekkend, maar lost niet elk probleem op.

Kwaliteit daalt met lengte. Onderzoek toont dat modellen bij heel lange contexten moeite hebben om feiten uit het midden correct terug te vinden. Tussen 32.000 en 128.000 tokens zakt de prestatie op needle in a haystack-tests meetbaar.

Kosten stijgen lineair. Elke token in de prompt wordt gefactureerd, ook als hij niet relevant blijkt. Een goed ontworpen RAG met 5.000 tokens context verslaat bijna altijd een brute-force prompt met 500.000 tokens.

Latency stijgt mee. Grote prompts vragen meer rekentijd. Voor interactieve toepassingen is een antwoord na 30 seconden vaak onbruikbaar.

In de praktijk combineer je een ruim context window met een doordachte pipeline: slim ophalen, slim samenvatten, slim cachen. Dan haal je het beste uit beide werelden.