À l'ère de l'IA, l'accès et le traitement efficaces des données web sont cruciaux. Crawl4AI émerge comme un puissant outil d'exploration et d'extraction de données web open-source, méticuleusement conçu pour les développeurs travaillant avec des modèles linguistiques volumineux (LLM), des agents d'IA et des pipelines de données modernes. Ce tutoriel fournit une plongée approfondie dans Crawl4AI, couvrant tous les aspects, de l'installation aux techniques d'exploration avancées.
Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?
Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !
Pourquoi choisir Crawl4AI pour vos projets ?
Crawl4AI est bien plus qu'un simple outil d'extraction de données web standard. Il est conçu dès le départ pour être LLM-friendly. Cela signifie qu'il se concentre sur :
- Génération de Markdown propre : Produire un Markdown bien structuré et concis, optimisé pour les systèmes de génération augmentée par récupération (RAG) et le fine-tuning des modèles en supprimant le code récurrent et le bruit.
- Extraction de données structurées : Permettre l'extraction de points de données spécifiques dans des formats tels que JSON en utilisant des méthodes traditionnelles (sélecteurs CSS, XPath) ou en tirant parti des LLM pour des tâches d'extraction sémantique plus complexes.
- Haute performance : Utilisation de la bibliothèque
asynciode Python et du puissant framework d'automatisation de navigateur Playwright pour une exploration asynchrone rapide. - Contrôle avancé du navigateur : Offrir un contrôle précis sur l'instance du navigateur, y compris l'exécution de JavaScript, la gestion du contenu dynamique, la gestion des sessions (cookies, stockage local), l'utilisation de proxys et la simulation de différents environnements utilisateur (agents utilisateur, géolocalisations).
- Open Source & Flexibilité : Être entièrement open-source (Apache 2.0 avec attribution) sans dépendre de clés API externes ou de services payants. Il offre une flexibilité de déploiement via Docker ou une installation pip directe.
Crawl4AI vise à démocratiser l'accès aux données, permettant aux développeurs de collecter et de façonner les données web avec rapidité et efficacité.
Installation et configuration de Crawl4AI
L'exécution de Crawl4AI est simple, offrant des options pip et Docker.
Méthode 1 : Installation Pip (recommandée pour l'utilisation de la bibliothèque)
Installer le package : Ouvrez votre terminal et exécutez :
# Installer la dernière version stable
pip install -U crawl4ai
# Ou, installer la dernière pré-version (pour les fonctionnalités de pointe)
# pip install crawl4ai --pre
Exécuter la configuration post-installation : Cette étape cruciale installe les binaires de navigateur Playwright nécessaires (Chromium par défaut) :
crawl4ai-setup
Vérifier : Vérifiez votre configuration à l'aide de l'outil de diagnostic :
crawl4ai-doctor
Dépannage : Si crawl4ai-setup rencontre des problèmes, installez manuellement les dépendances du navigateur :
python -m playwright install --with-deps chromium
Méthode 2 : Déploiement Docker (idéal pour le service API)
Extraire l'image : Obtenez l'image Docker officielle (vérifiez GitHub pour la dernière balise) :
# Exemple de balise, remplacez si nécessaire
docker pull unclecode/crawl4ai:latest
Exécuter le conteneur : Démarrez le service Crawl4AI, en exposant son API (port par défaut 11235) :
docker run -d -p 11235:11235 --name crawl4ai --shm-size=1g unclecode/crawl4ai:latest
Cela exécute Crawl4AI avec un backend FastAPI, prêt à accepter les requêtes d'exploration via HTTP. Vous pouvez accéder à un bac à sable API interactif à l'adresse http://localhost:11235/playground.
Comment exécuter votre première exploration avec Crawl4AI
Crawl4AI rend l'exploration de base incroyablement simple en utilisant AsyncWebCrawler.
import asyncio
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode
async def run_basic_crawl():
# --- Exemple de base ---
print("--- Exécution de l'exploration de base ---")
# Utilisez 'async with' pour le démarrage et l'arrêt automatiques du navigateur
async with AsyncWebCrawler() as crawler:
# La méthode arun() effectue l'exploration pour une seule URL
# Elle renvoie un objet CrawlResult
result = await crawler.arun(url="https://example.com")
if result and result.success:
# Accéder au Markdown généré (généralement 'fit_markdown')
print("Exploration réussie !")
# result.markdown fournit à la fois le markdown brut et filtré
print(f"Fit Markdown (300 premiers caractères) : {result.markdown.fit_markdown[:300]}...")
else:
print(f"Exploration échouée : {result.error_message}")
# --- Exemple avec configuration de base ---
print("\n--- Exécution de l'exploration avec configuration de base ---")
# Configurer le comportement du navigateur (par exemple, exécuter headful pour le débogage)
browser_conf = BrowserConfig(headless=True) # Définir sur False pour voir la fenêtre du navigateur
# Configurer les paramètres spécifiques à l'exécution (par exemple, contourner le cache)
# CacheMode.ENABLED (par défaut), CacheMode.DISABLED, CacheMode.BYPASS
run_conf = CrawlerRunConfig(cache_mode=CacheMode.BYPASS)
async with AsyncWebCrawler(config=browser_conf) as crawler:
result = await crawler.arun(
url="https://crawl4ai.com/", # Explorer le site officiel
config=run_conf # Appliquer la configuration d'exécution
)
if result and result.success:
print("Exploration réussie !")
print(f"Nombre de mots Fit Markdown : {result.markdown.word_count}")
print(f"URL explorée : {result.url}")
else:
print(f"Exploration échouée : {result.error_message}")
if __name__ == "__main__":
asyncio.run(run_basic_crawl())
Concepts clés de Crawl4AI :
AsyncWebCrawler: La classe principale pour lancer les explorations. L'utilisation deasync withgarantit que le navigateur est correctement géré.arun(url, config=None): La méthode asynchrone principale pour explorer une seule URL.BrowserConfig: Contrôle les paramètres au niveau du navigateur (headless, agent utilisateur, proxys). Passé lors de l'initialisation d'AsyncWebCrawler.CrawlerRunConfig: Contrôle les paramètres d'une tâche d'exploration spécifique (mise en cache, stratégies d'extraction, délais d'attente, exécution de JavaScript). Passé à la méthodearun.CacheMode: Détermine comment Crawl4AI interagit avec son cache (ENABLED,DISABLED,BYPASS).BYPASSest utile pour garantir des données fraîches pendant le développement.
Comment fonctionne l'objet CrawlResult de Crawl4AI ?
Chaque appel arun ou arun_many réussi renvoie un ou plusieurs objets CrawlResult, qui encapsulent toutes les informations collectées lors de l'exploration.
L'objet CrawlResult contient divers attributs, notamment :
url: L'URL finale explorée (après les redirections).success: Booléen indiquant si l'exploration a réussi.error_message: Contient les détails de l'erreur sisuccessestFalse.status_code: Code d'état HTTP de la réponse.markdown: Un objet contenant les versions Markdown (raw_markdown,fit_markdown,word_count).html: Le contenu HTML brut de la page.text: Contenu texte brut extrait de la page.extracted_content: Stocke le résultat de toute stratégie d'extraction configurée (par exemple, chaîne JSON).links: Une liste de liens trouvés sur la page (internal,external).media: Informations sur les médias extraits (images, tableaux, etc.).metadata: Métadonnées de la page (titre, description, etc.).cookies: Cookies du navigateur après l'exploration.screenshot_path: Chemin d'accès à la capture d'écran si elle est prise.network_log_path: Chemin d'accès au fichier HAR réseau s'il est capturé.console_log_path: Chemin d'accès au fichier journal de la console s'il est capturé.
L'inspection de cet objet est essentielle pour accéder aux données spécifiques dont vous avez besoin à partir d'une exploration Crawl4AI.
Comment générer du Markdown prêt pour l'IA avec Crawl4AI
Une force essentielle de Crawl4AI est sa capacité à générer un Markdown propre, adapté aux LLM.
L'attribut result.markdown contient :
result.markdown.raw_markdown: La conversion directe et non filtrée de la zone de contenu principale de la page en Markdown.result.markdown.fit_markdown: Une version filtrée du Markdown. C'est souvent le plus utile pour les LLM, car Crawl4AI applique des filtres heuristiques (commePruningContentFilterouBM25ContentFilter) pour supprimer l'encombrement web courant (menus, publicités, pieds de page, barres latérales).result.markdown.word_count: Le nombre de mots dufit_markdown.
Vous pouvez personnaliser le processus de filtrage dans Crawl4AI :
import asyncio
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode
# Importer des stratégies spécifiques pour la personnalisation
from crawl4ai.content_filter_strategy import PruningContentFilter
from crawl4ai.markdown_generation_strategy import DefaultMarkdownGenerator
async def run_custom_markdown_crawl():
print("\n--- Exécution de l'exploration avec filtrage Markdown personnalisé ---")
# Configurer un générateur Markdown avec un filtre de contenu spécifique
# PruningContentFilter supprime les éléments en fonction des seuils de nombre de mots
markdown_generator_with_filter = DefaultMarkdownGenerator(
content_filter=PruningContentFilter(
threshold=0.48, # Ajuster le seuil (0 à 1) pour la rigueur
threshold_type="fixed" # 'fixed' ou 'relative'
)
)
# Appliquer ce générateur dans la configuration d'exécution
run_conf = CrawlerRunConfig(
cache_mode=CacheMode.BYPASS,
markdown_generator=markdown_generator_with_filter
)
async with AsyncWebCrawler() as crawler:
result = await crawler.arun(
url="https://www.nbcnews.com/business", # Un site d'actualités a souvent de l'encombrement
config=run_conf
)
if result and result.success:
print("Exploration réussie !")
print(f"Longueur du Markdown brut : {len(result.markdown.raw_markdown)}")
print(f"Longueur du Markdown ajusté : {len(result.markdown.fit_markdown)}") # Généralement plus court
# Comparer raw_markdown et fit_markdown pour voir l'effet du filtre
else:
print(f"Exploration échouée : {result.error_message}")
if __name__ == "__main__":
asyncio.run(run_custom_markdown_crawl())
En ajustant le content_filter dans le markdown_generator, vous contrôlez la manière dont Crawl4AI nettoie agressivement le contenu avant de produire fit_markdown.
Comment utiliser l'exploration approfondie de Crawl4AI
Crawl4AI ne se limite pas aux pages uniques. Il peut effectuer des explorations approfondies, en naviguant sur un site web en suivant les liens.
Utilisez la méthode adeep_crawl (ou l'indicateur --deep-crawl de l'interface de ligne de commande crwl) :
import asyncio
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode
async def run_deep_crawl():
print("\n--- Exécution de l'exploration approfondie ---")
# La configuration peut être appliquée globalement ou par exécution comme d'habitude
run_conf = CrawlerRunConfig(cache_mode=CacheMode.ENABLED)
async with AsyncWebCrawler() as crawler:
# adeep_crawl renvoie un générateur asynchrone, produisant des résultats au fur et à mesure que les pages se terminent
crawl_generator = await crawler.adeep_crawl(
start_url="https://docs.crawl4ai.com/", # Point de départ
strategy="bfs", # 'bfs' (Breadth-First), 'dfs' (Depth-First), 'bestfirst'
max_depth=2, # Limiter le nombre de liens à suivre en profondeur
max_pages=10, # Limiter le nombre total de pages à explorer
config=run_conf
)
# Traiter les résultats au fur et à mesure qu'ils arrivent
pages_crawled = 0
async for result in crawl_generator:
if result.success:
print(f"[OK] Exploré : {result.url} (Profondeur : {result.depth}, Longueur du Markdown ajusté : {len(result.markdown.fit_markdown)})")
pages_crawled += 1
else:
print(f"[ÉCHEC] URL : {result.url}, Erreur : {result.error_message}")
print(f"\nExploration approfondie terminée. Nombre total de pages explorées avec succès : {pages_crawled}")
if __name__ == "__main__":
asyncio.run(run_deep_crawl())
Paramètres d'exploration approfondie de Crawl4AI :
start_url: L'URL initiale à partir de laquelle commencer l'exploration.strategy: Comment découvrir et hiérarchiser les liens (bfs,dfs,bestfirst).max_depth: Distance maximale des liens par rapport à lastart_url.max_pages: Nombre total maximal de pages à explorer dans cette tâche.include_patterns,exclude_patterns: Utilisez des modèles regex pour filtrer les URL suivies.
Comment gérer le contenu dynamique et les interactions avec Crawl4AI
Les sites web modernes s'appuient fortement sur JavaScript pour charger du contenu. Crawl4AI gère cela grâce aux capacités de Playwright.
Vous pouvez exécuter du JavaScript arbitraire ou attendre des conditions spécifiques en utilisant CrawlerRunConfig :
import asyncio
import json
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode
from crawl4ai.extraction_strategy import JsonCssExtractionStrategy # Par exemple
async def crawl_dynamic_page():
print("\n--- Exploration de la page dynamique avec interaction JS ---")
# Exemple de schéma pour l'extraction CSS (adapter au site cible)
schema = { "items": { "selector": "div.product-item", "type": "list", "fields": { "title": "h2", "price": ".price" } } }
css_extractor = JsonCssExtractionStrategy(schema)
# JavaScript à exécuter sur la page (par exemple, cliquer sur un bouton 'Charger plus')
# Remarque : Le sélecteur doit correspondre au site web cible
js_to_run = """
(async () => {
const loadMoreButton = document.querySelector('button#load-more');
if (loadMoreButton) {
console.log('Cliquer sur le bouton "Charger plus"...');
loadMoreButton.click();
// Attendre un peu que le contenu se charge potentiellement après le clic
await new Promise(resolve => setTimeout(resolve, 2000));
console.log('Attendu après le clic.');
} else {
console.log('Bouton "Charger plus" non trouvé.');
}
})();
"""
run_conf = CrawlerRunConfig(
cache_mode=CacheMode.BYPASS,
js_code=[js_to_run], # Liste d'extraits JS à exécuter
wait_for_timeout=3000, # Attendre 3 secondes après le chargement initial ET après l'exécution de JS
# wait_for_selector="div.newly-loaded-content", # Ou attendre un élément spécifique
extraction_strategy=css_extractor, # Extraire les données après l'exécution de JS
output_formats=['markdown', 'extracted_content']
)
# S'assurer que JS est activé dans BrowserConfig (il l'est par défaut)
browser_conf = BrowserConfig(headless=True, java_script_enabled=True)
async with AsyncWebCrawler(config=browser_conf) as crawler:
result = await crawler.arun(
url="URL_OF_DYNAMIC_PAGE_HERE", # Remplacer par l'URL réelle
config=run_conf
)
if result and result.success:
print("Exploration de la page dynamique réussie !")
print(f"Longueur du Markdown ajusté : {len(result.markdown.fit_markdown)}")
if result.extracted_content:
try:
extracted_data = json.loads(result.extracted_content)
print(f"Aperçu du contenu extrait : {json.dumps(extracted_data, indent=2)[:500]}...")
except json.JSONDecodeError:
print(f"Contenu extrait (non-JSON) : {result.extracted_content[:500]}...")
else:
print(f"Exploration échouée : {result.error_message}")
if __name__ == "__main__":
# Remplacer par une URL réelle qui charge du contenu de manière dynamique pour les tests
# asyncio.run(crawl_dynamic_page())
print("Veuillez remplacer 'URL_OF_DYNAMIC_PAGE_HERE' et décommenter la ligne ci-dessus pour exécuter l'exemple dynamique.")
Paramètres d'interaction clés de Crawl4AI dans CrawlerRunConfig :
js_code: Une liste de chaînes JavaScript à exécuter dans le contexte de la page.wait_for_timeout: Millisecondes à attendre après le chargement de la page et après l'exécution de JS.wait_for_selector: Un sélecteur CSS à attendre avant de considérer que la page est chargée/l'interaction est terminée.page_interaction_hooks: Des hooks plus avancés pour des interactions complexes.
Conclusion de Crawl4AI
Crawl4AI fournit une solution complète, Pythonique et axée sur l'IA pour l'exploration et l'extraction de données web. Son accent sur la génération de Markdown propre, l'extraction flexible de données structurées (CSS et basée sur LLM), la gestion robuste du contenu dynamique et le fonctionnement asynchrone efficace en font un excellent choix pour les projets impliquant RAG, le fine-tuning de LLM ou toute tâche nécessitant des informations structurées à partir du web. En tirant parti de son API claire, de ses options de configuration (BrowserConfig, CrawlerRunConfig) et de son objet CrawlResult détaillé, les développeurs peuvent créer des flux de travail de collecte de données sophistiqués et efficaces.
Vous voulez une plateforme intégrée, tout-en-un, pour que votre équipe de développeurs travaille ensemble avec une productivité maximale ?
Apidog répond à toutes vos demandes et remplace Postman à un prix beaucoup plus abordable !
