Systèmes d’IA multi-agents avec LangChain : Construire un
Les systèmes d’IA multi-agents avec LangChain : ce qu’est un système multi-agents, quand plusieurs agents surpassent un seul agent LLM, et comment créer et relier les rôles.
Sources: Multi-Agent AI Systems with LangChain: Building an Orchestrator That Delegates Work
Les notes suivantes reconstituent une approche pratique pour aborder le sujet « Systèmes d’IA multi-agents avec LangChain : Création d’un orchestrateur qui délègue les tâches ». L’accent est mis sur les contrats, les vérifications et les placeholders de code à insérer, plutôt que sur une présentation motivante. Lors de la phase d’aperçu, notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût en tokens ou en requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque l’approche passe de la démonstration à des environnements partagés.
1. Qu’est-ce qu’un système multi-agents ?
The 1 « Qu’est-ce qu’une étape ? » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un transcript exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du graphe. Maintenez l’état du graphe plat et typé. Les blocs imbriqués masquent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption.
User
|
v
Single Agent
|
+-- Search
+-- Analyze
+-- Calculate
+-- Generate Report
User
|
v
+--------------+
| Main Agent |
| Orchestrator |
+------+-------+
|
+------------+------------+
| |
v v
+-------------+ +-------------+
| Math Agent | | Search Agent|
+-------------+ +-------------+
| |
square() search()
2. Pourquoi utiliser plusieurs agents ?
La méthode « 2 Why Use Multiple stages » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et le traitement des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Gardez l’état des graphes plat et typé ; les blocs imbriqués masquent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption.
Database queries
Security analysis
Documentation search
Report generation
"I have a database question → call database agent."
"I have a security question → call security agent.""I need documentation → call documentation agent."
Agent unique
La phase à un seul agent fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit pointer vers une seule responsabilité plutôt que vers un processus embrouillé. Maintenez l’état du graphe plat et typé. Les blocs imbriqués cachent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption.
LLM
|
+-------------+-------------+
| | |
Database Search Security
| | |
+-------------+-------------+
La phase à un seul agent fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement idéal, un cas d’échec et la note de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe de la démonstration aux environnements partagés.
Multi-agent
Pour l’étape multi-agents, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du système. Mettez en place une approbation humaine pour les actions qui entraînent des dépenses ou modifient des données de production. La connexion en temps de compilation ne garantit pas la complétude du processus métier.
Main Agent
/ | \
/ | \
v v v
DB Agent Search Security
Agent Agent
3. Exemple : Deux agents spécialisés
Pour l’étape spécialisée Exemple Deux 3, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Faites approuver par un humain les cas où de l’argent est dépensé ou où des données de production sont modifiées. La connexion en temps de compilation ne garantit pas l’exhaustivité du fonctionnement commercial.
Calculate the square of a number
Calculate the square root of a number
@tool
def square_root(x: float) -> float:
"""Calculate the square root of a number"""
return x ** 0.5
@tool
def square(x: float) -> float:
"""Calculate the square of a number"""
return x ** 2
subagent_square_root = create_agent(
model=llm,
tools=[square_root]
)
subagent_square = create_agent(
model=llm,
tools=[square]
)
square_root()
square()
4. La partie importante : transformer les agents en outils
Pour l’étape « 4 The Important Part », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Authentifiez au niveau du gateway et réautorisez au niveau du plan de données. Un simple token porteur ne constitue pas une frontière entre les tenants. Pour l’étape « 4 The Important Part », définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite les factures inattendues lorsque le processus passe d’un environnement de démonstration à des environnements partagés.
@tool
def call_subagent_square_root(x: float) -> float:
"""Call subagent 1 in order to calculate
the square root of a number"""
response = subagent_square_root.invoke(
{
"messages": [
HumanMessage(
content=f"Calculate the square root of {x}"
)
]
}
) return response["messages"][-1].content
@tool
def call_subagent_square(x: float) -> float:
"""Call subagent 2 in order to calculate
the square of a number"""
response = subagent_square.invoke(
{
"messages": [
HumanMessage(
content=f"Calculate the square of {x}"
)
]
}
) return response["messages"][-1].content
Main Agent
|
+-- call_subagent_square_root()
|
+-- call_subagent_square()
5. Création de l’orchestrateur
Lorsque vous travaillez sur l’étape 5 relative à la création de l’orchestrateur, notez d’abord les exigences : entrées requises, signal de succès et conséquences en cas d’échec partiel. Cette liste de contrôle permet de maintenir l’intégrité des modifications ultérieures du code. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans avoir à lire l’ensemble du schéma. Créez des points de contrôle après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel au LLM lorsque un opérateur réessaie un nœud ultérieur.
main_agent = create_agent(
model=llm,
tools=[
call_subagent_square_root,
call_subagent_square
],
system_prompt=
"You are a helpful assistant who can call "
"subagents to calculate the square root or "
"square of a number."
)
User
|
|
v
+----------------+
| Main Agent |
| Orchestrator |
+-------+--------+
|
Tool selection
/ \
/ \
v v
+----------------+ +----------------+
| Square Root | | Square |
| Subagent | | Subagent |
+-------+--------+ +-------+--------+
| |
v v
square_root() square()
6. Que se passe-t-il lorsque l’utilisateur pose une question ?
Lorsque vous travaillez sur l’étape 6 « What Happens When », notez d’abord les éléments essentiels du contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non traités font partie intégrante du produit, et non d’améliorations apportées ultérieurement. Faites un point après les étapes coûteuses. Le système de reprise ne doit pas facturer à nouveau la même appel du LLM lorsque l’opérateur tente à nouveau un nœud ultérieur.
What is the square root of 456?
response = main_agent.invoke(
{
"messages": [
HumanMessage(
content="What is the square root of 456?"
)
]
}
)
call_subagent_square_root(x=456)
Calculate the square root of 456
square_root()
21.3541565
The square root of 456 is approximately 21.35.
User
|
| "What is the square root of 456?"
v
Main Agent
|
| selects call_subagent_square_root
v
Square Root Subagent
|
| invokes square_root(456)
v
21.3541565
|
v
Main Agent
|
v
"The square root of 456 is approximately 21.35."
7. Où s’insère le LLM ?
Lorsque vous travaillez sur l’étape « 7 Where Does the stage », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Préférez des unités petites et testables plutôt que des scripts volumineux. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité et non un processus embrouillé. Cachez les instructions du système stables ainsi que les schémas des outils. Envoyer à nouveau un préambule identique est une cause fréquente de gaspillage. Lorsque vous travaillez sur l’étape « 7 Where Does the stage », notez d’abord le contrat : les entrées requises, le signal de succès et ce qui se passe en cas d’échec partiel. Cette liste de contrôle permet de rester honnête lors des modifications ultérieures du code. Enregistrez les temps d’exécution ainsi que le coût des tokens ou des requêtes à côté des résultats fonctionnels. Une visibilité précoce du coût évite les factures inattendues lorsque le processus passe de la démonstration aux environnements partagés.
llm = ChatOllama(
model="llama3.2:latest",
base_url="http://localhost:11434",
temperature=0,
)
Ollama / Llama
|
+----------+----------+
| |
v v
Main Agent Subagents
Orchestrator Specialized
Main Agent → powerful reasoning model
Security Agent → security-specialized modelCoding Agent → coding modelSimple Agent → smaller/cheaper model
8. Multi-Agent ne signifie pas plusieurs LLM
Le guide 8 Multi-Agent Does Not fonctionne le mieux lorsqu’il est considéré comme une surface mesurable. Capturez un transcript parfait, un cas d’échec et la note de réversion avant d’élargir le périmètre. Conservez les configurations en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les administrateurs peuvent auditer sans devoir lire l’ensemble du système. Fixez un budget de tokens par tour et par session. Les outils agents élargissent lourdement le contexte ; des plafonds stricts empêchent que les démonstrations ne se transforment en factures inattendues.
Model A
|
+-- Agent 1
+-- Agent 2
+-- Agent 3
Model A → Agent 1
Model B → Agent 2
Model C → Agent 3
Agent =
Model
+ Instructions
+ Tools
+ State/Context
+ Decision-making
9. Pourquoi ne pas donner tous les outils à un seul agent ?
La méthode 9 Why Not Just fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un enregistrement exemplaire, un cas d’échec et la note de réversion avant d’élargir le périmètre. Documentez ensemble le parcours optimal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Fournissez des outils dotés de schémas restreints et de labels explicites indiquant les effets secondaires. Les hôtes doivent savoir quels appels modifient l’état avant de valider automatiquement.
Orchestrator
|
+-------------------+-------------------+
| | |
v v v
Database Agent Security Agent Research Agent
| | |
PostgreSQL SIEM/Security Web/MCP
|
v
Report Generator
10. Workflow multi-agent vs. workflow séquentiel
La phase « 10 Multi-Agent vs Sequential » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple idéal, un cas d’échec et des notes de réversion avant d’élargir le périmètre. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’erreur doit indiquer une seule responsabilité plutôt qu’un processus embrouillé. Maintenez l’état du graphe plat et typé. Les blocs imbriqués masquent le fait que tel nœud a écrit telle champ et perturbent la reprise après interruption. La phase « 10 Multi-Agent vs Sequential » fonctionne le mieux lorsqu’elle est considérée comme une surface mesurable. Capturez un exemple idéal, un cas d’échec et des notes de réversion avant d’élargir le périmètre. Enregistrez les temps d’exécution ainsi que le coût en tokens ou requêtes à côté des résultats fonctionnels. Une visibilité précoce des coûts évite des factures inattendues lorsque le processus passe d’une démonstration à des environnements partagés.
Flux de travail séquentiel
Pour l’étape du flux de travail séquentiel, définissez les entrées, le responsable de l’étape et les critères de sortie avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Conservez la configuration en dehors du code de l’application. Les fichiers d’environnement, les bases de données secrètes et les indicateurs fonctionnels doivent être regroupés en un seul endroit que les opérateurs peuvent auditer sans devoir lire l’ensemble du système. Mettez en place une approbation humaine pour les actions qui entraînent des dépenses ou modifient des données de production. La connexion en temps de compilation ne garantit pas la complétude du processus métier.
Step 1
↓
Step 2
↓
Step 3
↓
Step 4
Retrieve documents
↓
Analyze documents
↓
Generate report
↓
Send email
Système multi-agent orchestré
Pour l’étape du système multi-agents orchestré, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier le code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Documentez ensemble le parcours normal et le parcours de récupération. Les tentatives répétées, les contrôles humains et la gestion des messages non livrés font partie intégrante du produit, et non d’une mise en forme ultérieure. Imposez l’approbation humaine pour les actions qui entraînent des dépenses ou modifient des données de production. La connexion en temps de compilation ne garantit pas la complétude du fonctionnement métier.
Orchestrator
/ | \
/ | \
Agent A Agent B Agent C
Workflow = predefined control flow
Multi-Agent =
LLM-driven delegation between specialized agents
11. Architecture de production
Pour l’étape 11 de l’architecture de production, définissez les entrées, le responsable de l’étape et les critères de fin avant de modifier du code. Les opérateurs doivent pouvoir relancer l’étape à partir d’un point de contrôle connu sans deviner l’état caché. Préférez des unités petites et testables aux scripts complexes. Lorsqu’une étape échoue, l’échec doit indiquer une seule responsabilité plutôt qu’un processus embrouillé.
User
|
v
+-------------------+
| Orchestrator |
| Agent |
+---------+---------+
|
+----------------+----------------+
| | |
v v v
+-----------+ +-----------+ +-----------+
| Research | | Security | | Database |
| Agent | | Agent | | Agent |
+-----+-----+ +-----+-----+ +-----+-----+
| | |
v v v
Web/MCP SIEM/APIs PostgreSQL
| | |
+----------------+----------------+
|
v
+----------------+
| Final Response |
| / Report Agent |
+----------------+
Research Agent
→ web search
→ document retrieval
→ RAG
Security Agent
→ SIEM
→ vulnerability database
→ security APIsDatabase Agent
→ SQL
→ analyticsReport Agent
→ summarize
→ format
→ email
12. Points clés
1. Spécialiser les agents
Agent → one domain / capability
2. Encapsuler les sous-agents en outils
Main Agent
|
+-- Subagent Tool
3. Laisser l’orchestrateur déléguer
4. Garder les interfaces simples
Tool name
Description
Arguments
Result
5. Commencer simplement
AI Orchestrator
|
+----------------+----------------+
| | |
Research Coding Security
Agent Agent Agent
| | |
MCP GitHub Security APIs
RAG Tools SIEM
Conclusion
User
↓
Main Agent
↓
Tool representing a subagent
↓
Specialized Subagent
↓
Domain-specific Tool
↓
Result
↓
Main Agent
↓
User