Tool-Calling

Was dieser Artikel über Tool-Calling behandelt

• Was Tool-Calling ist und warum es den Unterschied zwischen einem reinen Chatbot und einem echten Agenten ausmacht
• Wie der Ablauf funktioniert, vom Nutzer-Input bis zur fertigen Antwort
• Wie Du ein eigenes Tool in Python definierst und das Modell es aufrufen lässt
• Wie Du mehrere Tools gleichzeitig bereitstellst und das Modell wählen lässt
• Wie Du Tool-Calling mit lokalen Modellen über Ollama nutzt

Einleitung: Tool-Calling verständlich erklärt

Ein Sprachmodell allein kann nur Text erzeugen. Es kennt Wörter, Muster und Zusammenhänge aus seinem Training, aber es kann keine Datenbank abfragen, keine Datei lesen und keine E-Mail verschicken. Genau hier kommt Tool-Calling ins Spiel. Mit Tool-Calling gibst Du einem Modell die Möglichkeit, externe Funktionen aufzurufen und so über seinen eigenen Wissensstand hinauszugreifen.

Das ist der Kernunterschied zwischen einem einfachen Chatbot und einem KI-Agenten. Ein Chatbot beantwortet Fragen mit dem, was er gelernt hat. Ein Agent nutzt Tools, um aktuelle Daten zu beschaffen, Berechnungen durchzuführen oder Aktionen in der echten Welt auszulösen. Wenn Du verstehen willst, wie Agenten tatsächlich arbeiten, kommst Du an Tool-Calling nicht vorbei. Mehr dazu findest Du in Was ist ein KI-Agent? und Chatbot vs. KI-Agent.

Warum brauche ich Tool-Calling?

Stell Dir vor, Du fragst ein Sprachmodell: “Wie ist das Wetter gerade in Hamburg?” Ohne Tools muss das Modell raten oder auf sein Trainingswissen zurückgreifen. Das Wetter von heute war beim Training aber noch gar nicht bekannt. Die Antwort ist also entweder falsch oder vage.

Mit Tool-Calling sieht das anders aus. Du definierst eine Funktion, die eine Wetter-API abfragt. Das Modell erkennt, dass es diese Funktion braucht, und gibt Dir den Funktionsnamen plus den Parameter “Hamburg” zurück. Dein Code führt die Funktion aus, holt das echte Wetterergebnis und gibt es an das Modell zurück. Das Modell formuliert daraus eine natürliche Antwort wie “In Hamburg sind es aktuell 14 Grad und es regnet leicht.”

Ohne Tools ist ein Modell auf sein Training beschränkt. Mit Tools kann es auf aktuelle Daten, Dateien, Datenbanken und APIs zugreifen. Das ist der entscheidende Schritt von einem Textgenerator zu einem System, das Dinge tut.

Tool-Calling - In A Nutshell

Tool-Calling bedeutet: Das Modell erzeugt nicht direkt eine Antwort, sondern eine strukturierte Nachricht, die besagt, welche Funktion es aufgerufen haben möchte und mit welchen Parametern. Dein Programm führt die Funktion aus und schickt das Ergebnis zurück ans Modell. Das Modell nutzt dieses Ergebnis, um eine verständliche Antwort zu formulieren.

Das klassische Beispiel ist die Wetterabfrage:

1. Du definierst ein Tool get_weather mit dem Parameter location.
2. Der Nutzer fragt nach dem Wetter in Berlin.
3. Das Modell gibt zurück: Rufe get_weather auf mit location = "Berlin".
4. Dein Code führt die Funktion aus und erhält das Ergebnis, zum Beispiel “14 Grad, Regen”.
5. Du schickst dieses Ergebnis ans Modell zurück.
6. Das Modell formuliert die finale Antwort für den Nutzer.

Das Modell führt die Funktion nie selbst aus. Es sagt Dir nur, welche Funktion es braucht und mit welchen Parametern. Die Ausführung passiert immer in Deinem Code. Das ist wichtig zu verstehen, weil es bedeutet, dass Du die volle Kontrolle darüber hast, was tatsächlich passiert.

Für wen ist Tool-Calling gedacht?

