Appels parallèles et séquentiels
Op deze pagina
Appels parallèles et séquentiels
Le modèle peut émettre plusieurs appels de fonctions dans une seule réponse, le faisant automatiquement dès qu’il identifie des besoins indépendants. Ce n’est pas qu’une optimisation cosmétique : trois appels de deux secondes exécutés ensemble prennent deux secondes au total, mais chaînés séquentiellement, ils en prennent six.
Le véritable objectif de cette leçon n’est pas de savoir comment paralléliser — le modèle s’en charge — mais comment identifier les cas où vous ne devez pas le faire. Deux appels sont indépendants lorsque l’ordre d’exécution n’affecte pas le résultat. Dès qu’une opération lit ce qu’une autre écrit, ou qu’un paramètre doit provenir d’un appel précédent, le parallélisme devient un bug difficile à reproduire.
Appels parallèles
Rien ne doit être activé : c’est le comportement par défaut. Une requête concernant trois villes produit trois éléments function_call dans la même réponse ; vous les exécutez. Notez que le modèle raisonne sur la signification des fonctions en fonction de vos descriptions — les descriptions pilotent la décision, comme pour presque tout dans ce cours.
from openai import OpenAI
import json
import asyncio
client = OpenAI()
tools = [
{
"type": "function",
"name": "get_meteo",
"description": "Get current weather for a city",
"parameters": {
"type": "object",
"properties": {
"ville": {"type": "string"}
},
"required": ["ville"],
"additionalProperties": False
},
"strict": True
},
{
"type": "function",
"name": "get_taux_change",
"description": "Get exchange rate between two currencies",
"parameters": {
"type": "object",
"properties": {
"source": {"type": "string"},
"cible": {"type": "string"}
},
"required": ["source", "cible"],
"additionalProperties": False
},
"strict": True
}
]
response = client.responses.create(
model="gpt-5.6-terra",
input="What's the weather in Paris and Berlin, "
"and what is the EUR/USD exchange rate?",
tools=tools
)
# The model emits 3 calls in parallel
appels = [item for item in response.output if item.type == "function_call"]
print(f"Nombre d'appels : {len(appels)}")
# => Nombre d'appels : 3
Exécuter des appels parallèles côté client
Recevoir trois appels simultanément est inutile si votre code les exécute l’un après l’autre : vous perdez tout le gain côté client. asyncio.gather est le minimum ; ajoutez deux précautions pour la production : une limite de concurrence, pour ne pas ouvrir cinquante connexions simultanées vers un service qui n’en supporte que dix, et une gestion d’erreur par appel, pour qu’une défaillance isolée n’emporte pas les autres résultats.
async def executer_fonction(name: str, arguments: str) -> dict:
args = json.loads(arguments)
if name == "get_meteo":
return await api_meteo(args["ville"])
elif name == "get_taux_change":
return await api_change(args["source"], args["cible"])
async def traiter_appels_paralleles(appels):
taches = [
executer_fonction(appel.name, appel.arguments)
for appel in appels
]
resultats = await asyncio.gather(*taches)
return [
{
"type": "function_call_output",
"call_id": appel.call_id,
"output": json.dumps(resultat)
}
for appel, resultat in zip(appels, resultats)
]
# Execute
resultats = asyncio.run(traiter_appels_paralleles(appels))
# Send back to the model
response_finale = client.responses.create(
model="gpt-5.6-terra",
input=response.output + resultats,
tools=tools
)
print(response_finale.output_text)
Désactiver les appels parallèles
parallel_tool_calls=False force le modèle à n’émettre qu’un seul appel par réponse. Utilisez ce paramètre délibérément : il échange la latence contre la sécurité. Réservez-le aux fonctions qui écrivent, modifient ou déclenchent quelque chose d’externe.
response = client.responses.create(
model="gpt-5.6-terra",
input="Process these three orders",
tools=tools,
parallel_tool_calls=False # One call per response
)
Cas d’usage pour désactiver le parallélisme :
- Opérations devant s’exécuter dans un ordre spécifique
- Fonctions ayant des effets de bord qui interfèrent entre elles
- Lorsque le résultat d’un appel conditionne le suivant
Appels séquentiels avec une boucle
L’exécution séquentielle n’est pas contrôlée par un paramètre : elle émerge de la boucle. Vous exécutez l’appel, renvoyez le résultat, et le modèle décide de l’étape suivante en fonction de ce qu’il vient d’apprendre. C’est précisément ce qui distingue une chaîne dynamique d’un plan rigide : si l’étape 2 révèle que l’étape 3 est inutile, le modèle ne l’appellera pas.
def boucle_function_calling(prompt: str, tools: list, max_tours: int = 10):
"""Complete loop for sequential function calling."""
messages_input = prompt
tour = 0
while tour < max_tours:
response = client.responses.create(
model="gpt-5.6-terra",
input=messages_input,
tools=tools,
parallel_tool_calls=False
)
# Check for function calls
appels = [i for i in response.output if i.type == "function_call"]
if not appels:
# Model is done, responding with text
return response.output_text
# Execute each call
resultats = []
for appel in appels:
resultat = executer_fonction_sync(appel.name, appel.arguments)
resultats.append({
"type": "function_call_output",
"call_id": appel.call_id,
"output": json.dumps(resultat)
})
# Prepare next turn
messages_input = response.output + resultats
tour += 1
return "Turn limit reached"
Exemple concret : pipeline de traitement
Un cas typique où l’exécution séquentielle est obligatoire, car chaque étape consomme ce que la précédente a produit :
tools_pipeline = [
{
"type": "function",
"name": "valider_commande",
"description": "Verify order validity (stock, price, customer)",
"parameters": {
"type": "object",
"properties": {
"commande_id": {"type": "string"}
},
"required": ["commande_id"],
"additionalProperties": False
},
"strict": True
},
{
"type": "function",
"name": "calculer_livraison",
"description": "Calculate shipping fees and delays. "
"Requires a validated order.",
"parameters": {
"type": "object",
"properties": {
"commande_id": {"type": "string"},
"mode": {"type": "string", "enum": ["standard", "express"]}
},
"required": ["commande_id", "mode"],
"additionalProperties": False
},
"strict": True
},
{
"type": "function",
"name": "confirmer_commande",
"description": "Confirm the order and trigger payment. "
"Requires prior validation and shipping calculation.",
"parameters": {
"type": "object",
"properties": {
"commande_id": {"type": "string"},
"livraison_id": {"type": "string"}
},
"required": ["commande_id", "livraison_id"],
"additionalProperties": False
},
"strict": True
}
]
# The model will naturally call in this order:
# 1. valider_commande
# 2. calculer_livraison (using step 1 result)
# 3. confirmer_commande (using results from steps 1 and 2)
resultat = boucle_function_calling(
"Process order CMD-42567 with express shipping",
tools_pipeline
)
Modèle hybride : parallèle puis séquentiel
En pratique, la plupart des flux de travail réels suivent ce modèle mixte : une phase de collecte où tout peut s’exécuter simultanément, suivie d’une phase de traitement qui respecte les dépendances. Vous n’avez besoin de coder rien de spécial pour cela : c’est la conséquence naturelle de la boucle, à condition que vos descriptions rendent les dépendances claires.
# Turn 1: Parallel data collection
# The model calls get_client AND get_stock in parallel
# Turn 2: Sequential decision based on results
# The model calls valider_commande with collected info
# Turn 3: Final action
# The model calls confirmer_commande
Ce modèle semble naturel : le modèle parallélise automatiquement lorsque les appels sont indépendants, puis enchaîne séquentiellement lorsqu’une dépendance apparaît.
Belangrijkste punten
- Le modèle parallélise automatiquement les appels indépendants
- Utilisez
asyncio.gatherpour exécuter des appels parallèles côté client - Désactivez avec
parallel_tool_calls=Falselorsque l’ordre importe - Implémentez une boucle pour les flux de travail en plusieurs étapes
- Les descriptions de fonctions guident le modèle sur les dépendances entre les étapes