Fehleranalyse für KI-Agenten

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Fehleranalyse für KI-Agenten behandelt

• Welche häufigen Fehler bei KI-Agenten auftreten und wie Du sie erkennst.
• Wie Du Tracing, Debugging und Logging für Agenten einrichtest.
• Wie Du Fehler systematisch analysierst und behebst.
• Praxisbeispiele für Endlosschleifen, Halluzinationen und Tool-Fehler.
• Best Practices für zuverlässige Agenten.

Einleitung: Fehleranalyse für KI-Agenten verständlich erklärt

KI-Agenten sind komplex: Sie rufen Modelle auf, führen Tools aus, treffen Entscheidungen. Wenn etwas schiefgeht, kann der Agent in Endlosschleifen feststecken, falsche Tools aufrufen, halluzinieren oder abstürzen. Fehleranalyse ist die Disziplin, diese Fehler zu erkennen, zu verstehen und zu beheben.

Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die KI-Agenten bauen und debuggen. Du solltest verstehen, was KI-Agenten sind und wie man sie lokal mit Ollama betreibt. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.

Warum brauche ich Fehleranalyse?

Stell Dir vor, Dein Agent soll E-Mails sortieren, aber er tut nichts. Warum? Hat das Modell nicht geantwortet? Hat das Tool versagt? Ist der Agent in einer Schleife feststecken? Ohne Fehleranalyse rätst Du im Dunkeln. Mit Fehleranalyse siehst Du jeden Schritt, jede Entscheidung, jeden Fehler und kannst gezielt eingreifen.

Fehleranalyse für KI-Agenten kurz erklärt

Fehleranalyse ist die systematische Untersuchung von Agenten-Fehlern. Du nutzt Tracing (jeder Schritt wird aufgezeichnet), Logging (Ereignisse werden protokolliert) und Debugging (gezieltes Untersuchen), um die Ursache zu finden und zu beheben.

Der Kerngedanke lautet: Ohne Tracing kein Debugging, ohne Debugging keine Zuverlässigkeit.

Für wen ist dieser Artikel gedacht?

• Entwicklerinnen und Entwickler, die KI-Agenten bauen und debuggen.
• Systemadministratoren, die Agenten in Produktion betreuen.
• Teams, die Agenten-Qualität systematisch verbessern.
• Forscherinnen und Forscher, die Agenten-Verhalten untersuchen.

Vorkenntnisse in Python, KI-Agenten und Ollama sind erforderlich.

Wichtige Begriffe

• Tracing - Aufzeichnung jedes Agenten-Schritts. Wann nützlich: für Nachvollziehbarkeit.
• Protokollierung - Strukturierte Logs. Wann nützlich: Basis für Analyse.
• Debugging - Systematische Fehlersuche. Wann nützlich: um Ursachen zu finden.
• Endlosschleife - Agent wiederholt Schritte ohne Fortschritt. Wann nützlich: häufiger Fehler.
• Halluzination - Modell erfindet Fakten. Wann nützlich: häufiger Fehler.
• Tool-Fehler - Tool-Aufruf schlägt fehl. Wann nützlich: häufiger Fehler.
• KI-Agenten - Was debuggt wird. Wann nützlich: der Untersuchungsgegenstand.
• Ollama - Lokaler Modellserver. Wann nützlich: Backend, dessen Fehler analysiert werden.
• Function Calling - Tool-Use. Wann nützlich: häufige Fehlerquelle.

Häufige Fehler bei KI-Agenten

1. Endlosschleifen

Der Agent wiederholt Schritte, ohne voranzukommen.

Symptome: Agent läuft sehr lange, gleiche Tool-Aufrufe wiederholen sich, keine finale Antwort.

Ursachen:

• Modell kann Aufgabe nicht lösen, versucht es immer wieder.
• Tool gibt unerwartete Ergebnisse, Modell versteht es nicht.
• Keine Schritt-Begrenzung.

Lösung: Schritt-Begrenzung einbauen.

MAX_STEPS = 20
step = 0
while step < MAX_STEPS:
    step += 1
    # Agenten-Schritt
    if is_done(result):
        break
else:
    log_error("endless_loop", f"Agent hat {MAX_STEPS} Schritte überschritten")

2. Halluzinationen

Das Modell erfindet Fakten, die nicht in den Quellen stehen.

Symptome: Antwort enthält Fakten, die nicht belegt sind, Quellenangaben sind falsch.

Ursachen:

• Modell hat nicht genug Kontext.
• Modell neigt zu Halluzinationen (modellabhängig).
• Keine Validierung der Ausgaben.

