Skip to content
Learni
Voir tous les tutoriels
Intelligence Artificielle

Comment orchestrer des crews d'agents IA avec CrewAI en 2026

22 minEXPERT
Python IACrewAIAgents IAMulti-AgentsOutils Custom
Read in English

Introduction

CrewAI est un framework Python open-source révolutionnaire pour orchestrer des crews d'agents IA autonomes, conçu pour des workflows complexes en 2026. Contrairement à LangChain qui se concentre sur les chaînes linéaires, CrewAI excelle dans la collaboration multi-agents : chaque agent a un rôle, des outils et une mémoire, comme une équipe de spécialistes en entreprise. Imaginez un researcher qui fouille le web, un analyst qui synthétise les données, et un writer qui rédige un rapport – tout orchestré automatiquement.

Pourquoi c'est crucial en 2026 ? Avec l'essor des LLMs comme GPT-5 et Claude 4, les agents isolés ne suffisent plus ; les crews gèrent des tâches réelles comme l'analyse concurrentielle, la génération de code ou l'automatisation DevOps. Ce tutoriel expert vous guide de A à Z : installation, agents basiques, tâches hiérarchiques, outils custom, mémoire persistante et inputs humains. À la fin, vous bookmarkerez ce guide pour vos projets prod. Prêt à scaler vos IA ? (128 mots)

Prérequis

  • Python 3.11+ installé
  • Clé API OpenAI (ou Grok, Anthropic) : export OPENAI_API_KEY=sk-...
  • pip install crewai==0.51.1 crewai[tools]
  • Connaissances avancées en Python, LLMs et async/await
  • IDE comme VS Code avec Pylance pour le typage
  • Git pour versionner vos crews

Installation et setup environnement

terminal
python -m venv crewai-env
source crewai-env/bin/activate  # Linux/Mac
# crewai-env\Scripts\activate  # Windows

pip install --upgrade pip
pip install 'crewai[tools]'==0.51.1
pip install 'crewai-tools[serpapi,yfinance]'==0.8.1
pip install langchain-openai==0.2.2
pip install duckduckgo-search

mkdir crewai-project
cd crewai-project
touch agents.py tasks.py crew.py tools.py main.py

# Dans .env
cat > .env << EOF
OPENAI_API_KEY=sk-your-key-here
SERPAPI_API_KEY=your-serpapi-key  # Optionnel pour recherche web
EOF

Ce script crée un environnement virtuel isolé, installe CrewAI avec outils intégrés (Serper pour recherche, YFinance pour finance) et LangChain-OpenAI. Les outils comme DuckDuckGo sont gratuits. Copiez-collez pour un setup en 2 min ; évitez les globals pour prévenir les conflits de versions en prod.

Concepts fondamentaux : Agents, Tâches et Crews

Un agent est un LLM avec rôle, backstory, outils et LLM spécifique – comme un employé expert. Une tâche assigne un objectif à un agent, avec contexte, output format et dépendances. Un crew orchestre tout : délégation automatique, verbose pour debug. En mode expert, priorisez process=hierarchical pour une supervision CEO-like, ou manager pour décisions dynamiques. Analogie : un crew est une startup agile où le manager priorise les tâches en temps réel.

Agents et tâches basiques

agents.py
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool, tool
from langchain_openai import ChatOpenAI
import os

llm = ChatOpenAI(model="gpt-4o", temperature=0)

researcher = Agent(
    role="Senior Market Researcher",
    goal="Identifier les tendances clés sur {topic}",
    backstory="""Tu es un analyste de marché chevronné avec 20 ans d'expérience.
    Tu utilises des données fraîches du web pour des insights précis.""",
    tools=[SerperDevTool()],
    llm=llm,
    verbose=True
)

analyst = Agent(
    role="Data Analyst",
    goal="Analyser les données de recherche pour des recommandations actionnables",
    backstory="Expert en stats et visualisation, tu transformes raw data en insights business.",
    llm=llm,
    verbose=True
)

task1 = Task(
    description="Recherche les 5 dernières tendances sur {topic} via web search.",
    expected_output="Rapport structuré avec sources et bullet points.",
    agent=researcher
)

task2 = Task(
    description="Analyse le rapport de recherche et propose 3 recommandations prioritaires.",
    expected_output="Synthèse en JSON : {{'recommendations': [...], 'priorities': [...]}}",
    context=[task1],
    agent=analyst
)

Définit deux agents collaboratifs avec outils (Serper pour search). Les tâches ont dépendances via context=[task1]. Utilisez verbose=True pour tracer les appels LLM. Piège : oubliez tools sans importer ; testez avec topic='IA en 2026'.

Créer et exécuter un crew simple

crew.py
from agents import researcher, analyst, task1, task2

crew = Crew(
    agents=[researcher, analyst],
    tasks=[task1, task2],
    process=Process.sequential,  # Ou hierarchical
    verbose=2,
    memory=True
)

result = crew.kickoff(inputs={'topic': 'CrewAI avancées 2026'})
print(result)

Assemble le crew en séquentiel (task1 → task2). memory=True active mémoire short-term partagée. kickoff(inputs=...) lance ; output est raw string. En prod, wrappez en async pour scalabilité.

