Tool Calling, erklärt: Wie KI-Agenten entscheiden, was als Nächstes zu tun ist

Tool Calling, erklärt: Wie KI-Agenten entscheiden, was als Nächstes zu tun ist

Große Sprachmodelle (LLMs) haben sich weit über die einfache Textgenerierung hinaus entwickelt. Die heutigen KI-Agenten beantworten nicht nur Fragen – sie ergreifen Aktionen. Sie durchsuchen das Web, führen Code aus, fragen Datenbanken ab und steuern APIs. Diese Fähigkeit wird durch einen Mechanismus namens **Tool Calling** (auch Function Calling genannt) ermöglicht. In diesem Artikel entmystifizieren wir Tool Calling: Was es ist, wie es unter der Haube funktioniert und wie Sie es mit konkreten Schritt-für-Schritt-Anleitungen in Ihren eigenen KI-Agenten implementieren können.

Was ist Tool Calling?

Tool Calling ist der Prozess, bei dem ein LLM entscheidet, eine externe Funktion oder API aufzurufen, anstatt eine rein textuelle Antwort zu generieren. Das Modell gibt eine strukturierte Anfrage (normalerweise im JSON-Format) aus, die angibt, welches Tool mit welchen Parametern verwendet werden soll. Die aufrufende Anwendung führt dann das Tool aus, gibt das Ergebnis an das Modell zurück, und das Modell integriert dieses Ergebnis in seine endgültige Antwort.

Dieser Mechanismus verwandelt LLMs von passiven Textgeneratoren in aktive Problemlöser. Wenn Sie beispielsweise einen KI-Agenten fragen: "Wie ist das Wetter in London?", könnte das Modell ein `get_weather`-Tool mit dem Parameter `location="London"` aufrufen, die aktuellen Wetterdaten erhalten und dann eine menschenlesbare Antwort wie "Das Wetter in London beträgt 15°C und ist bewölkt" verfassen.

Warum Tool Calling wichtig ist

Ohne Tool Calling kann ein LLM sich nur auf seine Trainingsdaten verlassen, die mit der Zeit veralten. Mit Tool Calling können Agenten:

• Auf Echtzeitinformationen zugreifen (Aktienkurse, Nachrichten, Wetter)
• Berechnungen durchführen oder Code ausführen
• Mit Datenbanken und internen Systemen interagieren
• Workflows auslösen und Benachrichtigungen senden
• Private oder domänenspezifische Daten abrufen

Wie Branchenführer wie OpenAI und Anthropic betonen, ist Tool Calling eine grundlegende Fähigkeit für den Bau zuverlässiger, autonomer KI-Agenten. Es überbrückt die Lücke zwischen Sprachverständnis und realen Aktionen.

Wie Tool Calling funktioniert: Der Entscheidungsprozess

Der Kernentscheidungsprozess umfasst drei Schritte:

1. **Das Modell erhält eine Benutzeranfrage und eine Liste verfügbarer Tools** (jeweils definiert durch Name, Beschreibung und Parameterschema). 2. **Das Modell analysiert die Anfrage und entscheidet, ob ein Tool benötigt wird.** Falls ja, gibt es eine strukturierte Anfrage aus (z.B. `{"tool": "search_web", "args": {"query": "neueste KI-Nachrichten"}}`). 3. **Die Anwendung führt das Tool aus, gibt das Ergebnis an das Modell zurück, und das Modell generiert eine endgültige Antwort**, die die Ausgabe des Tools integriert.

Diese Entscheidung ist nicht fest codiert – sie ergibt sich aus dem Training des LLMs. Das Modell hat gelernt zu erkennen, wann eine Frage externe Daten erfordert, und den entsprechenden Tool-Aufruf auszugeben. Der Schlüssel liegt darin, dass das Modell *entscheidet*, ein Tool aufzurufen; der Entwickler stellt nur die Tool-Definitionen bereit.

Voraussetzungen

Bevor wir mit der Implementierung beginnen, stellen Sie sicher, dass Folgendes vorhanden ist:

