Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Conversazione multi-turno

Lezione 7 di 14 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Oltre le chiamate singole
  2. Il principio: mantenere la cronologia
  3. Ciclo completo della conversazione
  4. Esempio di conversazione multi-turno
  5. Concatenazione di chiamate sequenziali
  6. Gestione della dimensione della cronologia
  7. Punti chiave

Oltre le chiamate singole

In un’applicazione reale, gli utenti non fanno una sola domanda per poi sparire. Concatenano le richieste, tornano su argomenti precedenti e lanciano allusioni come «e questo?» che la frase da sola non può risolvere. La chiamata di funzioni deve operare in questo contesto di conversazione multi-turno, dove il modello può invocare funzioni a ogni passo del dialogo senza mai perdere il filo di ciò che è stato detto prima.

Il principio: mantenere la cronologia

Tutto si riduce a una frase: conserva tutti i messaggi in una lista che cresce a ogni scambio. Il modello non ha memoria propria tra una chiamata API e l’altra; l’unico contesto di cui dispone è ciò che gli invii. È questa cronologia completa che gli permette di comprendere i riferimenti impliciti.

import os
import json
from mistralai.client import Mistral
from functools import partial

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Cronologia della conversazione
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Ciclo completo della conversazione

Il codice sottostante funziona in due fasi. process_tool_calls esegue tutte le chiamate richieste dal modello e riavvia la conversazione con i risultati; chat gestisce un turno completo, dall’input dell’utente al testo finale.

def process_tool_calls(response, messages, available_functions, tools):
    """Elabora le tool_calls e restituisce la risposta finale."""
    message = response.choices[0].message
    messages.append(message)

    # Esegui ogni tool_call
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)

        if function_name in available_functions:
            result = available_functions[function_name](**function_params)
        else:
            result = json.dumps({"error": f"Unknown function {function_name}"})

        messages.append({
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        })

    # Richiama il modello con i risultati
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Gestisce un turno completo di conversazione."""
    messages.append({"role": "user", "content": user_input})

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message

    # Ripeti finché il modello vuole chiamare funzioni
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # Il modello ha finito: risponde con del testo
    messages.append(message)
    return message.content

Il ciclo while è l’elemento cruciale. Dopo aver ricevuto il risultato di una funzione, il modello potrebbe ben chiederne un’altra: il ciclo prosegue finché produce tool_calls e si interrompe solo quando restituisce finalmente del testo. Un semplice if gestirebbe la prima chiamata per poi restituire una risposta vuota in tutti i casi in cui fossero necessarie due chiamate.

Esempio di conversazione multi-turno

Vediamo come si comporta questo ciclo attraverso quattro turni concatenati.

# Turno 1
reponse = chat("What is the status of payment T1001?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."

# Turno 2 — domanda di follow-up
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Turno 3 — nuova transazione
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Turno 4 — domanda senza funzione
reponse = chat("Thanks, that's all for today.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."

Il Turno 2 è quello da esaminare con attenzione. «When was it made?» non contiene alcun identificativo; è la cronologia che permette al modello di capire che si riferisce ancora a T1001 e di chiamare retrieve_payment_date con l’argomento corretto. Rimuovi i messaggi del Turno 1 e questa frase diventa irrisolvibile. Nel Turno 3, il modello può decidere di chiamare più funzioni—stato e data per T1003—per costruire il confronto con i risultati già ottenuti per T1001. Il Turno 4 non attiva alcuna chiamata: il modello sa anche quando astenersi.

Concatenazione di chiamate sequenziali

Alcune richieste obbligano il modello ad attendere un risultato prima di sapere cosa chiedere successivamente. Il ciclo while in chat() gestisce questo caso senza aggiungere una sola riga di codice.

# L'utente chiede qualcosa che richiede 2 chiamate sequenziali
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# Il modello può:
# 1. Chiamare retrieve_payment_status(T1002)
# 2. Ricevere il risultato
# 3. Chiamare retrieve_payment_date(T1002)
# 4. Ricevere il risultato
# 5. Formulare la risposta finale con entrambe le informazioni

Vista dalla prospettiva della cronologia dei messaggi, il flusso sequenziale appare così:

user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)

Conta i turni dell’assistente: tre, ovvero tre richieste fatturate all’API. Questo è il costo dell’esecuzione sequenziale, ed è il motivo per cui la prossima lezione si concentrerà sulle chiamate parallele.

Gestione della dimensione della cronologia

In produzione, una conversazione di lunga durata diventa costosa: ogni turno rinvia l’intero set di messaggi precedenti e il conteggio dei token cresce quadraticamente. Una strategia semplice consiste nel mantenere solo il messaggio di sistema e gli scambi più recenti.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Mantiene il messaggio di sistema e gli ultimi N messaggi."""
    system_messages = [m for m in messages if hasattr(m, "role")
                       and m.get("role") == "system"
                       or (isinstance(m, dict) and m.get("role") == "system")]

    non_system = [m for m in messages if m not in system_messages]

    if len(non_system) > max_messages:
        non_system = non_system[-max_messages:]

    return system_messages + non_system

Una precauzione prima di integrare questa funzione: non tagliare mai una tool_call senza il suo corrispondente messaggio tool. Se il troncamento cade tra i due, l’API riceve una richiesta di chiamata senza risposta e rifiuta la query. Regola il punto di taglio per preservare le coppie complete invece di contare ciecamente i messaggi.

Punti chiave

  • Mantieni una cronologia completa dei messaggi affinché il modello comprenda il contesto
  • Usa un ciclo while per gestire le chiamate di funzioni sequenziali
  • Il modello comprende i riferimenti impliciti («quello», «il precedente») grazie al contesto
  • In produzione, limita la dimensione della cronologia mantenendo intatte le coppie tool_call/tool
  • La funzione chat() mostrata qui è uno schema riutilizzabile per qualsiasi applicazione di chiamata di funzioni