0%

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

StapJe code
Kies de beschrijvingendescribe_tools(tools, AGENT_DESCRIPTIONS) (meegeleverd, les 2)
Lees de aanroepen uit een antwoordread_tool_calls(response) (hoofdstuk 6)
Leg de toolaanroepen van het model vastassistant_turn(calls) (hoofdstuk 6)
Voer de aanroepen uit, en vraag eerst toestemming waar nodigrun_calls(calls, tools, approve) (les 6)
Merk een herhaling oprepeated_call(calls, trace) (les 7)
Tel stappen en tokens, houd de trace bijbinnen 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:

  1. "answered" als calls leeg is.

  2. "budget" als used >= max_tokens_total.

  3. "stuck" als repeated waar is.

  4. "max_steps" als steps >= max_steps.

  5. 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.

In de agentlus controleert stop_reason answered, budget, stuck en max_steps in die volgorde, en alleen als geen ervan klopt, worden de aanroepen uitgevoerd vóór de volgende stap.

Bouw run_agent opnieuw

run_agent(question, *, client, tools, system, approve, max_steps, max_tokens_total):

  1. Begin messages met het systeembericht en de vraag, haal de beschrijvingen op met describe_tools, en start de trace, de stappenteller en het tokentotaal.

  2. Roep in een while True:-lus create aan met model=MODEL, messages en de beschrijvingen. Tel de stap, tel de usage.total_tokens van het antwoord op bij het totaal en lees de aanroepen.

  3. Bepaal repeated = repeated_call(calls, trace) en voeg daarna het trace-item van deze stap toe.

  4. Roep stop_reason(calls, repeated, used, max_tokens_total, steps, max_steps) aan.

  5. Voeg bij "answered" {"role": "assistant", "content": answer} toe aan messages, met de content van het antwoord of "", en geef {"answer": answer, "stop_reason": "answered", "trace": trace, "messages": messages} terug.

  6. 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.

  7. Voeg bij None assistant_turn(calls) toe aan messages, voer de aanroepen uit met run_calls(calls, tools, approve), voeg elk toolbericht toe aan messages en de content ervan 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.

  1. stop_reason controleert in deze volgorde: "answered" als calls leeg is, "budget" als used >= max_tokens_total, "stuck" als repeated, "max_steps" als steps >= max_steps. Anders geeft de functie None terug.

  2. run_agent(question, *, client, tools, system, approve, max_steps, max_tokens_total) roept na elk antwoord stop_reason aan.

  3. 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.

  4. Voer bij None de aanroepen uit met run_calls en 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.