Niveau intermédiaire : Outils custom et mémoire

Outils custom étendent les agents comme des fonctions Python exposées au LLM – parfaits pour APIs privées. La mémoire (short/long-term) persiste le contexte multi-runs, cruciale pour conversations longues. En 2026, intégrez VectorStores comme FAISS pour RAG avancé.

Outil custom et crew avec mémoire

tools.py
from crewai_tools import BaseTool
from langchain_community.tools import DuckDuckGoSearchRun

@tool("News Summarizer")
def summarize_news(query: str) -> str:
    """Résume les dernières news sur un topic."""
    search = DuckDuckGoSearchRun()
    results = search.run(query)
    # Simulation summary (remplacez par LLM call)
    return f"Résumé news {query}: {results[:200]}... Sources citées."

# Dans main.py ou crew.py
# Ajoutez à researcher.tools = [SerperDevTool(), summarize_news]

from crewai import Memory

crew = Crew(
    agents=[researcher, analyst],
    tasks=[task1, task2],
    process=Process.sequential,
    memory=Memory(
        short_term=True,
        long_term=True  # Nécessite embedder comme OpenAIEmbeddings
    ),
    verbose=2
)

result = crew.kickoff(inputs={'topic': 'CrewAI en finance 2026'})

Crée un tool décoré @tool qui encapsule DuckDuckGo. Ajoutez à agent.tools. Memory(long_term=True) stocke embeddings pour recall. Piège : long-term nécessite pip install crewai[long-term-memory] et embeddings config.

Processus hiérarchique avec manager

hierarchical_crew.py
from crewai import Agent, Crew, Process, Task
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o")

manager = Agent(
    role="Project Manager",
    goal="Coordonner la recherche et analyse sur {topic}",
    backstory="Manager senior qui délègue et valide outputs.",
    llm=llm,
    verbose=True
)

researcher = Agent(  # Comme avant
    role="Researcher",
    goal="Rechercher {topic}",
    llm=llm,
    verbose=True
)

writer = Agent(
    role="Writer",
    goal="Rédiger rapport final",
    llm=llm,
    verbose=True
)

task_research = Task(description="Recherche complète {topic}", agent=researcher)
task_write = Task(description="Rédige rapport basé sur recherche", agent=writer, context=[task_research])

crew = Crew(
    agents=[manager, researcher, writer],
    tasks=[task_research, task_write],
    process=Process.hierarchical,  # Manager supervise
    manager_llm=llm,
    verbose=2
)

result = crew.kickoff(inputs={'topic': 'Tendances IA 2026'})
print(result)

Mode hierarchical : manager décompose/délègue dynamiquement. manager_llm pour décisions. Idéal pour tâches ambiguës. Avantage : adaptatif ; piège : coûts LLM x2 si mal calibré.

Avancé : Input humain et delegation

HumanInputTool permet feedback loop : agent pause pour approbation humaine. Delegation auto entre agents via goals. En prod 2026, chainnez avec Streamlit pour UI interactive.

Crew avec input humain et exécution main

main.py
import os
from dotenv import load_dotenv
from crewai import Crew
from agents import researcher, analyst, task1, task2  # Imports

load_dotenv()

crew = Crew(
    agents=[researcher, analyst],
    tasks=[task1, task2],
    verbose=2,
    share_crew=True  # Pour callbacks
)

# Exécution avec input dynamique
inputs = {'topic': input("Entrez le topic: ") or 'CrewAI expert'}
result = crew.kickoff(inputs=inputs)
print("Output final:", result)

# Pour human input, ajoutez HumanInputTool à tools et référencez dans task

Script main complet : charge .env, input CLI, exécute. share_crew=True pour reuse. Ajoutez from crewai_tools import HumanInputTool pour pauses interactives. Fonctionnel out-of-box.

Bonnes pratiques

  • Prompt engineering strict : backstory > 200 mots pour rôle clair ; utilisez JSON outputs pour parsabilité.
  • Rate limiting & caching : Intégrez crewai-tools avec Redis pour éviter LLM quotas.
  • Monitoring : verbose=2 + LangSmith tracing ; loggez crew.last_messages.
  • Scalabilité : Async crews avec crew.kickoff_async() ; déploiez sur Ray pour multi-crews.
  • Sécurité : Validez tools inputs ; utilisez Guardrails pour outputs sensibles.

Erreurs courantes à éviter

  • Pas de context chaining : Oublier context=[prev_task] → perte d'infos ; toujours lier.
  • Outils non importés : LLM ignore tools sans @tool ou listage ; testez isolated.
  • Mémoire sans embeddings : Long-term crash sans pip install faiss-cpu et config.
  • Process mal choisi : Sequential pour linéaire, hierarchical pour complexe – benchmarkez coûts.

Pour aller plus loin

Plongez dans les formations Learni sur l'IA avancée : CrewAI + AutoGen hybride. Docs officielles : crewAI GitHub. Exemples prod : intégrez avec FastAPI pour API crews. Communauté Discord CrewAI pour cas réels. Next step : hierarchical multi-crews pour simulations business.