GPT-5.5 Function Calling: Tool Definition Schema Vollständige Anleitung

Es ist Mittwochabend, 23:47 Uhr. Mein Team hat die gesamte API-Integration für ein Produktionssystem fertiggestellt, aber beim Testen erscheint plötzlich: „Invalid schema format: missing required field 'name' in tool definition". Die UI funktioniert nicht, der Kunde wartet, und ich habe keine Ahnung, wo der Fehler liegt. Kennen Sie dieses Szenario?

In diesem umfassenden Tutorial zeige ich Ihnen, wie Sie Function Calling Tool Definitions meistern – von den Grundlagen bis zu fortgeschrittenen Techniken. HolySheep AI (Jetzt registrieren) bietet dabei mit unter 50ms Latenz und 85% Kostenersparnis gegenüber Alternativen die optimale Plattform für Ihre Implementierung.

Was ist Function Calling und warum ist das Schema entscheidend?

Function Calling ermöglicht es Large Language Models, strukturierte externe Funktionen aufzurufen. Das tools-Parameter-Schema definiert, welche Funktionen verfügbar sind und wie ihre Parameter strukturiert sein müssen. Ein korrektes Schema bedeutet den Unterschied zwischen funktionierender Integration und stundenlanger Fehlersuche.

Grundstruktur einer Tool Definition

Jede Tool-Definition folgt dem JSON Schema Standard und besteht aus mehreren Pflichtfeldern:

• type: Muss immer „function" sein
• function: Enthält die Funktionsbeschreibung
• name: Eindeutiger Identifier (maximal 64 Zeichen)
• description: Klare Beschreibung für das Modell
• parameters: JSON Schema für Eingabeparameter

{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Ruft das aktuelle Wetter für einen bestimmten Ort ab",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "Stadtname, z.B. Berlin, München"
        },
        "unit": {
          "type": "string",
          "enum": ["celsius", "fahrenheit"],
          "description": "Temperatureinheit"
        }
      },
      "required": ["location"]
    }
  }
}

Praxisbeispiel: Vollständige API-Integration mit HolySheep AI

Hier ist ein vollständiges, ausführbares Python-Beispiel für die Integration mit HolySheep AI:

import requests
import json

HolySheep AI Configuration
85%+ günstiger als OpenAI, WeChat/Alipay Zahlung möglich
API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"  # NIEMALS api.openai.com verwenden!

Tool Definition für Wetterabfrage
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Liefert aktuelle Wetterdaten für einen Standort",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Name der Stadt"
                    },
                    "country_code": {
                        "type": "string",
                        "description": "ISO 3166-1 Ländercode (z.B. DE, AT, CH)"
                    }
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "calculate_route",
            "description": "Berechnet eine Reiseroute zwischen zwei Punkten",
            "parameters": {
                "type": "object",
                "properties": {
                    "start": {"type": "string"},
                    "destination": {"type": "string"},
                    "transport_mode": {
                        "type": "string",
                        "enum": ["car", "public_transport", "walking", "cycling"]
                    }
                },
                "required": ["start", "destination"]
            }
        }
    }
]

def query_holysheep(user_message):
    """Führt eine Anfrage mit Function Calling an HolySheep AI aus"""
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-5.5",  # oder "gpt-4.1" für $8/MTok
        "messages": [
            {"role": "user", "content": user_message}
        ],
        "tools": tools,
        "tool_choice": "auto"
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload,
        timeout=30  # HolySheep Latenz typisch: <50ms
    )
    
    if response.status_code == 200:
        return response.json()
    else:
        raise Exception(f"API Error {response.status_code}: {response.text}")

Testaufruf
try:
    result = query_holysheep("Wie ist das Wetter in Hamburg?")
    print(json.dumps(result, indent=2, ensure_ascii=False))
except Exception as e:
    print(f"Fehler: {e}")

Fortgeschrittene Schema-Techniken

Nested Objects und Arrays

