Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Funktionsaufrufe: Verbinden Sie KI mit Ihren Systemen

Lektion 10 von 22 Aktualisiert am 29. Juli 2026 Entwickler
Auf dieser Seite
  1. Funktionsaufrufe: Verbinden Sie KI mit Ihren Systemen
  2. Der vollständige Ablauf, Schritt für Schritt
  3. Dem Modell die Wahl zwischen mehreren Werkzeugen überlassen
  4. Der Agenten-Loop
  5. Argumente mit Strict Mode absichern
  6. Kernaussagen

Funktionsaufrufe: Verbinden Sie KI mit Ihren Systemen

Funktionsaufrufe ermöglichen es dem Modell, Funktionen auszurufen, die Sie definieren. Halten Sie eine Regel im Mittelpunkt, da alles andere daraus folgt: Das Modell führt sie nicht aus. Es teilt Ihnen mit, welche Funktion aufgerufen werden soll und mit welchen Argumenten; Ihr Code führt die Ausführung durch und gibt das Ergebnis zurück. Ihre Datenbank, Ihre Zugangsdaten und Ihre Geschäftslogik verlassen niemals Ihre Infrastruktur.

Der vollständige Ablauf, Schritt für Schritt

Der Austausch findet in vier Phasen statt:

  1. Sie deklarieren verfügbare Funktionen zusammen mit ihren Parametern
  2. Das Modell analysiert die Anfrage und entscheidet sich für einen Funktionsaufruf
  3. Ihr Code führt die Funktion aus und erhält das Ergebnis
  4. Sie senden das Ergebnis zurück an das Modell, damit es seine Antwort formulieren kann

Die Deklaration verdient besondere Sorgfalt: Die Funktion description und die Beschreibung jedes Parameters sind die einzige Dokumentation, die das Modell hat, um seine Entscheidung zu treffen. Vage Beschreibungen führen zu ungenauen Aufrufen. Beachten Sie auch, wie der Kreis geschlossen wird: Das Ergebnis geht mit dem call_id zurück, das Sie erhalten haben, was als Bestätigung dient und es der API ermöglicht, die Antwort der Anfrage zuzuordnen.

from openai import OpenAI
import json

client = OpenAI()

# Schritt 1: Verfügbare Funktionen deklarieren
tools = [{
    "type": "function",
    "name": "get_meteo",
    "description": "Holen Sie sich das aktuelle Wetter für eine Stadt",
    "parameters": {
        "type": "object",
        "properties": {
            "ville": {
                "type": "string",
                "description": "Der Name der Stadt"
            },
            "unite": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperatureinheit"
            }
        },
        "required": ["ville"]
    }
}]

# Schritt 2: Das Modell entscheidet sich für den Funktionsaufruf
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Wie ist das Wetter in Marseille?",
    tools=tools
)

# Schritt 3: Die Funktion ausführen
for item in response.output:
    if item.type == "function_call":
        print(f"Funktion: {item.name}")
        print(f"Argumente: {item.arguments}")
        args = json.loads(item.arguments)

        # Ihre tatsächliche Implementierung
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Schritt 4: Das Ergebnis zurück an das Modell senden
        final = client.responses.create(
            model="gpt-5.6-terra",
            input=[
                {"role": "user", "content": "Wie ist das Wetter in Marseille?"},
                {
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": json.dumps(resultat_meteo)
                }
            ],
            tools=tools
        )
        print(f"Antwort: {final.output_text}")

# Ergebnis:
# Funktion: get_meteo
# Argumente: {"ville": "Marseille"}
# Antwort: Es ist derzeit 22 °C in Marseille mit sonnigem Wetter.

Dem Modell die Wahl zwischen mehreren Werkzeugen überlassen

Der wahre Wert zeigt sich, wenn Sie einen gesamten Katalog an Fähigkeiten offenlegen. In einem E-Commerce-Assistenten würden Sie die Suche nach Produkten, die Lagerbestandsprüfung und die Auftragserteilung deklarieren und dem Modell die Entscheidung überlassen. Angesichts der Frage „Ist der XPS-Gaming-Laptop verfügbar?” führt es keine Suche durch, sondern fragt direkt den Lagerbestand ab: Ihre Funktionsbeschreibungen, nicht eine fest codierte Regel, trieben diese Entscheidung voran.

tools = [
    {
        "type": "function",
        "name": "rechercher_produit",
        "description": "Suchen Sie nach einem Produkt im Katalog",
        "parameters": {
            "type": "object",
            "properties": {
                "requête": {"type": "string", "description": "Suchbegriffe"},
                "categorie": {"type": "string", "description": "Kategorie (optional)"}
            },
            "required": ["requête"]
        }
    },
    {
        "type": "function",
        "name": "verifier_stock",
        "description": "Prüfen Sie die Produktverfügbarkeit",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string", "description": "Produkt-ID"}
            },
            "required": ["produit_id"]
        }
    },
    {
        "type": "function",
        "name": "passer_commande",
        "description": "Erstellen Sie einen Auftrag für ein Produkt",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string"},
                "quantite": {"type": "integer", "description": "Anzahl der Einheiten"}
            },
            "required": ["produit_id", "quantite"]
        }
    }
]

