CrewAI Tools : le guide complet des outils integres et comment les utiliser

Introduction

Dans CrewAI, un tool est la capacite brute qu'un agent utilise pour agir sur le monde reel.

Sans tool : l'agent ne fait que raisonner, il n'agit pas
Avec un tool : l'agent peut naviguer sur le web, lire des fichiers, executer du code, appeler des API

CrewAI adopte un modele tool-first : chaque agent recoit un ensemble de tools qu'il peut mobiliser quand sa tache l'exige.

Dans ce guide :

Le catalogue complet des tools integres avec exemples de code

Les patterns d'usage les plus courants

Comment creer un custom tool en 5 minutes

Les bonnes pratiques pour des tools robustes en production

Resume rapide des tools CrewAI

Tool	Categorie	Cas d'usage principal
`BrowserbaseScrapeTool`	Browser	Scraper le contenu d'une page web
`BrowserbaseLoadTool`	Browser	Charger une page et extraire le HTML
`DirectoryReadTool`	FileSystem	Lire le contenu d'un repertoire
`DirectoryWriteTool`	FileSystem	Ecrire des fichiers dans un repertoire
`FileReadTool`	FileSystem	Lire un fichier precis
`FileWriteTool`	FileSystem	Ecrire dans un fichier precis
`GithubSearchTool`	Search	Rechercher dans des repositories GitHub
`GoogleSearchTool`	Search	Recherche web via SerpAPI
`SerpApiSearchTool`	Search	Recherche avancee via SerpAPI
`MCPServerTool`	Integration	Appeler un serveur MCP externe
`JSONWriteFileTool`	FileSystem	Ecrire du JSON structure
`PDFSearchTool`	Search	Rechercher dans un document PDF

Le modele tool-first de CrewAI

Un tool n'est rien d'autre qu'une fonction Python decoratee que l'agent peut appeler.

Le decorateur @tool (fourni par crewai.tools) expose cette fonction au systeme d'agents avec :

Un nom : identifies the tool
Une description : guide le LLM dans son choix (cruciale)
Un schema de parametres : definit les entrees attendues

Comment le LLM choisit un tool

CrewAI utilise le function calling pour decide quel tool invoquer. Le cycle :

La tache est-elle realisable avec les tools disponibles ?
Quel tool est le plus pertinent pour cette etape ?
Le tool retourne-t-il le resultat attendu ?

Ce cycle se repete jusqu'a resolution complete.

Pourquoi la description est si importante

Une description floue ou generique : agent qui appelle le mauvais tool, ou aucun tool.

Mauvais exemple : "Utilise pour diverses taches"

Bon exemple : "Envoie un message dans un canal Slack. Utilise cet outil quand tu veux notifier une equipe ou declencher une alerte."

Les 3 familles de tools

Browser tools : interaction avec le web (scraping, chargement de pages)
FileSystem tools : lecture et ecriture locale de fichiers et repertoires
Search tools : recherche web ou dans des sources specifiques (GitHub, PDF, SerpAPI)
Custom tools : etendent le catalogue avec n'importe quelle capacite Python ou API

Catalogue complet des tools integres

Browser tools

BrowserbaseScrapeTool : scrape le contenu textuel d'une page web

from crewai import Agent
from crewai_tools import BrowserbaseScrapeTool

scrape_tool = BrowserbaseScrapeTool(
    api_key="your-browserbase-api-key",
    verbose=True
)

agent = Agent(
    role="veilleur web",
    goal="Extraire les dernieres nouvelles sur l'IA",
    tools=[scrape_tool],
    backstory="Tu es un analyste specialise en veille technologique."
)

BrowserbaseLoadTool : charge une page et retourne le HTML brut

from crewai_tools import BrowserbaseLoadTool

load_tool = BrowserbaseLoadTool(
    api_key="your-browserbase-api-key"
)

# L'agent charge l'URL via ce tool

FileSystem tools

DirectoryReadTool : liste et lit le contenu d'un repertoire

from crewai_tools import DirectoryReadTool