Tool-Calling richtet sich an Entwicklerinnen und Entwickler, die mehr bauen wollen als einen simplen Chatbot. Wenn Du einen Agenten entwickeln willst, der auf echte Daten zugreift, Aktionen ausführt oder mit anderen Systemen kommuniziert, brauchst Du Tool-Calling.

Typische Szenarien sind:

• Du baust einen Agenten, der aktuelle Informationen aus dem Internet abruft.
• Du willst, dass ein Modell auf Deine lokale Dateiablage oder Datenbank zugreift.
• Du entwickelst einen Assistenten, der Termine erstellt oder E-Mails verschickt.
• Du nutzt ein Framework wie LangGraph oder CrewAI und willst verstehen, was unter der Haube passiert. Mehr dazu unter Frameworks.

Du brauchst keine jahrelange Erfahrung in KI-Entwicklung, aber Du solltest grundlegende Programmierkenntnisse mitbringen, idealerweise in Python. Die Beispiele in diesem Artikel sind so aufgebaut, dass Du ihnen Schritt für Schritt folgen kannst.

Wichtige Begriffe rund um Tool-Calling

Begriff	Bedeutung
Tool	Eine externe Funktion, die das Modell aufrufen kann, zum Beispiel eine Wetterabfrage
Schema	Die formale Beschreibung eines Tools mit Name, Parametern und Zweck
Function Calling	Ein anderer Begriff für Tool-Calling, häufig bei OpenAI verwendet
Parameter	Die Argumente, die das Modell an das Tool übergibt, zum Beispiel ein Ortsname
Tool-Aufruf	Die Ausgabe des Modells, die eine Funktion anstelle einer direkten Antwort anfordert
JSON	Das Format, in dem Tool-Aufrufe und Parameter strukturiert werden
API	Eine Schnittstelle, über die Dein Tool Daten von externen Diensten abruft
MCP	Model Context Protocol, ein Standard, um Tools einheitlich an Modelle anzubinden

Wie funktioniert Tool-Calling Schritt für Schritt?

Der Ablauf von Tool-Calling folgt einem klaren Muster. Jeder Schritt ist wichtig, und wenn Du das Prinzip einmal verstanden hast, kannst Du es auf jede Art von Tool anwenden.

Schritt 1: Der Nutzer stellt eine Frage.

Der Nutzer schreibt eine Nachricht, zum Beispiel “Wie ist das Wetter in München?” Diese Nachricht landet in der Nachrichtenliste, die Du an das Modell übergibst.

Schritt 2: Das Modell entscheidet, ob ein Tool nötig ist.

Das Modell erhält nicht nur die Nachricht, sondern auch die Liste der verfügbaren Tools inklusive ihrer Schemata. Es analysiert die Frage und prüft, ob ein Tool helfen kann. Wenn ja, entscheidet es sich für einen Tool-Aufruf. Wenn nein, antwortet es direkt.

Schritt 3: Das Modell gibt einen Tool-Aufruf zurück.

Der Tool-Aufruf ist eine strukturierte Ausgabe, meist im JSON-Format. Sie enthält den Namen der Funktion und die Parameterwerte. Das Modell erzeugt keinen normalen Antworttext, sondern diese strukturierte Anweisung.

Schritt 4: Dein Code führt die Funktion aus.

Jetzt kommst Du ins Spiel. Dein Programm nimmt den Tool-Aufruf, liest den Funktionsnamen und die Parameter und führt die tatsächliche Funktion aus. Das kann ein API-Call, eine Datenbankabfrage oder eine Berechnung sein.

Schritt 5: Das Ergebnis geht zurück ans Modell.

Du nimmst das Ergebnis der Funktion und fügst es als neue Nachricht zur Nachrichtenliste hinzu, typischerweise mit der Rolle “tool”. Dann rufst Du das Modell erneut auf.

Schritt 6: Das Modell formuliert die Antwort.

Das Modell sieht das Ergebnis und formuliert eine natürliche Antwort für den Nutzer. Aus “14 Grad, Regen” wird “In München sind es aktuell 14 Grad und es regnet.”

