Construire des Systèmes Multi-Agents avec crewAI

Ce document synthétise les concepts, la structure et la mise en œuvre de systèmes d’IA multi-agents en utilisant le framework crewAI. L’objectif est de passer d’une simple interaction avec un LLM à l’orchestration d’une équipe d’agents spécialisés qui collaborent pour accomplir des tâches complexes.

Partie 1 : Des LLMs aux Agents – Le Changement de Paradigme

  • Le LLM de base : Un grand modèle de langage (comme GPT, Mistral, Llama) est fondamentalement un « prédicteur de token ». Il prédit le mot suivant le plus probable dans une séquence.
  • La Naissance de l’Agent : Un agent naît lorsque l’on donne au LLM la capacité de raisonner et de suivre un processus de pensée interne (« inner thinking process »). Au lieu de simplement répondre, il peut planifier, utiliser des outils, et réfléchir en plusieurs étapes pour optimiser sa réponse.
  • Le Système Multi-Agents : L’étape suivante consiste à créer une équipe d’agents (Crew). Chaque agent est spécialisé dans un domaine, et ils collaborent pour atteindre un objectif commun, un peu comme une équipe d’experts humains.

L’avantage de crewAI : C’est un framework open-source qui simplifie énormément cette orchestration. Il fournit :

  • Une structure claire et des « Design Patterns » pour assembler ces systèmes.
  • Des outils prêts à l’emploi.
  • Un modèle pour créer ses propres outils.
  • Une plateforme pour mettre ces agents en production.

Partie 2 : Les Blocs de Construction Fondamentaux de crewAI

L’architecture de crewAI repose sur trois piliers : Agent, Task (Tâche), et Crew (Équipe).

Un agent est un travailleur autonome doté d’une personnalité et de compétences. On le définit avec plusieurs paramètres clés :codePython

planner = Agent(
    role="Content Planner",
    goal="Plan engaging and factually accurate content on {topic}",
    backstory="You're working on planning a blog article about {topic}...",
    tools=[search_tool],
    allow_delegation=False,
    verbose=True
)

Explication des paramètres :

  • role (chaîne de caractères) : Le titre du poste de l’agent. C’est sa spécialité. Ex: « Planificateur de Contenu », « Analyste Financier ». Le jeu de rôle (Role Playing) est crucial car les LLMs sont plus performants lorsqu’ils incarnent un personnage précis.
  • goal (chaîne de caractères) : L’objectif final que l’agent doit atteindre. Il doit être clair et concis. Ex: « Créer un plan de contenu factuel et engageant ».
  • backstory (chaîne de caractères) : Le contexte de l’agent. C’est son histoire, son expérience, ce qui l’aide à mieux « incarner » son rôle. Ex: « Vous êtes un planificateur chevronné qui sait identifier les tendances… ».
  • tools (liste d’outils) : La liste des outils que l’agent a le droit d’utiliser (ex: recherche web, lecture de fichiers).
  • allow_delegation (booléen) : Si True, cet agent peut déléguer une tâche à un autre agent de l’équipe, ce qui est essentiel pour la collaboration.
  • verbose (booléen) : Si True, affiche en détail le processus de pensée de l’agent (le « inner thinking process »), ce qui est très utile pour le débogage.

Une tâche définit ce qu’un agent doit faire spécifiquement.codePython

plan = Task(
    description="1. Prioritize the latest trends on {topic}...",
    expected_output="A comprehensive content plan document with an outline...",
    agent=planner,
    output_file="content_plan.md"
)

Éléments clés d’une tâche bien définie :

  • description : Des instructions très précises sur le travail à effectuer. Soyez le plus détaillé possible.
  • expected_output : Une description claire et concise de ce à quoi doit ressembler le résultat final. Cela guide l’agent vers le format de sortie attendu.
  • agent : L’agent assigné à cette tâche.
  • Fonctionnalités avancées (vues dans les labos) :
    • output_file : Sauvegarde le résultat de la tâche dans un fichier.
    • output_json : Force la sortie à être un objet JSON structuré (via un modèle Pydantic).
    • human_input=True : Met l’exécution en pause et demande une validation humaine avant de finaliser la tâche.
    • context=[task1, task2] : Rend cette tâche dépendante des résultats des tâches task1 et task2. Elle ne démarrera que lorsque les autres seront terminées.
    • async_execution=True : Permet à cette tâche de s’exécuter en parallèle avec d’autres tâches asynchrones.

Le Crew rassemble les agents et les tâches, et gère le déroulement du travail.codePython

crew = Crew(
    agents=[planner, writer, editor],
    tasks=[plan, write, edit],
    process=Process.sequential, # ou Process.hierarchical
    memory=True,
    verbose=2
)

# Pour lancer le travail :
result = crew.kickoff(inputs={"topic": "Artificial Intelligence"})
  • agents et tasks : Les listes des agents et des tâches qui composent l’équipe.
  • process : La méthode de collaboration (voir Partie 4).
  • memory=True : Active la mémoire à court terme, permettant aux agents de partager le contexte et les informations apprises pendant l’exécution.
  • verbose=2 : Affiche tous les journaux d’exécution, y compris ceux du manager de l’équipe.