Lösung: Fakten validieren, Quellen fordern.

Siehe Recherche-Workflows für Strategien gegen Halluzinationen.

3. Tool-Fehler

Tool-Aufrufe schlagen fehl.

Symptome: Tool gibt Fehler zurück, Agent versteht Fehler nicht, bricht ab.

Ursachen:

• Tool nicht erreichbar (Netzwerk, Dienst down).
• Falsche Parameter (Modell hat falsche Parameter gesendet).
• Berechtigungsproblem (Tool darf nicht ausgeführt werden).

Lösung: Error-Handling im Agenten.

def call_tool_safe(tool_name, parameters):
    try:
        result = execute_tool(tool_name, parameters)
        return {"success": True, "result": result}
    except NetworkError as e:
        return {"success": False, "error": "tool_unreachable", "message": str(e)}
    except InvalidParameters as e:
        return {"success": False, "error": "invalid_parameters", "message": str(e)}
    except PermissionError as e:
        return {"success": False, "error": "permission_denied", "message": str(e)}

4. Kontextlänge überschritten

Der Kontext wird zu lang, das Modell kann nicht mehr antworten.

Symptome: Modell-Antwort wird abgeschnitten, Fehlermeldung wegen Kontextlänge.

Ursachen:

• Zu viele Nachrichten im Verlauf.
• Lange Tool-Ergebnisse.
• Keine Summary-Funktion.

Lösung: Summary Memory nutzen.

def manage_context(messages, max_tokens=4000):
    total = sum(len(m["content"]) for m in messages)
    if total > max_tokens:
        # Zusammenfassen
        summary = call_ollama([
            {"role": "system", "content": "Fasse zusammen."},
            {"role": "user", "content": str(messages[:5])}
        ])
        messages = [messages[0], {"role": "system", "content": f"Zusammenfassung: {summary}"}] + messages[-3:]
    return messages

5. Modell nicht erreichbar

Ollama oder Cloud-API ist nicht erreichbar.

Symptome: Timeout, Connection-Error, Agent bricht ab.

Ursachen:

• Ollama läuft nicht.
• Netzwerk-Problem.
• Cloud-API down.

Lösung: Retry-Logik und Fallback.

import time

def call_model_retry(messages, max_retries=3, delay=1):
    for attempt in range(max_retries):
        try:
            return call_ollama(messages)
        except (ConnectionError, TimeoutError) as e:
            if attempt < max_retries - 1:
                time.sleep(delay * (attempt + 1))
            else:
                log_error("model_unreachable", str(e))
                raise

Tracing implementieren

from datetime import datetime
import json

class AgentTracer:
    def __init__(self, trace_file="agent_trace.json"):
        self.trace_file = trace_file
        self.steps = []

    def trace_step(self, step_type, data):
        step = {
            "timestamp": datetime.now().isoformat(),
            "step_type": step_type,
            "data": data
        }
        self.steps.append(step)
        with open(self.trace_file, "a") as f:
            f.write(json.dumps(step) + "\n")

    def trace_model_call(self, model, messages, response, duration_ms):
        self.trace_step("model_call", {
            "model": model,
            "input_messages": len(messages),
            "response_length": len(response),
            "duration_ms": duration_ms
        })

    def trace_tool_call(self, tool, parameters, result, duration_ms):
        self.trace_step("tool_call", {
            "tool": tool,
            "parameters": parameters,
            "result_status": result.get("status", "unknown"),
            "duration_ms": duration_ms
        })

    def trace_decision(self, decision, reasoning):
        self.trace_step("decision", {
            "decision": decision,
            "reasoning": reasoning
        })

    def trace_error(self, error_type, message, context):
        self.trace_step("error", {
            "error_type": error_type,
            "message": message,
            "context": context
        })

Agent mit Tracing

