Hướng Dẫn Crawl4AI: Dành Cho Người Mới Bắt Đầu

Trong thời đại AI, việc truy cập và xử lý dữ liệu web một cách hiệu quả là rất quan trọng. Crawl4AI nổi lên như một công cụ thu thập và trích xuất dữ liệu web mã nguồn mở mạnh mẽ, được thiết kế tỉ mỉ cho các nhà phát triển làm việc với Mô hình Ngôn ngữ Lớn (LLMs), tác nhân AI và các đường ống dữ liệu hiện đại. Hướng dẫn này cung cấp một cái nhìn sâu sắc về Crawl4AI, bao gồm mọi thứ từ cài đặt đến các kỹ thuật thu thập nâng cao.

💡

Bạn muốn một công cụ Kiểm thử API tuyệt vời có thể tạo ra Tài liệu API đẹp mắt?

Bạn muốn một nền tảng tích hợp, Tất cả trong Một cho Nhóm Phát triển của bạn làm việc cùng nhau với năng suất tối đa?

Apidog đáp ứng mọi nhu cầu của bạn, và thay thế Postman với mức giá phải chăng hơn nhiều!

button

Tại sao chọn Crawl4AI cho dự án của bạn?

Crawl4AI không chỉ là một công cụ trích xuất dữ liệu web tiêu chuẩn. Nó được thiết kế từ đầu để thân thiện với LLM. Điều này có nghĩa là nó tập trung vào:

Tạo Markdown sạch: Tạo ra Markdown có cấu trúc tốt, súc tích, được tối ưu hóa cho các hệ thống Retrieval-Augmented Generation (RAG) và fine-tuning mô hình bằng cách loại bỏ các phần thừa và nhiễu.
Trích xuất dữ liệu có cấu trúc: Cho phép trích xuất các điểm dữ liệu cụ thể sang các định dạng như JSON bằng cách sử dụng các phương pháp truyền thống (CSS selectors, XPath) hoặc tận dụng LLMs cho các tác vụ trích xuất ngữ nghĩa phức tạp hơn.
Hiệu suất cao: Sử dụng thư viện asyncio của Python và framework tự động hóa trình duyệt mạnh mẽ Playwright để thu thập dữ liệu không đồng bộ nhanh chóng.
Kiểm soát trình duyệt nâng cao: Cung cấp khả năng kiểm soát chi tiết phiên bản trình duyệt, bao gồm thực thi JavaScript, xử lý nội dung động, quản lý phiên (cookies, local storage), sử dụng proxy và mô phỏng các môi trường người dùng khác nhau (user agents, geolocations).
Mã nguồn mở & Linh hoạt: Hoàn toàn là mã nguồn mở (Apache 2.0 với ghi công) mà không phụ thuộc vào khóa API bên ngoài hoặc dịch vụ trả phí. Nó cung cấp sự linh hoạt trong triển khai qua Docker hoặc cài đặt pip trực tiếp.

Crawl4AI nhằm mục đích dân chủ hóa quyền truy cập dữ liệu, trao quyền cho các nhà phát triển thu thập và định hình dữ liệu web với tốc độ và hiệu quả.

Cài đặt và Thiết lập Crawl4AI

Việc chạy Crawl4AI rất đơn giản, cung cấp cả tùy chọn pip và Docker.

Phương pháp 1: Cài đặt Pip (Khuyến nghị cho việc sử dụng thư viện)

Cài đặt Gói: Mở terminal của bạn và chạy:

# Cài đặt phiên bản ổn định mới nhất
pip install -U crawl4ai

# Hoặc, cài đặt phiên bản tiền phát hành mới nhất (cho các tính năng tiên tiến)
# pip install crawl4ai --pre

Chạy Thiết lập sau cài đặt: Bước quan trọng này cài đặt các tệp nhị phân trình duyệt Playwright cần thiết (Chromium theo mặc định):

crawl4ai-setup