• **Python 3.9+** auf Ihrem System installiert
• **Ein API-Schlüssel** von OpenAI, Anthropic oder einem anderen Anbieter, der Function Calling unterstützt
• **Grundlegende Vertrautheit** mit der Kommandozeile und Python
• **pip** (Python-Paketmanager) auf dem neuesten Stand

Wir verwenden die OpenAI-API als primäres Beispiel, da sie eine ausgereifte Tool-Calling-Unterstützung bietet. Die Konzepte gelten gleichermaßen für Anthropics Claude und andere Modelle.

Schritt-für-Schritt-Installation

1. Einrichten einer Python-Virtual Environment

Isolieren Sie Ihre Projektabhängigkeiten, um Konflikte zu vermeiden.

python -m venv tool-calling-env

Aktivieren Sie die Umgebung:

• Auf macOS/Linux: `source tool-calling-env/bin/activate`
• Auf Windows: `tool-calling-env\Scripts\activate`

2. Installieren der OpenAI Python-Bibliothek

Diese Bibliothek stellt den Client für die Interaktion mit der OpenAI-API bereit.

pip install openai

3. Installieren zusätzlicher Abhängigkeiten

Wir benötigen `requests` für HTTP-Aufrufe und `python-dotenv`, um unseren API-Schlüssel sicher zu verwalten.

pip install requests python-dotenv

4. Einrichten Ihres API-Schlüssels

Erstellen Sie eine `.env`-Datei in Ihrem Projektverzeichnis:

OPENAI_API_KEY=ihr-api-schluessel-hier

Ersetzen Sie `ihr-api-schluessel-hier` durch Ihren tatsächlichen OpenAI-API-Schlüssel. Codieren Sie Schlüssel niemals fest in Ihrem Quellcode.

5. Überprüfen der Installation

Führen Sie eine kurze Prüfung durch, um sicherzustellen, dass alles funktioniert.

# test_import.py
import openai
import requests
from dotenv import load_dotenv
import os

load_dotenv()
print("Alle Importe erfolgreich.")
print(f"API-Schlüssel geladen: {os.getenv('OPENAI_API_KEY')[:8]}...")

Ausführen: `python test_import.py`

Verwendungsbeispiele

Jetzt bauen wir einen praktischen KI-Agenten, der Tool Calling verwendet, um aktuelle Zeit- und Wetterdaten abzurufen. Dieser Agent demonstriert den vollständigen Entscheidungsprozess.

Beispiel 1: Ein einfacher Zeit- und Wetter-Agent

Erstellen Sie eine Datei `agent.py`:

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

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

# Definieren unserer Tools
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "Aktuelles Datum und Uhrzeit abrufen",
            "parameters": {"type": "object", "properties": {}}
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Aktuelles Wetter für einen Ort abrufen",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Stadtname, z.B. 'London'"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# Tool-Implementierungen
def get_current_time():
    return datetime.now().strftime("%Y-%m-%d %H:%M:%S")

def get_weather(location):
    # Simulierte Wetterdaten - in Produktion echte API aufrufen
    weather_data = {
        "London": "15°C, bewölkt",
        "New York": "22°C, sonnig",
        "Tokyo": "18°C, regnerisch"
    }
    return weather_data.get(location, "Wetterdaten nicht verfügbar")

