Parallelle funktionskald
På denne side
Når modellen har brug for flere oplysninger på én gang
Indtil videre har hver omgang i samtalen resulteret i et enkelt funktionskald. Mange spørgsmål fra den virkelige verden passer ikke ind i den skabelon. Forestil dig en bruger, der spørger: “Hvad er status og dato for betaling T1001?” Modellen har brug for to oplysninger, der findes i to forskellige funktioner: retrieve_payment_status og retrieve_payment_date. Den kunne anmode om dem én efter én og vente på dit svar imellem. Men her vurderer den, at ingen af dem afhænger af den anden, så den genererer flere tool_calls i ét enkelt svar. Du modtager hele arbejdsmængden på én gang, og du beslutter, hvordan den skal udføres.
Læsning af et svar med flere kald
Den praktiske konsekvens er enkel: message.tool_calls er ikke længere en liste med ét element. Du skal iterere over den i stedet for blot at gribe tool_calls[0], hvilket er en almindelig refleks, når man lærer funktionskald ud fra eksempler med én enkelt funktion.
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
message = response.choices[0].message
# Flere tool_calls i samme svar
for tc in message.tool_calls:
print(f"Funktion: {tc.function.name}")
print(f"Argumenter: {tc.function.arguments}")
print(f"ID: {tc.id}")
print("---")
# Muligt output:
# Funktion: retrieve_payment_status
# Argumenter: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Funktion: retrieve_payment_date
# Argumenter: {"transaction_id": "T1001"}
# ID: call_def456
Bemærk, at begge kald bruger samme argument, T1001, men har forskellige ID’er: call_abc123 og call_def456. Disse ID’er er den eneste måde, modellen ved, hvilket resultat der svarer til hvilken anmodning.
Returnering af hvert resultat til det oprindelige kald
Reglen er streng: Du skal udføre alle funktioner og returnere alle resultater i en separat tool-besked, der bærer det tilsvarende tool_call_id. Hvis du glemmer eller bytter om på et ID, kan modellen tilskrive datoen til statusfeltet, eller den kan nægte at svare.
message = response.choices[0].message
messages.append(message)
# Udfør alle anmodede funktioner
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Udfør funktionen
result = available_functions[function_name](**function_params)
# Tilføj resultatet med det korrekte tool_call_id
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Send alle resultater tilbage til modellen
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
print(final_response.choices[0].message.content)
# → "Betaling T1001 blev foretaget den 15. marts 2026, og dens status er: betalt."
Modellen syder derefter de to fragmenter sammen til én sætning, som om oplysningerne kom fra én kilde. Det er præcis den effekt, du ønsker set fra brugerens perspektiv.
Fra tilsyneladende parallelisme til rigtig parallelisme
En nuance undgår ofte læsere ved første øjekast: I for-løkken ovenfor udføres funktionerne én efter én. Modellen anmodede om sine kald parallelt, men din kode forbliver sekventiel. Så længe dine funktioner læser en DataFrame i hukommelsen, betyder det ikke noget. Men når de først spørger en ekstern API eller database, bliver to kald på 300 ms til 600 ms oplevet ventetid, og fordelen ved parallelisme forsvinder. Hvis dine funktioner er asynkrone, starter asyncio.gather dem sammen og venter på hele batchet.
import asyncio
import json
async def execute_tools_parallel(tool_calls, available_functions):
"""Udfører tool_calls parallelt og returnerer resultaterne."""
async def execute_one(tool_call):
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Hvis dine funktioner er async:
result = await available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
# Udfør alle funktioner parallelt
tasks = [execute_one(tc) for tc in tool_calls]
return await asyncio.gather(*tasks)
De fleste eksisterende kodebaser eksponerer synkrone funktioner, som du ikke har lyst til at omskrive til async blot for dette. En thread-pool giver samme effekt uden at røre din forretningslogik.
from concurrent.futures import ThreadPoolExecutor
def execute_tools_threaded(tool_calls, available_functions):
"""Udfører tool_calls ved hjælp af en thread-pool."""
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
Genvind kontrol med parallel_tool_calls
Parallelisme er ikke altid ønskværdig. Parameteren parallel_tool_calls lader dig tillade eller forbyde den. Når den sættes til True (standard), beslutter modellen, om den skal gruppere sine kald. Når den sættes til False, kan den kun producere ét tool_call per svar.
# Tillad parallelle kald (standard)
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=True # Modellen beslutter
)
# Tving sekventielle kald
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=False # Kun ét tool_call per svar
)
Tre situationer berettiger til at sætte denne til False. Den første er, når udførelsesrækkefølgen betyder noget: fakturering før lagerkontrol giver et andet resultat end omvendt. Den anden involverer dataafhængigheder, hvor resultatet af én funktion er nødvendig for at kalde den næste – for eksempel at finde en kontakt for at få deres ID, før du modificerer deres post. Den tredje handler simpelthen om behovet for finere kontrol over flowet, typisk under fejlfinding, når du vil observere hvert kald isoleret, før du åbner sluserne.
Hvad parallelisme reelt ændrer
Gevinsten handler ikke kun om threads; den vedrører primært antallet af ture frem og tilbage til API’en, hvilket dominerer den samlede ventetid.
# Sekventiel (2 API-kald til modellen)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)
# Parallel (kun 1 ekstra API-kald)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)
I det sekventielle mønster skal modellen gennemføre to fulde ræsonnementsomgange før det endelige svar. I det parallelle mønster henter en enkelt anmodning alle tool_calls, og kun én ekstra anmodning er nødvendig for svaret. For et spørgsmål, der involverer to eller tre funktioner, sparer dette ofte brugeren for flere sekunder.
Vigtige pointer
- Modellen kan generere flere
tool_callsi ét enkelt svar - Hvert resultat skal returneres med det korrekte
tool_call_id - Til netværksfunktioner skal du bruge
asyncioellerThreadPoolExecutorfor rigtig parallel udførelse - Parameteren
parallel_tool_callsstyrer denne adfærd (Truesom standard) - Det parallelle mønster reducerer API-anmodninger og forbedrer ventetiden