class TraceableAgent:
    def __init__(self, model="llama3.1"):
        self.model = model
        self.tracer = AgentTracer()

    def run(self, task):
        self.tracer.trace_step("start", {"task": task})
        step = 0

        while step < 20:
            step += 1
            self.tracer.trace_step("step", {"step_number": step})

            # Modell aufrufen
            start = time.time()
            try:
                response = call_ollama([
                    {"role": "user", "content": task}
                ])
                duration = (time.time() - start) * 1000
                self.tracer.trace_model_call(self.model, [task], response, duration)
            except Exception as e:
                self.tracer.trace_error("model_error", str(e), {"step": step})
                raise

            # Tool-Aufruf?
            if has_tool_call(response):
                tool_name, params = extract_tool_call(response)
                start = time.time()
                try:
                    result = execute_tool(tool_name, params)
                    duration = (time.time() - start) * 1000
                    self.tracer.trace_tool_call(tool_name, params, result, duration)
                except Exception as e:
                    self.tracer.trace_error("tool_error", str(e), {"tool": tool_name})
                    result = {"success": False, "error": str(e)}

            # Fertig?
            if is_done(response):
                self.tracer.trace_step("done", {"result": response})
                return response

        self.tracer.trace_error("max_steps", "Maximale Schrittzahl überschritten", {"steps": step})

Trace analysieren

# Alle Fehler
jq 'select(.step_type == "error")' agent_trace.json

# Alle Tool-Aufrufe
jq 'select(.step_type == "tool_call")' agent_trace.json

# Alle fehlgeschlagenen Tool-Aufrufe
jq 'select(.step_type == "tool_call" and .data.result_status == "failed")' agent_trace.json

# Langsame Modell-Aufrufe
jq 'select(.step_type == "model_call" and .data.duration_ms > 5000)' agent_trace.json

Praxisbeispiel 1: Endlosschleife debuggen

# Trace zeigt: Agent ruft 20 Mal das gleiche Tool auf
# Analyse: Tool gibt unerwartetes Ergebnis, Modell versteht es nicht

# Lösung: Bessere Fehlerbeschreibung an Modell
def call_tool_with_explanation(tool_name, parameters):
    result = execute_tool(tool_name, parameters)
    if not result["success"]:
        # Klare Fehlerbeschreibung für das Modell
        result["explanation"] = f"Tool {tool_name} ist fehlgeschlagen: {result['error']}. Versuche eine andere Methode."
    return result

Praxisbeispiel 2: Halluzination debuggen

# Trace zeigt: Modell gibt Fakten ohne Quellen
# Analyse: Modell hat nicht genug Kontext

# Lösung: Quellen fordern
system_prompt = """
Du bist ein Recherche-Agent.
Jeder Fakt muss eine Quelle haben.
Wenn Du keine Quelle hast, sage "Ich weiß es nicht."
Erfinde keine Fakten.
"""

Praxisbeispiel 3: Tool-Fehler debuggen

# Trace zeigt: Tool-Aufruf schlägt fehl mit "connection refused"
# Analyse: Ollama läuft nicht

# Lösung: Health-Check vor Agenten-Start
def check_ollama_health():
    try:
        requests.get("http://localhost:11434/api/tags", timeout=5)
        return True
    except:
        return False

if not check_ollama_health():
    print("Ollama läuft nicht. Starte Ollama.")
    subprocess.Popen(["ollama", "serve"])
    time.sleep(5)

Typische Stolpersteine

• Kein Tracing: Ohne Trace kannst Du nicht nachvollziehen, was passiert ist.
• Kein Error-Handling: Wenn ein Tool fehlschlägt, bricht der Agent ab.
• Keine Schritt-Begrenzung: Agent kann in Endlosschleifen feststecken.
• Keine Kontext-Verwaltung: Kontext wird zu lang, Modell kann nicht antworten.
• Keine Retry-Logik: Einmaliger Netzwerkfehler bricht den Agenten ab.
• Trace zu groß: Zu viele Details machen Trace unübersichtlich. Nutze Log-Level.

Weiterführende Links

• KI-Agenten Grundlagen - Was KI-Agenten sind.
• Protokollierung - Logging-Basis.
• Kostenkontrolle - Kosten überwachen.
• Recherche-Workflows - Gegen Halluzinationen.
• KI-Agenten mit Ollama - Agenten lokal betreiben.
• Function Calling - Tool-Use.
• Ollama Fehlerbehebung - Ollama debuggen.

Key Takeaways:

• Häufige Fehler: Endlosschleifen, Halluzinationen, Tool-Fehler, Kontextlänge.
• Tracing aufgezeichnet jeden Schritt für Nachvollziehbarkeit.
• Error-Handling fängt Tool-Fehler ab, ohne den Agenten abbrechen zu lassen.
• Schritt-Begrenzung verhindert Endlosschleifen.
• Retry-Logik und Fallback erhöhen Zuverlässigkeit.

FAQ

Quellen und weiterführende Literatur

• LangSmith - Tracing für LangChain.
• Langfuse - Open-Source Tracing.
• Ollama - Lokaler Modellserver.
• Protokollierung - Logging-Basis.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert