OpenAI Function Calling: Beispiele für den Einstieg

Name

Viktor Zinchenko

Updated on 14.11.2025

In der sich rasant entwickelnden Welt der künstlichen Intelligenz (AI) ist OpenAIs Function Calling (heute über tools verfügbar) zu einem der wichtigsten Bausteine für echte Anwendungen geworden. Es ermöglicht dir, leistungsstarke Sprachmodelle wie gpt-4.1 und gpt-4.1-mini mit deinen eigenen APIs, Datenbanken und deiner Business-Logik zu verbinden.

Anstatt das Modell zu bitten, „etwas JSON zu schreiben“ und zu hoffen, dass es deinem Format folgt, beschreibst du Funktionen in JSON Schema, und das Modell gibt einen strukturierten Funktionsaufruf zurück, den du in deinem Code sicher ausführen kannst.

In dieser Anleitung lernst du:

• Was OpenAI Function Calling ist und wie es heute funktioniert
• Wie du Tools/Funktionen mit JSON Schema definierst
• Praktische Beispiele: Meetings planen, Aktienkurse abrufen, Reisen buchen
• Wie du moderne Features wie Structured Outputs nutzt, um Function Calling verlässlicher zu machen
• Best Practices, typische Stolperfallen und FAQs

Was ist OpenAI Function Calling (Tools)?

Function Calling ermöglicht es einem Modell, statt einfachem Text mit maschinenlesbaren Funktionsaufrufen zu antworten. In der modernen API werden diese als Tools repräsentiert:

• Du definierst Tools mit:
  • type: "function"
  • function.name, function.description
  • function.parameters (ein JSON Schema, das die Argumente beschreibt)
• Du sendest diese Tools zusammen mit deinem Prompt.
• Das Modell entscheidet, ob es ein Tool aufrufen soll, und gibt einen Tool Call mit Funktionsnamen und JSON-Argumenten zurück.
• Deine Anwendung:
  1. Parst den Tool Call,
  2. Führt die entsprechende Funktion in deinem Backend aus,
  3. Schickt optional das Ergebnis zurück an das Modell, damit dieses eine finale, benutzerfreundliche Antwort generiert.

Unter der Haube wird Function Calling unterstützt in:

• Der Responses API (POST /v1/responses) – der empfohlenen Variante für neue Anwendungen.
• Der klassischen Chat Completions API (POST /v1/chat/completions) – weiterhin weit verbreitet und unterstützt.

Historisch wurde Function Calling über die Parameter functions und function_call genutzt. Diese sind jetzt zugunsten von tools und tool_choice deprecated, daher sollte neuer Code immer den neuen Stil verwenden.

Einfaches Beispiel: Ein Meeting planen (Chat Completions API)

Wir starten mit einem einfachen Beispiel über die Chat Completions API. Wir bitten das Modell, ein Meeting zu planen, und lassen es strukturierte Argumente für eine Funktion schedule_meeting zurückgeben.

JSON-Request (konzeptionell)

{
    "model": "gpt-4.1-mini",
    "messages": [
        {
            "role": "user",
            "content": "Schedule a meeting with John Doe next Tuesday at 3 PM."
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "schedule_meeting",
                "description": "Schedule a meeting in the calendar.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "attendee": {
                            "type": "string",
                            "description": "Name of the attendee for the meeting."
                        },
                        "date": {
                            "type": "string",
                            "description": "Date of the meeting in ISO 8601 format."
                        },
                        "time": {
                            "type": "string",
                            "description": "Time of the meeting, including time zone."
                        }
                    },
                    "required": ["attendee", "date", "time"],
                    "additionalProperties": false
                },
                "strict": true
            }
        }
    ],
    "tool_choice": "auto"
}

Die Antwort des Modells enthält dann etwa Folgendes:

{
    "role": "assistant",
    "tool_calls": [
        {
            "id": "call_123",
            "type": "function",
            "function": {
                "name": "schedule_meeting",
                "arguments": "{\"attendee\":\"John Doe\",\"date\":\"2025-11-18\",\"time\":\"15:00 Europe/Berlin\"}"
            }
        }
    ]
}

Dein Backend kann arguments parsen, deine echte Funktion schedule_meeting aufrufen (z. B. über Google Calendar oder Outlook) und optional das Ergebnis an das Modell zurückgeben, damit dieses eine freundliche Bestätigung formuliert.

Beispiel: Aktienkurs-Abfrage

Hier ein stärker „API-artiges“ Beispiel: Aufruf einer Funktion get_stock_price basierend auf natürlicher Sprache.