read_dir_tool = DirectoryReadTool(
    directory="./data"
)

# Retourne la liste des fichiers et sous-repertoires

DirectoryWriteTool : ecrit un ou plusieurs fichiers dans un repertoire

from crewai_tools import DirectoryWriteTool

write_dir_tool = DirectoryWriteTool(
    output_dir="./output"
)

# Ecrit les fichiers passes en parametre dans output_dir

FileReadTool : lit le contenu d'un fichier texte

from crewai_tools import FileReadTool

read_file_tool = FileReadTool(
    file_path="./config/settings.yaml"
)

# Retourne le contenu texte du fichier

FileWriteTool : ecrit du contenu dans un fichier

from crewai_tools import FileWriteTool

write_file_tool = FileWriteTool(
    file_path="./output/rapport.md"
)

# Ecrit le contenu fourni dans le fichier specifie

JSONWriteFileTool : ecrit des donnees structurees au format JSON

from crewai_tools import JSONWriteFileTool

json_tool = JSONWriteFileTool(
    file_path="./output/data.json"
)

# Serialize le dict Python en JSON et l'ecrit dans le fichier

Search tools

GoogleSearchTool : recherche web via Google (via SerpAPI)

from crewai_tools import GoogleSearchTool

google_tool = GoogleSearchTool(
    api_key="your-serpapi-api-key"
)

# L'agent invoque ce tool avec une query
# Retourne les resultats de recherche Google

SerpApiSearchTool : recherche avancee via SerpAPI avec parametres pousses

from crewai_tools import SerpApiSearchTool

serp_tool = SerpApiSearchTool(
    api_key="your-serpapi-api-key"
)

GithubSearchTool : recherche dans des repositories GitHub

from crewai_tools import GithubSearchTool

github_tool = GithubSearchTool(
    github_token="ghp_your_github_token"
)

# L'agent peut chercher des issues, code, repos

PDFSearchTool : recherche de texte dans un document PDF

from crewai_tools import PDFSearchTool

pdf_tool = PDFSearchTool(
    pdf_path="./documents/rapport-2025.pdf"
)

# Retourne les pages contenant la query recherchee

Integration tools

MCPServerTool : appelle un serveur MCP (Model Context Protocol)

from crewai_tools import MCPServerTool

mcp_tool = MCPServerTool(
    server_url="http://localhost:3000"
)

# Delegate l'appel a un serveur MCP qui expose des tools distants

Patterns d'usage courants

Deux chaines reviennent systematiquement dans les agents CrewAI en production.

Pattern 1 : Recherche - Extraction - Traitement

L'agent utilise GoogleSearchTool pour identifier les sources pertinentes, puis BrowserbaseScrapeTool pour extraire le contenu, puis un tool FileSystem pour stocker les resultats.

research_agent = Agent(
    role="analyste veille",
    goal="Constituer un dossier de veille sur {topic}",
    tools=[google_tool, scrape_tool, write_dir_tool],
    backstory="Tu es un analyste de veille sectorielle."
)

Pattern 2 : Scraping - Stockage - Alerting

L'agent scrape periodiquement une page, stocke le resultat en JSON, et notifie via un custom tool.

monitoring_agent = Agent(
    role="monitoring prix",
    goal="Detecter les variations de prix importantes",
    tools=[scrape_tool, json_tool, slack_tool],
    backstory="Tu surveilles les prix pour ton entreprise."
)

Creer un custom tool avec le decorateur `@tool`

Quand les tools natifs ne couvrent pas ton besoin, CrewAI permet de creer un custom tool en quelques minutes.

Structure minimale d'un custom tool

from crewai.tools import tool
import requests

# Option 1 : decorateur @tool (simple et rapide)
@tool
def send_slack_notification(channel: str, message: str) -> str:
    """Envoie un message dans un canal Slack."""
    webhook_url = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
    payload = {"channel": channel, "text": message}
    response = requests.post(webhook_url, json=payload)
    
    if response.status_code == 200:
        return f"Message envoye dans {channel}."
    return f"Echec de l'envoi Slack : {response.status_code}"