Xác minh: Kiểm tra thiết lập của bạn bằng công cụ chẩn đoán:

crawl4ai-doctor

Khắc phục sự cố: Nếu crawl4ai-setup gặp vấn đề, hãy cài đặt thủ công các phụ thuộc trình duyệt:

python -m playwright install --with-deps chromium

Phương pháp 2: Triển khai Docker (Lý tưởng cho Dịch vụ API)

Tải Image: Lấy image Docker chính thức (kiểm tra GitHub để có tag mới nhất):

# Tag ví dụ, thay thế nếu cần
docker pull unclecode/crawl4ai:latest

Chạy Container: Khởi động dịch vụ Crawl4AI, hiển thị API của nó (cổng mặc định 11235):

docker run -d -p 11235:11235 --name crawl4ai --shm-size=1g unclecode/crawl4ai:latest

Lệnh này chạy Crawl4AI với backend FastAPI, sẵn sàng chấp nhận các yêu cầu thu thập dữ liệu qua HTTP. Bạn có thể truy cập sân chơi API tương tác tại http://localhost:11235/playground.

Cách thực hiện lần thu thập đầu tiên với Crawl4AI

Crawl4AI làm cho việc thu thập dữ liệu cơ bản trở nên cực kỳ đơn giản bằng cách sử dụng AsyncWebCrawler.

import asyncio
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode

async def run_basic_crawl():
    # --- Ví dụ Cơ bản ---
    print("--- Chạy Thu thập Cơ bản ---")
    # Sử dụng 'async with' để tự động khởi động và tắt trình duyệt
    async with AsyncWebCrawler() as crawler:
        # Phương thức arun() thực hiện thu thập dữ liệu cho một URL duy nhất
        # Nó trả về một đối tượng CrawlResult
        result = await crawler.arun(url="https://example.com")

        if result and result.success:
            # Truy cập Markdown được tạo (thường là 'fit_markdown')
            print("Thu thập thành công!")
            # result.markdown cung cấp cả markdown thô và đã lọc
            print(f"Fit Markdown (300 ký tự đầu): {result.markdown.fit_markdown[:300]}...")
        else:
            print(f"Thu thập thất bại: {result.error_message}")

    # --- Ví dụ với Cấu hình Cơ bản ---
    print("\n--- Chạy Thu thập với Cấu hình Cơ bản ---")
    # Cấu hình hành vi trình duyệt (ví dụ: chạy ở chế độ headful để gỡ lỗi)
    browser_conf = BrowserConfig(headless=True) # Đặt thành False để xem cửa sổ trình duyệt

    # Cấu hình cài đặt cụ thể cho lần chạy (ví dụ: bỏ qua bộ nhớ đệm)
    # CacheMode.ENABLED (mặc định), 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/", # Thu thập trang web chính thức
            config=run_conf # Áp dụng cấu hình chạy
        )
        if result and result.success:
            print("Thu thập thành công!")
            print(f"Số từ trong Fit Markdown: {result.markdown.word_count}")
            print(f"URL đã thu thập: {result.url}")
        else:
            print(f"Thu thập thất bại: {result.error_message}")

if __name__ == "__main__":
    asyncio.run(run_basic_crawl())

Các Khái niệm Chính của Crawl4AI:

AsyncWebCrawler: Lớp chính để khởi tạo các lần thu thập dữ liệu. Sử dụng async with đảm bảo trình duyệt được quản lý đúng cách.
arun(url, config=None): Phương thức không đồng bộ cốt lõi để thu thập một URL duy nhất.
BrowserConfig: Kiểm soát các cài đặt cấp trình duyệt (headless, user agent, proxies). Được truyền khi khởi tạo AsyncWebCrawler.
CrawlerRunConfig: Kiểm soát các cài đặt cho một công việc thu thập cụ thể (bộ nhớ đệm, chiến lược trích xuất, thời gian chờ, thực thi JavaScript). Được truyền vào phương thức arun.
CacheMode: Xác định cách Crawl4AI tương tác với bộ nhớ đệm của nó (ENABLED, DISABLED, BYPASS). BYPASS hữu ích để đảm bảo dữ liệu mới trong quá trình phát triển.

