Parallele Aufrufe — Function Calling mit Grok

Mehrere Werkzeuge in einer einzigen Antwort

Eine der leistungsfähigsten Funktionen von Grok beim Funktionsaufruf ist die Fähigkeit, mehrere Werkzeugaufrufe in einer einzigen Antwort zurückzugeben. Anstatt für jede Funktion eine Hin- und Rückreise zu unternehmen, identifiziert das Modell alle benötigten Informationen und generiert jeden Aufruf parallel.

Der Parameter parallel_tool_calls

Parallele Aufrufe sind standardmäßig aktiviert. Der Parameter parallel_tool_calls steuert dieses Verhalten:

# Standardmäßig aktiviert (keine Angabe erforderlich)
response = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Dies ist der Standardwert
)

Wenn ein Benutzer fragt: „Wie ist das Wetter in Paris und Lyon?”, gibt das Modell zwei tool_calls in derselben Antwort zurück:

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

Umgang mit parallelen Aufrufen

Ihr Code muss ein Array von tool_calls verarbeiten, nicht nur einen einzelnen Aufruf:

import json
import asyncio

message = response.choices[0].message

if message.tool_calls:
    # Alle Funktionen ausführen
    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)
        })

    # Alle Ergebnisse zurück an das Modell senden
    messages = [
        {"role": "user", "content": "Wie ist das Wetter in Paris und Lyon?"},
        message,
        *tool_results  # Alle Ergebnisse
    ]

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

Wichtiger Punkt: Sie müssen alle Werkzeugergebnisse zurückgeben, nicht nur das erste. Jedes Ergebnis ist mit seinem entsprechenden tool_call_id verknüpft.

Echte parallele Ausführung auf dem Client

Das Modell gibt Aufrufe parallel zurück, aber Ihr Code muss sie ausführen parallel. In Python verwenden Sie asyncio oder 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

Die parallele Ausführung reduziert die Gesamtlatenz erheblich. Wenn jeder API-Aufruf 200 ms dauert, betragen zwei sequenzielle Aufrufe 400 ms, während zwei parallele Aufrufe nur etwa 200 ms benötigen.

Deaktivierung paralleler Aufrufe

In manchen Fällen möchten Sie sequenzielle Aufrufe:

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

Deaktivieren Sie die Parallelität, wenn die Unabhängigkeit der Aufrufe nicht garantiert ist. Der offensichtlichste Fall ist die Datenabhängigkeit: Wenn das Ergebnis eines Werkzeugs in die Argumente des nächsten Werkzeugs einfließt – beispielsweise die Suche nach einer Kunden-ID vor der Abholung ihrer Bestellungen – führt die parallele Ausführung bestenfalls zu einem Fehler und schlimmstenfalls zu einem stummen, falschen Ergebnis. Geschäftslogische Reihenfolgen unterliegen derselben Einschränkung: Die Erstellung eines Benutzers vor der Zuweisung einer Rolle ist unverhandelbar, und nur der sequenzielle Modus garantiert dies. Zwei weitere praktische Gründe vervollständigen das Bild: Eine externe API, die Begrenzungen für gleichzeitige Anfragen unterliegt, kann einen Stoß paralleler Aufrufe nicht gut verarbeiten, und während der Entwicklung macht der sequenzielle Modus das Verfolgen der Aufrufe unendlich lesbarer – ein Aufruf, ein Ergebnis, ein Protokolleintrag, in der richtigen Reihenfolge.

Parallele Aufrufe mit verschiedenen Werkzeugen

Das Modell kann auch verschiedene Werkzeuge parallel aufrufen:

# Anfrage: "Tisch reservieren und mir das Wetter heute Abend sagen"
# Das Modell gibt zurück:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")

Dies ist besonders nützlich für vielseitige Assistenten, die Informationen aus verschiedenen Quellen sammeln müssen.

Fehlerbehandlung bei parallelen Aufrufen

Wenn ein Aufruf fehlschlägt, andere aber erfolgreich sind, geben Sie dennoch alle Ergebnisse zurück. Das Modell verarbeitet individuelle Fehler:

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)})
        })

Kernaussagen

Parallele Aufrufe sind standardmäßig aktiviert (parallel_tool_calls: true)
Das Modell gibt mehrere tool_calls in einer einzigen Antwort zurück
Sie müssen alle Ergebnisse zurückgeben, wobei jedes mit seinem tool_call_id verknüpft ist
Implementieren Sie die parallele Ausführung auf Client-Seite, um die Latenz zu reduzieren
Deaktivieren Sie die Parallelität, wenn Abhängigkeiten zwischen den Aufrufen bestehen
Behandeln Sie Fehler einzeln – blockieren Sie nicht alles aufgrund eines einzelnen Fehlers