Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Benutzerdefinierte Funktionen (Function Calling)

Lektion 11 von 16 Aktualisiert am 30. Juli 2026 Entwickler
Auf dieser Seite
  1. Grok mit Ihren eigenen Diensten verbinden
  2. Funktionsweise
  3. Funktion erklären
  4. Empfangen des Funktionsaufrufs
  5. Ergebnis zurückgeben
  6. Best Practices für Beschreibungen
  7. Fehlerbehandlung
  8. Kernaussagen

Grok mit Ihren eigenen Diensten verbinden

Server-Tools (web_search, x_search, code_interpreter) sind zwar praktisch, beschränken sich jedoch auf xAI-Dienste. Mit benutzerdefinierten function-Tools können Sie Grok mit beliebigen APIs oder Diensten in Ihrer Infrastruktur verbinden.

Funktionsweise

Das Function Calling folgt einem dreistufigen Zyklus:

  1. Erklärung: Sie beschreiben Ihre Funktionen (Name, Beschreibung, Parameter) in der Anfrage.
  2. Aufruf: Das Modell generiert einen Funktionsaufruf mit den entsprechenden Argumenten und pausiert die Generierung.
  3. Ergebnis: Ihr Code führt die Funktion aus, und Sie senden das Ergebnis zurück an das Modell, damit es seine Antwort formulieren kann.

Funktion erklären

{
  "model": "grok-4.20-0309-reasoning",
  "input": "Buchen Sie mir heute Abend um 20:00 Uhr einen Tisch für 2 Personen.",
  "tools": [{
    "type": "function",
    "name": "book_restaurant",
    "description": "Bucht einen Tisch in einem Restaurant",
    "parameters": {
      "type": "object",
      "properties": {
        "restaurant_name": {
          "type": "string",
          "description": "Name des Restaurants"
        },
        "date": {
          "type": "string",
          "description": "Datum im Format YYYY-MM-DD"
        },
        "time": {
          "type": "string",
          "description": "Zeit im Format HH:MM"
        },
        "guests": {
          "type": "integer",
          "description": "Anzahl der Gäste"
        }
      },
      "required": ["date", "time", "guests"]
    }
  }]
}

Die Beschreibung jeder Funktion und jedes Parameters ist entscheidend. Das Modell nutzt sie, um zu entscheiden, wann es die Funktion aufrufen soll und wie es die Argumente ausfüllen soll.

Empfangen des Funktionsaufrufs

Wenn das Modell entscheidet, Ihre Funktion aufzurufen, enthält die Antwort ein function_call-Element:

{
  "id": "resp-xyz789",
  "status": "completed",
  "output": [{
    "type": "function_call",
    "name": "book_restaurant",
    "arguments": "{\"date\": \"2026-04-03\", \"time\": \"20:00\", \"guests\": 2}",
    "call_id": "call-abc123"
  }]
}

Das Feld arguments ist eine JSON-Zeichenfolge, die Sie parsen müssen. Das Feld call_id identifiziert diesen spezifischen Aufruf.

Ergebnis zurückgeben

Nachdem Sie die Funktion in Ihrem Code ausgeführt haben, geben Sie das Ergebnis zurück:

import json

# 1. Initiale Anfrage
response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="Wie ist das Wetter in Paris?",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Holt das aktuelle Wetter",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }]
)

# 2. Prüfen, ob das Modell eine Funktion aufrufen möchte
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)

        # 3. Ihre Funktion ausführen
        weather_data = get_weather_from_api(args["city"])

        # 4. Das Ergebnis an das Modell zurückgeben
        final = client.responses.create(
            model="grok-4.20-0309-reasoning",
            input=[{
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(weather_data)
            }],
            previous_response_id=response.id
        )
        print(final.output[0].content[0].text)

Best Practices für Beschreibungen

Das Modell stützt sich auf Beschreibungen, um Ihre Funktionen zu verstehen. Seien Sie präzise:

{
  "name": "search_products",
  "description": "Sucht nach Produkten im E-Commerce-Katalog. Gibt die Top-10-Ergebnisse nach Relevanz sortiert zurück. Unterstützt Suche nach Name, Kategorie oder Preisbereich.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Suchbegriffe (Produktname, Marke, Schlüsselwort)"
      },
      "category": {
        "type": "string",
        "enum": ["electronics", "clothing", "home", "sports"],
        "description": "Produktkategorie zur Filterung"
      },
      "max_price": {
        "type": "number",
        "description": "Maximaler Preis in Euro"
      }
    },
    "required": ["query"]
  }
}

Verwenden Sie enum für vordefinierte Werte, eine detaillierte description für jeden Parameter und markieren Sie nur wesentliche Parameter als required.

Fehlerbehandlung

Wenn Ihre Funktion fehlschlägt, geben Sie den Fehler als Ergebnis zurück:

try:
    result = call_external_api(args)
    output = json.dumps(result)
except Exception as e:
    output = json.dumps({"error": str(e)})

final = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input=[{
        "type": "function_call_output",
        "call_id": call_id,
        "output": output
    }],
    previous_response_id=response.id
)

Das Modell interpretiert den Fehler und kann seine Antwort umformulieren oder einen anderen Ansatz versuchen.

Kernaussagen

  • Benutzerdefinierte Funktionen verbinden Grok mit Ihren eigenen Diensten.
  • Der Zyklus lautet: erklären, Aufruf empfangen, ausführen, Ergebnis zurückgeben.
  • Funktions- und Parameterbeschreibungen leiten die Wahl des Modells.
  • Das Feld arguments ist eine JSON-Zeichenfolge, die auf der Client-Seite geparsed werden muss.
  • Geben Sie Fehler als Ergebnisse zurück, damit sich das Modell anpassen kann.