0%

Hoofdstuk 7

Een kleine agent

Van één toolaanroep naar een lus

Hoofdstuk 6 eindigde met answer_with_tools: één request, één ronde toolaanroepen, nog één request en een antwoord. De functie geeft het op wanneer het model een tweede keer om een tool vraagt, omdat hij niet kan weten hoeveel rondes een vraag nodig heeft. Dit hoofdstuk haalt die grens weg en vervangt die door grenzen die je zelf kiest.

Je project voor dit hoofdstuk

Open agent.py in de projecteditor. Het bestand importeert uit drie cursusbestanden:

from client_calls import MODEL, make_client, scenario_client
from prompts import TOOLS_SYSTEM
from tools import (
    TOOL_DESCRIPTIONS,
    answer_with_tools,
    assistant_turn,
    ...
)

tools.py is de afgeronde code van hoofdstuk 6. Het staat ernaast, samen met de eerdere bestanden die het importeert: client_calls.py, structured.py, quiz_models.py, conversation.py, llm_basics.py en errors.py. Je hoeft geen van die bestanden te veranderen. Net als eerder gebruikt de controle van je werk eigen kopieën, dus een wijziging daarin kan geen beoordeling veranderen, maar wel de demonstratie laten vastlopen.

Bovenaan agent.py staat afgeronde code die je in latere lessen leest: een derde tool, save_flashcard, die een flashcardbestand schrijft, met een beschrijving en een controle op de bestandsnaam; twee dictionaries met tools, READ_TOOLS en AGENT_TOOLS; en een paar hulpfuncties, describe_tools, approve_all, refuse_all en print_trace. Daaronder staan vier onafgemaakte functies: run_agent, run_calls, repeated_call en stop_reason. Het meeste werk van het hoofdstuk gebeurt in run_agent, die in elke les een beetje groeit. python agent.py voert het bestand uit, en de demonstratie onderaan roept elk van je functies aan zodra die bestaat. De demonstratiecode onder je functies hoort niet bij de cursus. Eén hulpfunctie daarin, has_parameter, gebruikt de module inspect van Python om te zien welke parameters je run_agent tot nu toe heeft, zodat de demonstratie de versie kan aanroepen die je hebt. Je hoeft die niet te lezen.

Eén ronde is niet genoeg

Voer nu in de Shell python agent.py uit, voordat je iets verandert. De demonstratie stelt answer_with_tools een vraag over de notities van hoofdstuk 6, stuurt daarna zelf hetzelfde eerste request en drukt de toolaanroepen in het antwoord af:

print(answer_with_tools("What does the note on errors say about finally?", client=client))
One round of tools, from Chapter 6:
I needed more than one round of lookups to answer that.
The first reply asked for:
[{'id': 'call_1_1', 'name': 'list_notes', 'arguments': '{}'}]
The agent loop:
Run stopped at the next function to build: run_agent is built in Lesson 2.

answer_with_tools gaf NEEDS_MORE_LOOKUPS terug. Het eerste antwoord laat zien waarom. De vraag zegt “the note on errors”, niet 07-errors, dus het model kende de id van de notitie niet. Het vroeg eerst om list_notes. Met de lijst in handen vroeg het om read_note met 07-errors: een tweede ronde tools, en die weigert answer_with_tools uit te voeren.

Het gescripte model speelt dit na volgens een tabel, zoals SCRIPTED_MODEL.md laat zien, maar een live model doet voortdurend hetzelfde soort dingen. Het zoekt iets op, leest het resultaat en weet pas dan wat het daarna moet opzoeken. Een programma kan niet van tevoren zien hoeveel rondes dat kost.

De lus

De oplossing is doorgaan:

  1. Stuur het gesprek, met de tools.

  2. Als het antwoord nergens om vraagt, is het het antwoord. Stop.

  3. Voer anders elke gevraagde aanroep uit, voeg het assistant-bericht en de toolresultaten toe aan het gesprek en ga terug naar stap 1.

Een programma dat deze lus uitvoert, is wat mensen meestal bedoelen met een agent: het model kiest de volgende stap, en je programma voert die uit en meldt het resultaat terug. Binnen een ronde gebeurt niets nieuws. Elke ronde is precies de ronde die je in hoofdstuk 6 bouwde, met read_tool_calls, assistant_turn en tool_messages. Het enige nieuwe is dat het programma nog een ronde maakt.

Voor de vraag over errors doet de lus drie requests:

RequestHet gesprek dat het stuurtHet antwoord vraagt om
1systeembericht, vraaglist_notes
2hetzelfde, plus het assistant-bericht en de lijst met notitiesread_note met 07-errors
3hetzelfde, plus het assistant-bericht en de tekst van de notitieniets: het is het antwoord

Drie risico’s

Een lus die doorgaat tot het model tevreden is, heeft drie problemen, en de rest van het hoofdstuk pakt ze een voor een aan.

Ten eerste: het model beslist wanneer het stopt. De lus hierboven eindigt alleen wanneer een antwoord nergens om vraagt. Een model dat blijft vragen, door een bug in een tool, een verwarrend resultaat of gewoon pech, houdt het programma draaiende. Les 3 voegt een limiet op het aantal stappen toe.

Ten tweede: elke ronde kost meer dan de vorige. Elk request bevat het hele gesprek, en het gesprek groeit elke ronde met de tekst van een notitie, dus het derde request hierboven is vele malen groter dan het eerste. Les 4 telt de tokens en stopt bij een budget, en les 5 schrijft op wat elke stap deed en kostte.

Ten derde: een tool kan iets veranderen. Een notitie lezen is onschuldig. save_flashcard schrijft een bestand, en het model kiest de naam en de inhoud. Les 6 laat het programma een mens om toestemming vragen voordat zo’n tool draait.

Les 7 voegt nog een controle toe voor het eerste risico: een model dat twee keer om precies dezelfde aanroep vraagt, leert de tweede keer niets nieuws. Het project zet alle vier de stopcontroles in één functie, in een vaste volgorde.

Waarom gaf answer_with_tools NEEDS_MORE_LOOKUPS terug voor "What does the note on errors say about finally?"

Een eenvoudige agentlus stuurt een request, voert de tools uit waar het antwoord om vraagt, stuurt de resultaten terug en herhaalt dat. Wat laat de lus stoppen als er geen andere controles zijn?

Een agentlus stopt alleen wanneer een antwoord om geen enkele tool vraagt. Het model blijft elke beurt om read_note met 07-errors vragen. Wat is het risico?