KI-Agenten erklärt: Was ist eine ReAct-Schleife und wie funktioniert sie?

KI-Agenten erklärt: Was ist ein ReAct-Loop und wie funktioniert er?

Künstliche Intelligenz-Agenten haben sich weit über einfache Chatbots hinaus entwickelt. Heutzutage generieren die leistungsfähigsten KI-Systeme nicht nur Text – sie denken, handeln und passen sich in Echtzeit an. Im Zentrum dieser Entwicklung steht ein leistungsstarkes Muster namens **ReAct-Loop**. Wenn du dich jemals gefragt hast, wie KI-Agenten entscheiden, welches Tool sie verwenden, wann sie um Klarstellung bitten oder wie sie sich von Fehlern erholen, ist die Antwort oft ein ReAct-Loop.

In diesem Artikel erklären wir, was ein ReAct-Loop ist, warum er wichtig ist und wie du deinen eigenen Agenten mit diesem Muster bauen kannst. Wir geben konkrete Installationsschritte, Codebeispiele und praktische Anwendungsszenarien, die auf führender Forschung und Industriepraxis basieren.

Was ist ein ReAct-Loop?

Der Begriff "ReAct" steht für **Reasoning + Acting** (Denken + Handeln). Er wurde von Forschern populär gemacht, die große Sprachmodelle (LLMs) mit der Fähigkeit kombinieren wollten, in einer Umgebung Aktionen auszuführen – wie das Aufrufen von APIs, das Durchsuchen von Datenbanken oder das Ausführen von Code.

Ein ReAct-Loop ist ein zyklischer Prozess, bei dem ein KI-Agent:

1. **Einen Prompt oder eine Beobachtung erhält** (z. B. eine Benutzerfrage oder Sensordaten). 2. **Überlegt, was als Nächstes zu tun ist**, mithilfe eines LLMs. 3. **Handelt**, indem er ein Tool aufruft, eine Entscheidung trifft oder eine Antwort generiert. 4. **Das Ergebnis dieser Aktion beobachtet**. 5. **Kehrt zum Denken zurück** und verwendet die neue Beobachtung als Kontext.

Dieser Zyklus wird fortgesetzt, bis der Agent feststellt, dass er die Anfrage des Benutzers beantwortet oder einen Endzustand erreicht hat. Der Loop gibt Agenten eine strukturierte Möglichkeit, mehrstufige Aufgaben zu bewältigen, sich von Fehlern zu erholen und externe Tools zu verwenden.

Warum ist ReAct wichtig?

Traditionelle LLMs sind zustandslos – sie generieren eine einzelne Antwort, ohne die Möglichkeit, Fakten zu überprüfen oder Aktionen auszuführen. ReAct-Loops verwandeln LLMs in autonome Agenten, indem sie:

• **Tool-Nutzung ermöglichen**: Der Agent kann Suchmaschinen, Taschenrechner oder Datenbanken aufrufen.
• **Selbstkorrektur unterstützen**: Wenn eine Aktion fehlschlägt, kann der Agent einen anderen Ansatz versuchen.
• **Transparenz verbessern**: Jeder Schritt wird protokolliert, sodass der Denkprozess sichtbar ist.
• **Lange Aufgaben bewältigen**: Der Loop kann viele Iterationen durchlaufen und Aktionen miteinander verketten.

Branchenführer wie OpenAI, Microsoft und Anthropic haben alle ReAct-ähnliche Muster in ihre Agenten-Frameworks integriert. Beispielsweise basieren sowohl OpenAIs Function Calling als auch Microsofts AutoGen auf iterativem Denken und Handeln.

Wie der ReAct-Loop in der Praxis funktioniert

Gehen wir ein konkretes Beispiel durch. Angenommen, du fragst einen KI-Agenten: *"Wie war die Temperatur in London am 15. Januar 2024?"*

Ohne einen ReAct-Loop würde ein Standard-LLM raten oder sagen "Ich habe keine Echtzeitdaten." Mit einem ReAct-Loop folgt der Agent diesen Schritten:

1. **Denken**: "Ich muss die Temperatur in London an diesem Datum finden. Ich kann eine Wetter-API verwenden." 2. **Handeln**: Rufe die Wetter-API mit den Parametern `city: London, date: 2024-01-15` auf. 3. **Beobachten**: Die API gibt `{ "temperature": 5, "unit": "celsius" }` zurück. 4. **Denken**: "Ich habe die Temperatur. Die Antwort ist 5°C." 5. **Handeln**: Antworte dem Benutzer mit der Antwort.

Wenn der API-Aufruf fehlschlägt (z. B. aufgrund eines Rate-Limits), kann der Agent erneut denken: "Die API ist fehlgeschlagen. Ich sollte es nach einer Verzögerung erneut versuchen oder eine alternative Quelle verwenden."