Đối tượng `CrawlResult` của Crawl4AI hoạt động như thế nào?

Mỗi lần gọi arun hoặc arun_many thành công sẽ trả về một hoặc nhiều đối tượng CrawlResult, đóng gói tất cả thông tin thu thập được trong quá trình thu thập.

Đối tượng CrawlResult chứa nhiều thuộc tính khác nhau, bao gồm:

url: URL cuối cùng đã thu thập (sau khi chuyển hướng).
success: Boolean cho biết liệu lần thu thập có thành công hay không.
error_message: Chứa chi tiết lỗi nếu success là False.
status_code: Mã trạng thái HTTP của phản hồi.
markdown: Một đối tượng chứa các phiên bản Markdown (raw_markdown, fit_markdown, word_count).
html: Nội dung HTML thô của trang.
text: Nội dung văn bản thuần túy được trích xuất từ trang.
extracted_content: Lưu trữ kết quả từ bất kỳ chiến lược trích xuất nào được cấu hình (ví dụ: chuỗi JSON).
links: Một danh sách các liên kết tìm thấy trên trang (internal, external).
media: Thông tin về các phương tiện được trích xuất (hình ảnh, bảng, v.v.).
metadata: Siêu dữ liệu trang (tiêu đề, mô tả, v.v.).
cookies: Cookies trình duyệt sau khi thu thập.
screenshot_path: Đường dẫn đến ảnh chụp màn hình nếu được chụp.
network_log_path: Đường dẫn đến tệp HAR mạng nếu được ghi lại.
console_log_path: Đường dẫn đến tệp log console nếu được ghi lại.

Việc kiểm tra đối tượng này là chìa khóa để truy cập dữ liệu cụ thể bạn cần từ một lần thu thập của Crawl4AI.

Cách tạo Markdown sẵn sàng cho AI với Crawl4AI

Một thế mạnh cốt lõi của Crawl4AI là khả năng tạo ra Markdown sạch phù hợp cho LLMs.

Thuộc tính result.markdown chứa:

result.markdown.raw_markdown: Chuyển đổi trực tiếp, không lọc của khu vực nội dung chính của trang sang Markdown.
result.markdown.fit_markdown: Một phiên bản đã lọc của Markdown. Đây thường là phiên bản hữu ích nhất cho LLMs, vì Crawl4AI áp dụng các bộ lọc heuristic (như PruningContentFilter hoặc BM25ContentFilter) để loại bỏ các phần lộn xộn phổ biến trên web (menu, quảng cáo, chân trang, thanh bên).
result.markdown.word_count: Số từ của fit_markdown.

Bạn có thể tùy chỉnh quá trình lọc trong Crawl4AI:

import asyncio
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode
# Import specific strategies for customization
from crawl4ai.content_filter_strategy import PruningContentFilter
from crawl4ai.markdown_generation_strategy import DefaultMarkdownGenerator

async def run_custom_markdown_crawl():
    print("\n--- Chạy Thu thập với Lọc Markdown Tùy chỉnh ---")

    # Cấu hình trình tạo Markdown với bộ lọc nội dung cụ thể
    # PruningContentFilter loại bỏ các phần tử dựa trên ngưỡng số từ
    markdown_generator_with_filter = DefaultMarkdownGenerator(
        content_filter=PruningContentFilter(
            threshold=0.48, # Điều chỉnh ngưỡng (0 đến 1) cho độ nghiêm ngặt
            threshold_type="fixed" # 'fixed' hoặc 'relative'
            )
    )

    # Áp dụng trình tạo này trong cấu hình chạy
    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", # Một trang tin tức thường có nhiều thứ lộn xộn
            config=run_conf
        )
        if result and result.success:
            print("Thu thập thành công!")
            print(f"Độ dài Raw Markdown: {len(result.markdown.raw_markdown)}")
            print(f"Độ dài Fit Markdown: {len(result.markdown.fit_markdown)}") # Thường ngắn hơn
            # So sánh raw_markdown và fit_markdown để xem hiệu ứng của bộ lọc
        else:
            print(f"Thu thập thất bại: {result.error_message}")

