Maîtriser Crawl4AI : Préparer des données Web de haute qualité pour LLM et RAG

Tutoriels pratiques sur l'IAMise à jour il y a 4 mois Cercle de partage de l'IA

1.8K 00

Les moteurs de recherche traditionnels sont polyvalents, mais nécessitent souvent un nettoyage et un formatage supplémentaires lors du traitement des données, ce qui rend leur intégration avec les grands modèles de langage (LLM) relativement complexe. Les résultats de nombreux outils (par exemple, les données brutes de l HTML ou non structurés JSON) contient beaucoup de bruit et n'est pas adapté à une utilisation directe dans des scénarios tels que Retrieval Augmented Generation (RAG), car il dégraderait la qualité de l'information. LLM Efficacité et précision du traitement.

Crawl4AI offre une solution différente. Elle se concentre sur la production directe d'énergie propre et structurée. Markdown Contenu formaté. Ce format préserve la structure sémantique du texte original (par exemple, les titres, les listes, les blocs de code) tout en supprimant intelligemment les éléments superflus tels que la navigation, les publicités, les pieds de page, etc. LLM ou pour l'élaboration de produits de haute qualité RAG Ensemble de données.Crawl4AI est un projet entièrement open source qui n'utilise aucun API La clé n'est pas non plus fixée à un seuil de paiement à la séance.

Installation et configuration

