Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Tools definiëren in JSON

Les 4 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Van theorie naar praktijk
  2. Verzoekstructuur met tools
  3. Belangrijke cijfers voor implementatie
  4. De tool_call-respons verwerken
  5. Uitvoeren en het resultaat retourneren
  6. Meerdere tools definiëren
  7. finish_reason controleren
  8. Belangrijkste punten

Van theorie naar praktijk

U begrijpt nu het concept van function calling en de structuur van JSON-schema’s. Het is tijd om over te gaan tot concrete implementatie. In deze les leert u hoe u een compleet verzoek opbouwt met tool-definities en hoe u de respons van het model verwerkt.

Verzoekstructuur met tools

Hier ziet u een compleet verzoek aan de Grok API met een gedefinieerde tool:

from openai import OpenAI

client = OpenAI(
    api_key="your-api-key",
    base_url="https://api.x.ai/v1"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "default": "celsius"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="grok-4.5",
    messages=[
        {"role": "user", "content": "What's the weather like in Paris?"}
    ],
    tools=tools
)

Let op de geneste structuur: het tools-object bevat een array, waarbij elk element een type en een function-object met de details heeft.

Belangrijke cijfers voor implementatie

200
Maximaal aantal tools per verzoek
6
Ondersteunde JSON-types
3
Compatibele SDK's
1
Verzoek = volledige flow

De tool_call-respons verwerken

Wanneer het model besluit een functie aan te roepen, bevat de respons een tool_calls-array:

message = response.choices[0].message

if message.tool_calls:
    for tool_call in message.tool_calls:
        print(f"Function: {tool_call.function.name}")
        print(f"Arguments: {tool_call.function.arguments}")
        print(f"ID: {tool_call.id}")

Het veld tool_call.function.arguments is een JSON-tekenreeks (geen Python-object). U moet deze parseren:

import json

args = json.loads(tool_call.function.arguments)
city = args["city"]
unit = args.get("unit", "celsius")

Uitvoeren en het resultaat retourneren

Zodra de functie is uitgevoerd, stuurt u het resultaat terug naar het model in een tweede oproep:

import json

# 1. Voer de functie uit
weather_data = get_weather(city="Paris", unit="celsius")

# 2. Bouw de berichten op met het resultaat
messages = [
    {"role": "user", "content": "What's the weather like in Paris?"},
    message,  # De modelrespons met tool_calls
    {
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(weather_data)
    }
]

# 3. Roep het model opnieuw aan met het resultaat
final_response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)

Het bericht met de rol tool moet het volgende bevatten:

  • tool_call_id: de unieke identificatie van de tool_call (om deze aan het verzoek te koppelen)
  • content: het resultaat als een JSON-tekenreeks

Meerdere tools definiëren

U kunt zoveel tools als nodig is declareren in de tools-array:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city",
            "parameters": { ... }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_restaurants",
            "description": "Search for restaurants by city and cuisine type",
            "parameters": { ... }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "book_table",
            "description": "Book a table at a restaurant",
            "parameters": { ... }
        }
    }
]

Het model kiest automatisch de relevante tool(s) op basis van het gebruikersverzoek.

finish_reason controleren

Het veld finish_reason in de respons geeft aan of het model zijn respons heeft voltooid of wacht op een tool-resultaat:

finish_reason = response.choices[0].finish_reason

if finish_reason == "tool_calls":
    # Het model wacht op het resultaat van een of meer tools
    handle_tool_calls(response)
elif finish_reason == "stop":
    # Het model heeft zijn respons voltooid
    print(response.choices[0].message.content)

Belangrijkste punten

  • Het verzoek bevat messages en tools (definities)
  • tool_call-argumenten zijn een JSON-tekenreeks die geparsed moet worden
  • Stuur het resultaat in een bericht met rol tool, inclusief de tool_call_id
  • Controleer finish_reason om te weten of het model wacht op een resultaat
  • U kunt meerdere tools declareren; het model kiest automatisch