if __name__ == "__main__":
    asyncio.run(run_custom_markdown_crawl())

Bằng cách điều chỉnh content_filter trong markdown_generator, bạn kiểm soát mức độ Crawl4AI làm sạch nội dung trước khi tạo fit_markdown.

Cách sử dụng tính năng Thu thập sâu của Crawl4AI

Crawl4AI không chỉ giới hạn ở một trang duy nhất. Nó có thể thực hiện thu thập sâu, điều hướng qua một trang web bằng cách theo các liên kết.

Sử dụng phương thức adeep_crawl (hoặc cờ --deep-crawl của CLI crwl):

import asyncio
from crawl4ai import AsyncWebCrawler, CrawlerRunConfig, CacheMode

async def run_deep_crawl():
    print("\n--- Chạy Thu thập Sâu ---")
    # Cấu hình có thể được áp dụng toàn cục hoặc theo từng lần chạy như bình thường
    run_conf = CrawlerRunConfig(cache_mode=CacheMode.ENABLED)

    async with AsyncWebCrawler() as crawler:
        # adeep_crawl trả về một async generator, trả về kết quả khi các trang hoàn thành
        crawl_generator = await crawler.adeep_crawl(
            start_url="https://docs.crawl4ai.com/", # Điểm bắt đầu
            strategy="bfs", # 'bfs' (Chiều rộng), 'dfs' (Chiều sâu), 'bestfirst'
            max_depth=2,    # Giới hạn độ sâu liên kết cần theo
            max_pages=10,   # Giới hạn tổng số trang cần thu thập
            config=run_conf
        )

        # Xử lý kết quả khi chúng đến
        pages_crawled = 0
        async for result in crawl_generator:
            if result.success:
                print(f"[OK] Đã thu thập: {result.url} (Độ sâu: {result.depth}, Độ dài Fit Markdown: {len(result.markdown.fit_markdown)})")
                pages_crawled += 1
            else:
                print(f"[FAIL] URL: {result.url}, Lỗi: {result.error_message}")

        print(f"\nThu thập sâu hoàn thành. Tổng số trang đã thu thập thành công: {pages_crawled}")

if __name__ == "__main__":
    asyncio.run(run_deep_crawl())

Các Tham số Thu thập sâu của Crawl4AI:

start_url: URL ban đầu để bắt đầu thu thập.
strategy: Cách khám phá và ưu tiên các liên kết (bfs, dfs, bestfirst).
max_depth: Khoảng cách liên kết tối đa từ start_url.
max_pages: Tổng số trang tối đa cần thu thập trong công việc này.
include_patterns, exclude_patterns: Sử dụng các mẫu regex để lọc các URL nào sẽ được theo.

Cách xử lý Nội dung động và Tương tác với Crawl4AI

Các trang web hiện đại phụ thuộc nhiều vào JavaScript để tải nội dung. Crawl4AI xử lý điều này thông qua khả năng của Playwright.

Bạn có thể thực thi JavaScript tùy ý hoặc chờ các điều kiện cụ thể bằng cách sử dụng CrawlerRunConfig:

import asyncio
import json
from crawl4ai import AsyncWebCrawler, BrowserConfig, CrawlerRunConfig, CacheMode
from crawl4ai.extraction_strategy import JsonCssExtractionStrategy # For example

