Een kleine agent · eindproject
Eindproject: Project: een studieagent met grenzen
Les 2 bouwde de lus, en les 3, 4 en 7 voegden de stopcontroles een voor een toe, elk waar die paste. De volgorde van de controles doet er nu toe, en die is verspreid over meerdere if-statements midden in run_agent. Dit project verplaatst de beslissing naar één kleine functie, stop_reason, en laat run_agent handelen naar wat die zegt:
result = run_agent("What does the note on errors say about finally?",
client=make_client(), tools=READ_TOOLS, system=TOOLS_SYSTEM,
approve=refuse_all, max_steps=6, max_tokens_total=2000)
print(result["stop_reason"])
print_trace(result["trace"])
answered
Step 1 (48 tokens)
list_notes {} -> 140 characters
Step 2 (89 tokens)
read_note {"note_id": "07-errors"} -> 1325 characters
Step 3 (454 tokens)
answered
De onderdelen die je hebt
| Stap | Je code |
|---|---|
| Kies de beschrijvingen | describe_tools(tools, AGENT_DESCRIPTIONS) (meegeleverd, les 2) |
| Lees de aanroepen uit een antwoord | read_tool_calls(response) (hoofdstuk 6) |
| Leg de toolaanroepen van het model vast | assistant_turn(calls) (hoofdstuk 6) |
| Voer de aanroepen uit, en vraag eerst toestemming waar nodig | run_calls(calls, tools, approve) (les 6) |
| Merk een herhaling op | repeated_call(calls, trace) (les 7) |
| Tel stappen en tokens, houd de trace bij | binnen run_agent (les 3 tot en met 5) |
Bouw stop_reason
stop_reason(calls, repeated, used, max_tokens_total, steps, max_steps) krijgt alles wat de controles nodig hebben als argumenten, en geeft een reden of None terug. De functie controleert in deze volgorde:
"answered"alscallsleeg is."budget"alsused >= max_tokens_total."stuck"alsrepeatedwaar is."max_steps"alssteps >= max_steps.Anders
None: ga door.
De volgorde is het ontwerp:
Een antwoord wordt nooit weggegooid. Een antwoord zonder aanroepen is het resultaat waar de run voor was, dus het gaat voor elke limiet. Het is al betaald.
Geld komt eerst onder de limieten. Als het budget op is, is dat voor de aanroeper het belangrijkste om te weten, wat er verder ook waar is.
Een herhaling wordt vóór de stappenlimiet benoemd, zodat de reden zegt wat er misging. Een model dat vastzit op zijn laatste toegestane stap, zit vast; “de stappen waren op” verbergt dat.
Omdat stop_reason een gewone functie van zijn argumenten is, zonder client en zonder lus, kun je elke combinatie apart testen. De controles proberen alle zestien combinaties van de vier voorwaarden.
Hier is de lus die je zo opnieuw gaat bouwen, met stop_reason in het midden. Lees de controles van boven naar beneden: de eerste die klopt, beslist, en alleen None leidt tot het uitvoeren van de aanroepen.