Dieser Zyklus kann sich wiederholen, wenn das Modell entscheidet, dass es weitere Tools braucht. Bei komplexen Aufgaben kann ein Agent mehrere Tool-Aufrufe nacheinander durchführen.

Beispiel: Python mit einem einfachen Tool

Schauen wir uns den gesamten Ablauf in Python an. Wir nutzen die OpenAI-kompatible API, weil sie weit verbreitet ist und die meisten Frameworks und lokalen Lösungen wie Ollama sie unterstützen.

import json
from openai import OpenAI

client = OpenAI()

# Schritt 1: Die eigentliche Funktion definieren
def get_weather(location: str) -> str:
    # In einer echten Anwendung würdest Du hier eine API aufrufen.
    # Für dieses Beispiel geben wir einen festen Wert zurück.
    return f"Das Wetter in {location} ist sonnig und 22 Grad."

# Schritt 2: Das Tool-Schema definieren
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Gibt das aktuelle Wetter für einen Ort zurück.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Name des Ortes, zum Beispiel 'Berlin'"
                    }
                },
                "required": ["location"]
            }
        }
    }
]

# Schritt 3: Die Nachricht des Nutzers vorbereiten
messages = [
    {"role": "user", "content": "Wie ist das Wetter in München?"}
]

# Schritt 4: Das Modell aufrufen, mit Tools
response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

# Schritt 5: Prüfen, ob das Modell ein Tool aufrufen will
tool_calls = response.choices[0].message.tool_calls

if tool_calls:
    # Die Antwort des Modells zur Nachrichtenliste hinzufügen
    messages.append(response.choices[0].message)

    for tool_call in tool_calls:
        # Funktionsnamen und Parameter extrahieren
        function_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)

        # Die Funktion ausführen
        if function_name == "get_weather":
            result = get_weather(**arguments)
        else:
            result = "Unbekannte Funktion."

        # Das Ergebnis zur Nachrichtenliste hinzufügen
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })

    # Schritt 6: Das Modell erneut aufrufen, damit es die Antwort formuliert
    final_response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        tools=tools
    )
    print(final_response.choices[0].message.content)
else:
    # Wenn kein Tool aufgerufen wird, direkt antworten
    print(response.choices[0].message.content)

Gehen wir das Schritt für Schritt durch.

Zuerst definieren wir die Funktion get_weather. Sie nimmt einen Ort als Parameter und gibt einen String zurück. In einer echten Anwendung würdest Du hier eine Wetter-API wie OpenWeatherMap aufrufen. Für dieses Beispiel geben wir einfach einen festen Text zurück.

Dann definieren wir das Tool-Schema. Das Schema sagt dem Modell, wie die Funktion heißt, was sie tut und welche Parameter sie erwartet. Die description ist besonders wichtig, weil das Modell anhand dieser Beschreibung entscheidet, ob das Tool für eine Frage relevant ist. Je präziser die Beschreibung, desto besser die Entscheidung.

Die Nachrichtenliste messages enthält die Frage des Nutzers. Wir übergeben sie zusammen mit den Tools an das Modell. Der Parameter tool_choice mit dem Wert auto bedeutet, dass das Modell selbst entscheiden darf, ob es ein Tool aufruft oder direkt antwortet.

Nach dem Aufruf prüfen wir, ob tool_calls in der Antwort enthalten ist. Wenn ja, hängen wir die Antwort des Modells an die Nachrichtenliste an und durchlaufen jeden Tool-Aufruf. Wir extrahieren den Funktionsnamen und die Parameter, führen die Funktion aus und fügen das Ergebnis mit der Rolle tool zur Nachrichtenliste hinzu.

Am Ende rufen wir das Modell erneut auf, jetzt mit dem Ergebnis in der Nachrichtenliste. Das Modell formuliert die natürliche Antwort und gibt sie zurück.

Beispiel: Mehrere Tools

In der Praxis hast Du selten nur ein Tool. Ein Agent könnte Wetter abfragen, die Uhrzeit ermitteln und Berechnungen durchführen. Schauen wir uns an, wie Du mehrere Tools definierst und das Modell wählen lässt.

import json
from openai import OpenAI

client = OpenAI()

def get_weather(location: str) -> str:
    return f"Das Wetter in {location} ist bewölkt und 18 Grad."

