Function Calling: KI-Agenten mit Kalender, E-Mail und Webhooks verbinden

Function Calling — auch Tool Use genannt — ist die Technologie, die ein LLM vom reinen Textgenerator zum echten KI-Agenten macht. Statt nur zu antworten, kann das Modell entscheiden, wann es externe Funktionen aufrufen soll: Einen Kalender-Termin anlegen, eine E-Mail senden oder einen Webhook auslösen. Dieser Artikel erklärt das Konzept und zeigt ein vollständiges Python-Beispiel.

Was ist Function Calling?

Bei Function Calling beschreibst du dem LLM eine Menge von Werkzeugen — mit Name, Beschreibung und Parametern. Das Modell entscheidet selbst, ob und welches Werkzeug es aufruft, basierend auf der Nutzeranfrage. Du führst dann die eigentliche Funktion in deinem Code aus und gibst das Ergebnis zurück.

Der Ablauf im Überblick:

1. Du definierst Tools mit JSON-Schema-Beschreibung
2. Nutzer stellt eine Anfrage
3. LLM entscheidet: Antwort direkt ODER Tool aufrufen
4. Dein Code führt das Tool aus
5. Ergebnis geht zurück ans LLM
6. LLM formuliert die finale Antwort

Technisches Grundprinzip

from openai import OpenAI
import json

client = OpenAI()

# Schritt 1: Tools definieren
tools = [
    {
        "type": "function",
        "function": {
            "name": "create_calendar_event",
            "description": "Erstellt einen Termin im Google Kalender",
            "parameters": {
                "type": "object",
                "properties": {
                    "title": {
                        "type": "string",
                        "description": "Titel des Termins"
                    },
                    "date": {
                        "type": "string",
                        "description": "Datum im Format YYYY-MM-DD"
                    },
                    "time": {
                        "type": "string",
                        "description": "Uhrzeit im Format HH:MM"
                    }
                },
                "required": ["title", "date", "time"]
            }
        }
    }
]

# Schritt 2: Erste Anfrage
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Lege morgen um 14 Uhr einen Termin \"Team-Meeting\" an."}],
    tools=tools,
    tool_choice="auto"
)

message = response.choices[0].message
print(message.tool_calls)  # LLM hat Tool-Call generiert

Praktisches Beispiel: Kalender, E-Mail und Webhook

import json
from openai import OpenAI

client = OpenAI()

# Implementierungen der echten Funktionen
def create_calendar_event(title: str, date: str, time: str) -> dict:
    # Hier echte Google Calendar API aufrufen
    print(f"Kalender: {title} am {date} um {time}")
    return {"status": "created", "event_id": "evt_123"}

def send_email(to: str, subject: str, body: str) -> dict:
    # Hier echte E-Mail-Bibliothek aufrufen (z.B. SendGrid)
    print(f"E-Mail an {to}: {subject}")
    return {"status": "sent", "message_id": "msg_456"}

def trigger_webhook(url: str, payload: dict) -> dict:
    import requests
    response = requests.post(url, json=payload)
    return {"status": response.status_code}

# Dispatch-Funktion
def execute_tool(name: str, args: dict) -> str:
    if name == "create_calendar_event":
        result = create_calendar_event(**args)
    elif name == "send_email":
        result = send_email(**args)
    elif name == "trigger_webhook":
        result = trigger_webhook(**args)
    else:
        result = {"error": f"Unbekanntes Tool: {name}"}
    return json.dumps(result)

# Tool-Loop mit max. Iterationen
MAX_TOOL_CALLS = 5
messages = [{"role": "user", "content": "Lege Donnerstag 10 Uhr ein Meeting an und schreibe Tim eine E-Mail."}]

for _ in range(MAX_TOOL_CALLS):
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        tools=tools,
        tool_choice="auto"
    )
    message = response.choices[0].message
    messages.append(message)

    # Kein Tool-Call mehr? Fertig.
    if not message.tool_calls:
        print("Finale Antwort:", message.content)
        break

    # Tool-Calls ausführen und Ergebnis zurückgeben
    for tool_call in message.tool_calls:
        result = execute_tool(
            tool_call.function.name,
            json.loads(tool_call.function.arguments)
        )
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": result
        })

Best Practices

Beschreibungen sind entscheidend: Die Qualität der Tool-Beschreibungen bestimmt direkt, wie zuverlässig das LLM das richtige Tool wählt und korrekte Parameter übergibt. Klare, präzise Beschreibungen = bessere Ergebnisse.

Immer ein Limit setzen: MAX_TOOL_CALLS = 5 verhindert Endlosschleifen, falls das Modell in einer Kette feststeckt.

Fehlerbehandlung im Tool: Gibt ein Tool einen Fehler zurück, kann das LLM darauf reagieren und es erneut versuchen oder eine alternative Strategie wählen.

Parallele Tool-Calls: Neuere Modelle wie GPT-4o können mehrere Tools gleichzeitig aufrufen, was Latenz bei unabhängigen Operationen reduziert.

Wann ist Function Calling sinnvoll?

Function Calling eignet sich hervorragend für: Kalender- und Aufgaben-Management, E-Mail-Versand und CRM-Updates, Datenbank-Abfragen via natürliche Sprache, Webhook-Trigger für n8n oder Zapier, externe API-Aufrufe (Wetter, Kurs-Daten, etc.) und mehrstufige Workflows die koordiniert werden müssen.

Fazit

Function Calling ist der Schlüssel zu echten KI-Agenten. Das Muster ist einfach: Tools beschreiben, Tool-Loop implementieren, Limit setzen. Mit diesem Grundgerüst lässt sich nahezu jede externe API in einen LLM-gesteuerten Workflow einbinden — von simplen Kalender-Einträgen bis zu komplexen Multi-Step-Prozessen. Alle großen LLM-Anbieter unterstützen Function Calling 2026 nativ.