0%

Ein kleiner Agent · Abschlussprojekt

Abschlussprojekt: Projekt: Ein Lernagent mit Limits

Lektion 2 hat die Schleife gebaut, und die Lektionen 3, 4 und 7 haben ihre Stopp-Prüfungen einzeln hinzugefügt, jede dort, wo sie passte. Die Reihenfolge der Prüfungen ist jetzt wichtig, und sie ist über mehrere if-Anweisungen mitten in run_agent verteilt. Dieses Projekt verlagert die Entscheidung in eine kleine Funktion, stop_reason, und lässt run_agent danach handeln, was sie sagt:

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

Die Bausteine, die du hast

SchrittDein Code
Die Beschreibungen auswählendescribe_tools(tools, AGENT_DESCRIPTIONS) (mitgeliefert, Lektion 2)
Die Aufrufe aus einer Antwort lesenread_tool_calls(response) (Kapitel 6)
Die Anforderung des Modells festhaltenassistant_turn(calls) (Kapitel 6)
Die Aufrufe ausführen, wo nötig nach Rückfragerun_calls(calls, tools, approve) (Lektion 6)
Eine Wiederholung bemerkenrepeated_call(calls, trace) (Lektion 7)
Schritte und Tokens zählen, den Trace führeninnerhalb von run_agent (Lektionen 3 bis 5)

Baue stop_reason

stop_reason(calls, repeated, used, max_tokens_total, steps, max_steps) bekommt alles, was die Prüfungen brauchen, als Argumente und gibt einen Grund oder None zurück. Die Funktion prüft in dieser Reihenfolge:

  1. "answered", wenn calls leer ist.

  2. "budget", wenn used >= max_tokens_total gilt.

  3. "stuck", wenn repeated wahr ist.

  4. "max_steps", wenn steps >= max_steps gilt.

  5. Sonst None: weitermachen.

Die Reihenfolge ist das Design:

  • Eine eigentliche Antwort wird nie weggeworfen. Eine Antwort des Modells ohne Aufrufe ist das Ergebnis, für das der Lauf da war, also gewinnt sie gegen jedes Limit. Sie ist schon bezahlt.

  • Unter den Limits kommt das Geld zuerst. Wenn das Budget aufgebraucht ist, ist das für den Aufrufer das Wichtigste, egal was sonst noch zutrifft.

  • Eine Wiederholung wird vor dem Schrittlimit genannt, damit der Grund sagt, was schiefgelaufen ist. Ein Modell, das in seinem letzten erlaubten Schritt feststeckt, steckt fest; „die Schritte sind ausgegangen“ verschleiert das.

Weil stop_reason eine schlichte Funktion seiner Argumente ist, ohne Client und ohne Schleife, lässt sich jede Kombination für sich testen. Die Prüfungen probieren alle sechzehn Kombinationen der vier Bedingungen aus.

Hier ist die Schleife, die du gleich neu baust, mit stop_reason in der Mitte. Lies ihre Prüfungen von oben nach unten: Die erste, die zutrifft, entscheidet, und nur None führt dazu, dass die Aufrufe laufen.

In der Agentenschleife prüft stop_reason answered, budget, stuck und max_steps in dieser Reihenfolge, und nur wenn keine davon zutrifft, laufen die Aufrufe vor dem nächsten Schritt.

Baue run_agent neu

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

  1. Beginne messages mit der Systemnachricht und der Frage, hol die Beschreibungen mit describe_tools und starte den Trace, den Schrittzähler und die Token-Summe.

  2. Rufe in einer while True:-Schleife create mit model=MODEL, messages und den Beschreibungen auf. Zähle den Schritt, addiere usage.total_tokens der Antwort zur Summe und lies die Aufrufe.

  3. Berechne repeated = repeated_call(calls, trace) und hänge dann den Trace-Eintrag dieses Schritts an.

  4. Rufe stop_reason(calls, repeated, used, max_tokens_total, steps, max_steps) auf.

  5. Bei "answered" füge {"role": "assistant", "content": answer} zu messages hinzu, mit dem Inhalt der Antwort oder "", und gib {"answer": answer, "stop_reason": "answered", "trace": trace, "messages": messages} zurück.

  6. Bei jedem anderen Grund gib {"answer": "", "stop_reason": reason, "trace": trace, "messages": messages} zurück. Die Assistant-Nachricht der stoppenden Antwort wird nicht hinzugefügt, und ihre Aufrufe laufen nie.

  7. Bei None füge assistant_turn(calls) zu messages hinzu, führe die Aufrufe mit run_calls(calls, tools, approve) aus, füge jede Tool-Nachricht zu messages und ihren content zu "results" des Eintrags hinzu und starte die nächste Runde.

messages ist immer das Gespräch, wie es zuletzt gesendet wurde, plus die endgültige Assistant-Nachricht, wenn der Lauf geantwortet hat. Verwende die tools, das system und das approve, die du bekommst. Die Prüfungen übergeben ihre eigenen, geben die Antworten des Modells per Skript vor und schauen sich für jeden Stoppgrund den Trace und messages an, auch bei Antworten, auf die mehrere Bedingungen gleichzeitig zutreffen.