def get_time(timezone: str) -> str:
    return f"Die aktuelle Zeit in {timezone} ist 14:30 Uhr."

def calculate(expression: str) -> str:
    try:
        result = eval(expression)
        return f"Ergebnis: {result}"
    except Exception:
        return "Ungültiger Ausdruck."

# Ein Dictionary, das Funktionsnamen auf Python-Funktionen abbildet
available_functions = {
    "get_weather": get_weather,
    "get_time": get_time,
    "calculate": calculate
}

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Gibt das aktuelle Wetter für einen Ort zurück.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "Name des Ortes"}
                },
                "required": ["location"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "get_time",
            "description": "Gibt die aktuelle Uhrzeit für eine Zeitzone zurück.",
            "parameters": {
                "type": "object",
                "properties": {
                    "timezone": {"type": "string", "description": "Zeitzone, zum Beispiel 'Europe/Berlin'"}
                },
                "required": ["timezone"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Führt eine mathematische Berechnung durch.",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string", "description": "Mathematischer Ausdruck, zum Beispiel '2 + 3 * 4'"}
                },
                "required": ["expression"]
            }
        }
    }
]

messages = [
    {"role": "user", "content": "Wie ist das Wetter in Köln und wie spät ist es in Europe/Berlin?"}
]

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

tool_calls = response.choices[0].message.tool_calls

if tool_calls:
    messages.append(response.choices[0].message)

    for tool_call in tool_calls:
        function_name = tool_call.function.name
        arguments = json.loads(tool_call.function.arguments)

        # Funktion aus dem Dictionary holen und ausführen
        function = available_functions.get(function_name)
        if function:
            result = function(**arguments)
        else:
            result = "Unbekannte Funktion."

        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })

    final_response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        tools=tools
    )
    print(final_response.choices[0].message.content)
else:
    print(response.choices[0].message.content)

Hier definieren wir drei Funktionen: get_weather, get_time und calculate. Jede bekommt ihr eigenes Schema in der tools-Liste. Das Dictionary available_functions ordnet die Funktionsnamen den tatsächlichen Python-Funktionen zu. Das macht den Code sauberer, weil wir nicht für jede Funktion eine eigene if-Abfrage brauchen.

Die Nutzerfrage erwähnt zwei Dinge, das Wetter und die Uhrzeit. Das Modell kann entscheiden, beide Tools in einem einzigen Aufruf anzufordern. Die Schleife über tool_calls führt dann beide Funktionen aus und fügt beide Ergebnisse zur Nachrichtenliste hinzu. Das Modell formuliert am Ende eine Antwort, die beide Informationen enthält.

Wichtig: Die description jedes Tools muss klar formuliert sein. Wenn zwei Tools ähnliche Beschreibungen haben, kann das Modell sich für das falsche entscheiden. Nimm Dir Zeit für gute Beschreibungen.

Tool-Calling mit Ollama

Du brauchst keine Cloud-API, um Tool-Calling zu nutzen. Mit Ollama kannst Du Modelle lokal auf Deinem eigenen Rechner ausführen. Das ist besonders relevant, wenn Du sensible Daten verarbeitest oder keine Abhängigkeit von externen Diensten haben willst. Mehr zur Motivation findest Du unter Was ist lokale KI?.

Ollama unterstützt Tool-Calling mit bestimmten Modellen, zum Beispiel llama3.1 oder qwen2.5. Die API ist OpenAI-kompatibel, was bedeutet, dass Du fast denselben Code verwenden kannst.

import json
import requests

# Ollama läuft standardmäßig auf localhost:11434
OLLAMA_URL = "http://localhost:11434/api/chat"

def get_weather(location: str) -> str:
    return f"Das Wetter in {location} ist sonnig und 22 Grad."

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Gibt das aktuelle Wetter für einen Ort zurück.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "Name des Ortes"}
                },
                "required": ["location"]
            }
        }
    }
]

messages = [
    {"role": "user", "content": "Wie ist das Wetter in Berlin?"}
]

# Ersten Aufruf an Ollama senden
response = requests.post(OLLAMA_URL, json={
    "model": "llama3.1",
    "messages": messages,
    "tools": tools,
    "stream": False
})

