Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Conversations multi-tours en Python

Lekcija 7 od 14 Ažurirano 2. studenoga 2026. Programer
Na ovoj stranici
  1. Une mémoire qui n’en est pas vraiment une
  2. Les trois rôles qui structurent l’historique
  3. Une conversation complète, tour par tour
  4. Empêcher l’historique de devenir prohibitif
  5. Concevoir le message système
  6. Ključne točke

Une mémoire qui n’en est pas vraiment une

Contrairement à un moteur de recherche, un modèle de langage suit le fil d’une conversation : il prend en compte ce qui a été dit précédemment et construit ses réponses sur ce contexte accumulé. On appelle cela une conversation multi-tours, et c’est ce qui rend possibles les questions elliptiques comme « et avec des arguments ? ».

Techniquement, cependant, le modèle ne se souvient de rien. Aucun état n’est conservé sur le serveur entre les appels. À chaque requête, tu dois renvoyer l’historique complet, que le modèle lit du début à la fin avant de répondre. Ce mécanisme explique deux aspects que nous reverrons plus tard : tu es entièrement responsable de la gestion de la mémoire, et chaque tour de conversation coûte plus cher que le précédent.

Les trois rôles qui structurent l’historique

Chaque message de l’historique possède un rôle indiquant au modèle qui parle. Le rôle system définit le comportement global : placé en premier, il influence toutes les réponses suivantes.

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

Le rôle user contient les messages de l’utilisateur, c’est-à-dire la question ou l’instruction envoyée :

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

Enfin, le rôle assistant contient les réponses précédentes du modèle. Ce sont les messages que tu réinjectes dans l’historique pour maintenir la cohérence. Les oublier revient à effacer la mémoire de la conversation à chaque tour.

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

Une conversation complète, tour par tour

Le code ci-dessous applique ce principe : une fonction qui ajoute la question à l’historique, appelle le modèle, puis stocke la réponse au bon endroit avant de la retourner.

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:
    """Envoie une question et met à jour l'historique."""
    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

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

# Tour 2 — le modèle connaît le contexte
print("Q: Can you show me a concrete example?")
r2 = poser_question("Can you show me a concrete example?")
print(f"R: {r2}\n")

# Tour 3 — référence implicite aux tours précédents
print("Q: How do I use it with arguments?")
r3 = poser_question("How do I use it with arguments?")
print(f"R: {r3}\n")

Au troisième tour, la question ne mentionne plus jamais le mot « décorateur ». Le modèle comprend pourtant que « l’utiliser » fait référence à ce concept, car il relit l’intégralité de l’échange. Supprime la ligne qui ajoute la réponse à l’historique et relance le code : le modèle te demandera de quoi tu parles. C’est la preuve la plus rapide que la continuité ne vient pas du modèle, mais de ton code.

Empêcher l’historique de devenir prohibitif

Chaque modèle dispose d’une fenêtre de contexte limitée, mesurée en tokens. À mesure que l’historique grandit, chaque requête devient plus coûteuse car tout est retransmis. Une conversation de trente tours facture effectivement son début trente fois.

La solution la plus simple consiste à tronquer, en conservant le message système et les N derniers échanges :

MAX_MESSAGES = 20

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

    # Conserver le message système + les N derniers messages
    if len(historique) > MAX_MESSAGES + 1:  # +1 pour le message système
        system_msg = historique[0]
        historique = [system_msg] + historique[-(MAX_MESSAGES):]

    return historique

Cette approche est économique, mais brutale : ce que l’utilisateur a spécifié au deuxième tour disparaît à jamais. Lorsque la conversation est longue et que ce contexte ancien importe — lors d’un entretien de recueil des besoins, par exemple — résume-le plutôt que de le jeter :

def resumer_historique(client, historique):
    """Résume les anciens messages pour libérer du contexte."""
    texte_complet = "\n".join(
        f"{m['role']}: {m['content']}"
        for m in historique[1:-4]  # Exclure le système et les 4 derniers 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],  # Message système
        {"role": "assistant", "content": f"[Conversation Summary] {resume.choices[0].message.content}"},
    ] + historique[-4:]  # Les 4 derniers messages

L’idée est de compresser le passé lointain en quelques phrases tout en gardant intacts les quatre derniers messages, car ils portent le contexte immédiat. Le résumé consomme un appel supplémentaire, mais il est largement rentabilisé lors des tours suivants.

Concevoir le message système

Le message système est l’outil le plus puissant et le plus sous-utilisé de cette leçon. Beaucoup se contentent d’un générique « Tu es un assistant utile » qui n’apporte rien. Un bon message système énonce des contraintes vérifiables :

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."""

Chaque ligne produit ici un effet mesurable : la limite de longueur contient les coûts, l’invitation à reconnaître l’incertitude réduit les hallucinations, et la mention de la pile technique évite les réponses génériques hors sujet. Concis, précis, sans ambiguïté : c’est tout ce qu’il doit être.

Ključne točke

  • L’historique complet est renvoyé à chaque requête : le modèle ne « se souvient » de rien
  • Trois rôles (system, user, assistant) structurent la conversation
  • Le message system définit le comportement global : place-le toujours en premier
  • Gère la taille du contexte en tronquant ou en résumant les anciens messages
  • Plus l’historique est long, plus chaque requête coûte cher en tokens