Dieser Loop ist der Kern moderner KI-Agenten.

Voraussetzungen für den Bau eines ReAct-Agenten

Bevor wir in den Code eintauchen, skizzieren wir, was du benötigst.

Hardware-Anforderungen

• Ein Computer mit Internetzugang.
• Mindestens 8 GB RAM (16 GB empfohlen für lokale Modelle).

Software-Anforderungen

• **Python 3.10 oder neuer** (Python 3.11 empfohlen).
• **pip** Paketmanager.
• Ein **OpenAI-API-Schlüssel** (oder ein lokaler LLM-Anbieter wie Ollama für Open-Source-Modelle).

Wissensvoraussetzungen

• Grundlegende Python-Programmierung.
• Vertrautheit mit der Kommandozeile.
• Verständnis von REST-APIs ist hilfreich, aber nicht erforderlich.

Schritt-für-Schritt-Installation

Wir bauen einen minimalen ReAct-Agenten mit Python und der OpenAI-API. Dieser Agent kann das Internet durchsuchen und Berechnungen durchführen.

Schritt 1: Python-Virtual-Environment einrichten

Erstelle zunächst eine isolierte Umgebung für unser Projekt. Dies verhindert Abhängigkeitskonflikte.

python3 -m venv react-agent-env
source react-agent-env/bin/activate   # Unter Windows: react-agent-env\Scripts\activate

Schritt 2: Erforderliche Bibliotheken installieren

Wir benötigen den OpenAI-Python-Client und eine Bibliothek für HTTP-Anfragen.

pip install openai requests python-dotenv

• `openai` – ermöglicht uns, GPT-Modelle aufzurufen.
• `requests` – für API-Aufrufe an externe Dienste.
• `python-dotenv` – zum sicheren Speichern unseres API-Schlüssels.

Schritt 3: API-Schlüssel einrichten

Erstelle eine Datei namens `.env` in deinem Projektordner. Füge deinen OpenAI-Schlüssel wie folgt hinzu:

OPENAI_API_KEY=sk-dein-schlüssel-hier

Ersetze `sk-dein-schlüssel-hier` durch deinen tatsächlichen Schlüssel. Um einen zu erhalten, registriere dich bei [OpenAI](https://openai.com) und generiere einen Schlüssel im API-Dashboard.

Schritt 4: Das Agenten-Skript erstellen

Erstelle nun eine Datei namens `react_agent.py` und füge den folgenden Code ein. Dieses Skript implementiert einen grundlegenden ReAct-Loop.

import os
import json
import requests
from openai import OpenAI
from dotenv import load_dotenv

# Umgebungsvariablen laden
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

# Verfügbare Tools definieren
tools = [
    {
        "name": "web_search",
        "description": "Durchsuche das Internet nach aktuellen Informationen",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string", "description": "Suchanfrage"}
            },
            "required": ["query"]
        }
    },
    {
        "name": "calculator",
        "description": "Führe mathematische Berechnungen durch",
        "parameters": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Mathematischer Ausdruck zur Berechnung"}
            },
            "required": ["expression"]
        }
    }
]

def web_search(query):
    """Simuliere eine Websuche (später durch echte API ersetzen)"""
    return f"Suchergebnisse für '{query}': Beispielergebnis 1, Beispielergebnis 2"

def calculator(expression):
    """Werte einen mathematischen Ausdruck sicher aus"""
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"Fehler: {str(e)}"

def run_agent(user_input, max_iterations=5):
    """Haupt-ReAct-Loop"""
    messages = [{"role": "user", "content": user_input}]
    
    for _ in range(max_iterations):
        # Schritt 1: Denken - Frage das LLM, was zu tun ist
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        
        assistant_message = response.choices[0].message
        
        # Wenn das Modell sagt, dass es fertig ist, breche ab
        if assistant_message.content and not assistant_message.tool_calls:
            print(f"Assistent: {assistant_message.content}")
            break
        
        # Schritt 2: Handeln - Verarbeite Tool-Aufrufe
        if assistant_message.tool_calls:
            messages.append(assistant_message)
            for tool_call in assistant_message.tool_calls:
                function_name = tool_call.function.name
                arguments = json.loads(tool_call.function.arguments)
                
                # Führe das entsprechende Tool aus
                if function_name == "web_search":
                    result = web_search(arguments["query"])
                elif function_name == "calculator":
                    result = calculator(arguments["expression"])
                else:
                    result = "Unbekanntes Tool"
                
                # Schritt 3: Beobachten - Füge das Ergebnis zum Kontext hinzu
                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": result
                })
                
                print(f"Aktion: {function_name}({arguments}) -> {result}")
        
        # Setze den Loop mit der neuen Beobachtung fort
    
    return messages