Partie 3 : Les Outils (Tools) – Connecter les Agents au Monde Extérieur

Les agents sont plus puissants lorsqu’ils peuvent interagir avec des systèmes externes. C’est le rôle des outils.

Un bon outil est :

  • Versatile : Capable de gérer des entrées « floues » (langage naturel de l’agent) et de les transformer en sorties structurées (ex: JSON, liste) pour les systèmes logiciels externes.
  • Tolérant aux pannes (Fault-tolerant) : Capable de gérer les erreurs sans faire planter tout le processus.
  • Doté de mise en cache (Caching) : Le cache permet de sauvegarder les résultats d’appels aux outils. Si le même appel est refait, le résultat est récupéré du cache au lieu de ré-exécuter l’outil. C’est crucial pour :
    • Économiser des appels d’API (et donc de l’argent).
    • Respecter les limites de débit des API.
    • Accélérer considérablement l’exécution.

Types d’outils :

  1. Outils intégrés à crewAI :
    • SerperDevTool : Pour effectuer des recherches sur internet (nécessite une clé API Serper).
    • ScrapeWebsiteTool : Pour extraire le contenu d’une page web.
    • FileReadTool, DirectoryReadTool : Pour lire des fichiers locaux.
    • MDXSearchTool : Pour effectuer une recherche sémantique dans un fichier Markdown.
  2. Outils personnalisés :
    Vous pouvez créer vos propres outils en héritant de la classe BaseTool. C’est utile pour se connecter à vos propres bases de données, API internes, ou exécuter une logique métier spécifique.codePythonfrom crewai_tools import BaseTool class SentimentAnalysisTool(BaseTool): name: str = "Sentiment Analysis Tool" description: str = "Analyzes the sentiment of text..." def _run(self, text: str) -> str: # Votre logique personnalisée ici return "positive"

Partie 4 : Collaboration et Processus – Gérer le Flux de Travail

La manière dont les agents collaborent est définie par le process.

  1. Processus Séquentiel (Process.sequential)
    • Comportement : Les tâches sont exécutées l’une après l’autre, dans l’ordre où elles sont définies dans la liste. C’est le mode par défaut.
    • Cas d’usage : Parfait pour un pipeline simple où chaque étape dépend de la précédente (ex: Planifier -> Écrire -> Éditer).
  2. Processus Hiérarchique (Process.hierarchical)
    • Comportement : Un « manager » IA est ajouté à l’équipe. Ce manager reçoit la liste des tâches et décide quel agent est le plus apte à exécuter chaque tâche. Il peut même décomposer les tâches et orchestrer la délégation entre les agents.
    • Cas d’usage : Idéal pour des scénarios complexes nécessitant de la flexibilité et de la délégation. C’est ici que l’analogie du manager d’équipe prend tout son sens : vous définissez l’objectif et l’équipe, et le manager IA gère les détails de l’exécution.

Partie 5 : Synthèse des Cas d’Usage (Vos Laboratoires)

  • L2 : Écrire un article : Introduction aux concepts de base Agent, Task, Crew avec un flux de travail séquentiel simple (Planificateur -> Rédacteur -> Éditeur).
  • L4 : Prospection client : Démontre l’utilisation des outils, y compris un outil personnalisé (SentimentAnalysisTool), pour enrichir le travail des agents (recherche d’infos sur un prospect, analyse de sentiment).
  • L5 : Planification d’événement : Met en lumière les fonctionnalités avancées des tâches :
    • output_json pour structurer les détails d’un lieu.
    • output_file pour générer des rapports.
    • human_input=True pour demander une validation.
    • async_execution=True pour exécuter des tâches en parallèle (logistique et marketing).
  • L6 : Analyse financière : Le cas d’usage parfait pour le processus hiérarchique. Une équipe d’analystes et de traders collaborent sous la supervision d’un manager IA pour analyser une action et proposer des stratégies. Cela montre la puissance de la délégation.
  • L7 : Adaptation de CV : L’aboutissement de tous les concepts. Une équipe complète (Chercheur, Profileur, Stratège CV, Préparateur d’entretien) travaille ensemble, utilisant une variété d’outils (scrape, search, read_resume) et des dépendances de tâches (context) pour produire un CV sur mesure et des points de discussion pour un entretien. C’est un exemple très puissant et concret.

Conclusion et Cadre de Pensée (« Mental Framework »)

La meilleure façon de concevoir un système crewAI est de penser comme un manager :

  1. Quel est mon objectif final ? (Ex: « Obtenir un entretien pour ce poste »).
  2. Quel est le processus pour y arriver ? (Ex: Analyser l’offre, analyser mon profil, adapter le CV, préparer l’entretien).
  3. Quelles sont les personnes/rôles dont j’ai besoin ? (Ce seront vos Agents, avec leur role et backstory).
  4. Quelles tâches spécifiques chaque personne doit-elle accomplir ? (Ce seront vos Tasks avec leur description et expected_output).
  5. De quels outils ont-ils besoin ? (Accès internet, lecture de fichiers, API spécifiques…).

En adoptant cette approche, vous pouvez décomposer n’importe quel problème complexe en une structure crewAI logique et efficace.

Verifier l’accomplissement
Application concrète sur un projet

Publications similaires