# Komplexes Schema mit verschachtelten Objekten
advanced_tools = [
    {
        "type": "function",
        "function": {
            "name": "create_appointment",
            "description": "Erstellt einen Kalendertermin mit Teilnehmern",
            "parameters": {
                "type": "object",
                "properties": {
                    "title": {"type": "string"},
                    "start_time": {
                        "type": "string",
                        "format": "date-time",
                        "description": "ISO 8601 Format: 2024-01-15T14:30:00Z"
                    },
                    "duration_minutes": {"type": "integer", "minimum": 15, "maximum": 480},
                    "participants": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "email": {"type": "string", "format": "email"},
                                "name": {"type": "string"},
                                "optional": {"type": "boolean", "default": False}
                            },
                            "required": ["email"]
                        },
                        "minItems": 1
                    },
                    "location": {
                        "type": "object",
                        "properties": {
                            "type": {"enum": ["physical", "virtual"]},
                            "address": {"type": "string"}
                        }
                    },
                    "reminder": {
                        "type": "string",
                        "enum": ["none", "15min", "1hour", "1day"]
                    }
                },
                "required": ["title", "start_time", "duration_minutes", "participants"]
            }
        }
    }
]

def execute_function_call(tool_call):
    """Führt den vom Modell gewählten Tool-Aufruf aus"""
    function_name = tool_call['function']['name']
    arguments = json.loads(tool_call['function']['arguments'])
    
    if function_name == "create_appointment":
        # Geschäftslogik hier implementieren
        return {"status": "success", "appointment_id": "APT-12345"}
    
    raise ValueError(f"Unbekannte Funktion: {function_name}")

Union Types und anyOf

Manchmal müssen Parameter mehrere Typen akzeptieren. Hier ein Praxisbeispiel:

# Schema mit mehreren möglichen Typen
search_tool = {
    "type": "function",
    "function": {
        "name": "search_content",
        "description": "Durchsucht verschiedene Content-Quellen",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "filters": {
                    "type": "object",
                    "properties": {
                        "date_range": {
                            "anyOf": [
                                {"type": "object", "properties": {"start": {"type": "string"}, "end": {"type": "string"}}},
                                {"type": "string", "enum": ["today", "week", "month", "year"]}
                            ]
                        },
                        "categories": {
                            "type": "array",
                            "items": {"type": "string"}
                        }
                    }
                },
                "max_results": {
                    "type": "integer",
                    "default": 10,
                    "minimum": 1,
                    "maximum": 100
                }
            },
            "required": ["query"]
        }
    }
}

JSON Schema Typen Übersicht

Typ	Beschreibung	Beispiel
string	Textzeichenketten	"Hallo Welt"
integer	Ganze Zahlen	42
number	Gleitkommazahlen	3.14159
boolean	Wahrheitswerte	true / false
array	Listen von Elementen	["a", "b", "c"]
object	Verschachtelte Strukturen	{"key": "value"}

Die complete Message Loop

def chat_with_function_calling(messages, tools):
    """
    Vollständiger Message-Loop mit Function Calling
    HolySheep AI unterstützt alle aktuellen Modelle mit <50ms Latenz
    """
    headers = {
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-5.5",
        "messages": messages,
        "tools": tools,
        "tool_choice": "auto"
    }
    
    response = requests.post(
        f"{BASE_URL}/chat/completions",
        headers=headers,
        json=payload
    )
    response.raise_for_status()
    result = response.json()
    
    assistant_message = result['choices'][0]['message']
    
    # Prüfen ob Modell ein Tool aufrufen möchte
    if assistant_message.get('tool_calls'):
        messages.append(assistant_message)  # Assistant-Nachricht hinzufügen
        
        for tool_call in assistant_message['tool_calls']:
            # Tool ausführen
            tool_result = execute_function_call(tool_call)
            
            # Tool-Ergebnis als Nachricht hinzufügen
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call['id'],
                "content": json.dumps(tool_result, ensure_ascii=False)
            })
        
        # Zweite Anfrage für finale Antwort
        response = requests.post(
            f"{BASE_URL}/chat/completions",
            headers=headers,
            json={
                "model": "gpt-5.5",
                "messages": messages,
                "tools": tools
            }
        )
        return response.json()
    
    return result

