KI-Agenten und Function Calling: Tools für LLMs entwickeln

Sie bauen einen KI-Agenten, der Echtzeitdaten abrufen, Berechnungen durchführen oder mit externen APIs interagieren muss. Aber wie überbrücken Sie die Lücke zwischen der Textgenerierung des LLM und der tatsächlichen Codeausführung? Function Calling (auch bekannt als Tool-Nutzung) ist die Antwort. Es ermöglicht LLMs, bestimmte Aktionen anzufordern, und Ihr Code führt sie aus. Dieser Leitfaden führt Sie durch die Gestaltung, Implementierung und Fehlerbehebung von Function Calling für KI-Agenten.

Was ist Function Calling?

Function Calling ist ein Mechanismus, bei dem ein LLM eine strukturierte Anfrage zum Aufruf einer von Ihnen definierten Funktion ausgeben kann. Anstatt freien Text zu generieren, gibt das Modell ein JSON-Objekt mit dem Funktionsnamen und den Argumenten zurück. Ihre Anwendung führt dann die Funktion aus und speist das Ergebnis zurück in das Modell. Dies ermöglicht es Agenten, Aktionen jenseits der Textgenerierung auszuführen, wie das Abfragen von Datenbanken, das Senden von E-Mails oder das Aufrufen von APIs.

Große LLM-Anbieter wie OpenAI, Anthropic und Google unterstützen Function Calling. Die Kernidee ist konsistent: Sie beschreiben verfügbare Tools, das Modell entscheidet, wann es sie verwendet, und Sie übernehmen die Ausführung.

Tools für LLMs entwerfen

Gut gestaltete Tools sind entscheidend für zuverlässiges Agentenverhalten. Befolgen Sie diese Prinzipien:

• Klare Namen und Beschreibungen: Verwenden Sie beschreibende Funktionsnamen und detaillierte Beschreibungen. Das LLM verlässt sich darauf, um das richtige Tool auszuwählen.
• Einfache Parameter: Halten Sie die Parameter minimal und verwenden Sie Standardtypen (String, Number, Boolean, Array, Object). Vermeiden Sie nach Möglichkeit komplexe verschachtelte Strukturen.
• Idempotenz: Entwerfen Sie Tools nach Möglichkeit idempotent (sicher wiederholbar), um Fehler elegant zu behandeln.
• Fehlerbehandlung: Geben Sie informative Fehlermeldungen zurück, damit das LLM seinen Ansatz anpassen kann.

Beispiel: Wetter-Tool

Hier ist eine einfache Tool-Definition im JSON-Schema-Format, das häufig mit der OpenAI-API verwendet wird:

{
  "name": "get_weather",
  "description": "Get the current weather for a given city",
  "parameters": {
    "type": "object",
    "properties": {
      "city": {
        "type": "string",
        "description": "The city name, e.g., San Francisco"
      },
      "unit": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"],
        "description": "Temperature unit"
      }
    },
    "required": ["city"]
  }
}

Function Calling implementieren: Schritt für Schritt

Lassen Sie uns eine minimale Agentenschleife mit der OpenAI-API erstellen (das Muster gilt auch für andere Anbieter).

1. Definieren Sie Ihre Tools

Erstellen Sie eine Liste von Tool-Schemata und eine Zuordnung von Funktionsnamen zu tatsächlichen Python-Funktionen.

import json
import openai

# Tool schemas
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    }
]

# Actual functions
def get_weather(city: str, unit: str = "celsius") -> dict:
    # In reality, call a weather API
    return {"city": city, "temperature": 22, "unit": unit, "condition": "sunny"}

# Map names to functions
function_map = {
    "get_weather": get_weather
}

2. Erstellen Sie die Agentenschleife

Die Agentenschleife sendet Nachrichten an das LLM, prüft auf Tool-Aufrufe, führt sie aus und wiederholt dies, bis das Modell eine endgültige Antwort zurückgibt.

def run_agent(user_message: str):
    messages = [{"role": "user", "content": user_message}]
    
    while True:
        response = openai.ChatCompletion.create(
            model="gpt-4",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        
        message = response.choices[0].message
        messages.append(message)
        
        # If no tool calls, return the content
        if not message.get("tool_calls"):
            return message["content"]
        
        # Execute each tool call
        for tool_call in message.tool_calls:
            function_name = tool_call.function.name
            arguments = json.loads(tool_call.function.arguments)
            
            if function_name in function_map:
                result = function_map[function_name](**arguments)
            else:
                result = {"error": f"Unknown function: {function_name}"}
            
            # Append tool result to messages
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result)
            })