data = response.json()
message = data.get("message", {})

# Prüfen, ob das Modell ein Tool aufrufen will
if "tool_calls" in message and message["tool_calls"]:
    messages.append(message)

    for tool_call in message["tool_calls"]:
        function = tool_call["function"]
        function_name = function["name"]
        arguments = function["arguments"]

        if function_name == "get_weather":
            result = get_weather(**arguments)
        else:
            result = "Unbekannte Funktion."

        messages.append({
            "role": "tool",
            "content": result
        })

    # Zweiten Aufruf mit dem Ergebnis
    final_response = requests.post(OLLAMA_URL, json={
        "model": "llama3.1",
        "messages": messages,
        "tools": tools,
        "stream": False
    })

    final_data = final_response.json()
    print(final_data["message"]["content"])
else:
    print(message.get("content", ""))

Der Aufbau ist fast identisch mit dem OpenAI-Beispiel. Der Hauptunterschied ist, dass wir requests nutzen, um die Ollama-API direkt aufzurufen, anstatt das OpenAI-Python-Paket. Die Endpunkt-URL zeigt auf den lokalen Ollama-Server. Die Struktur der Tools und der Nachrichten ist dieselbe.

Beachte, dass nicht alle lokalen Modelle Tool-Calling gleich gut beherrschen. Größere Modelle wie llama3.1:8b oder qwen2.5:14b sind deutlich zuverlässiger als sehr kleine Modelle. Wenn das Modell den Tool-Aufruf nicht richtig formatiert, kann es helfen, ein größeres Modell zu wählen oder die Tool-Beschreibungen präziser zu formulieren.

Typische Tools für KI-Agenten mit Tool-Calling

Wenn Du anfängst, Agenten zu bauen, wirst Du feststellen, dass bestimmte Tool-Typen immer wieder auftauchen. Hier ist eine Übersicht der häufigsten Tools mit Beispielen.

Websuche: Der Agent sucht im Internet nach aktuellen Informationen. Beispiel: Eine Funktion web_search(query), die eine Such-API aufruft und die Top-Ergebnisse zurückgibt. Nützlich für Fragen zu aktuellen Ereignissen oder Fakten, die nicht im Trainingswissen des Modells enthalten sind.

Dateizugriff: Der Agent liest oder schreibt Dateien auf dem lokalen System. Beispiel: read_file(path) liest den Inhalt einer Datei, write_file(path, content) schreibt ihn. Nützlich, wenn der Agent mit Dokumenten arbeiten soll, die auf Deinem Rechner liegen.

Datenbankabfragen: Der Agent führt SQL-Queries aus. Beispiel: query_database(sql) sendet eine Anfrage an eine Datenbank und gibt die Ergebnisse zurück. Nützlich für Agenten, die auf strukturierte Daten zugreifen müssen.

E-Mail-Versand: Der Agent verschickt E-Mails. Beispiel: send_email(to, subject, body) nutzt einen SMTP-Server. Nützlich für Assistenten, die Benachrichtigungen oder Berichte verschicken sollen.

Rechner: Der Agent führt mathematische Berechnungen durch. Beispiel: calculate(expression) wertet einen mathematischen Ausdruck aus. Nützlich, weil Sprachmodelle bei komplexen Rechnungen oft unzuverlässig sind.

Code-Ausführung: Der Agent führt Programmcode aus. Beispiel: run_python(code) führt ein Python-Skript aus und gibt die Ausgabe zurück. Nützlich für Agenten, die Daten analysieren oder Skripte generieren sollen.

Jedes dieser Tools birgt Risiken. E-Mail-Versand und Code-Ausführung sind besonders sensibel, weil sie reale Auswirkungen haben. Überlege immer, welche Aktionen ein Agent tatsächlich durchführen darf und welche Freigaben erforderlich sind.

Typische Stolpersteine beim Tool-Calling

Tool-Calling klingt im ersten Moment einfach, aber in der Praxis gibt es einige Stolpersteine, auf die Du stoßen wirst. Hier sind die häufigsten Probleme.