Utilisation recommandée uv Créer et activer un Python un environnement virtuel pour gérer les dépendances du projet.uv Il est basé sur un Rust Pays développés Pays émergents Python avec son avantage significatif en termes de rapidité (généralement par rapport au gestionnaire de paquets pip (3 à 5 fois plus rapide) et une résolution efficace des dépendances en parallèle.

# 创建虚拟环境
uv venv crawl4ai-env
# 激活环境
# Windows
# crawl4ai-env\Scripts\activate
# macOS/Linux
source crawl4ai-env/bin/activate

Une fois l'environnement activé, utilisez la fonction uv montage Crawl4AI Bibliothèque de base :

uv pip install crawl4ai

Une fois l'installation terminée, lancez la commande d'initialisation, qui se chargera de l'installation ou de la mise à jour de l'application Playwright Pilotes de navigateur requis (par exemple Chromium) et effectuer des inspections environnementales.Playwright Il s'agit d'une de ces choses qui sont composées de Microsoft a développé des bibliothèques d'automatisation des navigateurs.Crawl4AI Utilisez-le pour simuler les interactions réelles de l'utilisateur afin de pouvoir gérer le contenu chargé dynamiquement de la page d'accueil. JavaScript Site web lourd.

crawl4ai-setup

Si vous rencontrez des problèmes liés au pilote du navigateur, vous pouvez essayer de l'installer manuellement :

# 手动安装 Playwright 浏览器及依赖
python -m playwright install --with-deps chromium

Le cas échéant, cette opération peut être effectuée en uv Installation de packs d'extension contenant des fonctionnalités supplémentaires :

# 安装文本聚类功能 (依赖 PyTorch)
uv pip install "crawl4ai[torch]"
# 安装 Transformers 支持 (用于本地 AI 模型)
uv pip install "crawl4ai[transformer]"
# 安装所有可选功能
uv pip install "crawl4ai[all]"

Exemple d'exploration de base

ce montant ou moins Python Le script démontre l'utilisation de la fonction Crawl4AI L'utilisation de base du Markdown.

import asyncio
from crawl4ai import AsyncWebCrawler
async def main():
# 初始化异步爬虫
async with AsyncWebCrawler() as crawler:
# 执行爬取任务
result = await crawler.arun(
url="https://www.sitepoint.com/react-router-complete-guide/"
)
# 检查爬取是否成功
if result.success:
# 输出结果信息
print(f"标题: {result.title}")
print(f"提取的 Markdown ({len(result.markdown)} 字符):")
# 仅显示前 300 个字符作为预览
print(result.markdown[:300] + "...")
# 将完整的 Markdown 内容保存到文件
with open("example_content.md", "w", encoding="utf-8") as f:
f.write(result.markdown)
print(f"内容已保存到 example_content.md")
else:
# 输出错误信息
print(f"爬取失败: {result.url}")
print(f"状态码: {result.status_code}")
print(f"错误信息: {result.error_message}")
if __name__ == "__main__":
asyncio.run(main())

Après l'exécution de ce script, leCrawl4AI activera Playwright Accès contrôlé du navigateur à des données spécifiées URLPage exécutive JavaScriptIl identifie et extrait de manière intelligente les principales zones de contenu, filtre les éléments distrayants et génère en fin de compte un contenu propre. Markdown Documentation.

Recherche par lots et en parallèle

processus multiple URL quandCrawl4AI de traitement parallèle peut accroître considérablement l'efficacité. En configurant le CrawlerRunConfig a fait mouche concurrency qui contrôle le nombre de pages traitées simultanément.

import asyncio
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode
async def main():
urls = [
"https://example.com/page1",
"https://example.com/page2",
"https://example.com/page3",
# 添加更多 URL...
]
# 浏览器配置：无头模式，增加超时
browser_config = BrowserConfig(
headless=True,
timeout=45000, # 45秒超时
)
# 爬取运行配置：设置并发数，禁用缓存以获取最新内容
run_config = CrawlerRunConfig(
concurrency=5,  # 同时处理 5 个页面
cache_mode=CacheMode.BYPASS # 禁用缓存
)
results = []
async with AsyncWebCrawler(browser_config=browser_config) as crawler:
# 使用 arun_many 进行批量并行爬取
# 注意：arun_many 需要将 run_config 列表传递给 configs 参数
# 如果所有 URL 使用相同配置，可以创建一个配置列表
configs = [run_config.clone(url=url) for url in urls] # 为每个URL克隆配置并设置URL
# arun_many 返回一个异步生成器
async for result in crawler.arun_many(configs=configs):
if result.success:
results.append(result)
print(f"已完成: {result.url}, 获取了 {len(result.markdown)} 字符")
else:
print(f"失败: {result.url}, 错误: {result.error_message}")
# 将所有成功的结果合并到一个文件
with open("combined_results.md", "w", encoding="utf-8") as f:
for i, result in enumerate(results):
f.write(f"## {result.title}\n\n")
f.write(result.markdown)
f.write("\n\n---\n\n")
print(f"所有成功内容已合并保存到 combined_results.md")
if __name__ == "__main__":
asyncio.run(main())

prendre noteLe code ci-dessus utilise la fonction arun_many qui est la méthode recommandée pour traiter de grandes listes d'URL, plutôt que de passer par un appel à la méthode arun Plus efficace.arun_many Une liste de configurations est requise, chacune correspondant à une URL. Si tous les URL En utilisant la même configuration de base, le clone() crée une copie et définit un URL.

Extraction de données structurées (basée sur un sélecteur)

en dehors de Markdown(math.) genreCrawl4AI Également disponible CSS Sélecteur ou XPath Extrait les données structurées, ce qui est idéal pour les sites dont les formats de données sont réguliers.

import asyncio
import json
from crawl4ai import AsyncWebCrawler, ExtractorConfig
async def main():
# 定义提取规则 (CSS 选择器)
extractor_config = ExtractorConfig(
strategy="css", # 明确指定策略为 CSS
rules={
"products": {
"selector": "div.product-card", # 主选择器
"type": "list",
"properties": {
"name": {"selector": "h2.product-title", "type": "text"},
"price": {"selector": ".price span", "type": "text"},
"link": {"selector": "a.product-link", "type": "attribute", "attribute": "href"}
}
}
}
)
async with AsyncWebCrawler() as crawler:
result = await crawler.arun(
url="https://example-shop.com/products",
extractor_config=extractor_config
)
if result.success and result.extracted_data:
extracted_data = result.extracted_data
with open("products.json", "w", encoding="utf-8") as f:
json.dump(extracted_data, f, ensure_ascii=False, indent=2)
print(f"已提取 {len(extracted_data.get('products', []))} 个产品信息")
print("数据已保存到 products.json")
elif not result.success:
print(f"爬取失败: {result.error_message}")
else:
print("未提取到数据或提取规则匹配失败")
if __name__ == "__main__":
asyncio.run(main())

Cette approche ne nécessite pas LLM L'intervention, peu coûteuse et rapide, convient aux scénarios dans lesquels l'élément cible est clair.

Extraction de données améliorée par l'IA

Pour les pages dont la structure est complexe ou qui n'ont pas de motif fixe, vous pouvez utiliser la fonction LLM Effectuer une extraction intelligente.

import asyncio
import json
from crawl4ai import AsyncWebCrawler, BrowserConfig, AIExtractorConfig
async def main():
# 配置 AI 提取器
ai_config = AIExtractorConfig(
provider="openai", # 或 "local", "anthropic" 等
model="gpt-4o-mini", # 使用 OpenAI 的模型
# api_key="YOUR_OPENAI_API_KEY", # 如果环境变量未设置，在此提供
schema={
"type": "object",
"properties": {
"article_summary": {"type": "string", "description": "A brief summary of the article."},
"key_topics": {"type": "array", "items": {"type": "string"}, "description": "List of main topics discussed."},
"sentiment": {"type": "string", "enum": ["positive", "negative", "neutral"], "description": "Overall sentiment of the article."}
},
"required": ["article_summary", "key_topics"]
},
instruction="Extract the summary, key topics, and sentiment from the provided article text."
)
browser_config = BrowserConfig(timeout=60000) # AI 处理可能需要更长时间
async with AsyncWebCrawler(browser_config=browser_config) as crawler:
result = await crawler.arun(
url="https://example-news.com/article/complex-analysis",
ai_extractor_config=ai_config
)
if result.success and result.ai_extracted:
ai_extracted = result.ai_extracted
print("AI 提取的数据:")
print(json.dumps(ai_extracted, indent=2, ensure_ascii=False))
# 也可以选择保存到文件
# with open("ai_extracted_data.json", "w", encoding="utf-8") as f:
#     json.dump(ai_extracted, f, ensure_ascii=False, indent=2)
elif not result.success:
print(f"爬取失败: {result.error_message}")
else:
print("AI 未能提取所需数据。")
if __name__ == "__main__":
asyncio.run(main())

L'extraction par IA offre une grande flexibilité pour comprendre le contenu et générer des résultats structurés à la demande, mais elle entraîne des coûts supplémentaires. API Coût de l'appel (en cas d'utilisation d'un service en nuage) LLM) et le temps de traitement. Sélectionnez le modèle local (par exemple Mistral, Llama) peuvent réduire les coûts et protéger la vie privée, mais ils nécessitent du matériel local.

