Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Conversazioni multi-turno in Python

Lezione 7 di 14 Aggiornata il 2 novembre 2026 Sviluppatore
In questa pagina
  1. Una memoria che non è davvero memoria
  2. I tre ruoli che strutturano la cronologia
  3. Una conversazione completa, turno per turno
  4. Evitare che la cronologia diventi proibitivamente costosa
  5. Creare il messaggio di sistema
  6. Punti chiave

Una memoria che non è davvero memoria

A differenza di un motore di ricerca, un modello linguistico segue il filo del discorso: tiene conto di ciò che è stato detto prima e costruisce le sue risposte su quel contesto accumulato. Questa è una conversazione multi-turno, ed è ciò che rende possibili domande ellittiche come «e con gli argomenti?».

Tecnicamente, però, il modello non ricorda nulla. Nessuno stato viene conservato sul server tra una chiamata e l’altra. Con ogni richiesta, devi reinviare l’intera cronologia, che il modello legge dall’inizio alla fine prima di rispondere. Questo meccanismo spiega due aspetti su cui torneremo più avanti: sei interamente responsabile della gestione della memoria e ogni turno della conversazione costa più del precedente.

I tre ruoli che strutturano la cronologia

Ogni messaggio nella cronologia ha un ruolo che indica al modello chi sta parlando. Il ruolo system definisce il comportamento generale: posizionato per primo, influenza tutte le risposte successive.

{"role": "system", "content": "You are an expert assistant in French cuisine. Always respond in French using precise culinary terms."}

Il ruolo user contiene i messaggi dell’utente, ovvero la domanda o l’istruzione inviata:

{"role": "user", "content": "How do I make perfect puff pastry?"}

Infine, il ruolo assistant contiene le risposte precedenti del modello. Questi sono i messaggi che devi reiniettare nella cronologia per mantenere la coerenza. Dimenticarli equivale a cancellare la memoria della conversazione a ogni turno.

{"role": "assistant", "content": "To make perfect puff pastry, start by..."}

Una conversazione completa, turno per turno

Il codice seguente applica questo principio: una funzione che aggiunge la domanda alla cronologia, chiama il modello, quindi archivia la risposta nel punto giusto prima di restituirla.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

historique = [
    {
        "role": "system",
        "content": "You are a teaching assistant specialized in Python programming. Respond concisely and include code examples."
    }
]

def poser_question(question: str) -> str:
    """Sends a question and updates the history."""
    historique.append({"role": "user", "content": question})

    response = client.chat.complete(
        model="mistral-small-latest",
        messages=historique,
    )

    reponse_texte = response.choices[0].message.content
    historique.append({"role": "assistant", "content": reponse_texte})

    return reponse_texte

# Turn 1
print("Q: What is a decorator in Python?")
r1 = poser_question("What is a decorator in Python?")
print(f"R: {r1}\n")

# Turn 2 — the model knows the context
print("Q: Can you show me a concrete example?")
r2 = poser_question("Can you show me a concrete example?")
print(f"R: {r2}\n")

# Turn 3 — implicit reference to previous turns
print("Q: How do I use it with arguments?")
r3 = poser_question("How do I use it with arguments?")
print(f"R: {r3}\n")

Al terzo turno, la domanda non menziona più la parola «decoratore». Il modello capisce comunque che «usarlo» si riferisce a quel concetto perché rilegge l’intero scambio. Rimuovi la riga che aggiunge la risposta alla cronologia ed eseguilo di nuovo: il modello ti chiederà di cosa stai parlando. Questa è la prova più rapida che la continuità non proviene dal modello, ma dal tuo codice.

Evitare che la cronologia diventi proibitivamente costosa

Ogni modello ha una finestra di contesto limitata, misurata in token. Man mano che la cronologia cresce, ogni richiesta diventa più costosa perché tutto viene ritrasmesso. Una conversazione di trenta turni fattura effettivamente il suo inizio trenta volte.

La soluzione più semplice è troncare, mantenendo il messaggio di sistema e gli ultimi N scambi:

MAX_MESSAGES = 20

def ajouter_message(historique, role, content):
    historique.append({"role": role, "content": content})

    # Keep the system message + the last N messages
    if len(historique) > MAX_MESSAGES + 1:  # +1 for the system message
        system_msg = historique[0]
        historique = [system_msg] + historique[-(MAX_MESSAGES):]

    return historique

Questo approccio è economico, ma brutale: ciò che l’utente ha specificato al secondo turno scompare per sempre. Quando la conversazione è lunga e quel contesto più vecchio conta (un’intervista di raccolta requisiti, ad esempio), riassumilo invece di scartarlo:

def resumer_historique(client, historique):
    """Summarizes old messages to free up context."""
    texte_complet = "\n".join(
        f"{m['role']}: {m['content']}"
        for m in historique[1:-4]  # Exclude system and the last 4 messages
    )

    resume = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": f"Summarize this conversation in 3-4 sentences:\n{texte_complet}"}
        ]
    )

    return [
        historique[0],  # System message
        {"role": "assistant", "content": f"[Conversation Summary] {resume.choices[0].message.content}"},
    ] + historique[-4:]  # The last 4 messages

L’idea è comprimere il passato distante in poche frasi mantenendo intatti gli ultimi quattro messaggi, poiché trasportano il contesto immediato. Il riepilogo consuma una chiamata extra, ma si ripaga molte volte nei turni successivi.

Creare il messaggio di sistema

Il messaggio di sistema è lo strumento più potente e sottoutilizzato di questa lezione. Molti si accontentano di un generico «Sei un assistente utile» che non aggiunge nulla. Un buon messaggio di sistema stabilisce vincoli verificabili:

system_prompt = """You are a Corsen AI technical assistant.

Rules:
- Respond in French with a professional tone
- Provide code examples when relevant
- If you are unsure, say so rather than making things up
- Limit your responses to 200 words unless asked otherwise

Context: The user is working on a Python 3.12 project with FastAPI."""

Ogni riga qui produce un effetto misurabile: il limite di lunghezza contiene i costi, l’invito ad ammettere l’incertezza riduce le allucinazioni e menzionare lo stack evita risposte generiche e fuori tema. Conciso, preciso, inequivocabile: è tutto ciò che serve.

Punti chiave

  • L’intera cronologia viene reinviata con ogni richiesta: il modello non «ricorda» nulla
  • Tre ruoli (system, user, assistant) strutturano la conversazione
  • Il messaggio system definisce il comportamento generale: posizionalo sempre per primo
  • Gestisci la dimensione del contesto troncando o riassumendo i messaggi vecchi
  • Più lunga è la cronologia, più ogni richiesta costa in token