0%

Mee naar huis

Hoe nu verder

Je begon deze cursus met één HTTP-request en een antwoord dat je met de hand las. Je eindigt met een programma dat een model aanroept via een client, de antwoorden streamt, ze omzet in gevalideerde objecten, het model in een lus met limieten je functies laat aanroepen, zijn antwoorden onderbouwt met je notities en zijn bronnen bewijst, netjes faalt, binnen een budget blijft, zonder netwerk wordt getest en tegen een echte aanbieder draait met een sleutel die niemand anders kan zien. Daaruit bestaat het grootste deel van een applicatie die op een taalmodel is gebouwd.

Vanaf hier lopen vier richtingen verder. Elke richting bouwt voort op iets wat je al met de hand hebt gedaan.

Ophalen op betekenis: embeddings

Het ophalen (retrieval) uit hoofdstuk 8 vergelijkt woorden. Een vraag en een alinea krijgen een punt voor elk woord dat ze delen, nadat de stopwoorden zijn verwijderd. Je zag twee keer wat die regel kost. In hoofdstuk 8 kwam tuples niet overeen met tuple. In de eval van hoofdstuk 10 miste de vraag over filteren met een list comprehension zijn notitie, omdat comprehension niet overeenkomt met comprehensions. Het programma wist niets van betekenis; het vergeleek spelling.

Een embedding is een manier om in plaats daarvan betekenis te vergelijken. Een model zet een stuk tekst om in een lange lijst getallen, zo gekozen dat teksten over hetzelfde onderwerp op vergelijkbare lijsten uitkomen. tuples en tuple komen dicht bij elkaar terecht, en “duplicate a list” en “make a copy” ook. Ophalen werkt dan zoals bij jou, met een andere score: maak één keer een embedding van elk fragment, maak een embedding van de vraag, en houd de fragmenten waarvan de getallen het dichtst bij die van de vraag liggen. Veel aanbieders bieden naast chat completions een embeddings-endpoint aan, en sommige modellen daarvoor draaien lokaal. Zodra er veel documenten zijn, bewaart een vectordatabase (vector store) de getallen en vindt hij snel de dichtstbijzijnde.

Alles rond de score blijft zoals je het hebt gebouwd: fragmenten met labels, de beste paar in de prompt, bronvermeldingen die worden gecontroleerd tegen wat er is verstuurd, en “I don’t know” als niets dichtbij genoeg ligt. Met de eval uit hoofdstuk 10 zou je uitzoeken of embeddings op je eigen notities beter ophalen dan woorden.

Agentframeworks

Bibliotheken voor het bouwen van agents schrijven de lus voor je: ze sturen het request, lezen de toolaanroepen, voeren je functies uit, sturen de resultaten terug en houden van elke stap een trace bij. Dat is run_agent uit hoofdstuk 7, met zijn stappenlimiet, zijn budget, zijn goedkeuringspoort voor tools die iets veranderen en zijn controle op een herhaalde aanroep. Omdat je die lus zelf hebt geschreven, weet je wat een framework namens jou moet doen en waar je moet kijken als het zich misdraagt: hoeveel stappen het toestaat, wat het uitgeeft, welke tools draaien zonder te vragen, en wat het doet als het model twee keer om hetzelfde vraagt.

Evaluatietools

De eval van hoofdstuk 10 bestond uit tien vragen, beoordeeld op ophalen en op bronvermeldingen, en één keer uitgevoerd. Evaluatietools doen hetzelfde op grotere schaal: meer cases, meerdere runs van elk om te zien hoeveel een live model varieert, en controles die zelf modellen zijn en moeten beoordelen of een antwoord klopt wanneer geen eenvoudige regel dat kan zeggen. De gewoonte is dezelfde die je in hoofdstuk 11 oefende: meet een wijziging voordat je die houdt, en vertrouw alleen verschillen die groter zijn dan de ruis.

Het Model Context Protocol

In hoofdstuk 6 beschreef je elke functie voor het model met een naam, een beschrijving en een JSON-schema van de argumenten, en je programma voerde de aanroep uit als het model erom vroeg. Het Model Context Protocol, MCP, is daar een gedeelde standaard voor. Een programma dat tools aanbiedt, een server genoemd, beschrijft ze één keer in een standaardvorm, en elke applicatie die het protocol spreekt, kan ze opvragen en aanroepen. Het zijn de beschrijvingen en het doorsturen (dispatch) uit hoofdstuk 6, afgesproken tussen veel programma’s, zodat een tool die één keer is geschreven door veel assistenten gebruikt kan worden.

Welke je ook kiest, dezelfde vragen die je leerde stellen blijven gelden: wat ziet het model, wat kan het mijn programma laten doen, hoe weet ik dat het antwoord klopt, wat gebeurt er als een aanroep faalt, en wat kost het.

Waarom miste het ophalen van de cursus de alinea over tuple bij een vraag over tuples, en wat zou een embedding veranderen?

Wat doet een agentframework dat run_agent met de hand deed?

Wat standaardiseert het Model Context Protocol?