def run_agent(user_query):
    messages = [{"role": "user", "content": user_query}]
    
    # Erster API-Aufruf: Modell entscheidet, ob ein Tool aufgerufen wird
    response = client.chat.completions.create(
        model="gpt-4o-mini",  # Kostengünstiges Modell mit Tool Calling
        messages=messages,
        tools=tools,
        tool_choice="auto"  # Modell entscheiden lassen
    )
    
    assistant_message = response.choices[0].message
    
    # Prüfen, ob das Modell ein Tool aufrufen möchte
    if assistant_message.tool_calls:
        for tool_call in assistant_message.tool_calls:
            function_name = tool_call.function.name
            arguments = json.loads(tool_call.function.arguments)
            
            print(f"Agent aufgerufen: {function_name} mit Args: {arguments}")
            
            # Das entsprechende Tool ausführen
            if function_name == "get_current_time":
                result = get_current_time()
            elif function_name == "get_weather":
                result = get_weather(arguments["location"])
            else:
                result = "Unbekanntes Tool"
            
            # Tool-Ergebnis zur Konversation hinzufügen
            messages.append(assistant_message)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": str(result)
            })
        
        # Zweiter API-Aufruf: Modell generiert endgültige Antwort mit Tool-Ergebnissen
        final_response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools
        )
        
        return final_response.choices[0].message.content
    
    # Wenn kein Tool-Aufruf, direkte Antwort zurückgeben
    return assistant_message.content

# Agent testen
if __name__ == "__main__":
    print(run_agent("Wie spät ist es?"))
    print("---")
    print(run_agent("Wie ist das Wetter in London?"))
    print("---")
    print(run_agent("Wie ist das Wetter in Tokyo und wie spät ist es?"))

Führen Sie den Agenten aus:

python agent.py

Sie sollten eine Ausgabe wie diese sehen:

Agent aufgerufen: get_current_time mit Args: {}
Die aktuelle Uhrzeit ist 2025-03-25 14:32:18.
---
Agent aufgerufen: get_weather mit Args: {'location': 'London'}
Das Wetter in London beträgt 15°C, bewölkt.
---
Agent aufgerufen: get_weather mit Args: {'location': 'Tokyo'}
Agent aufgerufen: get_current_time mit Args: {}
In Tokyo beträgt das Wetter 18°C, regnerisch. Die aktuelle Uhrzeit ist 2025-03-25 14:32:18.

Beachten Sie, wie das Modell intelligent entschieden hat, für die dritte Anfrage zwei Tools aufzurufen. Das ist der Kern von Tool Calling: Das Modell wählt autonom aus, welche Tools in welcher Reihenfolge aufgerufen werden.

Beispiel 2: Ein Web-Such-Agent mit Fehlerbehandlung

Lassen Sie uns einen robusteren Agenten bauen, der das Web durchsucht (mit einer simulierten Suche) und Fehler elegant behandelt.

Erstellen Sie `search_agent.py`:

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

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

tools = [
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Das Web nach aktuellen Informationen durchsuchen",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {
                        "type": "string",
                        "description": "Suchanfrage"
                    }
                },
                "required": ["query"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Eine mathematische Berechnung durchführen",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "Mathematischer Ausdruck, z.B. '2 + 2'"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

def web_search(query):
    # Simulierte Suche - in Produktion echte Such-API verwenden
    results = {
        "neueste KI-Nachrichten": "KI-Agenten werden mit Tool-Calling-Fähigkeiten immer autonomer.",
        "OpenAI Nachrichten": "OpenAI hat kürzlich GPT-4o mit verbessertem Function Calling veröffentlicht.",
        "Microsoft KI Blog": "Microsoft hat neue KI-Tools für Unternehmenskunden angekündigt."
    }
    return results.get(query.lower(), f"Keine Ergebnisse für '{query}' gefunden")

def calculate(expression):
    try:
        result = eval(expression)
        return str(result)
    except Exception as e:
        return f"Fehler: {str(e)}"

def run_agent_with_error_handling(user_query):
    messages = [{"role": "user", "content": user_query}]
    max_iterations = 3  # Endlosschleifen verhindern
    
    for _ in range(max_iterations):
        response = client.chat.completions.create(
            model="gpt-4o-mini",
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )
        
        assistant_message = response.choices[0].message
        
        if not assistant_message.tool_calls:
            # Keine weiteren Tools benötigt, endgültige Antwort zurückgeben
            return assistant_message.content
        
        for tool_call in assistant_message.tool_calls:
            function_name = tool_call.function.name
            arguments = json.loads(tool_call.function.arguments)
            
            print(f"Aufruf: {function_name}({arguments})")
            
            if function_name == "web_search":
                result = web_search(arguments["query"])
            elif function_name == "calculate":
                result = calculate(arguments["expression"])
            else:
                result = "Unbekanntes Tool"
            
            messages.append(assistant_message)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": result
            })
    
    return "Maximale Iterationen erreicht. Bitte versuchen Sie eine einfachere Anfrage."

