Hoofdstuk 8
Antwoorden uit je notities
Het model kent je notities niet
De agent uit hoofdstuk 7 antwoordt vanuit de notities door ze te lezen: hij vraagt om read_note, je programma stuurt de hele notitie terug en het model schrijft zijn antwoord op basis van die tekst. Zonder de notitie in het request heeft het model niets van jou om op te bouwen. Dit hoofdstuk maakt dat idee precies. Je programma zoekt de paar passages uit de notities die bij een vraag passen, stuurt alleen die mee, vraagt het model om op basis daarvan te antwoorden en ze te noemen, en controleert daarna of het dat ook gedaan heeft. Een antwoord op basis van passages die het programma aanlevert, heet een onderbouwd antwoord (grounded answer).
Je project voor dit hoofdstuk
Open retrieval.py in de projecteditor. Onder Path en openai importeert het uit drie cursusbestanden:
from answer_models import CitedAnswer
from client_calls import MODEL, make_client
from prompts import GROUNDED_SYSTEM
client_calls.py is de afgeronde code van hoofdstuk 5. agent.py, de afgeronde agent van hoofdstuk 7, staat ernaast, samen met elk eerder bestand dat het importeert, waaronder tools.py uit hoofdstuk 6; de code van dit hoofdstuk importeert het niet, maar het project bouwt de zoektool die die agent gaat gebruiken. Net als eerder gebruikt de controle van je werk eigen kopieën van deze bestanden, dus een wijziging daarin kan geen beoordeling veranderen, maar wel de demonstratie laten vastlopen. prompts.py bevat nu ook GROUNDED_SYSTEM, het systeembericht dat je in les 5 leest. answer_models.py is nieuw en bijna leeg: daarin schrijf je in les 6 een pydantic-model.
Onder de imports staan zes constanten die latere lessen uitleggen, één afgeronde functie, load_notes, twaalf onafgemaakte functies en één lege plaatshouder, SEARCH_NOTES_DESCRIPTION = {}. load_notes geeft een dictionary terug van elk notitie-id, zoals 03-lists, naar de tekst van die notitie, gelezen als UTF-8 uit de map notes, in de volgorde van de ids. python retrieval.py voert het bestand uit, en de demonstratie onderaan roept elke functie aan zodra die bestaat.
Een vraag over één detail
Op 2026-11-08 ging deze vraag als enige bericht naar openai/gpt-oss-20b, het model achter pl-live:
What example list does the Python Land lists note use, and what values are in it?
Dit is zijn eerste antwoord, onbewerkt:
In the ordinary Python‐language reference (the “Python Land” documentation) the *Lists* section uses a very small example list to illustrate how lists are made and how they’re indexed.
The example list is simply
```python
[1, 2, 3]
```
and it contains the three integers **1, 2** and **3**. The list is used throughout the section to demonstrate indexing, slicing, mutating, and other list operations.
Het leest prettig, het klinkt zeker van zijn zaak, en het klopt niet. Twee andere pogingen met dezelfde vraag noemden andere lijsten, [1, 2, 3, 4, 5, 6, 7, 8, 9] en ['spam', 'ham', 'eggs'], en drie pogingen met een vraag over de functienotitie noemden een functie greet of hello_world. De functienotitie definieert average. De cursus bewaart alle zes ruwe antwoorden, onbewerkt.
Wat de notitie zegt
Voer in de Shell nu python retrieval.py uit, voordat je iets verandert. De demonstratie laadt de notities met load_notes en drukt de lijstennotitie af:
load_notes read 12 notes. The lists note:
# Lists
A list is an ordered collection of values. You write one with square brackets, such as `scores = [90, 72, 85]`. A list can hold values of any type, including a mix of types and other lists.
Each item has a position, called its index, starting at 0. `scores[0]` is the first item and `scores[-1]` is the last. Reading an index that does not exist raises `IndexError`. A slice such as `scores[0:2]` returns a new list with the items from position 0 up to, but not including, position 2.
Lists are mutable, so you can change them after creating them. `scores.append(60)` adds an item to the end, `scores.insert(0, 100)` adds one at a position, `scores.remove(72)` removes the first matching value, and `scores[1] = 75` replaces an item in place. These methods change the list and return `None`, so `scores = scores.append(60)` loses the list.
Because a list is changed in place, two names that refer to the same list both see every change. Use `scores.copy()` or `list(scores)` when you need an independent list. Adding two lists with `+` also builds a new list and leaves both originals unchanged.
`len(scores)` tells you how many items a list holds, and `value in scores` tells you whether a value is one of them.
Run stopped at the next function to build: note_chunks is built in Lesson 2.
De eerste alinea bevat het antwoord: de voorbeeldlijst in de notitie is scores = [90, 72, 85]. De laatste regel is de gebruikelijke stopregel: de demonstratie stopt bij de eerste functie die je nog niet hebt geschreven.
Waarom het model het fout had
Een taalmodel heeft geleerd van een grote hoeveelheid openbare tekst, verzameld voordat het werd getraind. Deze twaalf notities zaten daar niet bij, en niets in de vraag bevatte ze. Dus deed het model wat het altijd doet: het schreef de meest waarschijnlijke voortzetting van de tekst die het kreeg. Een voorbeeldlijst in een tutorial over lijsten is heel vaak [1, 2, 3], dus dat schreef het. Het antwoord is aannemelijk, niet gecontroleerd. En niets in het antwoord vertelt je welke delen ergens echt vandaan kwamen.
Het gescripte model helpt hier ook niet. Het beantwoordt de prompts in zijn tabel en herhaalt al het andere. Geen van beide modellen kent je notities totdat je programma ze meestuurt.
Waarom niet elke notitie meesturen
De eenvoudigste oplossing is alle twaalf notities in elk request te plakken. Ze bevatten 14943 tekens, ongeveer 3700 tokens volgens de telling van het gescripte model, dus elke vraag zou voor allemaal betalen, zelfs een vraag die maar één alinea nodig heeft. Een request moet ook in het contextvenster van het model passen, dat in hoofdstuk 2 aan bod kwam, en een echte verzameling documenten is veel groter dan twaalf korte notities. En een model dat veel tekst krijgt, kan minder betrouwbaar antwoorden vanuit de ene alinea die ertoe doet dan wanneer het alleen die alinea krijgt.
Het plan: ophalen, labelen, vermelden, controleren
Ophalen (retrieval) kiest de paar passages die bij de vraag passen en stuurt alleen die mee:
Splits elke notitie in passages, fragmenten (chunks) genoemd. Hier is een fragment een alinea (les 2).
Geef elk fragment een score voor de vraag op basis van de woorden die ze delen (les 3), en houd de beste paar over (les 4).
Label elk fragment, zoals
03-lists#1voor de eerste alinea van de lijstennotitie, en stuur de fragmenten na de vraag mee. Het systeembericht zegt het model om alleen op basis daarvan te antwoorden en de labels op te sommen die het gebruikte (les 5).Controleer het antwoord in je programma: het moet geldige JSON in de verwachte vorm zijn, en elk label dat het vermeldt, moet een label zijn dat jij hebt verstuurd (les 6).
Geef geen antwoord wanneer geen enkel fragment goed genoeg past: antwoord “ik weet het niet” zonder het model iets te vragen (les 7).
Het project voegt deze stappen samen in answer_from_notes en maakt van het zoeken een tool, search_notes, voor de agent.
Stap 4 maakt het antwoord controleerbaar. Het model kan nog steeds iets verkeerds schrijven, maar een bronvermelding van een passage die nooit is verstuurd, vangt je programma elke keer af, en een mens kan de vermelde passage lezen om het antwoord ermee te vergelijken.
Dit hoofdstuk geeft fragmenten een score op basis van de woorden die ze met de vraag delen, met alleen de standaardbibliotheek. Hoofdstuk 12 legt embeddings uit, de methode die grotere systemen gebruiken om passages te vinden die hetzelfde betekenen in andere woorden.
Waarom zei het live model dat de lijstennotitie [1, 2, 3] gebruikt?
Waarom plak je niet alle twaalf notities in elk request?
Het model antwoordt met een antwoord en een lijst labels die het naar eigen zeggen heeft gebruikt. Wat kan je programma controleren zonder het model te vertrouwen?