# Option 2 : classe BaseTool avec Pydantic (avance)
from crewai.tools import BaseTool
from pydantic import Field

class CallSlackAPITool(BaseTool):
    name: str = "envoi_slack"
    description: str = "Envoie un message dans un canal Slack donne. Utilise cet outil quand tu veux notifier une equipe ou declencher une alerte."
    
    def _run(self, channel: str, message: str) -> str:
        webhook_url = "https://hooks.slack.com/services/YOUR/WEBHOOK/URL"
        payload = {"channel": channel, "text": message}
        response = requests.post(webhook_url, json=payload)
        return f"Message envoye dans {channel} : {message}" if response.status_code == 200 else f"Echec : {response.status_code}"

Integration dans un agent

slack_agent = Agent(
    role="notificateur",
    goal="Alerter l'equipe en cas d'anomalie detectee",
    tools=[send_slack_notification],
    backstory="Tu gères les alertes et la communication d'equipe."
)

crew = Crew(
    agents=[slack_agent],
    tasks=[alerting_task],
    verbose=True
)

result = crew.kickoff()

Astuce : Le decorateur @tool genere automatiquement le schema de parametres. Plus la description est precise, plus l'agent l'invoque correctement.

Cas d'usage : tool de recherche vectorielle avec ChromaDB

from crewai.tools import tool
import chromadb

@tool
def query_vector_db(query: str, top_k: int = 5) -> str:
    """Interroge une base vectorielle ChromaDB et retourne les top_k documents les plus similaires a la query."""
    client = chromadb.Client()
    collection = client.get_collection(name="knowledge_base")
    results = collection.query(
        query_texts=[query],
        n_results=top_k
    )
    
    if not results["documents"]:
        return "Aucun resultat trouve pour cette query."
    
    formatted = "\n".join([
        f"- {doc} (distance: {dist:.4f})"
        for doc, dist in zip(results["documents"][0], results["distances"][0])
    ])
    return formatted

search_agent = Agent(
    role="assistant knowledge",
    goal="Repondre aux questions en utilisant la base de connaissances interne",
    tools=[query_vector_db],
    backstory="Tu es un assistant qui repond en s'appuyant sur la documentation interne."
)

Exemple concret : agent de veille IA complet

Construisons un agent de veille IA avec CrewAI. Use case : scraper automatiquement les derniers articles sur un topic precis, extraire les informations cles, et stocker un rapport structure.

Setup

pip install crewai crewai-tools browserbase serpent-api chromadb

Code de l'agent

from crewai import Agent, Crew, Task
from crewai.tools import tool
from crewai_tools import GoogleSearchTool, BrowserbaseScrapeTool, FileWriteTool, JSONWriteFileTool

@tool
def extract_key_insights(content: str) -> str:
    """Extrait les idees principales d'un contenu textuel."""
    lines = [l.strip() for l in content.split("\n") if l.strip()]
    return "\n".join(lines[:5])

search_tool = GoogleSearchTool(api_key="your-serpapi-key")
scrape_tool = BrowserbaseScrapeTool(api_key="your-browserbase-key")
write_tool = FileWriteTool(file_path="./output/veille.md")
json_tool = JSONWriteFileTool(file_path="./output/veille.json")

veille_agent = Agent(
    role="analyste veille IA",
    goal="Constituer un dossier de veille complet sur {topic}",
    tools=[search_tool, scrape_tool, extract_key_insights, write_tool, json_tool],
    backstory="Tu es un analyste specialise en veille technologique et IA."
)

veille_task = Task(
    description=(
        "Recherche les 5 derniers articles sur {topic}. "
        "Pour chaque article : scrape le contenu, extrais les insights cles, "
        "puis stocke le rapport final en Markdown et JSON."
    ),
    agent=veille_agent,
    expected_output="Un rapport de veille structure en Markdown et JSON."
)

