Was ist Function Calling und Tool Use bei LLMs?

Vor Function Calling: Wie LLMs an Systemgrenzen scheiterten

Frühe Large Language Models wie GPT-3.5 waren reine Textgeneratoren. Sie konnten beeindruckend formulieren, aber nicht handeln. Typische Schwächen ohne Tool Use:

• Keine Echtzeitdaten: Fragen zu aktuellen Börsenkursen, Wetter oder Nachrichten endeten in veralteten oder erfundenen Informationen (Halluzinationen).
• Keine Berechnungen: Mathematisch anspruchsvolle Aufgaben wurden oft falsch berechnet, da das Modell Zahlen statistisch behandelt, nicht algebraisch.
• Keine persistenten Aktionen: Das Modell konnte keine E-Mails versenden, keine Kalendereinträge erstellen, keine Datenbankabfragen starten.
• Keine Systemintegration: APIs, CRM-Systeme, ERP-Lösungen waren für das LLM vollständig unsichtbar.

Function Calling überbrückt exakt diese Lücken. Es gibt dem LLM „Hände“, also die Fähigkeit, die Außenwelt zu erreichen und zu verändern.

Function Calling Schritt für Schritt

Der Ablauf lässt sich in sieben klar definierte Schritte unterteilen. Am Beispiel einer Aktienabfrage:

Schritt 1: Tool-Registrierung

Die Anwendung registriert beim LLM verfügbare Funktionen als JSON-Schema-Definition:

{
  "name": "get_stock_price",
  "description": "Ruft den aktuellen Aktienkurs eines Unternehmens ab.",
  "parameters": {
    "type": "object",
    "properties": {
      "symbol": {
        "type": "string",
        "description": "Das Börsenkürzel, z.B. SAP, AAPL, BMW"
      }
    },
    "required": ["symbol"]
  }
}

Schritt 2: Nutzeranfrage

Der Nutzer stellt eine natürlichsprachliche Frage: „Was ist der aktuelle Aktienkurs von SAP?“

Schritt 3: LLM-Entscheidung

Das LLM analysiert die Anfrage, erkennt, dass das registrierte Tool get_stock_price relevant ist, und entscheidet sich für dessen Aufruf, anstatt eine (womöglich halluzinierte) Freitextantwort zu generieren.

Schritt 4: Structured Output

Das LLM gibt kein Freitextdokument zurück, sondern ein strukturiertes JSON-Objekt:

{
  "tool_use": {
    "name": "get_stock_price",
    "parameters": {
      "symbol": "SAP"
    }
  }
}

Schritt 5: Tool-Ausführung durch die Anwendung

Die umgebende Applikation empfängt das JSON, führt tatsächlich die Funktion get_stock_price("SAP") aus, zum Beispiel durch einen Aufruf an die Yahoo Finance API, und erhält den aktuellen Kurs.

Schritt 6: Ergebnis an LLM zurückgeben

Das Ergebnis („SAP: 187,40 EUR“) wird als neue Nachricht in den Gesprächskontext eingespeist.

Schritt 7: LLM formuliert finale Antwort

Nun erst formuliert das LLM eine vollständige, natürlichsprachliche Antwort: „Der aktuelle Aktienkurs von SAP beträgt 187,40 EUR (Stand: gerade eben).“

Paralleles Function Calling

Moderne Modelle (GPT-4o, Claude Sonnet 4.6, Gemini 2.5 Pro) unterstützen paralleles Tool Use: In einem einzigen Schritt können mehrere Funktionen gleichzeitig aufgerufen werden. Beispiel: „Plane ein Meeting mit Max für morgen, schick ihm eine Einladung und prüfe das Wetter in München.“

Das LLM gibt in diesem Fall ein Array von Tool-Aufrufen zurück:

• check_calendar(user="max", date="tomorrow")
• send_email(to="max@firma.de", subject="Meeting-Einladung", ...)
• get_weather(city="München", date="tomorrow")

