Appels de fonctions parallèles
På denna sida
- Quand le modèle a besoin de plusieurs informations simultanément
- Lire une réponse contenant plusieurs appels
- Renvoyer chaque résultat à son appel d’origine
- Passer du parallélisme apparent au parallélisme réel
- Reprendre le contrôle avec parallel_tool_calls
- Ce que le parallélisme change vraiment
- Viktiga punkter
Quand le modèle a besoin de plusieurs informations simultanément
Jusqu’à présent, chaque tour de conversation a généré un seul appel de fonction. De nombreuses questions réelles ne rentrent pas dans ce cadre. Imagine un utilisateur qui demande : « Quel est le statut et la date du paiement T1001 ? ». Le modèle a besoin de deux informations stockées dans deux fonctions distinctes : retrieve_payment_status et retrieve_payment_date. Il pourrait les demander l’une après l’autre, en attendant ta réponse entre les deux. Cependant, il détermine ici qu’aucune ne dépend de l’autre, il génère donc plusieurs tool_calls dans une seule réponse. Tu reçois toute la charge de travail d’un coup, et c’est à toi de décider comment l’exécuter.
Lire une réponse contenant plusieurs appels
L’implication pratique est simple : message.tool_calls n’est plus une liste à élément unique. Tu dois itérer dessus plutôt que de récupérer tool_calls[0], un réflexe courant lorsqu’on apprend l’appel de fonctions avec des exemples à fonction unique.
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
message = response.choices[0].message
# Plusieurs tool_calls dans la même réponse
for tc in message.tool_calls:
print(f"Function: {tc.function.name}")
print(f"Arguments: {tc.function.arguments}")
print(f"ID: {tc.id}")
print("---")
# Sortie possible :
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456
Note que les deux appels utilisent le même argument, T1001, mais ont des ID différents : call_abc123 et call_def456. Ces ID sont le seul moyen pour le modèle de savoir quel résultat correspond à quelle demande.
Renvoyer chaque résultat à son appel d’origine
La règle est stricte : tu dois exécuter chaque fonction et renvoyer chaque résultat dans un message tool séparé portant le tool_call_id correspondant. Si tu oublies ou inverses un ID, le modèle pourrait attribuer la date au champ du statut, ou refuser de répondre.
message = response.choices[0].message
messages.append(message)
# Exécuter toutes les fonctions demandées
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Exécuter la fonction
result = available_functions[function_name](**function_params)
# Ajouter le résultat avec le bon tool_call_id
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Renvoyer tous les résultats au modèle
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
print(final_response.choices[0].message.content)
# → "Le paiement T1001 a été effectué le 15 mars 2026 et son statut est : payé."
Le modèle assemble ensuite les deux fragments en une seule phrase, comme si l’information provenait d’une source unique. C’est exactement l’effet recherché du point de vue de l’utilisateur.
Passer du parallélisme apparent au parallélisme réel
Une nuance échappe souvent aux lecteurs lors d’une première lecture : dans la boucle for ci-dessus, les fonctions s’exécutent les unes après les autres. Le modèle a demandé ses appels en parallèle, mais ton code reste séquentiel. Tant que tes fonctions lisent un DataFrame en mémoire, cela n’a pas d’importance. En revanche, dès qu’elles interrogent une API externe ou une base de données, deux appels de 300 ms deviennent 600 ms de latence perçue, et le bénéfice du parallélisme s’évapore. Si tes fonctions sont asynchrones, asyncio.gather les lance ensemble et attend que tout le lot soit terminé.
import asyncio
import json
async def execute_tools_parallel(tool_calls, available_functions):
"""Exécute les tool_calls en parallèle et renvoie les résultats."""
async def execute_one(tool_call):
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Si tes fonctions sont async :
result = await available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
# Exécuter toutes les fonctions en parallèle
tasks = [execute_one(tc) for tc in tool_calls]
return await asyncio.gather(*tasks)
La plupart des bases de code existantes exposent des fonctions synchrones que tu ne voudras pas réécrire en async juste pour cela. Un pool de threads produit le même effet sans toucher à ta logique métier.
from concurrent.futures import ThreadPoolExecutor
def execute_tools_threaded(tool_calls, available_functions):
"""Exécute les tool_calls en utilisant un pool de threads."""
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
Reprendre le contrôle avec parallel_tool_calls
Le parallélisme n’est pas toujours souhaitable. Le paramètre parallel_tool_calls te permet de l’autoriser ou de l’interdire. Lorsqu’il est défini sur True (la valeur par défaut), le modèle décide s’il regroupe ses appels. Lorsqu’il est défini sur False, il ne peut produire qu’un seul tool_call par réponse.
# Autoriser les appels parallèles (par défaut)
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=True # Le modèle décide
)
# Forcer les appels séquentiels
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=False # Un seul tool_call par réponse
)
Trois situations justifient de régler ce paramètre sur False. La première concerne les cas où l’ordre d’exécution importe : facturer avant de vérifier le stock donne un résultat différent de l’inverse. La seconde implique des dépendances de données, où le résultat d’une fonction est requis pour appeler la suivante – par exemple, trouver un contact pour obtenir son ID avant de modifier son enregistrement. La troisième relève simplement du besoin d’un contrôle plus fin sur le flux, typiquement lors du débogage, quand tu souhaites observer chaque appel isolément avant d’ouvrir les vannes.
Ce que le parallélisme change vraiment
Le gain ne réside pas seulement dans les threads ; il concerne principalement le nombre d’allers-retours vers l’API, qui dominent la latence totale.
# Séquentiel (2 appels API au modèle)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)
# Parallèle (1 seul appel API supplémentaire)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)
Dans le schéma séquentiel, le modèle doit effectuer deux tours de raisonnement complets avant la réponse finale. Dans le schéma parallèle, une seule requête récupère tous les tool_calls, et une seule requête supplémentaire est nécessaire pour la réponse. Pour une question impliquant deux ou trois fonctions, cela fait souvent gagner plusieurs secondes à l’utilisateur.
Viktiga punkter
- Le modèle peut générer plusieurs
tool_callsdans une seule réponse - Chaque résultat doit être renvoyé avec le
tool_call_idcorrect - Pour les fonctions réseau, utilise
asyncioouThreadPoolExecutorpour une exécution réellement parallèle - Le paramètre
parallel_tool_callscontrôle ce comportement (Truepar défaut) - Le motif parallèle réduit les requêtes API et améliore la latence