crew = Crew(
    agents=[veille_agent],
    tasks=[veille_task],
    verbose=True
)

result = crew.kickoff()
print(result)

Resultat attendu

output/veille.md : rapport format
output/veille.json : donnees structurees pretes pour un dashboard ou une base vectorielle

Bonnes pratiques

1. Descriptions de tools : precisez et actionnez

La description d'un tool est le seul signal que le LLM utilise pour decide de l'invoquer.

Mauvais exemple : "Utilise pour diverses taches"
Bon exemple : "Envoie un message dans un canal Slack. Utilise cet outil quand tu veux notifier une equipe ou declencher une alerte."

2. Timeout et gestion d'erreurs

Les appels reseau sont la cause n1 d'echec des tools. Configure toujours un timeout raisonnable :

@tool
def fetch_data(url: str) -> str:
    """Recupere le contenu d'une URL."""
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        return response.text[:5000]  # Limiter la taille du retour
    except requests.Timeout:
        return "Timeout : l'URL n'a pas repondu dans les 10 secondes."
    except requests.RequestException as e:
        return f"Erreur de requete : {str(e)}"

3. Limiter la taille des retours

Un tool qui retourne 50 000 tokens fait derrailler le contexte de l'agent.

Regle : tronquez toujours les retours volumineux avant de les retourner a l'agent.

4. Testabilite

Chaque custom tool devrait etre testable independamment de l'agent :

def test_slack_tool():
    result = send_slack_notification(channel="#test", message="Test")
    assert "envoye" in result.lower()
    
test_slack_tool()  # Doit passer avant integration

5. Securite : prompt injection dans les descriptions

Les descriptions de tools sont visibles par le LLM : elles peuvent etre manipulees par un utilisateur malveillant.

Bonne pratique : traite les entrees utilisateur dans les tools comme non fiables et applique une sanitization.

Questions frequentes

Quels sont les tools integres disponibles dans CrewAI ?

CrewAI propose des tools natifs dans trois categories :

Browser tools : BrowserbaseScrapeTool, BrowserbaseLoadTool
FileSystem tools : DirectoryReadTool, DirectoryWriteTool, FileReadTool, FileWriteTool, JSONWriteFileTool
Search tools : GoogleSearchTool, SerpApiSearchTool, GithubSearchTool, PDFSearchTool

Tous sont accessibles via le package crewai-tools.

Peut-on utiliser CrewAI sans Browserbase ou SerpAPI ?

Oui, mais partiellement.

Les FileSystem tools et les custom tools fonctionnent sans service externe
Les Browser tools et Search tools necessitent des cles API (Browserbase, SerpAPI)
Alternative : creer des custom tools avec playwright ou requests directs

Comment creer un custom tool dans CrewAI ?

Import from crewai.tools import tool
Definis une fonction avec une docstring : elle sert de description au LLM
Les parametres de la fonction sont automatiquement exposes pour le function calling
Retourne toujours une chaine de caracteres lisible

Difference entre FileReadTool et DirectoryReadTool ?

	FileReadTool	DirectoryReadTool
Cible	Un fichier precis	Un repertoire entier
Parametre	`file_path`	`directory`
Retour	Contenu texte du fichier	Liste des fichiers + structure des sous-dossiers

CrewAI supporte-t-il les tools MCP ?

Oui. Via MCPServerTool qui permet de se connecter a un serveur MCP (Model Context Protocol).

Cela ouvre l'integration avec des services comme Notion, Linear, ou n'importe quel outil qui expose une interface MCP.

Articles lies

Les tools sont le muscle de l'agent : sans une bonne comprehension des agents eux-memes et de leur architecture, les tools restent des outils isoles.

Pour aller plus loin :

Guide complet sur CrewAI : installation, concepts de base, creation d'une premiere crew
Tutoriel d'installation : pour debuter avec CrewAI pas a pas
Outils pour agents IA : panorama complet des capacites agentiques
CrewAI vs ses rivaux : forces et limites de chaque framework

CrewAI Tools : le guide complet des outils integres