Strukturierung eines autonomen AI-Agenten (Plan, Execute, Reflect)
Lerne die Kernarchitektur eines autonomen AI-Agenten kennen, der Aufgaben planen, ausführen und über seine Ergebnisse reflektieren kann. Diese Struktur ist entscheidend, um die Robustheit und Effektivität des Agenten zu maximieren.
Originalvideo ansehen: Mythos is real and it scares me...Definiere die `Agent`-Klasse.
Erstelle eine Python-Klasse, die den LLM, das Gedächtnis und die verfügbaren Tools initialisiert. Dies ist der zentrale Orchestrator.
class Agent:
def __init__(self, llm, memory, tools):
self.llm = llm
self.memory = memory
self.tools = tools
self.history = [] # Für den Verlauf der InteraktionenImplementiere die `plan`-Methode.
Diese Methode verwendet den LLM, um eine gegebene Aufgabe in eine Reihe von Unterschritten zu zerlegen. Der Prompt sollte den LLM anweisen, einen detaillierten, logischen Plan zu erstellen, der die verfügbaren Tools berücksichtigt.
def plan(self, task):
# Nutze LLM, um einen Plan zu generieren
prompt = f"Du bist ein erfahrener Planer. Zerlege die Aufgabe '{task}' in ausführbare Schritte. Berücksichtige die verfügbaren Tools: {list(self.tools.keys())}."
# ... LLM-Aufruf und Parsen des Plans ...
return ['Schritt 1', 'Schritt 2']Implementiere die `execute`-Methode.
Diese Methode nimmt einen Planschritt entgegen und wählt das passende Tool aus, um diesen Schritt auszuführen. Sie ruft das Tool auf und gibt dessen Ergebnis zurück.
def execute(self, step):
# Analysiere den Schritt, um das richtige Tool zu identifizieren und aufzurufen
# Beispiel: if 'search' in step: return self.tools['search'](query)
# ... Logik zur Tool-Auswahl und -Ausführung ...
return 'Ergebnis des Tools'Implementiere die `reflect`-Methode.
Nach der Ausführung eines Schritts bewertet diese Methode das Ergebnis. Der LLM wird verwendet, um zu beurteilen, ob der Schritt erfolgreich war, ob der Plan angepasst werden muss oder ob die Aufgabe abgeschlossen ist. Die Reflexion sollte auch im Langzeitgedächtnis gespeichert werden.
def reflect(self, task, plan, current_step, observation):
# Nutze LLM, um die Beobachtung zu bewerten und Feedback zu geben
prompt = f"Aufgabe: {task}\nPlan: {plan}\nAktueller Schritt: {current_step}\nBeobachtung: {observation}\nBewerte das Ergebnis und schlage die nächsten Schritte oder Planänderungen vor."
# ... LLM-Aufruf und Parsen der Reflexion ...
self.memory.add_entry(f"Reflexion: {prompt}\nErgebnis: {observation}") # Speichern im Gedächtnis
return 'Nächster Schritt oder Abschluss'Implementiere die `run`-Methode (den Hauptzyklus).
Diese Methode orchestriert den gesamten Prozess: Sie ruft `plan` auf, iteriert durch die Schritte, ruft `execute` und `reflect` auf, bis die Aufgabe abgeschlossen ist.
def run(self, task):
current_plan = self.plan(task)
while not self.is_task_complete(current_plan):
next_step = current_plan.pop(0) # Oder wähle den nächsten Schritt basierend auf Reflexion
observation = self.execute(next_step)
reflection_result = self.reflect(task, current_plan, next_step, observation)
# ... Logik zur Aktualisierung des Plans basierend auf Reflexion ...
if 'task_complete' in reflection_result: break
return 'Endgültige Antwort'