CrewAI : orchestre ton armée d'agents IA (de zéro à héro en 30 minutes)

Tu as déjà utilisé ChatGPT pour répondre à une question. Maintenant imagine une équipe entière d'IA spécialisées — un chercheur, un rédacteur, un relecteur — qui bossent ensemble sur une tâche complexe, sans que tu aies à les micro-manager. C'est exactement ce que permet CrewAI, le framework multi-agents qui explose en 2026 (45 000+ étoiles GitHub). Dans ce tutoriel, tu vas construire ta première crew d'agents IA.

Le problème que CrewAI résout

Un LLM seul, c'est comme un employé ultra-polyvalent mais sans spécialité. Il fait tout, moyennement bien. Dès que ta tâche devient complexe — par exemple « fais une recherche sur les dernières avancées en IA, rédige un article de 1000 mots, puis relis-le pour corriger les fautes » — un seul appel à ChatGPT ne suffit pas.

Tu pourrais enchaîner plusieurs prompts à la main. Mais c'est fastidieux, et tu perds le contexte entre chaque étape.

CrewAI résout ça avec un concept simple : tu définis des agents spécialisés avec des rôles, des objectifs et des outils, puis tu les fais collaborer sur une tâche commune. Chaque agent a un backstory (son « CV »), des compétences, et peut utiliser des outils comme la recherche web ou l'exécution de code.

Comment fonctionne CrewAI

Le framework repose sur quatre briques :

Agent — un « employé IA » avec un rôle, un objectif et une personnalité
Task — une mission confiée à un agent, avec un résultat attendu
Tool — un outil que l'agent peut utiliser (recherche web, scraping, calculatrice…)
Crew — l'orchestrateur qui lance les agents dans le bon ordre

La magie opère quand les tâches s'enchaînent : la sortie de l'agent A devient l'entrée de l'agent B. Tu obtiens un pipeline intelligent, sans couture.

Illustration : un schéma avec 3 agents (Chercheur → Rédacteur → Relecteur) reliés par des flèches, avec leurs outils respectifs (web_search, python_repl) affichés en dessous, le tout dans une « crew » représentée par un conteneur.

Installation : prépare ton environnement

On va tout faire en Python. Crée un dossier propre et un environnement virtuel :

bash

# Crée le dossier du projet
mkdir ma-crew-ia && cd ma-crew-ia

# Crée un environnement virtuel
python3 -m venv venv
source venv/bin/activate  # Sur Windows : venv\Scripts\activate

# Installe CrewAI
pip install crewai crewai-tools

Vérifie que tout est ok :

bash

python3 -c "import crewai; print(f'CrewAI {crewai.__version__} installé ')"

Tu dois voir quelque chose comme :

plaintext

CrewAI 0.80.0 installé

Ton premier agent : un assistant simple

Avant d'orchestrer une équipe, on va créer un seul agent pour comprendre la mécanique. Voici un agent « Assistant Personnel » :

python

# mon_premier_agent.py
from crewai import Agent, Task, Crew

# 1. Définir l'agent
assistant = Agent(
    role="Assistant Personnel",
    goal="Aider l'utilisateur avec des réponses claires et utiles",
    backstory=(
        "Tu es un assistant IA bienveillant, formé à la vulgarisation scientifique. "
        "Tu expliques les choses simplement, sans jargon inutile."
    ),
    verbose=True,          # Affiche ce que l'agent fait
    allow_delegation=False  # Pas besoin de déléguer pour un agent seul
)

# 2. Définir la tâche
tache = Task(
    description=(
        "Explique en 3 phrases simples ce qu'est un agent IA "
        "à quelqu'un qui n'y connaît rien en informatique."
    ),
    expected_output="Une explication en 3 phrases simples, en français.",
    agent=assistant
)

# 3. Créer la crew et lancer
crew = Crew(
    agents=[assistant],
    tasks=[tache],
    verbose=True
)

resultat = crew.kickoff()
print("\n=== RÉSULTAT FINAL ===")
print(resultat)

Lance le script :

bash

python3 mon_premier_agent.py

Ce que tu devrais observer : - L'agent réfléchit (tu vois le verbose afficher sa réflexion) - Il produit une explication en français, simple et claire - Le kickoff() retourne le résultat final

