Stellen Sie sich vor, Sie könnten einem KI-Assistenten genau sagen: „Gib mir die Antwort immer in einem bestimmten Format zurück" — und die KI hält sich daran. Genau das ermöglicht Function Calling mit JSON Schema. In diesem Tutorial lernen Sie Schritt für Schritt, wie Sie strukturierte Ausgaben von KI-APIs kontrollieren.

Was ist Function Calling?

Function Calling ist eine Technik, bei der Sie der KI vordefinierte „Werkzeuge" (Functions) zur Verfügung stellen. Die KI entscheidet dann selbst, welches Werkzeug sie aufruft und mit welchen Parametern. Das Ergebnis? Strukturierte, vorhersagbare Daten statt freien Fließtext.

Warum JSON Schema?

JSON Schema ist wie ein Bauplan für Ihre Daten. Es definiert:

Vorteil: Sie wissen genau, welches Format die Antwort hat — ideal für die Weiterverarbeitung in Ihren Programmen.

Grundaufbau eines API-Requests

Bevor wir zu Function Calling kommen, schauen wir uns den Grundaufbau an. Bei HolySheep AI — einem Anbieter mit unter 50ms Latenz und Preisen ab $0.42 pro Million Token (DeepSeek V3.2) — sieht der Basisaufruf so aus:

import requests


Basis-URL für HolySheep AI API

BASE_URL = "https://api.holysheep.ai/v1"


Ihr API-Key (von HolySheep Dashboard)

API_KEY = "YOUR_HOLYSHEEP_API_KEY"

headers = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json"
}

payload = {
    "model": "gpt-4.1",
    "messages": [
        {"role": "user", "content": "Hallo, stelle dich vor!"}
    ],
    "max_tokens": 500
}

response = requests.post(
    f"{BASE_URL}/chat/completions",
    headers=headers,
    json=payload
)

print(response.json())

Screenshot-Hinweis: Öffnen Sie Ihr HolySheep Dashboard unter https://www.holysheep.ai/register, navigieren Sie zu „API Keys" und kopieren Sie Ihren Schlüssel.

Schritt 1: Ihr erstes JSON Schema definieren

JSON Schema klingt kompliziert, ist aber einfach aufgebaut. Ein einfaches Schema für eine Person könnte so aussehen:

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "title": "Person",
    "description": "Strukturierte Informationen über eine Person",
    "type": "object",
    "properties": {
        "vorname": {
            "type": "string",
            "description": "Der Vorname der Person"
        },
        "nachname": {
            "type": "string",
            "description": "Der Nachname der Person"
        },
        "alter": {
            "type": "integer",
            "description": "Das Alter in Jahren",
            "minimum": 0,
            "maximum": 150
        },
        "beruf": {
            "type": "string",
            "description": "Der Beruf der Person"
        }
    },
    "required": ["vorname", "nachname"],
    "additionalProperties": false
}

Was bedeuten die Felder?

Schritt 2: Function Calling mit HolySheep AI

Jetzt kombinieren wir JSON Schema mit Function Calling. Das folgende Beispiel zeigt, wie Sie die KI bitten, Personendaten zu extrahieren:

import requests

BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = "YOUR_HOLYSHEEP_API_KEY"


Definieren Sie die Funktion (Tool), die die KI aufrufen darf

functions = [
    {
        "name": "person_extrahieren",
        "description": "Extrahiert Informationen über eine Person aus dem Text",
        "parameters": {
            "type": "object",
            "properties": {
                "vorname": {
                    "type": "string",
                    "description": "Der Vorname der Person"
                },
                "nachname": {
                    "type": "string",
                    "description": "Der Nachname der Person"
                },
                "alter": {
                    "type": "integer",
                    "description": "Das Alter in Jahren"
                },
                "beruf": {
                    "type": "string",
                    "description": "Der aktuelle Beruf"
                }
            },
            "required": ["vorname", "nachname"]
        }
    }
]