Request mit einem get_stock_price Tool

{
    "model": "gpt-4.1-mini",
    "messages": [
        {
            "role": "user",
            "content": "What's the current price of Apple stock?"
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_stock_price",
                "description": "Get the current stock price for a ticker symbol.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "ticker_symbol": {
                            "type": "string",
                            "description": "Ticker symbol of the stock, e.g. AAPL."
                        },
                        "currency": {
                            "type": "string",
                            "enum": ["USD", "EUR", "GBP"],
                            "description": "Currency for the price."
                        }
                    },
                    "required": ["ticker_symbol"],
                    "additionalProperties": false
                },
                "strict": true
            }
        }
    ],
    "tool_choice": "auto"
}

Wenn der/die Nutzer:in fragt „What’s the current price of Apple stock?“, erzeugt das Modell einen Tool Call wie:

{
    "type": "function",
    "function": {
        "name": "get_stock_price",
        "arguments": "{\"ticker_symbol\":\"AAPL\",\"currency\":\"USD\"}"
    }
}

Du:

1. Rufst deine echte Aktienkurs-API auf.
2. Übergibst das Ergebnis in einem Folge-Request zurück an das Modell.
3. Lässt das Modell eine leicht verständliche Erklärung formulieren.

Beispiel: Reisebuchung mit Function Calling

Function Calling spielt seine Stärken aus, wenn Prompts unstrukturiert und „menschlich“ sind, dein Backend aber saubere, strukturierte Parameter benötigt.

Betrachte folgende Äußerung:

„I need to book a trip from Bonn to Amsterdam for my wife, mother, my two sons, my daughter, and me. The airline must fly direct.“

Wir möchten, dass das Modell extrahiert:

• departure
• destination
• number_people
• travel_mode (z. B. plane / train)

Tool-Definition für book_travel

{
    "model": "gpt-4.1-mini",
    "messages": [
        {
            "role": "user",
            "content": "I need to book a trip from Bonn to Amsterdam for my wife, mother, my two sons and daughter, and me. The airline must fly direct."
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "book_travel",
                "description": "Search or book transportation for a group of travelers.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "departure": {
                            "type": "string",
                            "description": "City or airport you are traveling from."
                        },
                        "destination": {
                            "type": "string",
                            "description": "City or airport you are traveling to."
                        },
                        "number_people": {
                            "type": "integer",
                            "description": "How many people are traveling."
                        },
                        "travel_mode": {
                            "type": "string",
                            "enum": ["plane", "train", "bus", "car"],
                            "description": "Preferred mode of travel."
                        },
                        "non_stop_only": {
                            "type": "boolean",
                            "description": "Whether only non-stop options are allowed."
                        }
                    },
                    "required": ["departure", "destination", "number_people"],
                    "additionalProperties": false
                },
                "strict": true
            }
        }
    ],
    "tool_choice": "auto"
}

Das Modell könnte Folgendes ausgeben:

{
    "name": "book_travel",
    "arguments": "{\"departure\":\"Bonn\",\"destination\":\"Amsterdam\",\"number_people\":6,\"travel_mode\":\"plane\",\"non_stop_only\":true}"
}

Damit kannst du direkt deinen Flug-Suchservice ansteuern.

Nutzung der modernen OpenAI SDKs (Python & JavaScript)

In der Praxis wirst du selten rohes JSON von Hand senden. Stattdessen verwendest du die offiziellen SDKs und arbeitest mit stark typisierten Responses.

Python-Beispiel (Chat Completions + Tools)

from openai import OpenAI
 
client = OpenAI()
 
tools = [
    {
        "type": "function",
        "function": {
            "name": "schedule_meeting",
            "description": "Schedule a meeting in the calendar.",
            "parameters": {
                "type": "object",
                "properties": {
                    "attendee": {"type": "string"},
                    "date": {"type": "string"},
                    "time": {"type": "string"},
                },
                "required": ["attendee", "date", "time"],
                "additionalProperties": False,
            },
            "strict": True,
        },
    }
]
 
completion = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[
        {
            "role": "user",
            "content": "Schedule a meeting with John Doe next Tuesday at 3 PM.",
        }
    ],
    tools=tools,
    tool_choice="auto",
)
 
tool_calls = completion.choices[0].message.tool_calls
if tool_calls:
    call = tool_calls[0]
    args = client.responses._client._utils.json.loads(call.function.arguments)
    # Your real implementation:
    # result = schedule_meeting(**args)