Configurations avancées et conseils

Crawl4AI Fournit un grand nombre d'options de configuration pour gérer des scénarios complexes.

Configuration du navigateur (`BrowserConfig`)

BrowserConfig Contrôle le démarrage et le comportement du navigateur lui-même.

from crawl4ai import BrowserConfig
config = BrowserConfig(
browser_type="firefox",  # 使用 Firefox 浏览器
headless=False,         # 显示浏览器界面，方便调试
user_agent="MyCustomCrawler/1.0", # 设置自定义 User-Agent
proxy_config={          # 配置代理服务器
"server": "http://proxy.example.com:8080",
"username": "proxy_user",
"password": "proxy_password"
},
ignore_https_errors=True, # 忽略 HTTPS 证书错误 (开发环境常用)
use_persistent_context=True, # 启用持久化上下文
user_data_dir="./my_browser_profile", # 指定用户数据目录，用于保存 cookies, local storage 等
timeout=60000,          # 全局浏览器操作超时 (毫秒)
verbose=True            # 打印更详细的日志
)
# 在初始化 AsyncWebCrawler 时传入
# async with AsyncWebCrawler(browser_config=config) as crawler:
#    ...

Examinez la configuration de l'exécution (`CrawlerRunConfig`)

CrawlerRunConfig Contrôle unique arun() peut-être arun_many() Le comportement spécifique de l'appel.

from crawl4ai import CrawlerRunConfig, CacheMode
run_config = CrawlerRunConfig(
cache_mode=CacheMode.READ_ONLY, # 只读缓存，不写入新缓存
check_robots_txt=True,      # 检查并遵守 robots.txt 规则
wait_until="networkidle",   # 等待网络空闲再提取，适合JS动态加载内容
wait_for="css:div#final-content", # 等待特定 CSS 选择器元素出现
js_code="window.scrollTo(0, document.body.scrollHeight);", # 页面加载后执行 JS 代码 (例如滚动到底部触发加载)
scan_full_page=True,        # 尝试自动滚动页面以加载所有内容 (用于无限滚动)
screenshot=True,            # 截取页面截图 (结果在 result.screenshot，Base64编码)
pdf=True,                   # 生成页面 PDF (结果在 result.pdf，Base64编码)
word_count_threshold=50,    # 过滤掉少于 50 个单词的文本块
excluded_tags=["header", "nav", "footer", "aside"], # 从 Markdown 中排除特定 HTML 标签
exclude_external_links=True # 不提取外部链接
)
# 在调用 arun() 或创建配置列表给 arun_many() 时传入
# result = await crawler.arun(url="...", config=run_config)

Gestion de JavaScript et du contenu dynamique

grâce à Playwright(math.) genreCrawl4AI Bonne gestion des dépendances JavaScript Site web rendu. Configuration des clés :

wait_until: Réglé sur "networkidle" peut-être "load" Il est généralement un peu plus efficace que l'option par défaut "domcontentloaded" Plus adapté aux pages dynamiques.
wait_for: attente d'un élément spécifique ou d'une JavaScript Conditions remplies.
js_codePersonnalisation de la page : Exécuter la personnalisation après le chargement de la page JavaScriptIl s'agit de cliquer sur des boutons et de faire défiler des pages.
scan_full_pageLes pages à défilement infini : : gérer automatiquement les pages à défilement infini les plus courantes.
delay_before_return_htmlLes scripts doivent être exécutés avant l'extraction : ajouter un court délai avant l'extraction pour s'assurer que tous les scripts sont exécutés.

