Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Conversations persistantes

Lektion 5 av 18 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Un état qui persiste au fil des échanges
  2. Démarrer une conversation
  3. Poursuivre une conversation
  4. Le mécanisme d’immuabilité
  5. Lire l’historique d’une conversation
  6. Gérer le stockage
  7. Modèle de conversation multi-tours
  8. Viktiga punkter

Leçon mise à jour le 3 novembre 2026 sur la base du SDK mistralai 3.7.0 : récupère l’historique d’une conversation (ses entries) via client.beta.conversations.get_history ; retrieve n’existe pas et get ne renvoie que les métadonnées de la conversation. Source : client-python.

Un état qui persiste au fil des échanges

L’un des principaux avantages de l’API Agents par rapport aux Chat Completions est la persistance des conversations. Tu n’as plus besoin de gérer manuellement l’historique des messages : Mistral s’en charge côté serveur. Concrètement, la liste de dictionnaires que tu devais accumuler dans une variable, tronquer en cas de débordement de contexte et reconstruire à chaque redémarrage de processus disparaît de ton code. Une seule chose reste à suivre : un identifiant. Et cet identifiant obéit à une règle qui piège tout le monde lors du premier projet.

Démarrer une conversation

La méthode conversations.start() crée une nouvelle conversation et envoie le premier message. L’exemple suivant crée également l’agent qui l’exécutera, puis lui fournit un contexte de projet que tu pourras interroger sur plusieurs tours.

from mistralai.client import Mistral
import os

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

# Créer un agent
agent = client.beta.agents.create(
    model="mistral-medium-latest",
    name="Assistant de projet",
    description="Assistant de gestion de projet.",
    instructions="Tu aides à organiser et suivre les projets. Sois structuré."
)

# Démarrer la conversation
response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Je lance un nouveau projet pour refondre notre site web. Budget : 50 000 €, échéance : septembre 2026."
)

print(f"ID de conversation : {response.conversation_id}")

L’conversation_id renvoyé est ta clé pour reprendre cette conversation plus tard. Stocke-le là où ton application peut le récupérer : dans une session utilisateur, une base de données ou le ticket de support auquel il se rapporte.

Poursuivre une conversation

Pour ajouter un message à une conversation existante, passe l’conversation_id à conversations.append(). Suis le fil dans cet exemple : la deuxième question ne répète ni le budget ni l’échéance, et la troisième demande un planning sans rappeler à l’agent qu’il s’agit d’une refonte de site web. Pourtant, l’agent dispose de tout ce contexte.

# Premier échange
response1 = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Je lance un projet de refonte de site web. Budget 50 000 €."
)

# Deuxième échange — l'agent se souvient du contexte
response2 = client.beta.conversations.append(
    conversation_id=response1.conversation_id,
    inputs="Quelles sont les étapes prioritaires ?"
)

# Troisième échange — toujours dans le même contexte
response3 = client.beta.conversations.append(
    conversation_id=response2.conversation_id,
    inputs="Rédige un planning pour les 3 premiers mois."
)

Observe attentivement quel identifiant alimente chaque appel : response2 part de l’ID de response1, response3 de celui de response2. Ce n’est pas une bizarrerie, c’est le mécanisme central de l’API.

Le mécanisme d’immuabilité

Chaque appel à conversations.append() renvoie un nouvel conversation_id. L’ancien reste lisible, mais tu dois utiliser le dernier ID pour le prochain ajout.

# Chaque append renvoie un nouvel ID
id_1 = response1.conversation_id  # "conv-aaa"
id_2 = response2.conversation_id  # "conv-bbb"
id_3 = response3.conversation_id  # "conv-ccc"

# Utilise toujours le DERNIER id pour continuer
response4 = client.beta.conversations.append(
    conversation_id=id_3,  # Pas id_1 ni id_2
    inputs="Ajoute des jalons de validation client."
)

L’erreur classique consiste à sauvegarder l’identifiant initial dans ta base de données lorsque l’utilisateur ouvre le fil, puis à le réutiliser tel quel pour chaque message. Rien ne plante : l’API répond normalement, mais chaque question repart du contexte du premier échange, et ton agent semble atteint d’amnésie sans aucune erreur pour t’alerter. Écrase toujours l’identifiant stocké par celui renvoyé dans la réponse.

Lire l’historique d’une conversation

Tu peux lire l’historique à tout moment, ce qui aide aussi bien au débogage qu’à l’affichage d’un fil dans ton interface.

conversation = client.beta.conversations.get_history(
    conversation_id=response.conversation_id
)

for entry in conversation.entries:
    print(f"[{entry.role}] {entry.type}: {entry.content[:100]}...")

Gérer le stockage

Par défaut, les conversations sont stockées dans le cloud Mistral. Le paramètre store=False désactive ce comportement pour les échanges que ta politique interne interdit de laisser sur un serveur tiers.

# Conversation éphémère — rien n'est sauvegardé
response = client.beta.conversations.start(
    agent_id=agent.id,
    inputs="Données confidentielles à analyser...",
    store=False
)

Le compromis correspond à l’objectif : la conversation n’est pas récupérable après la session et les données ne sont pas conservées sur les serveurs de Mistral. Tu perds la lecture de l’historique décrite plus haut, et ton application doit gérer elle-même le suivi des échanges si nécessaire. Prends cette décision en amont, pas comme une case à cocher de dernière minute.

Modèle de conversation multi-tours

Le squelette ci-dessous applique tout ce qui précède dans une boucle interactive. Le point clé est la variable conversation_id, initialisée à None : elle décide quel appel effectuer — start() au premier tour, append() ensuite — et elle est réaffectée après chaque réponse, conformément à la règle d’immuabilité.

from mistralai.client import Mistral
import os

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

agent = client.beta.agents.create(
    model="mistral-large-latest",
    name="Coach technique",
    description="Coach pour les décisions techniques.",
    instructions="Tu es un coach technique senior. Pose des questions pour comprendre le contexte avant de conseiller."
)

# Boucle de conversation
conversation_id = None

while True:
    user_input = input("Toi : ")
    if user_input.lower() in ["quit", "exit"]:
        break

    if conversation_id is None:
        response = client.beta.conversations.start(
            agent_id=agent.id,
            inputs=user_input
        )
    else:
        response = client.beta.conversations.append(
            conversation_id=conversation_id,
            inputs=user_input
        )

    conversation_id = response.conversation_id

    for entry in response.outputs:
        if hasattr(entry, "content"):
            print(f"Agent : {entry.content}")

Adapte-le à ton contexte en remplaçant input() par ta source de messages réelle — requête HTTP, message de file d’attente, événement webhook — et en persistant conversation_id là où ton application pourra le retrouver au tour suivant.

Viktiga punkter

  • conversations.start() crée une nouvelle conversation avec un premier message
  • conversations.append() ajoute un message à une conversation existante
  • Chaque appel append renvoie un nouvel conversation_id — utilise toujours le dernier
  • store=False désactive la persistance côté Mistral pour les données sensibles
  • L’agent conserve le contexte complet de la conversation sans que tu aies besoin de renvoyer l’historique