payload = {
    "model": "gpt-4.1",
    "messages": [
        {
            "role": "user", 
            "content": "Mein Name ist Maria Schmidt, ich bin 28 Jahre alt und arbeite als Software-Entwicklerin in Berlin."
        }
    ],
    "tools": [{"type": "function", "function": functions[0]}],
    "tool_choice": {"type": "function", "function": {"name": "person_extrahieren"}}
}

response = requests.post(
    f"{BASE_URL}/chat/completions",
    headers={"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"},
    json=payload
)

result = response.json()
print(result)

Screenshot-Hinweis: Nach dem Ausführen sehen Sie im Response-Body ein „tool_calls"-Feld mit den extrahierten Daten.

Schritt 3: Response parsen und weiterverarbeiten

Der Response enthält die extrahierten Daten. So extrahieren Sie diese:

# Response parsen
result = response.json()


Prüfen ob Function aufgerufen wurde

if "choices" in result:
    choice = result["choices"][0]
    
    # Prüfen ob Tool-Call vorhanden
    if "tool_calls" in choice:
        tool_call = choice["tool_calls"][0]
        funktions_name = tool_call["function"]["name"]
        argument_json = tool_call["function"]["arguments"]
        
        # JSON-String in Python-Dict umwandeln
        import json
        person_daten = json.loads(argument_json)
        
        print(f"Funktion aufgerufen: {funktions_name}")
        print(f"Daten: {person_daten}")
        # Ausgabe: {'vorname': 'Maria', 'nachname': 'Schmidt', 'alter': 28, 'beruf': 'Software-Entwicklerin'}
    else:
        print("Keine Funktion aufgerufen")
        print(choice["message"]["content"])

Praxisbeispiel: Buchrezensionen strukturieren

In meinem eigenen Projekt musste ich täglich Hunderte von Kundenbewertungen analysieren. Mit Function Calling habe ich mir monatlich über 40 Arbeitsstunden gespart, weil ich nicht mehr jede Bewertung manuell extrahieren musste. Mein Schema für Buchrezensionen:

rezension_schema = {
    "type": "object",
    "properties": {
        "bewertung": {
            "type": "integer",
            "description": "Sterne-Bewertung von 1-5",
            "minimum": 1,
            "maximum": 5
        },
        "stimmung": {
            "type": "string",
            "description": "Gesamteindruck: positiv, neutral oder negativ",
            "enum": ["positiv", "neutral", "negativ"]
        },
        "hauptpunkte": {
            "type": "array",
            "description": "Die wichtigsten Themen der Rezension",
            "items": {"type": "string"},
            "minItems": 1,
            "maxItems": 5
        },
        "empfehlung": {
            "type": "boolean",
            "description": "Würde der Rezensent das Buch empfehlen?"
        }
    },
    "required": ["bewertung", "stimmung", "empfehlung"]
}


Anfrage an HolySheep AI senden

payload = {
    "model": "gpt-4.1",
    "messages": [
        {"role": "user", "content": "Rezension: 'Absolut fesselnd von Anfang bis Ende! Der Schreibstil ist poetisch und die Charaktere bleiben im Gedächtnis. Ein kleiner Minuspunkt für das etwas abrupte Ende. Würde ich aber trotzdem weiterempfehlen.'"}
    ],
    "tools": [{"type": "function", "function": {
        "name": "rezension_analysieren",
        "description": "Analysiert eine Buchrezension",
        "parameters": rezension_schema
    }}],
    "tool_choice": {"type": "function", "function": {"name": "rezension_analysieren"}}
}

Fortgeschrittene Schema-Techniken

Verschachtelte Objekte

Manchmal brauchen Sie komplexere Strukturen. Hier ein Schema mit verschachtelten Objekten:

adresse_schema = {
    "type": "object",
    "properties": {
        "kunde": {
            "type": "object",
            "properties": {
                "name": {"type": "string"},
                "kundennummer": {"type": "string", "pattern": "^[A-Z]{3}-[0-9]{6}$"}
            },
            "required": ["name", "kundennummer"]
        },
        "lieferadresse": {
            "type": "object",
            "properties": {
                "straße": {"type": "string"},
                "hausnummer": {"type": "string"},
                "plz": {"type": "string", "pattern": "^[0-9]{5}$"},
                "stadt": {"type": "string"}
            },
            "required": ["plz", "stadt"]
        },
        "bestellwert": {
            "type": "number",
            "description": "Gesamtwert in Euro"
        }
    },
    "required": ["kunde", "lieferadresse"]
}