JavaScript-Beispiel (Node.js)

import OpenAI from "openai";
 
const client = new OpenAI();
 
const tools = [
    {
        type: "function",
        function: {
            name: "get_stock_price",
            description: "Get the current price for a given ticker symbol.",
            parameters: {
                type: "object",
                properties: {
                    ticker_symbol: {
                        type: "string",
                        description: "Stock ticker symbol, e.g. AAPL",
                    },
                },
                required: ["ticker_symbol"],
                additionalProperties: false,
            },
            strict: true,
        },
    },
];
 
const response = await client.chat.completions.create({
    model: "gpt-4.1-mini",
    messages: [
        { role: "user", content: "What's the current price of Apple stock?" },
    ],
    tools,
    tool_choice: "auto",
});
 
const toolCalls = response.choices[0].message.tool_calls;

Structured Outputs: Zuverlässigeres Function Calling

JSON Mode stellt sicher, dass das Modell gültiges JSON zurückgibt, aber nicht zwingend JSON, das deinem Schema entspricht. Structured Outputs ist ein neueres Feature, das dies verschärft, indem es dein JSON Schema beim Aufruf von Tools durchsetzt:

• Setze "strict": true in der function-Definition deines Tools.
• Die Argumente des Modells entsprechen dann garantiert deinem Schema (Typen, Pflichtfelder, keine zusätzlichen Properties), was Parsing- und Validierungsfehler drastisch reduziert.

Das ist besonders hilfreich, wenn du:

• Komplexe, verschachtelte Daten aus unstrukturiertem Text extrahierst
• Mehrstufige Workflows baust, bei denen jeder Schritt präzise strukturierte Daten benötigt
• Parameter für nachgelagerte Systeme wie SQL, Analytics-Pipelines oder Data-Visualisierungen erzeugst

Auch mit Structured Outputs solltest du Werte weiterhin wie untrusted input behandeln (z. B. Wertebereiche prüfen, fehlende IDs abfangen, Business-Regeln validieren).

Design-Patterns & Best Practices

1. Tools klein und fokussiert halten

Anstatt einer riesigen do_everything-Funktion solltest du kleine, komponierbare Tools definieren:

• get_user_profile
• get_user_orders
• create_support_ticket
• schedule_meeting

Das macht Schemas wartbarer und verbessert die Fähigkeit des Modells, das passende Tool zu wählen.

2. Klare Namen und Beschreibungen verwenden

• Funktionsnamen sollten Verben sein: create_invoice, fetch_weather, book_travel.
• Beschreibungen sollten erklären, wann die Funktion genutzt werden soll, nicht nur, was sie macht.

Schlecht:

„Get data from the system.“

Gut:

„Use this function whenever the user asks about their recent orders or order history.“

3. Mit strengen Schemas arbeiten

• Nutze required-Felder und additionalProperties: false.
• Verwende Enums für bekannte Optionen ("enum": ["plane", "train"]).
• Ergänze einfache Constraints, wo sinnvoll (String-Formate, minimale Integer-Werte etc.).

4. Alles validieren und loggen

• Validere Tool-Argumente serverseitig immer, bevor du sie ausführst.
• Logge Tool Calls und natürliche Sprachprompts zum Debuggen.
• Ziehe Retries in Betracht (ggf. mit kurzer, korrigierender System Message), wenn die Validierung fehlschlägt.

5. Tools bei Bedarf verketten

Für komplexere Workflows (z. B. User holen → Bestellungen holen → zusammenfassen) kannst du:

1. Das Modell mehrere Tools in einer Antwort aufrufen lassen (parallele Tool Calls), oder
2. Die Schritte in deinem Backend orchestrieren und die Ergebnisse vorheriger Tools wieder ins Modell einspeisen.

Konkretes Multi-Step-Beispiel: Mathe mit gemischten Formaten

Betrachten wir ein klassisches Beispiel, das zeigt, warum Function Calling mehr als eine Spielerei ist:

„What’s the result of 22 plus 5 in decimal added to the hexadecimal number A?“

Wir können das mit zwei Tools lösen:

• add_decimal(a: number, b: number)
• add_hex(a: string, b: string)

Der Workflow:

1. Das Modell ruft add_decimal mit den Argumenten { "a": 22, "b": 5 } auf → dein Code gibt 27 zurück.
2. Du sendest das Ergebnis und die ursprüngliche Frage zurück an das Modell.
3. Das Modell ruft anschließend add_hex mit { "a": "27", "b": "A" } auf.
4. Dein Code gibt 31 zurück, und das Modell erklärt der Nutzerin/dem Nutzer das Endergebnis.