Bouw run_agent opnieuw
run_agent(question, *, client, tools, system, approve, max_steps, max_tokens_total):
Begin
messagesmet het systeembericht en de vraag, haal de beschrijvingen op metdescribe_tools, en start de trace, de stappenteller en het tokentotaal.Roep in een
while True:-luscreateaan metmodel=MODEL,messagesen de beschrijvingen. Tel de stap, tel deusage.total_tokensvan het antwoord op bij het totaal en lees de aanroepen.Bepaal
repeated = repeated_call(calls, trace)en voeg daarna het trace-item van deze stap toe.Roep
stop_reason(calls, repeated, used, max_tokens_total, steps, max_steps)aan.Voeg bij
"answered"{"role": "assistant", "content": answer}toe aanmessages, met de content van het antwoord of"", en geef{"answer": answer, "stop_reason": "answered", "trace": trace, "messages": messages}terug.Geef bij elke andere reden
{"answer": "", "stop_reason": reason, "trace": trace, "messages": messages}terug. Het assistant-bericht van het stoppende antwoord wordt niet toegevoegd, en de aanroepen ervan worden nooit uitgevoerd.Voeg bij
Noneassistant_turn(calls)toe aanmessages, voer de aanroepen uit metrun_calls(calls, tools, approve), voeg elk toolbericht toe aanmessagesen decontentervan aan de"results"van het item, en ga nog een ronde.
messages is altijd het gesprek zoals het het laatst is verstuurd, plus het laatste assistant-bericht als de run antwoordde. Gebruik de tools, system en approve die je krijgt. De controles geven hun eigen mee, scripten de antwoorden van het model en kijken bij elke stopreden naar de trace en messages, ook bij antwoorden waarbij meerdere voorwaarden tegelijk gelden.
Voer het uit
Voer python agent.py uit. Nu stop_reason bestaat, slaat de demonstratie de uitvoer van de lessen over en voert de afgeronde agent op vijf manieren uit, elk gevolgd door de trace:
Answered, with max_steps=6 and max_tokens_total=2000:
Step 1 (48 tokens)
list_notes {} -> 140 characters
Step 2 (89 tokens)
read_note {"note_id": "07-errors"} -> 1325 characters
Step 3 (454 tokens)
answered
stop_reason: answered
answer: The errors note says that a finally block always runs, whether or not an exception was raised. An else block, by contrast, runs only when nothing was raised. (07-errors)
Over budget, with max_tokens_total=100:
Step 1 (48 tokens)
list_notes {} -> 140 characters
Step 2 (89 tokens)
read_note {"note_id": "07-errors"} (not run)
stop_reason: budget
At the step limit, with max_steps=2:
Step 1 (48 tokens)
list_notes {} -> 140 characters
Step 2 (89 tokens)
read_note {"note_id": "07-errors"} (not run)
stop_reason: max_steps
Stuck, through the tool-loop scenario:
Step 1 (48 tokens)
list_notes {} -> 140 characters
Step 2 (83 tokens)
list_notes {} (not run)
stop_reason: stuck
The flashcard request, refused:
Step 1 (50 tokens)
read_note {"note_id": "03-lists"} -> 1226 characters
Step 2 (391 tokens)
save_flashcard {"name": "copying-a-list", "front": "How do you make an independent copy of a list?", "back": "Use scores.copy() or list(scores). Both build a new list."} -> 58 characters
Step 3 (414 tokens)
answered
stop_reason: answered
answer: I did not save the flashcard, because you did not approve it. Here it is, so you can write it down yourself: How do you make an independent copy of a list? Use scores.copy() or list(scores). (03-lists)
De runs met budget en met stappenlimiet stoppen bij hetzelfde antwoord om verschillende redenen, en hun traces lijken op elkaar: de reden is wat ze onderscheidt. Met max_steps=2 vraagt stap 2 om een nieuwe aanroep, read_note, dus de stappenlimiet stopt de run; in de tool-loop-run herhaalt stap 2 stap 1, dus zit de agent vast.
De demonstratie laat elke reden één keer zien. Denk, voordat je je werk controleert, na over de antwoorden die ze niet laat zien: een herhaling die ook het budget opmaakt, een antwoord dat op de laatste toegestane stap binnenkomt, en een antwoord dat op de laatste stap een herhaling is. De volgorde van stop_reason beslist over elk ervan. Loop je vast, vraag Monty dan om een hint over één geval zonder om de hele functie te vragen.
Probeer het live
Deze stap is optioneel. run_agent leest de MODEL van de module elke keer dat de functie het model aanroept, dus een kort script kan hem naar het live model laten wijzen zonder agent.py te veranderen. Maak naast agent.py een bestand try_live.py met deze regels, en voer daarna in de python try_live.py uit:
import agent
agent.MODEL = "pl-live"
result = agent.run_agent(
"What does the note on errors say about finally?",
client=agent.make_client(),
tools=agent.READ_TOOLS,
system=agent.TOOLS_SYSTEM,
approve=agent.refuse_all,
max_steps=6,
max_tokens_total=2000,
)
agent.print_trace(result["trace"])
print(result["stop_reason"])
print(result["answer"])
Het live model kiest zijn eigen stappen. Het kan eerst list_notes aanroepen, zoals het gescripte model doet, of de id van de notitie raden en die meteen lezen, en het schrijft zijn eigen antwoord op basis van de notitie. De tokenaantallen zijn echt: ze bevatten de toolbeschrijvingen en eventueel redeneerwerk, dus de run kan stoppen met "budget" waar de gescripte run antwoordde. Een 403 betekent dat je account geen live toegang heeft, en een 429 dat je voorlopig de limiet hebt bereikt. Ook een lees-time-out is een normale uitkomst: een live model kan langer nadenken dan de leesgrens van deze cursus. Verwijder try_live.py als je klaar bent.
Hoe het verdergaat
De studieassistent heeft nu een agent die dingen opzoekt zolang dat nodig is, binnen grenzen die jij instelt, die toestemming vraagt voordat die iets schrijft, en die elke stap rapporteert. Hoofdstuk 8 geeft de assistent een betere manier om dingen te vinden dan hele notities lezen: een zoektool die alleen de passages teruggeeft die bij een vraag passen. Hoofdstuk 9 stuurt elke modelaanroep door één wrapper die opnieuw probeert wat het opnieuw proberen waard is, en vervangt de tokentelling uit dit hoofdstuk door een budget dat alle aanroepen delen.
Na een antwoord dat een eerdere aanroep herhaalt, heeft het tokentotaal ook het budget bereikt. Wat geeft stop_reason terug?
Het antwoord op de laatste toegestane stap beantwoordt de vraag, en dat antwoord brengt het tokentotaal over het budget. Wat geeft run_agent terug?
Opdracht
Vervang in agent.py de onafgemaakte body van stop_reason(calls, repeated, used, max_tokens_total, steps, max_steps) en laat run_agent de functie daarna gebruiken.
stop_reasoncontroleert in deze volgorde:"answered"alscallsleeg is,"budget"alsused >= max_tokens_total,"stuck"alsrepeated,"max_steps"alssteps >= max_steps. Anders geeft de functieNoneterug.run_agent(question, *, client, tools, system, approve, max_steps, max_tokens_total)roept na elk antwoordstop_reasonaan.Voeg bij
"answered"het laatste assistant-bericht toe en geef de content (of"") terug als antwoord. Geef bij elke andere reden""terug als antwoord, zonder de aanroepen uit te voeren of hun assistant-bericht toe te voegen.Voer bij
Nonede aanroepen uit metrun_callsen ga nog een ronde.
Elk resultaat heeft "answer", "stop_reason", "trace" en "messages". Voer python agent.py uit om elke stopreden te zien, en controleer daarna je werk.