if __name__ == "__main__":
    user_query = input("Gib deine Frage ein: ")
    run_agent(user_query)

Dieses Skript definiert zwei Tools – `web_search` und `calculator` – und führt einen Loop aus, der wiederholt das LLM fragt, welches Tool aufgerufen werden soll, es ausführt und das Ergebnis zurückführt.

Anwendungsbeispiele

Jetzt, wo wir unseren Agenten haben, testen wir ihn mit echten Anfragen.

Beispiel 1: Einfache Berechnung

Führe das Skript aus und frage:

Gib deine Frage ein: Was ist 24 * 7?

Der Agent wird: 1. Denken, dass eine Berechnung nötig ist. 2. Das `calculator`-Tool mit `expression: "24 * 7"` aufrufen. 3. Das Ergebnis `168` beobachten. 4. Mit der Antwort antworten.

Du solltest eine Ausgabe sehen wie:

Aktion: calculator({'expression': '24 * 7'}) -> 168
Assistent: 24 multipliziert mit 7 ergibt 168.

Beispiel 2: Mehrstufige Aufgabe

Stelle eine Frage, die beide Tools erfordert:

Gib deine Frage ein: Was ist die Bevölkerung Japans geteilt durch 10 Millionen?

Der Agent könnte zuerst nach Japans Bevölkerung suchen und dann die Division durchführen. Der Loop bewältigt beide Schritte nacheinander.

Beispiel 3: Fehlerbehebung

Teste, was passiert, wenn ein Tool fehlschlägt. Ändere die `calculator`-Funktion so, dass sie absichtlich eine Ausnahme auslöst, und frage dann:

Gib deine Frage ein: Was ist die Quadratwurzel von -1?

Bei komplexen Zahlen könnte der Agent einen anderen Ansatz versuchen oder die Einschränkung erklären.

Den Agenten mit echten Tools erweitern

Das obige Beispiel verwendet eine simulierte Suche. Um es wirklich nützlich zu machen, ersetze `web_search` durch eine echte API wie SerpAPI oder Bing Search. So integrierst du eine echte Suche:

1. Installiere die `serpapi`-Bibliothek:

   pip install google-search-results

2. Aktualisiere die `web_search`-Funktion:

   from serpapi import GoogleSearch

   def web_search(query):
       params = {
           "q": query,
           "api_key": os.getenv("SERPAPI_KEY"),
           "num": 3
       }
       search = GoogleSearch(params)
       results = search.get_dict()
       snippets = [r.get("snippet", "") for r in results.get("organic_results", [])]
       return "\n".join(snippets)

3. Füge `SERPAPI_KEY` zu deiner `.env`-Datei hinzu.

Jetzt kann dein Agent Echtzeitinformationen aus dem Internet abrufen.

Best Practices für den Bau von ReAct-Agenten

Basierend auf Mustern von OpenAI, Microsoft und Anthropic hier einige wichtige Empfehlungen:

• **Iterationen begrenzen**: Setze immer eine maximale Anzahl von Loops (z. B. 5–10), um Endlosschleifen zu vermeiden.
• **Tool-Eingaben validieren**: Bereinige Parameter, bevor du externe Aufrufe ausführst.
• **Jeden Schritt protokollieren**: Drucke oder speichere jede Aktion und Beobachtung zum Debuggen.
• **Strukturierte Tool-Beschreibungen verwenden**: Beschreibe klar, was jedes Tool tut und welche Parameter es hat. Das LLM verlässt sich darauf, um richtig zu wählen.
• **Randfälle behandeln**: Bereite dich auf API-Fehler, leere Ergebnisse oder mehrdeutige Benutzeranfragen vor.

Fazit

Der ReAct-Loop ist ein grundlegendes Muster für den Bau intelligenter KI-Agenten. Durch die Kombination von Denken und Handeln in einem kontinuierlichen Zyklus können Agenten komplexe Aufgaben lösen, externe Tools verwenden und sich von Fehlern erholen – und das alles transparent.

In diesem Artikel hast du gelernt:

• Was ein ReAct-Loop ist und warum er wichtig ist.
• Wie der Denken-Handeln-Beobachten-Zyklus funktioniert.
• Wie du deinen eigenen ReAct-Agenten mit Python und OpenAI baust.
• Wie du ihn mit echten Tools wie der Websuche erweiterst.

Während sich KI weiterentwickelt, wird der ReAct-Loop ein zentrales Designprinzip bleiben. Egal, ob du einen Kundensupport-Bot, einen Forschungsassistenten oder ein Automatisierungstool baust – das Verständnis dieses Musters gibt dir die Macht, Agenten zu erschaffen, die nicht nur reden, sondern handeln.

Jetzt bist du dran. Installiere den Code, experimentiere mit verschiedenen Tools und sieh, was dein Agent kann. Der Loop ist erst der Anfang.