Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Parallelle aanroepen

Les 6 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Meerdere tools in één antwoord
  2. De parameter parallel_tool_calls
  3. Afhandeling van parallelle aanroepen
  4. Echte parallelle uitvoering aan de clientzijde
  5. Parallelle aanroepen uitschakelen
  6. Parallelle aanroepen met verschillende tools
  7. Foutafhandeling bij parallelle uitvoering
  8. Belangrijkste punten

Meerdere tools in één antwoord

Een van de krachtigste functies van Grok function calling is de mogelijkheid om meerdere tool-aanroepen in één enkel antwoord terug te geven. In plaats van voor elke functie een volledige round-trip te maken, identificeert het model alle benodigde informatie en genereert het elke aanroep parallel.

De parameter parallel_tool_calls

Parallelle aanroepen zijn standaard ingeschakeld. De parameter parallel_tool_calls stuurt dit gedrag:

# Standaard ingeschakeld (niet nodig om op te geven)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Dit is de standaardwaarde
)

Wanneer een gebruiker vraagt: “Wat is het weer in Parijs en Lyon?”, geeft het model twee tool_calls terug in hetzelfde antwoord:

{
  "tool_calls": [
    {
      "id": "call_001",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Paris\"}"
      }
    },
    {
      "id": "call_002",
      "function": {
        "name": "get_weather",
        "arguments": "{\"city\": \"Lyon\"}"
      }
    }
  ]
}

Afhandeling van parallelle aanroepen

Uw code moet een array van tool_calls afhandelen, niet slechts één:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Voer alle functies uit
    tool_results = []
    for tool_call in message.tool_calls:
        args = json.loads(tool_call.function.arguments)
        result = execute_function(tool_call.function.name, args)
        tool_results.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result)
        })

    # Stuur ALLE resultaten terug naar het model
    messages = [
        {"role": "user", "content": "What's the weather in Paris and Lyon?"},
        message,
        *tool_results  # Alle resultaten
    ]

    final = client.chat.completions.create(
        model="grok-4.5",
        messages=messages,
        tools=tools
    )

Cruciaal punt: u moet alle tool-resultaten teruggeven, niet alleen het eerste. Elk resultaat is gekoppeld aan de bijbehorende tool_call_id.

Echte parallelle uitvoering aan de clientzijde

Het model geeft aanroepen parallel terug, maar uw code moet ze ook daadwerkelijk parallel uitvoeren. Gebruik in Python asyncio of concurrent.futures:

import concurrent.futures

def execute_parallel(tool_calls):
    results = []
    with concurrent.futures.ThreadPoolExecutor() as executor:
        futures = {}
        for tc in tool_calls:
            args = json.loads(tc.function.arguments)
            future = executor.submit(execute_function, tc.function.name, args)
            futures[future] = tc.id

        for future in concurrent.futures.as_completed(futures):
            call_id = futures[future]
            result = future.result()
            results.append({
                "role": "tool",
                "tool_call_id": call_id,
                "content": json.dumps(result)
            })
    return results

Parallelle uitvoering vermindert de totale latentie aanzienlijk. Als elke API-aanroep 200 ms duurt, kosten twee sequentiële aanroepen 400 ms, terwijl twee parallelle aanroepen ongeveer 200 ms duren.

Parallelle aanroepen uitschakelen

In sommige gevallen wilt u sequentiële aanroepen:

response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False
)

Schakel parallelisme uit wanneer de onafhankelijkheid van aanroepen niet gegarandeerd is. Het meest voor de hand liggende geval is gegevensafhankelijkheid: als het resultaat van de ene tool dient als invoer voor de argumenten van de volgende tool—bijvoorbeeld het opzoeken van een klant-ID voordat diens bestellingen worden opgehaald—zal parallel uitvoeren op zijn best een fout veroorzaken en op zijn worst leiden tot een stilzwijgend onjuist resultaat. De volgorde van bedrijfslogica legt dezelfde beperking op: het aanmaken van een gebruiker voordat een rol wordt toegewezen is niet onderhandelbaar, en alleen de sequentiële modus garandeert dit. Twee meer praktische redenen maken het plaatje compleet: een externe API met limieten voor gelijktijdige verzoeken kan een burst van parallelle aanroepen slecht aan, en tijdens de ontwikkeling maakt de sequentiële modus het traceren van aanroepen oneindig leesbaarder—één aanroep, één resultaat, één logregel, op volgorde.

Parallelle aanroepen met verschillende tools

Het model kan ook verschillende tools parallel aanroepen:

# Verzoek: "Reserveer een tafel en vertel me het weer vanavond"
# Het model geeft terug:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Dit is bijzonder nuttig voor veelzijdige assistenten die informatie uit verschillende bronnen moeten verzamelen.

Foutafhandeling bij parallelle uitvoering

Wanneer één aanroep mislukt maar andere slagen, geeft u toch alle resultaten terug. Het model handelt individuele fouten af:

results = []
for tc in message.tool_calls:
    try:
        result = execute_function(tc.function.name, args)
        results.append({
            "role": "tool",
            "tool_call_id": tc.id,
            "content": json.dumps(result)
        })
    except Exception as e:
        results.append({
            "role": "tool",
            "tool_call_id": tc.id,
            "content": json.dumps({"error": str(e)})
        })

Belangrijkste punten

  • Parallelle aanroepen zijn standaard ingeschakeld (parallel_tool_calls: true)
  • Het model geeft meerdere tool_calls terug in één enkel antwoord
  • U moet alle resultaten teruggeven, elk gekoppeld aan de bijbehorende tool_call_id
  • Implementeer parallelle uitvoering aan de clientzijde om de latentie te verlagen
  • Schakel parallelisme uit wanneer er afhankelijkheden bestaan tussen aanroepen
  • Handel fouten individueel af—blokkeer niet alles vanwege één enkele mislukking