Gestion des erreurs et débogage

sonde result.successLes données relatives à l'état d'avancement de la recherche sont disponibles à l'adresse suivante : Veillez à vérifier cette propriété après chaque repérage.
vérifier result.status_code répondre en chantant result.error_message: : Obtenir la raison de l'échec.
mettre en place headless=False: En BrowserConfig Vous pouvez observer le fonctionnement du navigateur et diagnostiquer le problème visuellement.
commencer à utiliser verbose=True: En BrowserConfig dans les paramètres pour obtenir un journal d'exécution plus détaillé.
utiliser try...exceptColis : Colis arun() peut-être arun_many() qui capture un éventuel Python Exception.

import asyncio
from crawl4ai import AsyncWebCrawler, BrowserConfig
async def debug_crawl():
# 启用调试模式：显示浏览器，打印详细日志
debug_browser_config = BrowserConfig(headless=False, verbose=True)
async with AsyncWebCrawler(browser_config=debug_browser_config) as crawler:
try:
result = await crawler.arun(url="https://problematic-site.com")
if not result.success:
print(f"Crawl failed: {result.error_message} (Status: {result.status_code})")
else:
print("Crawl successful.")
# ... process result ...
except Exception as e:
print(f"An unexpected error occurred: {e}")
if __name__ == "__main__":
asyncio.run(debug_crawl())

observation `robots.txt`

Lorsque vous effectuez un balayage du web, respectez les droits d'auteur du site. robots.txt La documentation est un élément de base de la nétiquette et permet également d'éviter le blocage des adresses IP.Crawl4AI Il peut être traité automatiquement.

existent CrawlerRunConfig mettre en place check_robots_txt=True: :

respectful_config = CrawlerRunConfig(
check_robots_txt=True
)
# result = await crawler.arun(url="https://example.com", config=respectful_config)
# if not result.success and result.status_code == 403:
#    print("Access denied by robots.txt")

Crawl4AI Automatiquement téléchargée, mise en cache et analysée robots.txt si la règle interdit l'accès au fichier cible URL(math.) genrearun() échouera.result.success en raison de False(math.) genrestatus_code Il s'agit en général d'une erreur de 403 avec le message d'erreur approprié.

Gestion des sessions (`Session Management`)

Pour les opérations en plusieurs étapes qui nécessitent une connexion ou le maintien d'un état (par exemple, la soumission d'un formulaire, la navigation par page), la gestion de session peut être utilisée. Pour ce faire, il suffit d'ajouter un nouveau gestionnaire de session à l'élément CrawlerRunConfig Spécifiez la même chose dans le session_idLe système peut être utilisé dans plus d'une arun() La même instance de page de navigateur est réutilisée entre les appels, ce qui permet de préserver le caractère de la page. cookies répondre en chantant JavaScript Statut.

import asyncio
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode
async def session_example():
async with AsyncWebCrawler() as crawler:
session_id = "my_unique_session"
# Step 1: Load login page (hypothetical)
login_config = CrawlerRunConfig(session_id=session_id, cache_mode=CacheMode.BYPASS)
await crawler.arun(url="https://example.com/login", config=login_config)
print("Login page loaded.")
# Step 2: Execute JS to fill and submit login form (hypothetical)
login_js = """
document.getElementById('username').value = 'user';
document.getElementById('password').value = 'pass';
document.getElementById('loginButton').click();
"""
submit_config = CrawlerRunConfig(
session_id=session_id,
js_code=login_js,
js_only=True, # 只执行 JS，不重新加载页面
wait_until="networkidle" # 等待登录后跳转完成
)
await crawler.arun(config=submit_config) # 无需 URL，在当前页面执行 JS
print("Login submitted.")
# Step 3: Crawl a protected page within the same session
protected_config = CrawlerRunConfig(session_id=session_id, cache_mode=CacheMode.BYPASS)
result = await crawler.arun(url="https://example.com/dashboard", config=protected_config)
if result.success:
print("Successfully crawled protected page:")
print(result.markdown[:200] + "...")
else:
print(f"Failed to crawl protected page: {result.error_message}")
# 清理会话 (可选，但推荐)
# await crawler.crawler_strategy.kill_session(session_id)
if __name__ == "__main__":
asyncio.run(session_example())

Une gestion plus avancée des sessions comprend l'exportation et l'importation de l'état de stockage du navigateur (cookies, localStorage), ce qui permet de maintenir la connexion entre les exécutions du script.

Crawl4AI Fournit un ensemble de fonctionnalités puissantes et flexibles qui, lorsqu'elles sont correctement configurées, permettent d'extraire de manière efficace et fiable les informations requises à partir d'une variété de sites web et de préparer des données de haute qualité pour les applications d'IA en aval.