Cas d'usage multi-agents
På denne side
Du concept à la réalité
Tu maîtrises maintenant les passations, les modes d’exécution et l’enchaînement. Cette leçon assemble ces briques de base en trois systèmes complets, chacun reposant sur une topologie différente : une chaîne d’escalade, un pipeline et un routeur. Au fil de ta lecture, observe comment l’architecture découle du problème, et non l’inverse : c’est la nature du besoin qui dicte la forme, pas la technologie.
Cas 1 : Support client multi-niveaux
Les opérations de support fonctionnent par niveaux : la plupart des demandes sont résolues au premier contact, une minorité nécessite un diagnostic technique, et une poignée finit entre les mains d’un humain. Cette réalité correspond directement à une chaîne d’escalade, où chaque niveau ne transfère qu’au suivant.
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
# Level 1: FAQ and simple questions
level1 = client.beta.agents.create(
model="mistral-medium-latest",
name="support-level1",
description="Level 1 support: FAQ, common questions, basic information.",
instructions="""You are the first level of support.
- Answer simple questions (hours, rates, FAQ)
- If the question is technical or complex, transfer to level 2
- Be polite and professional""",
tools=[{"type": "document_library", "library_ids": ["faq-library-id"]}]
)
# Level 2: Technical support
level2 = client.beta.agents.create(
model="mistral-large-latest",
name="support-level2",
description="Technical support: diagnosis, troubleshooting, configuration.",
instructions="""You are technical support.
- Diagnose technical issues
- Propose step-by-step solutions
- If the problem requires manual intervention, transfer to level 3""",
tools=[{"type": "web_search"}, {"type": "code_interpreter"}]
)
# Level 3: Human escalation (simulation)
level3 = client.beta.agents.create(
model="mistral-large-latest",
name="support-level3",
description="Escalation: critical issues requiring human intervention.",
instructions="""Prepare a summary of the issue for the technical team:
- Problem context
- Diagnostic steps performed
- Solutions attempted
- Recommendation"""
)
# Chain the escalations
level1 = client.beta.agents.update(agent_id=level1.id, handoffs=[level2.id])
level2 = client.beta.agents.update(agent_id=level2.id, handoffs=[level3.id])
Deux décisions se distinguent ici. Le niveau 1 tourne sur mistral-medium-latest, tandis que les niveaux suivants utilisent mistral-large-latest. Le niveau 1 absorbe le plus gros volume ; lui attribuer le modèle le plus cher reviendrait à payer une expertise inutile pour des questions sur les horaires d’ouverture. Le niveau 3, quant à lui, ne résout rien : il rédige un dossier. C’est exactement ce que tu attends d’une escalade humaine : l’ingénieur qui prend le relais reçoit le contexte, les étapes de diagnostic déjà effectuées et les solutions déjà tentées, au lieu de recommencer l’interrogation depuis zéro.
En pratique, un client écrit : „Je n’arrive pas à me connecter à mon compte.” Le niveau 1 consulte la FAQ, ne trouve aucun cas correspondant et effectue un transfert. Le niveau 2 diagnostique un problème de base de données hors de son périmètre et transfère à nouveau. Le niveau 3 prépare le ticket avec l’historique complet.
Cas 2 : Pipeline de renseignement stratégique
Ici, l’ordre est fixe et connu à l’avance : tu ne peux pas analyser ce qui n’a pas été collecté, ni rédiger ce qui n’a pas été analysé. Une chaîne linéaire est donc obligatoire, et le point d’entrée n’est pas un routeur, mais le premier maillon.
# Collector — searches for raw information
collector = client.beta.agents.create(
model="mistral-large-latest",
name="intelligence-collector",
description="Collects strategic information via web search.",
instructions="""Search for information on the requested topic.
- Cover multiple sources
- Include numerical data
- Note publication dates""",
tools=[{"type": "web_search"}]
)
# Analyst — extracts insights
analyst = client.beta.agents.create(
model="mistral-large-latest",
name="intelligence-analyst",
description="Analyzes and extracts insights from raw data.",
instructions="""Analyze the collected data:
- Identify trends
- Spot opportunities and threats
- Quantify when possible""",
tools=[{"type": "code_interpreter"}]
)
# Reporter — produces the report
reporter = client.beta.agents.create(
model="mistral-large-latest",
name="intelligence-reporter",
description="Writes structured intelligence reports.",
instructions="""Write a professional intelligence report:
## Executive Summary (3 sentences)
## Key Facts (bullet points)
## Analysis (2-3 paragraphs)
## Recommendations (concrete actions)
## Sources"""
)
# Pipeline
collector = client.beta.agents.update(agent_id=collector.id, handoffs=[analyst.id])
analyst = client.beta.agents.update(agent_id=analyst.id, handoffs=[reporter.id])
# Launch
response = client.beta.conversations.start(
agent_id=collector.id,
inputs="Strategic intelligence: sovereign AI market in Europe, Q1 2026."
)
Le plan du rapport est écrit noir sur blanc dans les instructions du rédacteur, jusque dans le nombre de phrases du résumé exécutif. Ce niveau de précision est ce qui rend le renseignement exploitable dans le temps : chaque rapport sort dans le même format, ce qui te permet de comparer semaine après semaine et de les diffuser sans retouche. Note également l’instruction donnée au collecteur d’enregistrer les dates de publication : sans cela, un rapport de renseignement peut sembler solide tout en s’appuyant sur des sources obsolètes.
Cas 3 : L’assistant polyvalent
Lorsque les demandes impliquent des compétences sans rapport entre elles, il n’y a ni escalade ni pipeline ; il y a routage. Le routeur central lit la requête et l’envoie à l’un de ses quatre spécialistes, dont aucun n’a besoin de connaître les autres.
# Specialists
web_researcher = client.beta.agents.create(
model="mistral-large-latest",
name="web-researcher",
description="Searches for current information on the internet.",
tools=[{"type": "web_search"}]
)
data_analyst = client.beta.agents.create(
model="mistral-large-latest",
name="data-analyst",
description="Data analysis, statistics, and visualizations.",
tools=[{"type": "code_interpreter"}]
)
doc_expert = client.beta.agents.create(
model="mistral-large-latest",
name="doc-expert",
description="Queries and synthesizes internal documents.",
tools=[{"type": "document_library", "library_ids": ["docs-lib-id"]}]
)
creative = client.beta.agents.create(
model="mistral-large-latest",
name="creative-agent",
description="Creates visual content and illustrations.",
tools=[{"type": "image_generation"}]
)
# Central router
assistant = client.beta.agents.create(
model="mistral-large-latest",
name="research-assistant",
description="Versatile research assistant.",
instructions="""You are a research assistant. Analyze each request and transfer to the appropriate specialist:
- Current information → web-researcher
- Calculations and data → data-analyst
- Questions about our documents → doc-expert
- Need for illustrations → creative-agent""",
handoffs=[web_researcher.id, data_analyst.id, doc_expert.id, creative.id]
)
Chaque spécialiste ne possède qu’un seul outil, et les quatre descriptions ne se chevauchent nulle part. C’est cette absence de chevauchement qui assure la stabilité du routage : si deux agents pouvaient vraisemblablement traiter la même demande, le choix varierait d’une exécution à l’autre, et tes utilisateurs subiraient une qualité incohérente sans en comprendre la raison.
Ce qui distingue un prototype d’un système
Ces trois systèmes partagent la même règle de conception : un agent, une responsabilité. Dès qu’un agent accumule deux rôles, ses instructions se contredisent et sa description devient trop vague pour que le routeur décide correctement. Rédige donc chaque description en pensant à la décision qu’elle doit permettre, et rédige chaque jeu d’instructions pour préciser ce que l’agent ne doit pas faire, autant que ce qu’il doit faire.
Le passage en production ajoute quatre exigences qu’un prototype ignore. Premièrement, la journalisation : le mode client te permet de tracer chaque passation avec tes propres identifiants, ce qui sera ton seul recours le jour où un utilisateur signalera une réponse aberrante. Deuxièmement, les délais d’attente (timeouts), essentiels sur les longues chaînes où un maillon bloqué immobilise le reste. Troisièmement, les mécanismes de repli (fallbacks), car la question „que se passe-t-il si cet agent échoue ?” doit avoir une réponse écrite avant la mise en ligne, et non après le premier incident. Enfin, le suivi des coûts : une chaîne de trois agents consomme des jetons à chaque relais, et seul un compteur par conversation te dira si ton pipeline de renseignement coûte quelques centimes ou bien plus.
Vigtige pointer
- Le support client multi-niveaux est un cas d’usage naturel pour les passations
- Les pipelines de renseignement (collecter → analyser → rédiger) exploitent l’enchaînement linéaire
- Les assistants polyvalents utilisent un routeur central vers des spécialistes
- En production : la journalisation, les délais d’attente, les mécanismes de repli et le suivi des coûts sont essentiels
- Un agent = une responsabilité, avec une description précise pour le routage