async def crawl_dynamic_page():
    print("\n--- Thu thập Trang Động với Tương tác JS ---")

    # Ví dụ schema cho trích xuất CSS (điều chỉnh cho trang đích)
    schema = { "items": { "selector": "div.product-item", "type": "list", "fields": { "title": "h2", "price": ".price" } } }
    css_extractor = JsonCssExtractionStrategy(schema)

    # JavaScript để thực thi trên trang (ví dụ: nhấp vào nút 'Load More')
    # Lưu ý: Selector cần khớp với trang web đích
    js_to_run = """
    (async () => {
        const loadMoreButton = document.querySelector('button#load-more');
        if (loadMoreButton) {
            console.log('Clicking load more button...');
            loadMoreButton.click();
            # Chờ một chút để nội dung có thể tải sau khi nhấp
            await new Promise(resolve => setTimeout(resolve, 2000));
            console.log('Waited after click.');
        } else {
            console.log('Load more button not found.');
        }
    })();
    """

    run_conf = CrawlerRunConfig(
        cache_mode=CacheMode.BYPASS,
        js_code=[js_to_run], # Danh sách các đoạn JS để thực thi
        wait_for_timeout=3000, # Chờ 3 giây sau khi tải ban đầu VÀ sau khi thực thi JS
        # wait_for_selector="div.newly-loaded-content", # Hoặc chờ một phần tử cụ thể
        extraction_strategy=css_extractor, # Trích xuất dữ liệu sau khi JS chạy
        output_formats=['markdown', 'extracted_content']
    )

    # Đảm bảo JS được bật trong BrowserConfig (mặc định là bật)
    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", # Thay thế bằng URL thực tế
            config=run_conf
        )

        if result and result.success:
            print("Thu thập trang động thành công!")
            print(f"Độ dài Fit Markdown: {len(result.markdown.fit_markdown)}")
            if result.extracted_content:
                try:
                    extracted_data = json.loads(result.extracted_content)
                    print(f"Xem trước Nội dung đã trích xuất: {json.dumps(extracted_data, indent=2)[:500]}...")
                except json.JSONDecodeError:
                    print(f"Nội dung đã trích xuất (không phải JSON): {result.extracted_content[:500]}...")
        else:
            print(f"Thu thập thất bại: {result.error_message}")


if __name__ == "__main__":
    # Thay thế bằng một URL thực tế tải nội dung động để kiểm tra
    # asyncio.run(crawl_dynamic_page())
    print("Vui lòng thay thế 'URL_OF_DYNAMIC_PAGE_HERE' và bỏ comment dòng trên để chạy ví dụ động.")

Các Tham số Tương tác Chính của Crawl4AI trong CrawlerRunConfig:

js_code: Một danh sách các chuỗi JavaScript để thực thi trong ngữ cảnh trang.
wait_for_timeout: Số mili giây chờ sau khi tải trang và sau khi thực thi JS.
wait_for_selector: Một CSS selector để chờ trước khi coi trang đã tải/tương tác hoàn thành.
page_interaction_hooks: Các hook nâng cao hơn cho các tương tác phức tạp.

Kết luận về Crawl4AI

Crawl4AI cung cấp một giải pháp toàn diện, theo phong cách Pythonic và tập trung vào AI cho việc thu thập và trích xuất dữ liệu web. Việc nó tập trung vào tạo Markdown sạch, trích xuất dữ liệu có cấu trúc linh hoạt (dựa trên cả CSS và LLM), xử lý mạnh mẽ nội dung động và hoạt động không đồng bộ hiệu quả làm cho nó trở thành lựa chọn tuyệt vời cho các dự án liên quan đến RAG, fine-tuning LLM hoặc bất kỳ tác vụ nào yêu cầu thông tin có cấu trúc từ web. Bằng cách tận dụng API rõ ràng, các tùy chọn cấu hình (BrowserConfig, CrawlerRunConfig) và đối tượng CrawlResult chi tiết, các nhà phát triển có thể xây dựng các quy trình thu thập dữ liệu phức tạp và hiệu quả.

💡