Conversations sans agent

Le mode modèle direct

Vous n’avez pas toujours besoin de créer un objet Agent pour utiliser l’API Conversations. Mistral permet de démarrer une conversation directement avec un modèle, en bénéficiant de la persistance sans la couche de configuration Agent. Cette possibilité découle de ce que vous avez vu au chapitre sur l’architecture : la conversation est indépendante de l’agent, et peut donc parfaitement exister sans lui.

Plusieurs situations le rendent préférable à l’agent enregistré. Vous voulez la persistance des conversations sans définir un agent réutilisable, par exemple parce que chaque fil de votre application est unique. Vous testez rapidement un comportement avec des outils intégrés, et créer puis supprimer un agent à chaque essai vous ralentit. Votre cas d’usage est ponctuel : rien ne justifie de sauvegarder une configuration que vous n’emploierez qu’une fois. Ou vos instructions sont dynamiques, calculées à l’exécution à partir du profil de l’utilisateur ou du document en cours — un agent figé serait alors le mauvais outil.

Démarrer une conversation avec un modèle

Au lieu de passer un agent_id, vous passez directement un model :

from mistralai import Mistral
import os

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

response = client.beta.conversations.start(
    model="mistral-medium-latest",
    inputs=[
        {"role": "user", "content": "Qui est Albert Einstein ?"}
    ]
)

print(response.outputs[-1].content)

Tout se joue dans ce choix de paramètre. Avec agent_id, l’appel hérite de la configuration enregistrée de l’agent : ses instructions, ses outils, ses guardrails. Avec model, vous êtes en mode direct et vous configurez tout dans la requête elle-même — rien n’est mémorisé au-delà de l’appel.

Ajouter des outils en mode direct

Les outils intégrés ne sont pas réservés aux agents. Vous les déclarez dans la requête, exactement comme vous le feriez à la création.

response = client.beta.conversations.start(
    model="mistral-large-latest",
    inputs=[
        {"role": "user", "content": "Quels sont les derniers résultats de Ligue 1 ?"}
    ],
    tools=[{"type": "web_search"}]
)

C’est l’équivalent fonctionnel d’un agent avec web_search, mais sans la persistance de la configuration. La différence apparaît au dixième appel : avec un agent, vous auriez changé la température une fois pour toutes ; ici, vous devrez la répéter dans chaque requête, et rien ne garantit qu’un appel oublié quelque part dans votre code emploie les mêmes réglages.

Passer des instructions dynamiques

En mode direct, le system prompt prend la forme d’un message system placé en tête des inputs.

response = client.beta.conversations.start(
    model="mistral-large-latest",
    inputs=[
        {"role": "system", "content": "Vous êtes un expert en cuisine française. Répondez en 3 phrases maximum."},
        {"role": "user", "content": "Comment réussir une sauce béarnaise ?"}
    ]
)

Cela vous donne la même flexibilité que les instructions d’un agent, mais de manière éphémère — et surtout, cette chaîne peut être construite à l’exécution, ce qu’une instruction d’agent enregistrée ne permet pas.

Continuer une conversation en mode direct

Le mécanisme de persistance fonctionne exactement comme avec un agent : le premier appel retourne un conversation_id, les suivants s’y rattachent, et chaque append renvoie à son tour un nouvel identifiant.

# Premier échange
response1 = client.beta.conversations.start(
    model="mistral-large-latest",
    inputs=[{"role": "user", "content": "Parle-moi de la révolution française."}]
)

# Deuxième échange — le contexte est conservé
response2 = client.beta.conversations.append(
    conversation_id=response1.conversation_id,
    inputs="Quels en furent les principaux acteurs ?"
)

# Le modèle sait qu'on parle de la révolution française

La deuxième question ne nomme pas son sujet et n’en a pas besoin : la persistance ne dépend pas de l’existence d’un agent, seulement de la conversation.

Agent ou mode direct : comment trancher

Créez un agent dès que la même configuration sert plusieurs conversations, car vous gagnez alors un point unique de modification : corriger une instruction met à jour tous les fils à venir. C’est aussi le seul chemin possible si vos instructions sont stables d’une session à l’autre, si vous prévoyez des handoffs multi-agents — que la leçon consacrée au sujet détaillera —, ou si votre organisation exige une configuration centralisée et auditable, où l’on peut répondre à la question « avec quelles consignes cet assistant a-t-il été exécuté ? ».

Restez en mode direct dans les cas symétriques : un prototype ou un usage ponctuel, des instructions qui changent à chaque conversation, une absence de besoin en handoffs, ou la volonté de réduire le nombre d’appels API en supprimant les créations et suppressions d’agents. En développement, cette dernière raison suffit souvent à elle seule.

Un exemple : question dans un contexte imposé

La fonction ci-dessous illustre parfaitement le mode direct. Le contexte est un argument, donc différent à chaque appel, et le system prompt est fabriqué autour de lui pour interdire au modèle de puiser ailleurs. Aucun agent enregistré ne pourrait porter cette contrainte, puisqu’elle change à chaque invocation.

def poser_question(contexte: str, question: str):
    """Pose une question dans un contexte donné, sans créer d'agent."""
    response = client.beta.conversations.start(
        model="mistral-large-latest",
        inputs=[
            {"role": "system", "content": f"Contexte : {contexte}. Répondez uniquement à partir de ce contexte."},
            {"role": "user", "content": question}
        ]
    )
    return response.outputs[-1].content

# Usage
reponse = poser_question(
    contexte="Corsen AI est une startup française spécialisée en IA souveraine, fondée en 2025.",
    question="Quand a été fondée Corsen AI ?"
)

Reprenez ce patron pour vos propres besoins en remplaçant le contexte codé en dur par le texte réellement pertinent — la fiche produit consultée, l’extrait de document sélectionné — et vous obtenez une brique de questions-réponses cadrée, sans aucune configuration à administrer.

Points clés à retenir

• Les conversations peuvent être démarrées avec model= au lieu de agent_id=
• Le mode direct offre la persistance sans la couche de configuration Agent
• Vous pouvez passer des outils et des instructions directement dans la requête
• Le mode direct est idéal pour le prototypage et les usages ponctuels
• Pour les handoffs et les configurations réutilisables, préférez créer un agent