Das Modell ruft das falsche Tool auf. Wenn die Beschreibungen der Tools unklar sind oder sich mehrere Tools ähneln, kann das Modell sich für das falsche entscheiden. Lösung: Schreibe präzise, eindeutige Beschreibungen und vermeide überlappende Zuständigkeiten.

Die Parameter sind falsch oder unvollständig. Das Modell kann Parameter erfinden, die nicht im Schema definiert sind, oder erforderliche Parameter weglassen. Lösung: Definiere required-Parameter klar und validiere die Parameter in Deinem Code, bevor Du die Funktion ausführst.

Das Modell halluziniert Tools. Manchmal erfindet das Modell Funktionen, die gar nicht existieren. Das passiert häufig bei kleinen Modellen. Lösung: Prüfe immer, ob der Funktionsname in Deiner Liste der verfügbaren Funktionen existiert, bevor Du versuchst, ihn aufzurufen.

Kleine Modelle haben Schwierigkeiten mit Tool-Calling. Nicht jedes Modell kann Tool-Calling zuverlässig. Sehr kleine Modelle produzieren oft fehlerhaftes JSON oder verstehen die Tool-Beschreibungen nicht richtig. Lösung: Nutze Modelle, die explizit für Tool-Calling trainiert wurden, und teste mit verschiedenen Modellgrößen.

Sicherheitsrisiken durch unkontrollierte Ausführung. Wenn ein Tool sensible Aktionen ausführt, zum Beispiel Dateien löscht oder E-Mails verschickt, kann ein falscher Tool-Aufruf echten Schaden anrichten. Lösung: Begrenze die verfügbaren Tools, validiere alle Parameter und fordere für kritische Aktionen eine menschliche Freigabe.

Schlechtes Error-Handling verdeckt Probleme. Wenn ein Tool fehlschlägt und Du den Fehler nicht richtig an das Modell zurückgibst, kann das Modell nicht darauf reagieren. Lösung: Fange Fehler ab und gib eine klare Fehlermeldung ans Modell zurück, damit es entscheiden kann, was als Nächstes zu tun ist.

Hardware, Kosten und Sicherheit bei Tool-Calling

Hardware: Tool-Calling selbst benötigt kaum Ressourcen. Der rechenintensive Teil ist die Modell-Inferenz. Wenn Du ein lokales Modell über Ollama nutzt, brauchst Du ausreichend RAM und idealerweise eine GPU, je nach Modellgröße. Ein 8B-Modell läuft auf einem modernen Laptop mit 16 GB RAM, während größere Modelle wie 14B oder 32B deutlich mehr Arbeitsspeicher erfordern.

Kosten: Bei Cloud-APIs wie OpenAI zahlst Du pro Token. Tool-Calling bedeutet zusätzliche API-Aufrufe, weil Du das Modell nach jedem Tool-Ergebnis erneut anfragst. Bei mehreren Tools pro Frage können die Kosten steigen. Bei lokalen Modellen über Ollama fallen keine API-Kosten an, aber Du trägst die Hardware-Kosten selbst.

Sicherheit: Gib nur Tools frei, die der Agent wirklich braucht. Ein Tool, das Dateien löscht oder Befehle auf Systemebene ausführt, sollte nur mit zusätzlicher Freigabe genutzt werden. Validiere alle Parameter, die das Modell liefert, bevor Du sie verwendest. Nutze Sandboxing, wo immer möglich, besonders bei Code-Ausführung. Und denke daran, dass das Modell nie selbst Code ausführt, sondern nur vorschlägt, was ausgeführt werden soll. Die Kontrolle liegt bei Dir.

Weiterführende Links und Infos zu Tool-Calling

• Was ist ein KI-Agent? - Grundlagen zu Agenten und wie sie sich von Chatbots unterscheiden
• Chatbot vs. KI-Agent - Der Unterschied zwischen einfachen Chatbots und echten Agenten
• Frameworks - Übersicht über Frameworks wie LangGraph und CrewAI, die Tool-Calling abstrahieren
• Ollama - Lokale Modelle ausführen und Tool-Calling ohne Cloud nutzen
• Was ist lokale KI? - Warum lokale Modelle sinnvoll sind und was sie können

FAQ - Typische Fragen zu Tool-Calling

