Chiamate di funzione parallele
In questa pagina
- Quando il modello ha bisogno di più informazioni contemporaneamente
- Leggere una risposta con più chiamate
- Restituire ogni risultato alla sua chiamata originale
- Passare dalla parallelizzazione apparente a quella reale
- Riprendere il controllo con parallel_tool_calls
- Cosa cambia realmente con il parallelismo
- Punti chiave
Quando il modello ha bisogno di più informazioni contemporaneamente
Finora, ogni turno della conversazione ha generato una singola chiamata di funzione. Molte domande del mondo reale non rientrano in questo schema. Considera un utente che chiede: «Qual è lo stato e la data del pagamento T1001?». Il modello ha bisogno di due informazioni che risiedono in due funzioni distinte: retrieve_payment_status e retrieve_payment_date. Potrebbe richiederle una dopo l’altra, attendendo la tua risposta tra l’una e l’altra. Tuttavia, in questo caso determina che nessuna dipende dall’altra, quindi genera più tool_calls in un’unica risposta. Ricevi l’intero carico di lavoro tutto insieme e decidi tu come eseguirlo.
Leggere una risposta con più chiamate
L’implicazione pratica è semplice: message.tool_calls non è più una lista con un singolo elemento. Devi iterarci sopra invece di prendere semplicemente tool_calls[0], un riflesso comune quando si impara il function calling partendo da esempi a funzione singola.
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
message = response.choices[0].message
# Più tool_calls nella stessa risposta
for tc in message.tool_calls:
print(f"Function: {tc.function.name}")
print(f"Arguments: {tc.function.arguments}")
print(f"ID: {tc.id}")
print("---")
# Possibile output:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456
Nota che entrambe le chiamate usano lo stesso argomento, T1001, ma hanno ID diversi: call_abc123 e call_def456. Questi ID sono l’unico modo in cui il modello sa quale risultato corrisponde a quale richiesta.
Restituire ogni risultato alla sua chiamata originale
La regola è severa: devi eseguire ogni funzione e restituire ogni risultato in un messaggio tool separato, contenente il corrispondente tool_call_id. Se dimentichi o scambi un ID, il modello potrebbe attribuire la data al campo dello stato, oppure rifiutarsi di rispondere.
message = response.choices[0].message
messages.append(message)
# Esegui tutte le funzioni richieste
for tool_call in message.tool_calls:
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Esegui la funzione
result = available_functions[function_name](**function_params)
# Aggiungi il risultato con il tool_call_id corretto
messages.append({
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
})
# Invia tutti i risultati al modello
final_response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools
)
print(final_response.choices[0].message.content)
# → "Il pagamento T1001 è stato effettuato il 15 marzo 2026 e il suo stato è: pagato."
Il modello ricuce quindi i due frammenti in un’unica frase, come se le informazioni provenissero da un’unica fonte. Questo è esattamente l’effetto che desideri dal punto di vista dell’utente.
Passare dalla parallelizzazione apparente a quella reale
Una sfumatura spesso sfugge alla prima lettura: nel ciclo for sopra, le funzioni vengono eseguite una dopo l’altra. Il modello ha richiesto le sue chiamate in parallelo, ma il tuo codice rimane sequenziale. Finché le tue funzioni leggono un DataFrame in memoria, questo non importa. Tuttavia, una volta che interrogano un’API esterna o un database, due chiamate da 300 ms diventano 600 ms di latenza percepita e il beneficio del parallelismo svanisce. Se le tue funzioni sono asincrone, asyncio.gather le avvia insieme e attende l’intero batch.
import asyncio
import json
async def execute_tools_parallel(tool_calls, available_functions):
"""Esegue tool_calls in parallelo e restituisce i risultati."""
async def execute_one(tool_call):
function_name = tool_call.function.name
function_params = json.loads(tool_call.function.arguments)
# Se le tue funzioni sono async:
result = await available_functions[function_name](**function_params)
return {
"role": "tool",
"name": function_name,
"content": result,
"tool_call_id": tool_call.id
}
# Esegui tutte le funzioni in parallelo
tasks = [execute_one(tc) for tc in tool_calls]
return await asyncio.gather(*tasks)
La maggior parte dei codebase esistenti espone funzioni sincrone che non vorrai riscrivere come async solo per questo. Un pool di thread produce lo stesso effetto senza toccare la tua logica di business.
from concurrent.futures import ThreadPoolExecutor
def execute_tools_threaded(tool_calls, available_functions):
"""Esegue tool_calls utilizzando un pool di thread."""
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
Riprendere il controllo con parallel_tool_calls
Il parallelismo non è sempre desiderabile. Il parametro parallel_tool_calls ti permette di consentirlo o vietarlo. Quando è impostato su True (il valore predefinito), il modello decide se raggruppare le sue chiamate. Quando è impostato su False, può produrre solo un tool_call per risposta.
# Consenti chiamate parallele (predefinito)
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=True # Il modello decide
)
# Forza chiamate sequenziali
response = client.chat.complete(
model="mistral-large-latest",
messages=messages,
tools=tools,
parallel_tool_calls=False # Solo un tool_call per risposta
)
Tre situazioni giustificano l’impostazione di questo parametro su False. La prima è quando l’ordine di esecuzione conta: fatturare prima di controllare lo stock produce un risultato diverso rispetto all’inverso. La seconda riguarda le dipendenze dei dati, dove il risultato di una funzione è necessario per chiamare la successiva, ad esempio trovare un contatto per ottenere il suo ID prima di modificarne il record. La terza riguarda semplicemente la necessità di un controllo più fine sul flusso, tipicamente durante il debug, quando vuoi osservare ogni chiamata in isolamento prima di aprire le chiuse.
Cosa cambia realmente con il parallelismo
Il guadagno non riguarda solo i thread; concerne principalmente il numero di andata e ritorno (round trips) verso l’API, che dominano la latenza totale.
# Sequenziale (2 chiamate API al modello)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)
# Parallelo (solo 1 chiamata API aggiuntiva)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)
Nel pattern sequenziale, il modello deve completare due turni di ragionamento completi prima della risposta finale. Nel pattern parallelo, una singola richiesta recupera tutti i tool_calls ed è necessaria solo un’ulteriore richiesta per la risposta. Per una domanda che coinvolge due o tre funzioni, questo fa risparmiare comunemente all’utente diversi secondi.
Punti chiave
- Il modello può generare più
tool_callsin un’unica risposta - Ogni risultato deve essere restituito con il
tool_call_idcorretto - Per le funzioni di rete, usa
asynciooThreadPoolExecutorper una vera esecuzione parallela - Il parametro
parallel_tool_callscontrolla questo comportamento (Trueper impostazione predefinita) - Il pattern parallelo riduce le richieste API e migliora la latenza