De meeste mensen kunnen een LLM prompten. Het inbouwen ervan in een product dat echt verkeer overleeft, is een heel ander spel. Als je de stap wilt maken van typen in een chatvenster naar het lanceren van AI in productie, moet je begrijpen hoe de stack daadwerkelijk in elkaar zit. Het is geen magie. Het is een pijplijn van afzonderlijke engineeringproblemen, en elke laag heeft zijn eigen foutmodi.

Ik neem je mee in hoe een modern AI-systeem werkt, van het moment dat je een woord typt tot het moment dat een agent een taak voltooit.

De basis: Hoe modellen denken

In de kern doet een groot taalmodel precies één ding: het voorspelt het volgende token. Dat token kan het volgende woord zijn, een deel van een woord, of zelfs een symbool. Alles wat daarop volgt — poëzie, code, redeneren — is emergent gedrag dat voortkomt uit het uitvoeren van die ene taak op grote schaal.

De reis van je prompt naar de reactie van het model ziet er als volgt uit.

Tokenisatie is de eerste stap. Ruwe tekst is betekenisloos voor een neuraal netwerk, dus het model splitst je woorden in stukjes en koppelt elk stukje aan een getal. Het woord "tokenization" kan bijvoorbeeld drie afzonderlijke tokens worden. De frase "New York" kan één of twee tokens zijn, afhankelijk van de vocabulaire. Deze getallen zijn niet willekeurig; ze komen uit een vast woordenboek dat het model tijdens de training heeft geleerd.

Zodra woorden getallen zijn, hebben ze betekenis nodig. Embeddings zetten die getallen om in vectoren — lange lijsten met floating-point waarden die vergelijkbare concepten dicht bij elkaar plaatsen in een wiskundige ruimte. "King" en "Queen" liggen dicht bij elkaar. "Paris" en "Berlin" vormen een cluster, maar in een andere buurt dan "Python" of "JavaScript".

Maar vectoren alleen verliezen de volgorde. Positional encoding vertelt het model waar elk token in de zin staat. Zonder dit zouden "The dog bit the man" en "The man bit the dog" identiek lijken.

Dan volgt het attention-mechanisme. Dit is waar het model naar alle tokens in de input kijkt en beslist welke belangrijk zijn voor het voorspellen van de volgende. Wanneer je vraagt: "Wanneer is het bedrijf opgericht en wie leidt het nu?", moet het model "founded" koppelen aan een datum en "leads" aan een naam van een CEO. Attention creëert die verbindingen.

Deze operaties stapelen zich op in lagen — vaak tientallen — waarbij de vroege lagen de syntaxis afhandelen en de latere lagen abstract redeneren opbouwen. Ergens in het midden slaan feed-forward netwerken feitelijke associaties op. Dit is waar het model de kennis bewaart dat Parijs de hoofdstad van Frankrijk is, of dat een specifieke API een JSON-payload verwacht. Het is niet precies een database, maar een gecomprimeerd web van gewichten dat patronen activeert.

Ten slotte zet decoding de interne vectorrepresentaties weer om in voor mensen leesbare tokens. Het model "weet" niet dat het Engels schrijft; het rangschikt simpelweg duizenden mogelijke volgende tokens en kiest steeds de meest waarschijnlijke, totdat het een stopconditie bereikt.

De RAG-laag: Modellen een geheugen geven

Een basismodel is bevroren in de tijd. De gewichten leggen het internet vast tot een bepaalde afkapdatum, en het kan niet bij je privédocumenten tenzij je deze invoert. Dat maakt het nutteloos voor de meeste zakelijke taken. Retrieval-Augmented Generation, of RAG, lost dit op door het model een externe bibliotheek te geven die het kan raadplegen voordat het antwoordt.

Het concept is eenvoudig, maar de uitvoering is lastig. Eerst neem je je documenten en pas je chunking toe. Je dumpt geen honderd pagina's tellende PDF in het promptvenster. Je splitst het in paragrafen, secties of semantische blokken die klein genoeg zijn om binnen de contextlimiet van het model te passen, terwijl de betekenis behouden blijft.

Elk chunk gaat door een embedding model en wordt een vector, net als de tokens binnen de LLM. Deze vectoren leven in een vectordatabase — een gespecialiseerde opslag die is ontworpen voor gelijkeniszoekopdrachten (similarity search) in plaats van exacte zoekopdrachten. Wanneer een gebruiker een vraag stelt, maak je een embedding van hun zoekopdracht en vraag je aan de database: "Welke chunks liggen qua betekenis het dichtst bij deze vector?"

Alleen ruwe vectorzoekopdrachten missen vaak exacte overeenkomsten. Een goed productiesysteem gebruikt hybrid search, waarbij trefwoordmatching wordt gecombineerd met semantische gelijkenis. Als iemand vraagt naar "SLA-99 compliance", wil je het document dat letterlijk die tekst bevat, en niet alleen een document dat er 'vergelijkbaar' aan voelt.

Na de retrieval filtert re-ranking de ruis. De initiële zoekopdracht kan twintig chunks opleveren, maar slechts de bovenste drie of vier zijn daadwerkelijk nuttig. Een re-ranker beoordeelt de relevantie en gooit de rest weg voordat er iets naar de LLM gaat, wat tokens bespaart en hallucinaties vermindert.

De Agent-laag: Actie ondernemen

RAG lets a model read. Agents let it act.

An agent is fundamentally an LLM stuck inside a loop. It observes, reasons, acts, and then observes again. If you ask an agent to book a flight, it does not just describe how booking works. It breaks the task into steps, calls the right functions, reads the responses, and adjusts.

The loop looks like this. Observe: the agent reads the current state—your request, the results of previous tool calls, any errors. Reason: the LLM decides what to do next, often by generating a structured plan or selecting from predefined options. Act: it calls a tool.

Tools are how agents touch the real world. They are defined with JSON schemas that tell the model exactly what parameters an API needs. The LLM does not make arbitrary HTTP requests. It fills in a schema. "Call the weather API with city: London and units: metric." If the tool returns a temperature, the agent feeds