Unterstützen alle Modelle Tool-Calling?

Nein. Modelle müssen explizit für Funktionsaufrufe trainiert sein. Viele moderne Modelle wie Llama 3.1, Qwen 2.5 und Mistral beherrschen es, aber sehr kleine oder ältere Modelle können es oft nicht zuverlässig. Prüfe die Dokumentation des jeweiligen Modells.

Kann ich mehrere Tools gleichzeitig definieren?

Ja. Du übergibst eine Liste von Tools. Das Modell wählt das passende aus oder fordert mehrere Aufrufe in einer einzigen Antwort an. Du solltest aber darauf achten, dass die Tool-Beschreibungen eindeutig sind, damit das Modell sich nicht irrt.

Muss das Tool synchron antworten?

Nicht unbedingt. Du kannst asynchrone Tools nutzen, solange das Ergebnis zurück an das Modell gegeben wird, bevor die nächste Antwort generiert wird. In Python kannst Du async-Funktionen nutzen, musst dann aber sicherstellen, dass Du auf das Ergebnis wartest.

Wie sichere ich Tools ab?

Begrenze die verfügbaren Tools auf das Notwendige, validiere alle Parameter, setze Berechtigungen und nutze Sandboxing. Kritische Aktionen wie E-Mail-Versand oder Datei-Löschung sollten eine menschliche Freigabe erfordern. Gib nie unbegrenzten Systemzugriff.

Was passiert, wenn das Modell ein Tool halluziniert?

Das bedeutet, das Modell erfindet einen Funktionsnamen, der nicht in Deiner Tool-Liste steht. Prüfe in Deinem Code immer, ob der Funktionsname existiert, bevor Du versuchst, ihn aufzurufen. Wenn nicht, gib eine Fehlermeldung ans Modell zurück, damit es es erneut versuchen kann.

Kann ein Modell mehrere Tools nacheinander aufrufen?

Ja. Bei komplexen Aufgaben kann das Modell nach dem ersten Tool-Ergebnis entscheiden, dass es ein weiteres Tool braucht. Du implementierst dafür eine Schleife, die so lange läuft, bis das Modell keine Tool-Aufrufe mehr anfordert.

Brauche ich ein Framework für Tool-Calling?

Nein. Du kannst Tool-Calling direkt mit der API des Modell-Anbieters umsetzen, wie in den Beispielen in diesem Artikel. Frameworks wie LangGraph oder CrewAI nehmen Dir aber repetitive Arbeit ab und bieten zusätzliche Features wie Error-Handling und Schleifen-Logik.

Funktioniert Tool-Calling mit lokalen Modellen?

Ja, mit Einschränkungen. Ollama unterstützt Tool-Calling für bestimmte Modelle wie Llama 3.1 und Qwen 2.5. Die Zuverlässigkeit hängt von der Modellgröße ab. Sehr kleine Modelle produzieren oft fehlerhaftes JSON oder rufen die falschen Tools auf.

Wie viele Tools kann ich gleichzeitig definieren?

Theoretisch beliebig viele, aber in der Praxis leidet die Genauigkeit, wenn Du zu viele Tools anbietest. Das Modell muss alle Beschreibungen verarbeiten und die richtige Wahl treffen. Starte mit wenigen Tools und erweitere schrittweise.

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

Die Begriffe werden meist synonym verwendet. OpenAI nutzt traditionell “Function Calling”, während neuere Dokumentation und andere Anbieter eher “Tool-Calling” sagen. Gemeint ist immer dasselbe: Das Modell gibt an, welche Funktion es aufrufen will, und Dein Code führt sie aus.

Kann das Modell Parameter erfinden, die ich nicht definiert habe?

Ja, das passiert besonders bei kleineren Modellen. Dein Code sollte nur die Parameter verwenden, die im Schema definiert sind, und alle zusätzlichen Parameter ignorieren. Validiere die Parameter, bevor Du sie an die Funktion übergibst.

Quellen und weiterführende Literatur

• OpenAI Function Calling Dokumentation
• Ollama Tool-Support Dokumentation
• LangGraph Tools Dokumentation
• Model Context Protocol (MCP) Spezifikation