Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Aangepaste functies (function calling)

Les 11 van 16 Bijgewerkt op 30 juli 2026 Ontwikkelaar
Op deze pagina
  1. Grok verbinden met uw eigen services
  2. Hoe het werkt
  3. Een functie declareren
  4. De functieaanroep ontvangen
  5. Het resultaat retourneren
  6. Best practices voor beschrijvingen
  7. Foutafhandeling
  8. Belangrijkste punten

Grok verbinden met uw eigen services

Servertools (web_search, x_search, code_interpreter) zijn handig, maar beperkt tot xAI-services. Met aangepaste function-tools kunt u Grok verbinden met elke API of service in uw infrastructuur.

Hoe het werkt

Function calling volgt een cyclus van drie stappen:

  1. Declaratie: U beschrijft uw functies (naam, beschrijving, parameters) in het verzoek.
  2. Oproep: Het model genereert een functieaanroep met de juiste argumenten en pauzeert de generatie.
  3. Resultaat: Uw code voert de functie uit, waarna u het resultaat terugstuurt naar het model zodat het zijn antwoord kan formuleren.

Een functie declareren

{
  "model": "grok-4.20-0309-reasoning",
  "input": "Book me a table for 2 people tonight at 8 PM.",
  "tools": [{
    "type": "function",
    "name": "book_restaurant",
    "description": "Books a table at a restaurant",
    "parameters": {
      "type": "object",
      "properties": {
        "restaurant_name": {
          "type": "string",
          "description": "Restaurant name"
        },
        "date": {
          "type": "string",
          "description": "Date in YYYY-MM-DD format"
        },
        "time": {
          "type": "string",
          "description": "Time in HH:MM format"
        },
        "guests": {
          "type": "integer",
          "description": "Number of guests"
        }
      },
      "required": ["date", "time", "guests"]
    }
  }]
}

De beschrijving van elke functie en parameter is cruciaal. Het model gebruikt deze informatie om te beslissen wanneer de functie moet worden aangeroepen en hoe de argumenten moeten worden ingevuld.

De functieaanroep ontvangen

Wanneer het model besluit uw functie aan te roepen, bevat het antwoord een function_call-item:

{
  "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"
  }]
}

Het veld arguments is een JSON-tekenreeks die u moet parseren. De call_id identificeert deze specifieke aanroep.

Het resultaat retourneren

Na uitvoering van de functie in uw code, retourneert u het resultaat:

import json

# 1. Initial request
response = client.responses.create(
    model="grok-4.20-0309-reasoning",
    input="What's the weather like in Paris?",
    tools=[{
        "type": "function",
        "name": "get_weather",
        "description": "Retrieves current weather",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }]
)

# 2. Check if the model wants to call a function
for item in response.output:
    if item.type == "function_call":
        args = json.loads(item.arguments)

        # 3. Execute your function
        weather_data = get_weather_from_api(args["city"])

        # 4. Return the result to the model
        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 voor beschrijvingen

Het model vertrouwt op beschrijvingen om uw functies te begrijpen. Wees nauwkeurig:

{
  "name": "search_products",
  "description": "Searches for products in the e-commerce catalog. Returns the top 10 results sorted by relevance. Supports search by name, category, or price range.",
  "parameters": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Search terms (product name, brand, keyword)"
      },
      "category": {
        "type": "string",
        "enum": ["electronics", "clothing", "home", "sports"],
        "description": "Product category to filter"
      },
      "max_price": {
        "type": "number",
        "description": "Maximum price in euros"
      }
    },
    "required": ["query"]
  }
}

Gebruik enum voor vooraf gedefinieerde waarden, een gedetailleerde description voor elke parameter en markeer alleen essentiële parameters als required.

Foutafhandeling

Als uw functie mislukt, retourneer de fout dan als resultaat:

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
)

Het model interpreteert de fout en kan zijn antwoord herformuleren of een andere aanpak proberen.

Belangrijkste punten

  • Aangepaste functies verbinden Grok met uw eigen services.
  • De cyclus is: declareren, de aanroep ontvangen, uitvoeren, het resultaat retourneren.
  • Beschrijvingen van functies en parameters sturen de keuze van het model.
  • Het veld arguments is een JSON-tekenreeks die aan de clientzijde moet worden geparseerd.
  • Retourneer fouten als resultaten zodat het model zich kan aanpassen.