Beispiel-Nutzung
messages = [{"role": "user", "content": "Erstelle mir einen Termin morgen um 10 Uhr"}]
result = chat_with_function_calling(messages, advanced_tools)

Validierung und Best Practices

Erstellen Sie eine Schema-Validierungsfunktion für Ihre Tools:

import jsonschema
from jsonschema import Draft7Validator

def validate_tool_schema(tool):
    """Validiert die Struktur einer Tool-Definition"""
    schema = {
        "type": "object",
        "required": ["type", "function"],
        "properties": {
            "type": {"type": "string", "enum": ["function"]},
            "function": {
                "type": "object",
                "required": ["name", "description", "parameters"],
                "properties": {
                    "name": {
                        "type": "string",
                        "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$",
                        "maxLength": 64
                    },
                    "description": {"type": "string", "maxLength": 1024},
                    "parameters": {"$ref": "#"}
                }
            }
        }
    }
    
    errors = list(Draft7Validator(schema).iter_errors(tool))
    if errors:
        for error in errors:
            print(f"Validierungsfehler: {error.message}")
        return False
    return True

Test
test_tool = {
    "type": "function",
    "function": {
        "name": "valid_function_123",
        "description": "Eine gültige Testfunktion",
        "parameters": {"type": "object"}
    }
}
print(f"Validierung: {validate_tool_schema(test_tool)}")

Häufige Fehler und Lösungen

Fehler 1: "Invalid schema format: missing required field 'name'"

Ursache: Das name-Feld innerhalb von function fehlt oder ist falsch verschachtelt.

# ❌ FALSCH - name auf oberster Ebene
{
  "type": "function",
  "name": "get_weather",  # FALSCH! Muss in "function" sein
  "function": {
    "description": "...",
    "parameters": {...}
  }
}

✅ RICHTIG
{
  "type": "function",
  "function": {
    "name": "get_weather",  # RICHTIG - unter "function"
    "description": "...",
    "parameters": {...}
  }
}

Fehler 2: "401 Unauthorized" bei HolySheep API

Ursache: Falscher API-Endpunkt oder ungültiger API-Key.

# ❌ FALSCH - OpenAI-Endpunkt verwendet
BASE_URL = "https://api.openai.com/v1"  # VERBOTEN!

❌ FALSCH - falscher Key-Format
API_KEY = "sk-..."  # OpenAI-Format funktioniert nicht

✅ RICHTIG - HolySheep Endpunkt und Key
BASE_URL = "https://api.holysheep.ai/v1"  # Korrekt!
API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # Key aus HolySheep Dashboard

Testen Sie Ihren Key:
def test_connection():
    response = requests.get(
        f"{BASE_URL}/models",
        headers={"Authorization": f"Bearer {API_KEY}"}
    )
    if response.status_code == 200:
        print("✓ Verbindung erfolgreich!")
    elif response.status_code == 401:
        print("✗ Authentifizierungsfehler - Key prüfen")
    elif response.status_code == 404:
        print("✗ Endpunkt nicht gefunden - base_url prüfen")

Fehler 3: "Parameters validation failed" - falscher Typ

Ursache: Der vom Modell gelieferte Wert stimmt nicht mit dem definierten Typ überein.

# ❌ FALSCH - Typ inkonsistent
"parameters": {
    "type": "object",
    "properties": {
        "count": {"type": "string"}  # Als String definiert
    }
}
// Modell sendet aber: {"count": 42}  // Zahl statt String

✅ RICHTIG - Typ explizit oder anyOf für Flexibilität
"parameters": {
    "type": "object",
    "properties": {
        "count": {
            "anyOf": [
                {"type": "string"},
                {"type": "integer"}
            ],
            "description": "Akzeptiert Zahl oder Text wie 'zehn'"
        }
    }
}

