Parallele Funktionsaufrufe
Auf dieser Seite
- Wenn das Modell mehrere Informationen gleichzeitig benötigt
- Eine Antwort mit mehreren Aufrufen lesen
- Jedes Ergebnis an seinen ursprünglichen Aufruf zurückgeben
- Vom scheinbaren Parallelismus zum echten Parallelismus
- Kontrolle mit parallel_tool_calls wiedererlangen
- Was Parallelität wirklich ändert
- Kernaussagen
Wenn das Modell mehrere Informationen gleichzeitig benötigt
Bisher hat jeder Gesprächswechsel zu genau einem Funktionsaufruf geführt. Viele Fragen aus der Praxis passen nicht in dieses Schema. Stellen Sie sich einen Nutzer vor, der fragt: „Wie ist der Status und das Datum der Zahlung T1001?” Das Modell benötigt zwei Informationen, die in zwei unterschiedlichen Funktionen leben: retrieve_payment_status und retrieve_payment_date. Es könnte sie nacheinander anfordern und auf Ihre Antwort zwischenzeitlich warten. Hier jedoch bestimmt es, dass keiner der beiden Aufrufe vom anderen abhängt, und generiert daher mehrere tool_calls in einer einzigen Antwort. Sie erhalten die gesamte Arbeitslast auf einmal und entscheiden, wie Sie sie ausführen.
Eine Antwort mit mehreren Aufrufen lesen
Die praktische Konsequenz ist einfach: message.tool_calls ist keine Liste mit nur einem Element mehr. Sie müssen darüber iterieren, anstatt tool_calls[0] zu greifen, was eine häufige Reflexion beim Lernen von Funktionsaufrufen anhand von Beispielen mit nur einer Funktion ist.
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
message = response.choices[0].message
# Mehrere tool_calls in derselben Antwort
for tc in message.tool_calls:
print(f"Function: {tc.function.name}")
print(f"Arguments: {tc.function.arguments}")
print(f"ID: {tc.id}")
print("---")
# Mögliche Ausgabe:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456
Beachten Sie, dass beide Aufrufe dasselbe Argument, T1001, verwenden, aber unterschiedliche IDs haben: call_abc123 und call_def456. Diese IDs sind der einzige Weg, auf dem das Modell weiß, welchem Ergebnis welcher Antrag entspricht.
Jedes Ergebnis an seinen ursprünglichen Aufruf zurückgeben
Die Regel ist streng: Sie müssen jede Funktion ausführen und jedes Ergebnis in einem separaten tool-Nachricht zurückgeben, das das entsprechende tool_call_id trägt. Wenn Sie eine ID vergessen oder vertauschen, könnte das Modell das Datum dem Statusfeld zuordnen oder die Antwort verweigern.
message = response.choices[0].message
messages.append(message)
# Alle angeforderten Funktionen ausführen
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Die Funktion ausführen
result = available_functions[function_name](**function_params)
# Das Ergebnis mit der korrekten tool_call_id hinzufügen
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Alle Ergebnisse zurück an das Modell senden
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
print(final_response.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026, and its status is: paid."
Das Modell fügt dann die beiden Fragmente zu einem einzigen Satz zusammen, als käme die Information aus einer einzigen Quelle. Genau diesen Effekt wollen Sie aus Sicht des Nutzers erzielen.
Vom scheinbaren Parallelismus zum echten Parallelismus
Ein Nuance, die oft beim ersten Lesen übersehen wird: Im obigen for-Loop werden die Funktionen nacheinander ausgeführt. Das Modell hat seine Aufrufe parallel angefordert, aber Ihr Code bleibt sequentiell. Solange Ihre Funktionen einen im Speicher befindlichen DataFrame lesen, ist dies irrelevant. Sobald sie jedoch eine externe API oder eine Datenbank abfragen, werden zwei Aufrufe von jeweils 300 ms zu 600 ms wahrgenommener Latenz, und der Vorteil des Parallelismus verschwindet. Wenn Ihre Funktionen asynchron sind, startet asyncio.gather sie gemeinsam und wartet auf den gesamten Batch.
import asyncio
import json
async def execute_tools_parallel(tool_calls, available_functions):
"""Führt tool_calls parallel aus und gibt die Ergebnisse zurück."""
async def execute_one(tool_call):
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Wenn Ihre Funktionen asynchron sind:
result = await available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
# Alle Funktionen parallel ausführen
tasks = [execute_one(tc) for tc in tool_calls]
return await asyncio.gather(*tasks)
Die meisten bestehenden Codebasen stellen synchrone Funktionen bereit, die Sie nicht nur wegen dieses Zwecks als async umschreiben möchten. Ein Thread-Pool erzeugt denselben Effekt, ohne Ihre Geschäftslogik zu berühren.
from concurrent.futures import ThreadPoolExecutor
def execute_tools_threaded(tool_calls, available_functions):
"""Führt tool_calls unter Verwendung eines Thread-Pools aus."""
def execute_one(tool_call):
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
result = available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
with ThreadPoolExecutor(max_workers=5) as executor:
results = list(executor.map(execute_one, tool_calls))
return results
Kontrolle mit parallel_tool_calls wiedererlangen
Parallelität ist nicht immer wünschenswert. Der Parameter parallel_tool_calls ermöglicht es Ihnen, diese zu erlauben oder zu verbieten. Wenn er auf True (der Standardwert) gesetzt ist, entscheidet das Modell, ob es seine Aufrufe gruppiert. Wenn er auf False gesetzt ist, kann es pro Antwort nur einen tool_call erzeugen.
# Parallele Aufrufe erlauben (Standard)
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=True # Modell entscheidet
)
# Sequenzielle Aufrufe erzwingen
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=False # Nur ein tool_call pro Antwort
)
Drei Situationen rechtfertigen die Einstellung auf False. Die erste ist, wenn die Ausführungsreihenfolge wichtig ist: Eine Abrechnung vor der Überprüfung des Bestands ergibt ein anderes Ergebnis als umgekehrt. Die zweite betrifft Datenabhängigkeiten, bei denen das Ergebnis einer Funktion erforderlich ist, um die nächste aufzurufen – zum Beispiel, um einen Kontakt zu finden, um dessen ID zu erhalten, bevor Sie dessen Datensatz ändern. Die dritte bezieht sich einfach auf die Notwendigkeit einer feineren Kontrolle über den Fluss, typischerweise während des Debuggens, wenn Sie jeden Aufruf isoliert beobachten möchten, bevor Sie die Schleusen öffnen.
Was Parallelität wirklich ändert
Der Gewinn besteht nicht nur in Threads; er betrifft primär die Anzahl der Round-Trips zur API, die die Gesamtlatenz dominieren.
# Sequenziell (2 API-Aufrufe an das Modell)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)
# Parallel (nur 1 zusätzlicher API-Aufruf)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)
Im sequentiellen Muster muss das Modell zwei vollständige Denkphasen abschließen, bevor die endgültige Antwort bereitsteht. Im parallelen Muster wird mit einer einzigen Anfrage alle tool_calls abgerufen, und nur eine zusätzliche Anfrage ist für die Antwort erforderlich. Bei einer Frage, die zwei oder drei Funktionen betrifft, spart dies dem Nutzer häufig mehrere Sekunden.
Kernaussagen
- Das Modell kann mehrere tool_calls in einer einzigen Antwort generieren
- Jedes Ergebnis muss mit dem korrekten
tool_call_idzurückgegeben werden - Für Netzwerkfunktionen verwenden Sie
asynciooderThreadPoolExecutorfür eine echte parallele Ausführung - Der Parameter
parallel_tool_callssteuert dieses Verhalten (Truestandardmäßig) - Das parallele Muster reduziert API-Anfragen und verbessert die Latenz