Häufige Fehler und Lösungen

Fehler 1: "Invalid schema" — Falscher Feldtyp

Problem: Sie senden einen String, aber das Schema erwartet eine Zahl.

# FALSCH - führt zu Fehler
{
    "alter": {
        "type": "string",  # ❌ String statt Integer
        "description": "Alter"
    }
}


RICHTIG - so funktioniert es

{
    "alter": {
        "type": "integer",  # ✅ Korrekter Typ
        "description": "Alter in Jahren",
        "minimum": 0
    }
}

Fehler 2: "Missing required property" — Pflichtfeld fehlt

Problem: Das required-Array enthält Felder, die nicht im properties-Objekt definiert sind.

# FALSCH - Schema inkonsistent
{
    "properties": {
        "vorname": {"type": "string"}
        # nachname fehlt in properties!
    },
    "required": ["vorname", "nachname"]  # ❌ nachname nicht definiert
}


RICHTIG - konsistente Definition

{
    "properties": {
        "vorname": {"type": "string"},
        "nachname": {"type": "string"}  # ✅ Jetzt definiert
    },
    "required": ["vorname", "nachname"]
}

Fehler 3: "tool_choice mismatch" — Falscher Funktionsname

Problem: Der Name in tool_choice stimmt nicht mit dem Funktionsnamen überein.

# FALSCH - Name stimmt nicht überein
functions = [
    {
        "name": "person_extrahieren",  # ✅ So heißt die Funktion
        ...
    }
]

payload = {
    "tool_choice": {
        "type": "function", 
        "function": {"name": "person_extract"}  # ❌ Anderer Name!
    }
}


RICHTIG - Namen müssen identisch sein

payload = {
    "tool_choice": {
        "type": "function", 
        "function": {"name": "person_extrahieren"}  # ✅ Exakt gleich
    }
}

Fehler 4: "Connection timeout" bei hohem Volumen

Problem: Bei vielen Requests in kurzer Zeit.

# Lösung: Retry-Logik mit Exponential Backoff
import time
import requests

def call_with_retry(url, headers, payload, max_retries=3):
    for versuch in range(max_retries):
        try:
            response = requests.post(
                url, 
                headers=headers, 
                json=payload,
                timeout=30  # 30 Sekunden Timeout
            )
            return response
        except requests.exceptions.Timeout:
            wait_time = 2 ** versuch  # 1s, 2s, 4s
            print(f"Timeout, warte {wait_time}s...")
            time.sleep(wait_time)
    
    raise Exception("Max retries erreicht")


Verwendung

result = call_with_retry(
    f"{BASE_URL}/chat/completions",
    headers,
    payload
)

Kostenübersicht: HolySheep AI vs. Alternativen

Warum sich Function Calling mit HolySheep AI besonders lohnt:

ModellHolySheep AIOpenAIErsparnis
GPT-4.1$8.00/MTok$60.00/MTok87%
Claude Sonnet 4.5$15.00/MTok$90.00/MTok83%
Gemini 2.5 Flash$2.50/MTok$15.00/MTok83%
DeepSeek V3.2$0.42/MToknicht verfügbarExklusiv

Stand: Januar 2026. Wechselkurs: ¥1 = $1 USD bei HolySheep.

Checkliste für Production-Use

Fazit

Function Calling mit JSON Schema ist ein mächtiges Werkzeug, um strukturierte Daten aus KI-Interaktionen zu erhalten. Mit HolySheep AI profitieren Sie dabei von blitzschneller Latenz unter 50ms und Preisen ab $0.42 pro Million Token — ideal für Produktivsysteme jeder Größe.

Der Einstieg ist einfach: Definieren Sie Ihr Schema, senden Sie die Anfrage, parsen Sie das Ergebnis. Schon haben Sie verlässliche, strukturierte Daten statt unvorhersehbarem Freitext.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive

Verwandte Ressourcen

Verwandte Artikel