Alle drei Funktionen werden parallel ausgeführt, die Ergebnisse werden gebündelt zurückgegeben und das LLM formuliert eine konsolidierte Antwort. Das reduziert Latenz erheblich.

Function Calling vs. klassische API-Aufrufe vs. RPA

JSON Schema für Tool-Definitionen: Aufbau und Best Practices

Das JSON Schema einer Tool-Definition besteht aus drei Pflichtfeldern:

• name: Eindeutiger, maschinenlesbarer Bezeichner (snake_case empfohlen, z.B. send_slack_message)
• description: Natürlichsprachige Beschreibung für das LLM. Hier entscheidet sich, wann das Modell das Tool wählt. Präzision ist entscheidend.
• parameters: JSON Schema mit Typen, Beschreibungen und Required-Feldern für jeden Parameter

Best Practices:

• Descriptions so formulieren, als würde man einem neuen Mitarbeiter erklären, wann er diese Funktion aufrufen soll
• Parameter-Descriptions mit Beispielen anreichern („z.B. ‚AAPL‘ für Apple Inc.“)
• Enum-Werte für begrenzte Parametermöglichkeiten nutzen (verhindert Halluzinationen)
• Nicht zu viele Tools auf einmal registrieren; Qualität vor Quantität (Richtwert: unter 20 Tools)

Tool-Kategorien im Überblick

Modell-Support: Welche LLMs unterstützen Function Calling?

Tool Use in Produktionssystemen

Der Schritt von der Demo zur Produktion erfordert robuste Fehlerbehandlung:

• Timeouts: Jede Tool-Ausführung sollte ein definiertes Timeout haben (Empfehlung: 5 bis 30 Sekunden je nach API). Das LLM muss mit Timeout-Fehlern als Ergebnis umgehen können.
• Fallbacks: Wenn Tool A nicht verfügbar ist, sollte die Architektur einen Plan B kennen (alternatives Tool, Fehlermeldung an Nutzer, Warteschleife).
• Retry-Logik: Transiente Fehler (HTTP 429, 503) sollten mit exponentiellem Backoff wiederholt werden, aber nicht endlos.
• Logging & Tracing: Jeder Tool-Aufruf sollte mit Timestamp, Input, Output und Latenz protokolliert werden (für Debugging und Kostenanalyse).
• Idempotenz: Schreibende Operationen (E-Mail senden, Zahlung auslösen) müssen idempotent gestaltet sein, um Doppelausführungen zu verhindern.

Sicherheitsaspekte bei Function Calling

Function Calling erweitert die Angriffsfläche von LLM-Anwendungen erheblich. Wichtige Schutzmaßnahmen:

• Tool-Isolation: Tools sollten nur auf die Ressourcen zugreifen dürfen, die sie wirklich benötigen (Principle of Least Privilege). Ein Kalender-Tool braucht keinen Datenbankzugriff.
• Berechtigungsmanagement: Nutzerkontext an Tools übergeben. Eine KI darf nicht im Namen eines Nutzers Aktionen durchführen, die dieser nicht genehmigt hat.
• Prompt Injection verhindern: Externe Daten (Webseiteninhalt, E-Mail-Inhalt), die in den Kontext eingespeist werden, können bösartige Instruktionen enthalten. Sanitization und Isolation sind Pflicht.
• Confirmation Gates: Für destruktive Aktionen (löschen, senden, zahlen) immer eine explizite Nutzerbestätigung einbauen, auch wenn das LLM sicher ist.

Function Calling als Basis für KI-Agenten

Function Calling ist der technische Unterbau für KI-Agenten und Multi-Agent-Systeme. Ein Agent ist ein LLM, das in einer Schleife operiert: Beobachten → Denken → Handeln (Tool Use) → Beobachten. Bekannte Frameworks:

• OpenAI Assistants API: Managed Agent-Infrastruktur mit Code Interpreter, File Search und Custom Tools
• LangChain Tools: Open-Source-Framework mit Hunderten von vordefinierten Tool-Integrationen
• LlamaIndex Query Engines: Spezialisiert auf RAG + Tool Use über strukturierte Daten
• AutoGen (Microsoft): Multi-Agent-Conversations mit spezialisierten Agenten-Rollen
• Claude Tool Use: Native Anthropic-Implementierung mit besonders präziser Tool-Auswahl

Häufige Fragen zu Function Calling

Was ist der Unterschied zwischen Function Calling und normalen API-Aufrufen?

Bei normalen API-Aufrufen entscheidet ein Programmierer im Voraus, welche API wann aufgerufen wird. Die Logik ist hartkodiert. Beim Function Calling entscheidet das LLM dynamisch zur Laufzeit, welches Tool für die aktuelle Nutzeranfrage am geeignetsten ist. Das macht die Anwendung flexibel und natürlichsprachig steuerbar.

Wie verhindere ich Missbrauch durch Function Calling?

Durch strikte Berechtigungsmodelle (jedes Tool nur mit minimalem Scope), Confirmation Gates für destruktive Aktionen, Prompt-Injection-Schutz bei externen Daten und vollständiges Audit-Logging aller Tool-Aufrufe. Sensitive Operationen wie Zahlungen oder Datenlöschungen sollten immer eine menschliche Bestätigung erfordern.

Kann ein LLM unbegrenzt viele Tools nutzen?

Theoretisch ja, praktisch nein. Die meisten Modelle haben ein Kontextfenster-Limit, und zu viele Tool-Definitionen verschlechtern die Entscheidungsqualität des Modells. Best Practice: Maximal 15 bis 20 hochrelevante Tools pro Session. Bei größeren Tool-Bibliotheken dynamisch nur die kontextuell relevanten Tools einblenden (Tool Routing).

Was kostet Function Calling?

Function Calling selbst kostet keinen Aufpreis pro Aufruf; es wird über den normalen Token-Verbrauch abgerechnet. Tool-Definitionen und Tool-Ergebnisse verbrauchen Input-Token. Bei OpenAI GPT-4o liegen die Kosten bei ca. 2,50 USD pro 1 Million Input-Token. Wer viele komplexe Tool-Definitionen und große Ergebnisse hat, sollte die Token-Kosten kalkulieren.

Weiterführende Quellen

• OpenAI: Function Calling Dokumentation
• Anthropic: Tool Use mit Claude
• Google: Function Calling in der Gemini API
• Toolformer: Language Models Can Teach Themselves to Use Tools (Schick et al., 2023)
• Wikipedia: Application Programming Interface

Verwandte Artikel

• Was ist ein Large Language Model (LLM)? Die technische Basis, auf der Function Calling aufsetzt: Architektur, Training und Einsatzmöglichkeiten moderner Sprachmodelle.
• Was sind KI-Agenten? Autonome Systeme, die Function Calling als Kernmechanismus nutzen, um in Schleifen zu denken und zu handeln.
• Was sind Multi-Agent-Systeme? Wie mehrere Agenten mit Tool Use koordiniert zusammenarbeiten, um komplexe Aufgaben zu lösen.
• Was ist Prompt Engineering? Wie präzise Anweisungen und Kontext die Qualität von Tool-Entscheidungen bei LLMs verbessern.
• Was ist Retrieval-Augmented Generation (RAG)? Das Zusammenspiel von Vektordatenbank-Tool und LLM für faktenbasierte, aktuelle Antworten.
• Was ist KI-gestützte Softwareentwicklung? Code-Interpreter und Browser-Tools als Function Calling in modernen Entwicklungsumgebungen.

Mehr Zeit für dein Business?
Mit Prozessautomation!

Lass uns gemeinsam schauen, wie wir euch unterstützen können.
Unverbindlich und mit konkreten Handlungsideen!