Ausführen

Führe python agent.py aus. Jetzt, wo es stop_reason gibt, überspringt die Demonstration die Ausgabe der Lektionen und lässt den fertigen Agenten auf fünf Arten laufen, jeweils gefolgt von seinem 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)

Der Budget-Lauf und der Lauf mit Schrittlimit stoppen bei derselben Antwort aus unterschiedlichen Gründen, und ihre Traces sehen sich ähnlich: Erst der Grund unterscheidet sie. Mit max_steps=2 fordert Schritt 2 einen neuen Aufruf an, read_note, also stoppt das Schrittlimit den Lauf; im tool-loop-Lauf wiederholt Schritt 2 den Schritt 1, also steckt das Modell fest.

Die Demonstration zeigt jeden Grund einmal. Bevor du deine Arbeit prüfst, denk über die Antworten nach, die sie nicht zeigt: eine Wiederholung, die zugleich das Budget aufbraucht, eine Antwort, die im letzten erlaubten Schritt ankommt, und eine Antwort, die im letzten Schritt eine Wiederholung ist. Die Reihenfolge in stop_reason entscheidet jeden dieser Fälle. Wenn du nicht weiterkommst, bitte Monty um einen Hinweis zu einem Fall, ohne nach der ganzen Funktion zu fragen.

Live ausprobieren

Dieser Schritt ist optional. run_agent liest das MODEL des Moduls bei jedem Modellaufruf, also kann ein kurzes Skript es auf das Live-Modell umstellen, ohne agent.py zu ändern. Lege neben agent.py eine Datei namens try_live.py mit diesen Zeilen an und führe dann im python try_live.py aus:

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"])

Das Live-Modell wählt seine Schritte selbst. Es ruft vielleicht zuerst list_notes auf, wie das geskriptete Modell, oder es rät die ID der Notiz und liest sie sofort, und es schreibt seine eigene Antwort aus der Notiz. Seine Token-Zahlen sind echt: Sie enthalten die Tool-Beschreibungen und jegliches Reasoning, also kann der Lauf mit "budget" stoppen, wo der geskriptete Lauf geantwortet hat. Ein 403 bedeutet, dass dein Konto keinen Live-Zugang hat, und ein 429, dass du das Limit für den Moment erreicht hast. Ein Lese-Timeout ist ebenfalls ein normales Ergebnis: Ein Live-Modell kann länger nachdenken, als die Lesegrenze dieses Kurses erlaubt. Lösche try_live.py, wenn du fertig bist.

Wie es weitergeht

Der Lernassistent hat jetzt einen Agenten, der so lange nachschlägt, wie er muss, innerhalb von Limits, die du festlegst, der fragt, bevor er schreibt, und der jeden Schritt meldet. Kapitel 8 gibt ihm eine bessere Art, Dinge zu finden, als ganze Notizen zu lesen: ein Such-Tool, das nur die Passagen zurückgibt, die zu einer Frage passen. Kapitel 9 schickt jeden Modellaufruf durch einen einzigen Wrapper, der erneut versucht, was einen erneuten Versuch lohnt, und die Token-Zählung dieses Kapitels durch ein Budget ersetzt, das sich alle Aufrufe teilen.

Nach einer Antwort, die einen früheren Aufruf wiederholt, hat die Token-Summe auch das Budget erreicht. Was gibt stop_reason zurück?

Die Antwort im letzten erlaubten Schritt beantwortet die Frage, und diese Antwort bringt die Token-Summe über das Budget. Was gibt run_agent zurück?

Aufgabe

Ersetze in agent.py den unfertigen Rumpf von stop_reason(calls, repeated, used, max_tokens_total, steps, max_steps) und lass dann run_agent die Funktion verwenden.

  1. stop_reason prüft in dieser Reihenfolge: "answered", wenn calls leer ist, "budget", wenn used >= max_tokens_total gilt, "stuck", wenn repeated gilt, "max_steps", wenn steps >= max_steps gilt. Andernfalls gibt sie None zurück.

  2. run_agent(question, *, client, tools, system, approve, max_steps, max_tokens_total) ruft nach jeder Antwort stop_reason auf.

  3. Bei "answered" füge die endgültige Assistant-Nachricht hinzu und gib den Inhalt (oder "") als Antwort zurück. Bei jedem anderen Grund gib "" als Antwort zurück, ohne die Aufrufe auszuführen oder ihre Assistant-Nachricht hinzuzufügen.

  4. Bei None führe die Aufrufe mit run_calls aus und starte die nächste Runde.

Jedes Ergebnis hat "answer", "stop_reason", "trace" und "messages". Führe python agent.py aus, um jeden Stoppgrund zu sehen, und prüfe dann deine Arbeit.