Ce qui vient de se passer : CrewAI a pris ton agent, lui a donné sa tâche, a appelé le LLM sous-jacent (par défaut GPT-4o via l'API OpenAI), et t'a retourné la réponse. Propre, non ?

Brancher un LLM gratuit : passe en local avec Ollama

Par défaut, CrewAI utilise l'API OpenAI (payante). Bonne nouvelle : tu peux utiliser Ollama (gratuit, local) si tu as suivi notre tutoriel précédent.

Installe Ollama si ce n'est pas fait :

bash

# Installation Ollama (Linux/Mac)
curl -fsSL https://ollama.com/install.sh | sh

# Télécharge un modèle
ollama pull llama3.2:3b

Puis configure CrewAI pour utiliser Ollama :

python

# config_ollama.py — à exécuter avant ton script principal
import os

os.environ["OPENAI_API_BASE"] = "http://localhost:11434/v1"
os.environ["OPENAI_MODEL_NAME"] = "llama3.2:3b"
os.environ["OPENAI_API_KEY"] = "ollama"  # Ollama ignore la clé

Le vrai projet : une équipe de journalistes IA

Maintenant, on passe à la pratique. Tu vas créer trois agents qui collaborent pour produire un article d'actualité :

Agent	Rôle	Outil
Chercheur	Trouver les infos récentes sur un sujet	Recherche web
Rédacteur	Rédiger l'article à partir des recherches	—
Relecteur	Vérifier les fautes et la cohérence	—

Étape 1 : les outils

python

# equipe_journalistes.py
import os
from crewai import Agent, Task, Crew
from crewai_tools import SerperDevTool, ScrapeWebsiteTool

#  Pour la recherche web, il te faut une clé API Serper (gratuit, 2500 requêtes/mois)
# Inscris-toi sur https://serper.dev et copie ta clé
os.environ["SERPER_API_KEY"] = "ta-clé-serper-ici"

# Outils
outil_recherche = SerperDevTool()      # Recherche Google
outil_scraping = ScrapeWebsiteTool()    # Lit le contenu d'une page web

Étape 2 : les agents

python

# Agent 1 : le Chercheur
chercheur = Agent(
    role="Chercheur Web Senior",
    goal=(
        "Trouver les informations les plus récentes et pertinentes "
        "sur le sujet demandé. Tu dois citer tes sources."
    ),
    backstory=(
        "Ancien journaliste d'investigation reconverti dans la veille tech. "
        "Tu as un don pour dénicher l'info que personne d'autre ne trouve. "
        "Tu ne te contentes jamais du premier résultat Google."
    ),
    tools=[outil_recherche, outil_scraping],
    verbose=True,
    allow_delegation=False
)

# Agent 2 : le Rédacteur
redacteur = Agent(
    role="Rédacteur Tech",
    goal=(
        "Rédiger un article clair, engageant et bien structuré "
        "à partir des recherches fournies par le Chercheur."
    ),
    backstory=(
        "Plume affûtée de la rédaction tech. Tu sais transformer "
        "des notes de recherche brutes en contenu captivant. "
        "Ton style est direct, sans langue de bois, avec une pointe d'humour. "
        "Tu écris toujours en français."
    ),
    verbose=True,
    allow_delegation=False
)

# Agent 3 : le Relecteur
relecteur = Agent(
    role="Relecteur-Correcteur",
    goal=(
        "Relire l'article rédigé, corriger les fautes d'orthographe, "
        "de grammaire et améliorer la fluidité. Vérifier la cohérence."
    ),
    backstory=(
        "Correcteur professionnel avec 20 ans d'expérience dans la presse. "
        "Aucune coquille ne t'échappe. Tu es intraitable sur la grammaire "
        "mais respectueux du style de l'auteur."
    ),
    verbose=True,
    allow_delegation=False
)

Étape 3 : les tâches (le séquencement)

C'est ici que la magie opère. La tâche du Rédacteur utilise context=[tache_recherche] pour recevoir la sortie du Chercheur. Le Relecteur reçoit la sortie du Rédacteur.

python

# Tâche 1 : Recherche
tache_recherche = Task(
    description=(
        "Recherche les 3 actualités les plus importantes en intelligence "
        "artificielle de cette semaine (juillet 2026). Pour chaque actualité, "
        "trouve une source fiable, résume le sujet en 2-3 phrases, et note l'URL."
    ),
    expected_output=(
        "Un rapport de recherche structuré avec 3 actualités. "
        "Pour chacune : titre, résumé 2-3 phrases, source (URL). "
        "Format : markdown."
    ),
    agent=chercheur
)

# Tâche 2 : Rédaction (dépend de la recherche)
tache_redaction = Task(
    description=(
        "À partir du rapport de recherche fourni, rédige un article "
        "de 400-500 mots en français. Structure :"
        "\n1. Un titre accrocheur"
        "\n2. Une introduction qui donne le contexte"
        "\n3. Une section par actualité"
        "\n4. Une conclusion qui fait le lien entre les 3 actus"
    ),
    expected_output="Un article complet en markdown, 400-500 mots, en français.",
    agent=redacteur,
    context=[tache_recherche]  #  La sortie du chercheur devient l'entrée du rédacteur
)

# Tâche 3 : Relecture (dépend de la rédaction)
tache_relecture = Task(
    description=(
        "Relis l'article fourni. Corrige TOUTES les fautes d'orthographe "
        "et de grammaire. Améliore les tournures maladroites. "
        "Vérifie que tous les liens et URLs sont corrects. "
        "Retourne l'article corrigé EN ENTIER."
    ),
    expected_output="L'article intégralement relu et corrigé, en markdown.",
    agent=relecteur,
    context=[tache_redaction]  #  La sortie du rédacteur devient l'entrée du relecteur
)

Étape 4 : le lancement

python

# Assemblage et décollage
equipe = Crew(
    agents=[chercheur, redacteur, relecteur],
    tasks=[tache_recherche, tache_redaction, tache_relecture],
    verbose=True
)

print("\n LANCEMENT DE LA CREW JOURNALISTE\n")
article_final = equipe.kickoff()
print("\n" + "="*60)
print(" ARTICLE FINAL (relu et corrigé)")
print("="*60)
print(article_final)

Le script complet equipe_journalistes.py fait moins de 100 lignes. Copie-colle tout dans un fichier et lance :

bash

python3 equipe_journalistes.py

Tu vas voir CrewAI enchaîner les trois agents automatiquement. Le Relecteur ne démarre que quand le Rédacteur a fini, qui ne démarre que quand le Chercheur a fini. Aucune orchestration manuelle.

Ce que tu viens d'accomplir

En 30 minutes, tu as :

Installé CrewAI et créé ton premier agent
Compris le modèle Agent → Task → Crew
Construit une vraie équipe multi-agents avec chaînage
Produit un article complet avec recherche web

Le plus important : tu n'as pas eu à gérer toi-même l'enchaînement. CrewAI s'en charge.

Pièges classiques (et comment les éviter)

Piège	Solution
API key manquante : `SERPER_API_KEY` non définie	La recherche web échoue silencieusement. Crée un compte gratuit sur serper.dev
Agent qui boucle : le verbose montre qu'il répète la même action	Ajoute `allow_delegation=False` et sois plus précis dans `expected_output`
Contexte trop long : la recherche renvoie trop d'infos	Limite dans le `description` : « résume en 2-3 phrases »
Ollama trop lent : le modèle local rame	Passe à `llama3.2:1b` pour tester, ou utilise un modèle plus petit
Résultat en anglais : l'agent répond en anglais malgré les consignes	Ajoute « en français » dans le `backstory` ET le `goal` ET la `description`
Coût API : GPT-4o via OpenAI facture à l'usage	Passe par Ollama (gratuit) ou utilise `gpt-4o-mini` qui coûte 10x moins cher

Pour aller plus loin

Ajoute un 4e agent « Illustrateur » qui génère un prompt DALL·E ou Midjourney pour illustrer l'article. Le tool DallETool est inclus dans crewai-tools.

Planifie ta crew automatiquement — au lieu d'écrire les tâches à la main, utilise Crew(..., planning=True) et laisse CrewAI découper l'objectif en sous-tâches.

Crée une interface web avec Streamlit (le tuto est juste au-dessus !) pour que n'importe qui puisse saisir un sujet et recevoir un article généré par ta crew. Combine les deux tutoriels pour un projet complet.

Tu as maintenant une équipe d'agents IA qui bosse pour toi. La prochaine étape, c'est d'imaginer ce que TU veux automatiser : une veille concurrentielle quotidienne ? Un générateur de posts LinkedIn ? Un assistant de code qui se relit tout seul ? Avec CrewAI, la limite, c'est ton imagination.

Bon courage, et amuse-toi bien avec ta nouvelle armée d'agents !