# Das Modell wählt automatisch die richtige Funktion aus
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Ist der XPS-Gaming-Laptop verfügbar?",
    tools=tools
)

for item in response.output:
    if item.type == "function_call":
        print(f"Ausgewählte Funktion: {item.name}")
        print(f"Argumente: {item.arguments}")

# Ergebnis: Ausgewählte Funktion: verifier_stock
# Argumente: {"produit_id": "xps-gaming"}

Eine einzelne Anfrage kann auch mehrere Aufrufe gleichzeitig auslösen. Der Vergleich des Wetters in zwei Städten erzeugt zwei unabhängige Aufrufe: Ihr Code muss daher durch response.output iterieren und alle function_call-Elemente verarbeiten, niemals nur das erste. Dies ist auch eine Gelegenheit, diese Aufrufe parallel auszuführen und die Latenz um die Hälfte zu reduzieren.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Vergleichen Sie das Wetter zwischen Paris und Lyon.",
    tools=[{
        "type": "function",
        "name": "get_meteo",
        "description": "Holen Sie sich das Wetter für eine Stadt",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"]
        }
    }]
)

# Das Modell führt zwei Aufrufe parallel durch
function_calls = [item for item in response.output if item.type == "function_call"]
print(f"Anzahl der Aufrufe: {len(function_calls)}")
for call in function_calls:
    args = json.loads(call.arguments)
    print(f"  - get_meteo({args['ville']})")

# Ergebnis:
# Anzahl der Aufrufe: 2
#   - get_meteo(Paris)
#   - get_meteo(Lyon)

Der Agenten-Loop

Eine einzelne Hin-und-Her-Runde reicht selten aus: Das Ergebnis einer Funktion führt das Modell oft dazu, eine weitere aufzurufen. Daher wickeln Sie den Austausch in einen Loop ein, der so lange läuft, wie die Antwort Funktionsaufrufe enthält, und stoppt, sobald dies nicht mehr der Fall ist – ein Zeichen dafür, dass das Modell seine endgültige Antwort formuliert hat. Dies ist das Skelett jedes Agenten, und Sie werden es in verschiedenen Formen in allen Agenten-Frameworks sehen.

def executer_fonction(nom: str, arguments: str) -> str:
    """Führen Sie eine Funktion aus und geben Sie das Ergebnis zurück."""
    args = json.loads(arguments)

    if nom == "get_meteo":
        # Simulation — ersetzen Sie dies durch Ihre echte API
        return json.dumps({"temp": 18, "condition": "cloudy"})
    elif nom == "get_heure":
        return json.dumps({"heure": "14:30", "timezone": "CET"})

    return json.dumps({"error": "Unbekannte Funktion"})

def agent_loop(frage: str, tools: list) -> str:
    """Agenten-Loop: Rufen Sie Funktionen auf, bis die endgültige Antwort da ist."""
    input_messages = [{"role": "user", "content": frage}]

    while True:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=input_messages,
            tools=tools
        )

        # Prüfen auf Funktionsaufrufe
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Keine Funktionsaufrufe = endgültige Antwort
            return response.output_text

        # Jede Funktion ausführen und Ergebnisse hinzufügen
        for call in function_calls:
            resultat = executer_fonction(call.name, call.arguments)
            input_messages.append({
                "type": "function_call_output",
                "call_id": call.call_id,
                "output": resultat
            })

# Nutzung
reponse = agent_loop("Wie ist das Wetter in Paris?", tools)
print(reponse)

Ein Wort zur Vorsicht bei diesem Muster: Der while True-Loop hat keine Schutzmechanismen. In der Produktion fügen Sie einen maximalen Iterationszähler hinzu; andernfalls würde ein Modell, das unendlich dieselbe Werkzeuganfrage stellt, Ihr Budget verbrennen, ohne je zu einem Abschluss zu kommen.

Argumente mit Strict Mode absichern

Strict Mode wendet die gleiche Garantie für Funktionsparameter an, wie Structured Output für Antworten: Argumente halten sich strikt an das deklarierte Schema. Für eine Funktion, die einen Benutzer erstellt, verhindert dies, dass Sie ein Alter als String erhalten oder ein zusätzliches Feld, das Ihr Code nicht erwartet.

tools = [{
    "type": "function",
    "name": "creer_utilisateur",
    "description": "Erstellen Sie einen neuen Benutzer",
    "strict": True,
    "parameters": {
        "type": "object",
        "properties": {
            "nom": {"type": "string"},
            "email": {"type": "string"},
            "age": {"type": "integer"}
        },
        "required": ["nom", "email", "age"],
        "additionalProperties": False
    }
}]

Kernaussagen

  • Funktionsaufrufe verbinden das Modell mit Ihren Systemen, ohne Ihre Daten preiszugeben
  • Das Modell entscheidet, welche Funktion aufgerufen werden soll; Ihr Code führt sie aus
  • Geben Sie das Ergebnis mit function_call_output und dem call_id zurück
  • Das Modell kann mehrere Funktionen parallel aufrufen
  • Verwenden Sie einen Agenten-Loop für mehrstufige Gespräche, die Funktionen beinhalten
  • Aktivieren Sie strict: True, um die Argumenteinhaltung zu garantieren