Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Chiamate di funzione parallele

Lezione 8 di 14 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Quando il modello ha bisogno di più informazioni contemporaneamente
  2. Leggere una risposta con più chiamate
  3. Restituire ogni risultato alla sua chiamata originale
  4. Passare dalla parallelizzazione apparente a quella reale
  5. Riprendere il controllo con parallel_tool_calls
  6. Cosa cambia realmente con il parallelismo
  7. 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_calls in un’unica risposta
  • Ogni risultato deve essere restituito con il tool_call_id corretto
  • Per le funzioni di rete, usa asyncio o ThreadPoolExecutor per una vera esecuzione parallela
  • Il parametro parallel_tool_calls controlla questo comportamento (True per impostazione predefinita)
  • Il pattern parallelo riduce le richieste API e migliora la latenza