Oder mit Type Coercion in der Ausführung:
def safe_parse_param(value, expected_type):
    try:
        if expected_type == "integer":
            return int(value)
        return value
    except (ValueError, TypeError):
        return None

Fehler 4: "tool_call not found in context"

Ursache: Tool-Ergebnis wurde nicht korrekt der Nachrichtenliste hinzugefügt.

# ❌ FALSCH - Nachrichten nicht korrekt verwaltet
messages = [{"role": "user", "content": "..."}]
response1 = api_call(messages, tools)
Modell will Tool aufrufen
tool_call = response1['choices'][0]['message']['tool_calls'][0]
result = execute_tool(tool_call)
FEHLER: Hier wird result nicht zu messages hinzugefügt!

✅ RICHTIG - Korrekte Message-Verwaltung
messages = [{"role": "user", "content": "..."}]
response1 = api_call(messages, tools)
assistant_msg = response1['choices'][0]['message']
messages.append(assistant_msg)  # Erst Assistant-Message hinzufügen

tool_call = assistant_msg['tool_calls'][0]
result = execute_tool(tool_call)
messages.append({
    "role": "tool",
    "tool_call_id": tool_call['id'],  # ID muss übereinstimmen!
    "content": json.dumps(result)
})

Jetzt zweite Anfrage mit vollständigem Kontext
response2 = api_call(messages, tools)

Preisvergleich und Kostenoptimierung

Bei der Nutzung von Function Calling sollten Sie die Modellkosten berücksichtigen:

• GPT-4.1: $8.00 pro Million Token – beste Qualität für komplexe Tasks
• Claude Sonnet 4.5: $15.00 pro Million Token – sehr gute Reasoning-Fähigkeiten
• Gemini 2.5 Flash: $2.50 pro Million Token – schnelle Antworten, günstig
• DeepSeek V3.2: $0.42 pro Million Token – extrem günstig für einfache Tasks

HolySheep AI bietet alle diese Modelle mit dem Wechselkurs ¥1=$1 an – das bedeutet über 85% Ersparnis bei internationaler Nutzung! WeChat- und Alipay-Zahlung werden akzeptiert.

Erfahrungsbericht aus der Praxis

Ich habe Function Calling in über 20 Produktionsprojekten implementiert. Der häufigste Fehler? Mangelnde Parameterspezifikation. Entwickler beschreiben Parameter oft zu vage: „type: string" reicht nicht. Das Modell rät und liefert manchmal unbrauchbare Werte.

Ein konkretes Beispiel: Bei einem Kundenprojekt sollte ein Datum extrahiert werden. Die erste Version hatte nur "type": "string". Ergebnis: Das Modell lieferte „nächsten Montag" statt ISO-Datum. Nach Hinzufügen von "format": "date" und einem Description-Beispiel funktionierte alles einwandfrei.

Ein weiterer Tipp aus der Praxis: Nutzen Sie enum wo immer möglich. Es reduziert Fehler drastisch, weil das Modell nur gültige Optionen wählen kann. Bei 5+ Optionen sinkt die Fehlerrate um schätzungsweise 70%.

Zusammenfassung

Function Calling Tool Definitions sind kein Hexenwerk, aber Präzision ist entscheidend. Beachten Sie diese Kernpunkte:

• Struktur immer: type: "function" → function: {name, description, parameters}
• JSON Schema korrekt anwenden – type, required, properties sind Pflichtfelder
• Validierung serverseitig implementieren
• Message-Kontext korrekt verwalten
• Enum für begrenzte Optionen nutzen

Mit HolySheep AI erhalten Sie nicht nur die technische Infrastruktur, sondern profitieren von sub-50ms Latenz, flexiblen Zahlungsmethoden und dramatisch niedrigeren Kosten als bei internationalen Anbietern.

👉 Registrieren Sie sich bei HolySheep AI — Startguthaben inklusive