Dieses Pattern lässt sich auf jedes Domänengebiet übertragen: Finanzen, Analytics, Data Viz, DevOps, BI-Dashboards usw. Function Calling + deine eigenen Tools = ein flexibler, domänenspezifischer AI-Assistent.

Du möchtest beliebige Diagrammtypen ganz einfach mit der Power von ChatGPT erzeugen? Probiere VizGPT (opens in a new tab) — beschreibe deine Daten und dein Diagramm in natürlicher Sprache und erhalte schöne Charts ganz ohne Code.

(opens in a new tab)

(opens in a new tab)

Verwandte OpenAI-Updates (High-Level)

OpenAI hat das Erlebnis rund um Function Calling und Tools weiter verbessert durch:

• Größere Kontextfenster in modernen Modellen, wodurch sich leichter mit langen Konversationen, Dokumenten oder Schemas arbeiten lässt.
• Structured Outputs für Tools und Response-Formate, die sicherstellen, dass die Ausgabe des Modells deinem JSON Schema entspricht.
• Eine stärkere Responses API und ein wachsendes Tool-Ökosystem (Websuche, File Search, Code-Ausführung und mehr), wodurch sich vollständige agentische Workflows mit denselben Function-Calling-Konzepten realisieren lassen.

Für Preise und die aktuelle Modellliste solltest du immer die offizielle OpenAI-Dokumentation und die Pricing-Seite konsultieren.

Fazit

Function Calling ist eine der mächtigsten Methoden, um LLMs in praktische, verlässliche Bestandteile deines Stacks zu verwandeln:

• Du beschreibst, was deine Funktionen tun können, in JSON Schema.
• Das Modell entscheidet, wann und wie es sie aufruft.
• Dein Backend führt die Aufrufe aus und baut zusammen mit dem Modell reichhaltige User Experiences.

Ob du Meetings planst, Aktienkurse abfragst, Reisen buchst oder ein vollständiges BI-Dashboard mit Tools wie PyGWalker und VizGPT betreibst – Function Calling ist der Klebstoff zwischen natürlicher Sprache und echten Aktionen.

Starte einfach mit einer einzigen Funktion, validiere alles und wachse dann nach und nach in vollständige, mehrstufige agentische Workflows hinein, sobald deine Anwendung reift.

Häufig gestellte Fragen (FAQ)

1. Was ist das Function Calling Feature von OpenAI?

   Function Calling ermöglicht dir, Funktionen (Tools) mit JSON Schema zu beschreiben, sodass das Modell statt einfachem Text einen strukturierten Funktionsaufruf zurückgibt. Das Modell führt selbst nichts aus; deine Anwendung parst den Tool Call und ruft die reale Funktion auf.

2. Welche Modelle unterstützen Function Calling?

   Moderne GPT‑4-, GPT‑4.1-, GPT‑4o-, GPT‑4o‑mini- und neuere GPT‑5/o‑Serien-Modelle unterstützen Tools/Function Calling über die Chat Completions und Responses APIs. Schau in die OpenAI-Dokumentation für die jeweils aktuelle Liste der unterstützten Modelle.

3. Soll ich die alten Parameter functions / function_call verwenden?

   Nein. Diese waren die erste Generation von Function-Calling-Parametern und gelten heute als Legacy. Neuer Code sollte tools und tool_choice verwenden, die flexibler sind und mit neueren Modellen und APIs zusammenarbeiten.

4. Worin besteht der Unterschied zu JSON Mode oder Structured Outputs?

   • JSON Mode (response_format: { "type": "json_object" }) stellt gültiges JSON sicher, erzwingt aber kein bestimmtes Schema.
   • Function Calling mit Structured Outputs (strict: true in der Tool-Definition) stellt sicher, dass die Argumente dem von dir vorgegebenen JSON Schema entsprechen.
   • Du kannst Function Calling mit JSON Mode kombinieren, um noch mehr Kontrolle zu erhalten.

5. Was sind typische Use Cases?

   • Chatbots, die externe APIs aufrufen (Wetter, CRM, Ticketing, interne Tools)
   • Natürliche Sprache → API Calls, SQL-Queries, Suchfilter
   • Data-Extraction-Pipelines, die unstrukturierten Text in strukturierte Datensätze umwandeln
   • Mehrstufige „Agent“-Workflows für Automatisierung, Analytics und BI