Diese Schleife läuft weiter, bis das LLM eine Antwort ohne Tool-Aufrufe produziert, was anzeigt, dass es genügend Informationen hat.

3. Fehler und Randfälle behandeln

Realitätsnahe Agenten müssen Folgendes bewältigen:

• Ungültige Argumente: Fangen Sie Ausnahmen beim Parsen von Argumenten oder beim Aufrufen von Funktionen ab.
• Unbekannte Tools: Geben Sie eine Fehlermeldung an das LLM zurück, damit es sich selbst korrigieren kann.
• Timeouts: Legen Sie Timeouts für externe API-Aufrufe fest, um Hängenbleiben zu vermeiden.
• Rate Limits: Implementieren Sie Wiederholungsversuche mit exponentiellem Backoff.

Best Practices für zuverlässige Agenten

• Begrenzen Sie die Tool-Anzahl: Zu viele Tools verwirren das Modell. Gruppieren Sie verwandte Funktionen oder verwenden Sie einen Router.
• Validieren Sie Eingaben: Bereinigen und validieren Sie alle Argumente vor der Ausführung.
• Protokollieren Sie alles: Protokollieren Sie Tool-Aufrufe und Ergebnisse für Debugging und Auditing.
• Testen Sie mit verschiedenen Prompts: Stellen Sie sicher, dass der Agent in verschiedenen Szenarien die richtigen Tools auswählt.
• Bieten Sie Fallbacks: Wenn ein Tool fehlschlägt, sollte der Agent Alternativen versuchen oder um Klärung bitten.

Vergleich der Function-Calling-Unterstützung

Fortgeschrittene Muster

Wenn Ihr Agent wächst, sollten Sie diese Muster in Betracht ziehen:

• Parallele Tool-Aufrufe: Einige Modelle können mehrere Tools gleichzeitig anfordern. Führen Sie sie gleichzeitig aus, um Geschwindigkeit zu gewinnen.
• Human-in-the-Loop: Für sensible Aktionen (z. B. Geld senden) ist eine menschliche Genehmigung vor der Ausführung erforderlich.
• Gedächtnis: Speichern Sie den Gesprächsverlauf und Tool-Ergebnisse, um Kontext in langen Sitzungen bereitzustellen.
• Tool-Routing: Verwenden Sie einen leichten Klassifikator, um relevante Tools auszuwählen, bevor Sie das Haupt-LLM aufrufen.

Debugging von Function Calling

Wenn etwas schiefgeht, prüfen Sie:

• Sind die Tool-Beschreibungen klar und eindeutig?
• Sind die Parameternamen und -typen korrekt?
• Hat das Modell genügend Kontext, um das richtige Tool auszuwählen?
• Behandeln Sie Tool-Ergebnisse korrekt (z. B. JSON-Serialisierung)?

Verwenden Sie Logging, um den vollständigen Nachrichtenverlauf und Tool-Aufrufe zu erfassen. Oft liegt das Problem in einer Diskrepanz zwischen erwarteten und tatsächlichen Argumenten.

FAQ

Was ist der Unterschied zwischen Function Calling und Tool-Nutzung?

Sie beziehen sich auf dasselbe Konzept. OpenAI nennt es "Function Calling", während Anthropic "Tool Use" verwendet. Beide ermöglichen es LLMs, die Ausführung externer Funktionen anzufordern.

Kann ich Function Calling mit Open-Source-Modellen verwenden?

Ja, einige Open-Source-Modelle wie Llama 3.1 unterstützen Function Calling, und Frameworks wie LangChain bieten Abstraktionen. Die Unterstützung variiert jedoch, und Sie müssen möglicherweise feinabstimmen oder bestimmte Prompt-Formate verwenden.

Wie verhindere ich, dass das LLM gefährliche Funktionen aufruft?

Setzen Sie gefährliche Funktionen niemals direkt aus. Verwenden Sie Allowlists, validieren Sie Eingaben und implementieren Sie Berechtigungsprüfungen. Für sensible Vorgänge ist eine menschliche Bestätigung vor der Ausführung erforderlich.

Bereit, Ihren eigenen KI-Agenten zu bauen? Beginnen Sie mit der Definition eines einfachen Tools und testen Sie die Agentenschleife. Weitere Entwicklertools finden Sie in unserem JSON Formatter, um Tool-Aufruf-Payloads zu debuggen.