Chiamate parallele e sequenziali
In questa pagina
Chiamate parallele e sequenziali
Il modello può emettere più chiamate di funzioni in un’unica risposta, farlo automaticamente ogni volta che identifica esigenze indipendenti. Non si tratta solo di un’ottimizzazione estetica: tre chiamate da due secondi eseguite insieme richiedono due secondi totali, ma se concatenate sequenzialmente ne richiedono sei.
Il vero focus di questa lezione non è come parallelizzare — il modello se ne occupa — ma come riconoscere i casi in cui non dovresti farlo. Due chiamate sono indipendenti quando l’ordine di esecuzione non influisce sul risultato. Non appena un’operazione legge ciò che un’altra scrive, o un parametro deve provenire da una chiamata precedente, il parallelismo diventa un bug difficile da riprodurre.
Chiamate parallele
Non c’è nulla da abilitare: questo è il comportamento predefinito. Una query su tre città produce tre elementi function_call nella stessa risposta; tu li esegui. Nota che il modello ragiona sul significato delle funzioni basandosi sulle tue descrizioni: le descrizioni guidano la decisione, come in quasi tutto questo corso.
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
Eseguire chiamate parallele lato client
Ricevere tre chiamate contemporaneamente è inutile se il tuo codice le esegue una dopo l’altra: perdi tutto il guadagno lato client. asyncio.gather è il minimo; aggiungi due precauzioni per la produzione: un limite di concorrenza, per non aprire cinquanta connessioni simultanee a un servizio che ne supporta solo dieci, e una gestione degli errori per chiamata, affinché un fallimento isolato non comprometta gli altri risultati.
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)
Disabilitare le chiamate parallele
parallel_tool_calls=False forza il modello a emettere una sola chiamata per risposta. Usa questa impostazione deliberatamente: scambi latenza per sicurezza. Riservalo alle funzioni che scrivono, modificano o attivano qualcosa di esterno.
response = client.responses.create(
model="gpt-5.6-terra",
input="Process these three orders",
tools=tools,
parallel_tool_calls=False # One call per response
)
Casi d’uso per disabilitare il parallelismo:
- Operazioni che devono essere eseguite in un ordine specifico
- Funzioni con effetti collaterali che interferiscono tra loro
- Quando il risultato di una chiamata condiziona la successiva
Chiamate sequenziali con un ciclo
L’esecuzione sequenziale non è controllata da un parametro: emerge dal ciclo. Esegui la chiamata, invii indietro il risultato e il modello decide il passo successivo basandosi su ciò che ha appena appreso. Questo è esattamente ciò che distingue una catena dinamica da un piano rigido: se il passo 2 rivela che il passo 3 è inutile, il modello non lo chiamerà.
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"
Esempio pratico: Pipeline di elaborazione
Un caso tipico in cui l’esecuzione sequenziale è obbligatoria, perché ogni passo consuma ciò che il precedente ha prodotto:
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
)
Pattern ibrido: Parallelo poi sequenziale
Nella pratica, la maggior parte dei flussi di lavoro reali segue questo pattern misto: una fase di raccolta in cui tutto può essere eseguito simultaneamente, seguita da una fase di elaborazione che rispetta le dipendenze. Non devi codificare nulla di speciale per questo: è la conseguenza naturale del ciclo, a patto che le tue descrizioni rendano chiare le dipendenze.
# 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
Questo pattern sembra naturale: il modello parallelizza automaticamente quando le chiamate sono indipendenti, poi le concatena sequenzialmente quando appare una dipendenza.
Punti chiave
- Il modello parallelizza automaticamente le chiamate indipendenti
- Usa
asyncio.gatherper eseguire chiamate parallele lato client - Disabilita con
parallel_tool_calls=Falsequando l’ordine è importante - Implementa un ciclo per flussi di lavoro multi-step
- Le descrizioni delle funzioni guidano il modello sulle dipendenze tra i passi