> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-fr/plateformes-ia-et-agents/crewai.md).

# Framework multi-agents CrewAI

Déployez CrewAI sur Clore.ai — orchestrez des équipes d'agents IA autonomes jouant des rôles pour des tâches complexes à plusieurs étapes avec n'importe quel fournisseur de LLM.

## Aperçu

[CrewAI](https://github.com/crewAIInc/crewAI) est un cadre de pointe pour orchestrer **des agents IA autonomes jouant des rôles**, avec **plus de 44 k étoiles sur GitHub**Contrairement aux systèmes à agent unique, CrewAI vous permet de définir des agents spécialisés (Chercheur, Rédacteur, Codeur, Analyste...) qui collaborent comme un « équipage » pour accomplir des tâches complexes — chaque agent ayant son propre rôle, objectif, historique et boîte à outils.

Sur **Clore.ai**, CrewAI peut être déployé dans un environnement conteneurisé Docker pour aussi peu que **$0.05–0.20/hr**Bien que CrewAI lui-même soit limité par le CPU (il orchestre des appels API), le combiner avec un serveur local Ollama ou vLLM sur le même nœud GPU vous donne un système multi-agents totalement privé, capable de fonctionner hors ligne.

**Fonctionnalités clés :**

* 👥 **Équipages multi-agents** — définissez des personas d'agents avec rôles, objectifs et historiques
* 🎯 **Délégation des tâches** — l'agent gestionnaire attribue automatiquement les tâches au bon spécialiste
* 🛠️ **Écosystème d'outils** — recherche web, E/S de fichiers, exécution de code, accès aux bases de données, outils personnalisés
* 🔁 **Séquentiel et parallèle** — exécutez les tâches dans l'ordre ou exécutez des tâches indépendantes simultanément
* 🧠 **Mémoire des agents** — types de mémoire à court terme, à long terme, d'entité et contextuelle
* 🔌 **Indépendant du LLM** — fonctionne avec OpenAI, Anthropic, Google, Ollama, Groq, Azure et plus encore
* 📊 **CrewAI Studio** — interface visuelle pour créer des équipages sans code (entreprise)
* 🚀 **Pipelines** — enchaînez plusieurs équipages pour des workflows complexes à plusieurs étapes

***

## Exigences

CrewAI est une bibliothèque Python. Elle s'exécute sur CPU et ne nécessite qu'un environnement système Python 3.10+ ou Docker. Le GPU est facultatif, mais il débloque une inférence locale puissante des modèles.

| Configuration                    | GPU             | VRAM  | RAM système | Disque | Prix Clore.ai                             |
| -------------------------------- | --------------- | ----- | ----------- | ------ | ----------------------------------------- |
| **Minime** (API cloud)           | Aucun / CPU     | —     | 2 Go        | 10 Go  | \~0,03 $/h (CPU)                          |
| **Standard**                     | Aucun / CPU     | —     | 4 Go        | 20 Go  | \~0,05 $/h                                |
| **+ LLM local (petit)**          | RTX 3080        | 10 Go | 8 Go        | 40 Go  | 0,05–0,19 $/h                             |
| **+ LLM local (grand)**          | RTX 3090 / 4090 | 24 Go | 16 Go       | 60 Go  | 0,07–0,21 $/h                             |
| **+ LLM local de haute qualité** | A100 40 Go      | 40 Go | 32 Go       | 100 Go | [bare metal](https://clore.ai/bare-metal) |

### Clés API

CrewAI fonctionne avec la plupart des principaux fournisseurs de LLM. Il vous en faut au moins un :

* **OpenAI** — GPT-4o (meilleur raisonnement pour les tâches complexes)
* **Anthropic** — Claude 3.5 Sonnet (excellent pour les équipes orientées rédaction)
* **Groq** — formule gratuite, inférence rapide (Llama 3 70B)
* **Ollama** — entièrement local, aucune clé API requise (voir [Accélération GPU](#gpu-acceleration))

***

## Démarrage rapide

### 1. Louez un serveur Clore.ai

Connectez-vous à [clore.ai](https://clore.ai):

* **CPU uniquement** si vous utilisez des API LLM cloud
* **RTX 3090/4090** pour l'inférence locale Ollama
* Accès SSH activé
* Aucune exigence particulière de port pour l'utilisation en ligne de commande (n'exposez des ports que pour les interfaces web)

### 2. Connectez-vous et préparez l'environnement

```bash
ssh root@<clore-server-ip> -p <ssh-port>

# Mettre à jour le système
apt-get update && apt-get upgrade -y

# Installer Python 3.11 (si absent)
apt-get install -y python3.11 python3.11-venv python3-pip
python3 --version   # Doit être 3.10+

# Vérifier Docker
docker --version
```

### 3. Option A — Installation directe via pip (la plus rapide)

```bash
# Créez un environnement virtuel
python3 -m venv crewai-env
source crewai-env/bin/activate

# Installez CrewAI avec tous les outils
pip install crewai crewai-tools

# Vérifier l'installation
python -c "import crewai; print(crewai.__version__)"
crewai --version
```

### 4. Option B — Conteneur Docker (recommandé pour la reproductibilité)

```bash
# Créez le répertoire du projet
mkdir my-crew && cd my-crew

# Écrivez le Dockerfile
cat > Dockerfile << 'EOF'
FROM python:3.11-slim

# Installez les dépendances système
RUN apt-get update && apt-get install -y \
    curl \
    git \
    && rm -rf /var/lib/apt/lists/*

# Définissez le répertoire de travail
WORKDIR /app

# Installez CrewAI et les outils courants
RUN pip install --no-cache-dir \
    crewai \
    crewai-tools \
    langchain-openai \
    langchain-anthropic \
    python-dotenv

# Copiez le code de l'application
COPY . .

# Commande par défaut
CMD ["python", "main.py"]
EOF

# Construisez l'image
docker build -t my-crewai-app .
```

### 5. Créez votre premier équipage

```bash
# Initialisez un nouveau projet CrewAI à l'aide de la CLI
source crewai-env/bin/activate
crewai create crew my-research-crew
cd my-research-crew

# Configurez les clés API
cat > .env << 'EOF'
OPENAI_API_KEY=sk-...
# Ou pour Anthropic :
# ANTHROPIC_API_KEY=sk-ant-...
# Ou pour Ollama (aucune clé nécessaire) :
# OPENAI_API_BASE=http://localhost:11434/v1
# OPENAI_API_KEY=ollama
EOF

# Installez les dépendances du projet
crewai install

# Exécutez l'équipage
crewai run
```

***

## Configuration

### Structure du projet (depuis `crewai create`)

```
my-research-crew/
├── .env                    # Clés API et paramètres
├── pyproject.toml          # Dépendances
├── src/
│   └── my_research_crew/
│       ├── config/
│       │   ├── agents.yaml   # Définitions des agents
│       │   └── tasks.yaml    # Définitions des tâches
│       ├── tools/
│       │   └── custom_tool.py  # Vos outils personnalisés
│       ├── crew.py           # Assemblage de l'équipage
│       └── main.py           # Point d'entrée
```

### agents.yaml — Définissez vos agents

```yaml
researcher:
  role: >
    Analyste principal en recherche
  goal: >
    Mettre au jour les avancées de pointe dans {topic} et synthétiser des informations exploitables
  backstory: >
    Vous êtes un chercheur expert doué pour trouver et relier des informations
    issues de sources diverses. Vous avez un œil aiguisé pour la crédibilité et la pertinence.
  tools:
    - SerperDevTool
    - ScrapeWebsiteTool
  llm: gpt-4o                # Peut être défini par agent
  verbose: true
  max_iter: 15               # Nombre maximal d'itérations de raisonnement
  memory: true               # Activer la mémoire de l'agent

writer:
  role: >
    Rédacteur technique expert
  goal: >
    Transformez des recherches complexes en contenu clair, convaincant et précis
  backstory: >
    Vous rédigez des explications qui rendent les sujets complexes accessibles sans sacrifier la profondeur.
    Vous citez vos sources et structurez le contenu pour une lisibilité maximale.
  llm: claude-3-5-sonnet-20241022
  verbose: true
```

### tasks.yaml — Définissez les tâches

```yaml
research_task:
  description: >
    Recherchez les dernières avancées dans {topic} au cours des 6 derniers mois.
    Identifiez les grandes tendances, les percées et les implications.
    Compilez au moins 10 sources crédibles.
  expected_output: >
    Un rapport de recherche détaillé avec des résultats organisés par thème,
    incluant les URL des sources et les dates de publication.
  agent: researcher

writing_task:
  description: >
    À partir du rapport de recherche, rédigez un article de blog complet sur {topic}.
    Longueur cible : 1500 à 2000 mots. Incluez un titre, une introduction, des sections principales,
    et une conclusion avec une perspective d'avenir.
  expected_output: >
    Un article de blog prêt à être publié au format Markdown.
  agent: writer
  context:
    - research_task    # La tâche d'écriture reçoit la production du chercheur
  output_file: output/blog_post.md
```

### crew\.py — Assemblez l'équipage

```python
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task
from crewai_tools import SerperDevTool, ScrapeWebsiteTool

@CrewBase
class MyResearchCrew():
    """Équipage de recherche et de rédaction"""
    agents_config = 'config/agents.yaml'
    tasks_config = 'config/tasks.yaml'

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            tools=[SerperDevTool(), ScrapeWebsiteTool()],
            verbose=True
        )

    @agent
    def writer(self) -> Agent:
        return Agent(
            config=self.agents_config['writer'],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(config=self.tasks_config['research_task'])

    @task
    def writing_task(self) -> Task:
        return Task(
            config=self.tasks_config['writing_task'],
            output_file='output/blog_post.md'
        )

    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,  # ou Process.hierarchical
            verbose=True,
            memory=True,
            max_rpm=10   # Limite le débit des appels API
        )
```

### Exécution avec Docker Compose (avec Ollama)

```yaml
# docker-compose.yml
version: "3.8"

services:
  crewai:
    build: .
    volumes:
      - ./src:/app/src
      - ./output:/app/output
    environment :
      - OPENAI_API_BASE=http://ollama:11434/v1
      - OPENAI_API_KEY=ollama
      - OPENAI_MODEL_NAME=llama3.1:70b
      - SERPER_API_KEY=${SERPER_API_KEY}
    depends_on :
      - ollama

  ollama:
    image: ollama/ollama:latest
    volumes:
      - ollama_data:/root/.ollama
    ports:
      - "11434:11434"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama_data:
```

```bash
# Démarrez la pile
docker compose up -d ollama

# Téléchargez votre modèle
docker compose exec ollama ollama pull llama3.1:70b

# Exécutez votre équipage
docker compose run --rm crewai python src/my_research_crew/main.py
```

***

## Accélération GPU

CrewAI lui-même n'utilise pas le GPU — mais le LLM qu'il appelle, oui. Exécutez Ollama ou vLLM sur le même serveur Clore pour une inférence locale accélérée par GPU.

### Configuration d'Ollama (recommandée pour la simplicité)

```bash
# Installez Ollama sur l'hôte
curl -fsSL https://ollama.com/install.sh | sh

# Vérifiez la détection du GPU
nvidia-smi
ollama run llama3:8b "Test"   # Doit utiliser le GPU

# Téléchargez les modèles selon les besoins des différents agents
ollama pull llama3.1:8b          # Raisonnement rapide et léger
ollama pull llama3.1:70b         # Raisonnement complexe (nécessite A100+)
ollama pull codestral:latest     # Spécialisé pour les agents de code
ollama pull nomic-embed-text     # Pour les embeddings de mémoire/RAG

# Configurez CrewAI pour utiliser Ollama
export OPENAI_API_BASE=http://localhost:11434/v1
export OPENAI_API_KEY=ollama
export OPENAI_MODEL_NAME=llama3.1:8b
```

### Configurez le LLM CrewAI par agent

```python
from crewai import Agent, LLM

# Utilisez Ollama pour un agent spécifique
local_llm = LLM(
    model="ollama/llama3.1:8b",
    base_url="http://localhost:11434"
)

# Utilisez l'API cloud pour un autre agent (par exemple, pour un raisonnement complexe)
cloud_llm = LLM(
    model="gpt-4o",
    api_key="sk-..."
)

researcher = Agent(
    role="Chercheur",
    goal="Trouver des informations",
    backstory="Chercheur expert",
    llm=local_llm    # Utilise le GPU local
)

strategist = Agent(
    role="Stratège",
    goal="Planifier les actions",
    backstory="Esprit stratégique",
    llm=cloud_llm    # Utilise l'API cloud
)
```

### Recommandations de modèles pour les tâches des agents

| Type de tâche             | Modèle recommandé | VRAM   | Remarques                   |
| ------------------------- | ----------------- | ------ | --------------------------- |
| Recherche + recherche web | Llama 3.1 70B     | 40 Go  | Meilleur raisonnement local |
| Génération de code        | Codestral 22B     | 13 Go  | Spécialisé pour le code     |
| Rédaction                 | Llama 3.1 8B      | 6 Go   | Rapide, de bonne qualité    |
| Orchestration complexe    | GPT-4o (API)      | —      | Meilleur dans l'ensemble    |
| Embeddings/mémoire        | nomic-embed-text  | < 1 Go | Requis pour la mémoire      |

> Voir [Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md) et [vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md) pour les guides complets de configuration de l'inférence.

***

## Conseils et bonnes pratiques

### Optimisation des coûts

```bash
# Suivez les coûts des API LLM avec le suivi d'utilisation intégré de CrewAI
# Ajoutez à votre équipage :
result = crew.kickoff(inputs={"topic": "AI agents"})
print(f"Nombre total de jetons utilisés : {result.token_usage}")

# Utilisez des modèles moins coûteux pour les tâches simples, des modèles premium pour les tâches complexes
# Llama 3.1 8B sur Ollama = 0 $ de coût API
# GPT-4o = ~0,005 $/1K jetons d'entrée

# Définissez max_iter pour éviter les agents incontrôlables
Agent(max_iter=10, max_execution_time=120)  # Délai d'attente de 2 minutes

# Mettez en cache les réponses du LLM pendant le développement
os.environ["CREWAI_DISABLE_CACHE"] = "false"
```

### Exécuter des équipages comme service persistant

```bash
# Servez les équipages via un point de terminaison FastAPI
pip install fastapi uvicorn

cat > server.py << 'EOF'
from fastapi import FastAPI, BackgroundTasks
from my_research_crew.crew import MyResearchCrew
import asyncio

app = FastAPI()
results = {}

@app.post("/run/{topic}")
async def run_crew(topic: str, background_tasks: BackgroundTasks):
    job_id = f"job-{topic}-{len(results)}"
    background_tasks.add_task(execute_crew, job_id, topic)
    return {"job_id": job_id, "status": "started"}

async def execute_crew(job_id: str, topic: str):
    crew = MyResearchCrew().crew()
    result = crew.kickoff(inputs={"topic": topic})
    results[job_id] = str(result)

@app.get("/result/{job_id}")
async def get_result(job_id: str):
    return {"result": results.get(job_id, "pending")}

EOF

# Lancer le serveur
uvicorn server:app --host 0.0.0.0 --port 8080 &

# Déclencher une exécution de crew
curl -X POST http://<clore-ip>:8080/run/quantum-computing
```

### Outils intégrés utiles de CrewAI

```python
from crewai_tools import (
    SerperDevTool,        # Recherche Google via l’API Serper
    ScrapeWebsiteTool,    # Extraction de données web
    FileReadTool,         # Lire des fichiers locaux
    FileWriterTool,       # Écrire des fichiers
    DirectoryReadTool,    # Lister le contenu d’un répertoire
    CodeInterpreterTool,  # Exécuter du code Python
    GithubSearchTool,     # Rechercher dans des dépôts GitHub
    YoutubeVideoSearchTool, # Rechercher sur YouTube
    PGSearchTool,         # Interroger PostgreSQL
)
```

### Mise en œuvre du human-in-the-loop

```python
# Demander une saisie humaine pour une tâche spécifique
task = Task(
    description="Recherche sur {topic}",
    expected_output="Rapport de recherche",
    agent=researcher,
    human_input=True    # Met en pause et invite l'utilisateur à fournir un retour
)
```

***

## Dépannage

### "openai.AuthenticationError" même avec une clé valide

```bash
# Vérifiez que votre clé API est chargée
python3 -c "import os; from dotenv import load_dotenv; load_dotenv(); print(os.getenv('OPENAI_API_KEY')[:10])"

# Si vous utilisez Ollama, assurez-vous que ces éléments sont définis :
export OPENAI_API_BASE=http://localhost:11434/v1
export OPENAI_API_KEY=ollama
export OPENAI_MODEL_NAME=llama3.1:8b

# Vérifiez qu'Ollama est accessible
curl http://localhost:11434/v1/models
```

### Agent bloqué dans une boucle de raisonnement

```bash
# Définissez une limite stricte sur les itérations
Agent(
    max_iter=10,            # Nombre maximal d'étapes de raisonnement
    max_execution_time=300  # Délai d'expiration strict de 5 minutes
)

# Activez le mode verbeux pour voir où il boucle
Agent(verbose=True)

# Vérifiez si le modèle prend en charge l'appel d'outils
# Certains modèles plus petits ne le font pas ; utilisez llama3.1 ou mistral-nemo
```

### Les outils CrewAI échouent (SerperDevTool 403)

```bash
# SerperDevTool nécessite une clé API gratuite de serper.dev
export SERPER_API_KEY=your-serper-key

# Alternative : utilisez DuckDuckGo (aucune clé API requise)
from langchain_community.tools import DuckDuckGoSearchRun
from crewai import tool

@tool("Recherche DuckDuckGo")
def ddg_search(query: str) -> str:
    """Rechercher sur le web avec DuckDuckGo."""
    return DuckDuckGoSearchRun().run(query)
```

### Erreurs de mémoire (ChromaDB / embeddings)

```bash
# La mémoire de CrewAI utilise ChromaDB pour le stockage vectoriel
# En cas d'échec, vérifiez l'espace disque et les permissions
df -h
ls -la ~/.local/share/crewai/

# Effacez la mémoire corrompue
rm -rf ~/.local/share/crewai/

# Ou désactivez la mémoire si elle n'est pas nécessaire
Crew(memory=False)

# Si vous utilisez des embeddings Ollama, assurez-vous que le modèle a été téléchargé
docker exec ollama ollama pull nomic-embed-text
```

### La construction Docker échoue en cas de non-correspondance ARM/x86

```bash
# Les serveurs Clore.ai sont en x86_64 ; spécifiez explicitement la plateforme :
docker build --platform linux/amd64 -t my-crewai-app .

# Ou dans docker-compose.yml :
services:
  crewai:
    platform: linux/amd64
    build: .
```

### Limitation de débit des API LLM

```bash
# Réduisez les requêtes par minute
Crew(max_rpm=5)   # 5 requêtes par minute

# Ajoutez une logique de nouvelle tentative dans la configuration LLM
LLM(
    model="gpt-4o",
    max_retries=3,
    timeout=60
)
```

***

## Pour aller plus loin

* [Documentation officielle de CrewAI](https://docs.crewai.com)
* [Dépôt GitHub de CrewAI](https://github.com/crewAIInc/crewAI)
* [Documentation des outils CrewAI](https://docs.crewai.com/concepts/tools)
* [Dépôt d'exemples CrewAI](https://github.com/crewAIInc/crewAI-examples)
* [Exécuter Ollama sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/ollama.md)
* [Exécuter vLLM sur Clore.ai](/guides/guides_v2-fr/modeles-de-langage/vllm.md)
* [Comparaison des GPU Clore.ai](/guides/guides_v2-fr/premiers-pas/gpu-comparison.md)
* [Discord de la communauté CrewAI](https://discord.com/invite/X4JWnZnxPb)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-fr/plateformes-ia-et-agents/crewai.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.