if __name__ == "__main__":
    print(run_agent_with_error_handling("Suche nach neuesten KI-Nachrichten"))
    print("---")
    print(run_agent_with_error_handling("Was ist 1234 * 5678?"))
    print("---")
    print(run_agent_with_error_handling("Suche nach OpenAI-Nachrichten und berechne 100/3"))

Führen Sie es aus:

python search_agent.py

Sie werden sehen, wie der Agent erfolgreich mehrere Tools nacheinander aufruft und Fehler wie ungültige Ausdrücke elegant behandelt.

Fortgeschrittene Überlegungen

Tool-Beschreibungen sind wichtig

Das Modell verlässt sich stark auf Tool-Beschreibungen, um zu entscheiden, wann ein Tool aufgerufen werden soll. Eine vage Beschreibung wie "Daten abrufen" verwirrt das Modell. Seien Sie explizit: "Aktuelles Wetter für eine bestimmte Stadt abrufen. Gibt Temperatur in Celsius und Bedingungen zurück."

Parameterschemata

Verwenden Sie klare, beschreibende Parameternamen und fügen Sie `required`-Felder hinzu. Das Modell versteht JSON Schema, nutzen Sie daher Funktionen wie `enum` für eingeschränkte Werte und `minimum`/`maximum` für numerische Bereiche.

Sicherheit und Validierung

Vertrauen Sie Tool-Call-Argumenten niemals blind. Validieren Sie immer die Eingaben, bevor Sie das Tool ausführen. Wenn ein Tool beispielsweise Shell-Befehle ausführt, bereinigen Sie die Eingabe, um Injection-Angriffe zu verhindern.

Kostenmanagement

Tool Calling erhöht die API-Kosten, da jeder Tool-Aufruf eine zusätzliche Roundtrip erfordert. Verwenden Sie günstigere Modelle (wie `gpt-4o-mini`) für einfache Entscheidungen und bündeln Sie mehrere Tool-Aufrufe, wenn möglich.

Fazit

Tool Calling ist der Motor, der moderne KI-Agenten antreibt. Indem wir LLMs erlauben, autonom zu entscheiden, wann und wie externe Funktionen aufgerufen werden, erschließen wir Fähigkeiten, die weit über die Textgenerierung hinausgehen: Echtzeit-Datenzugriff, Berechnung, Automatisierung und Integration mit bestehenden Systemen.

In diesem Artikel haben wir den gesamten Prozess durchlaufen: vom Verständnis des Entscheidungsmechanismus bis zum Bau funktionierender Python-Agenten, die Tools für Zeit, Wetter und Suche aufrufen. Die wichtigste Erkenntnis ist, dass das Modell *entscheidet*, welches Tool basierend auf Ihren Beschreibungen verwendet wird – Ihre Aufgabe ist es, die Tools klar zu definieren und die Ergebnisse sicher zu verarbeiten.

Wenn Sie Ihre eigenen Agenten bauen, denken Sie an diese Prinzipien:

• **Beschreiben Sie Tools präzise**, damit das Modell ihren Zweck versteht.
• **Validieren Sie alle Eingaben**, bevor Sie Tools ausführen.
• **Behandeln Sie Fehler elegant** – Tools können fehlschlagen.
• **Iterieren und testen Sie** – Tool Calling verbessert sich mit besseren Definitionen und Prompt Engineering.

Die Zukunft der KI-Agenten ist autonom, toolgestützt und zunehmend leistungsfähiger. Mit den hier bereitgestellten Schritten und Beispielen sind Sie nun gerüstet, um Agenten zu bauen, die nicht nur reden – sie handeln.