Cas d'usage multi-agents
På denna sida
Du concept à la réalité
Tu maîtrises maintenant les transferts, les modes d’exécution et l’enchaînement. Cette leçon assemble ces briques de base en trois systèmes complets, chacun bâti 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 se résolvent au premier contact, une minorité nécessite un diagnostic technique et une poignée aboutit à 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. 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 transfère. 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, jusqu’au nombre de phrases du résumé exécutif. Ce niveau de précision rend le renseignement actionnable 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 aussi 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 font appel à des compétences sans lien 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 possède exactement un outil, et les quatre descriptions ne se chevauchent nulle part. Cette absence de chevauchement est ce qui rend le routage stable : 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 transfert avec tes propres identifiants, ce qui sera ton seul recours le jour où un utilisateur signale une réponse aberrante. Deuxièmement, les délais d’attente, essentiels sur les longues chaînes où un maillon bloqué immobilise le reste. Troisièmement, les mécanismes de repli, 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.
Viktiga punkter
- Le support client multi-niveaux est un cas d’usage naturel pour les transferts
- 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