Cách xây dựng hệ thống RAG đạt tiêu chuẩn sản xuất và giảm chi phí token LLM xuống 70%

Những Lưu Ý Chính:

• Markdown sạch là định dạng mà LLM thực sự mong muốn. HTML thô chủ yếu là điều hướng, tập lệnh, vị trí quảng cáo và định dạng nội tuyến — tiếng ồn lãng phí cửa sổ ngữ cảnh và làm giảm chất lượng truy xuất. scrape_markdown của Scrapeless trả về nội dung dễ đọc của một trang dưới dạng Markdown sạch, vì vậy văn bản mà mô hình nhúng của bạn nhận được là văn bản mà trang đó nói về.
• Quy trình bao gồm bốn bước: Khám phá → Xuất → Chia nhỏ → Nhúng. Tìm các URL quan trọng, hiển thị từng cái thành Markdown sạch bằng trình duyệt đám mây, chia nhỏ Markdown thành các khối chồng chéo kích thước phù hợp với mô hình của bạn, sau đó nhúng và lưu trữ vào cơ sở dữ liệu vector để tạo ra thông tin được tăng cường.
• Các trang nặng JavaScript và tường chống bot được xử lý tại nền tảng. Nhiều nguồn có giá trị cao cung cấp nội dung của họ thông qua việc hiển thị phía client hoặc nằm sau các thử thách bot. Trình duyệt Scraping của Scrapeless hiển thị trang trong một trình duyệt đám mây chống phát hiện thực sự với đầu ra từ hộ gia đình, vì vậy Markdown bạn nhận được là trang đã được tạo đầy đủ, không phải là một vỏ rỗng.
• Hai bề mặt, một nguyên thủy. Gọi scrape_markdown từ máy chủ MCP của Scrapeless khi một tác nhân AI điều khiển quy trình, hoặc khởi tạo một phiên trình duyệt đám mây với SDK Python khi một kịch bản tạo vòng lặp. Cả hai đều sử dụng cùng một trình duyệt đám mây chống phát hiện.
• Công cụ MCP không trạng thái thêm tiền tố cho dữ liệu của họ là Response:\n\n. Khi bạn đọc đầu ra của scrape_markdown qua máy chủ MCP, hãy loại bỏ tiền tố đó trước khi chia nhỏ — một sửa chữa một dòng giúp giữ cho tiêu đề thừa ra khỏi bộ dữ liệu của bạn.
• Trình duyệt đám mây chống phát hiện, proxy hộ gia đình ở 195+ quốc gia. Trình duyệt Scraping của Scrapeless xử lý việc hiển thị JavaScript, đầu ra proxy hộ gia đình và ngẫu nhiên hóa dấu vân tay (UA, múi giờ, WebGL, canvas) trong mọi phiên, vì vậy kịch bản xây dựng bộ dữ liệu vẫn tập trung vào chất lượng văn bản thay vì kỹ thuật trốn tránh.
• Miễn phí để bắt đầu. Tài khoản Scrapeless mới bao gồm thời gian chạy miễn phí của Trình duyệt Scraping — đăng ký tại Scrapeless.

Giới thiệu: cung cấp cho mô hình của bạn văn bản, không phải chrome của trang

Một mô hình ngôn ngữ chỉ tốt như văn bản mà nó đọc. Dù bạn đang xây dựng một bộ dữ liệu tinh chỉnh, xây dựng một cơ sở kiến thức tăng cường truy xuất (RAG) trên tài liệu của riêng bạn, hay định hướng một tác nhân trong dữ liệu thị trường trực tiếp, giai đoạn đầu vào quyết định trần cho mọi thứ phía dưới. Đầu vào rác không chỉ là đầu ra rác — đó là token lãng phí, nhúng ô nhiễm và truy xuất xuất hiện một bảng cookie thay vì một câu trả lời.

Vấn đề là web hiện đại được xây dựng cho trình duyệt và con người, không phải cho các mô hình nhúng. Một trang bài viết điển hình có vài nghìn từ nội dung thực tế được bao bọc trong hàng chục nghìn ký tự của menu điều hướng, nút chia sẻ, lưới bài viết liên quan, widget bình luận, thông báo cookie, tập lệnh theo dõi và CSS nội tuyến. Cung cấp HTML thô đó cho một bộ nhúng và tín hiệu sẽ bị chìm trong mã đánh dấu. Hơn nữa, một phần ngày càng tăng của các trang hiển thị nội dung chính của chúng bằng JavaScript sau khi tải ban đầu, vì vậy một yêu cầu HTTP đơn giản trả về một container trống. Những trang khác thì nằm sau các thử thách chống bot mà chặn hoàn toàn việc thu thập tự động.

Bài viết này hướng dẫn qua quy trình làm việc Python trên Trình duyệt Scraping của Scrapeless, biến các trang web công cộng lộn xộn thành văn bản sạch, được chia nhỏ, sẵn sàng cho nhúng. Quy trình có bốn bước — khám phá các URL, xuất Markdown sạch, chia nhỏ cho RAG, nhúng vào cơ sở dữ liệu vector — và scrape_markdown thực hiện công việc nặng nhọc ở giai đoạn xuất bằng cách trả về nội dung dễ đọc của bất kỳ trang nào dưới dạng Markdown sạch. Để biết phiên bản của cùng một nguyên thủy dành cho khung tác nhân, hãy xem bài viết tích hợp LangChain.

Bạn Có Thể Xây Dựng Gì

Việc trích xuất văn bản sạch là nền tảng cho một loạt các hệ thống LLM và RAG:

• RAG trên tài liệu của riêng bạn. Crawling một trang docs hoặc cơ sở kiến thức để có Markdown sạch, chia nhỏ nó và nhúng nó để một tác nhân hỗ trợ trả lời từ tài liệu hiện tại thay vì một cắt bỏ đào tạo đã cũ.
• Tập hợp và tiếp tục đào tạo trên các tập dữ liệu. Tập hợp các bộ dữ liệu văn bản lớn, đã loại bỏ trùng lặp từ các bài viết và tài liệu công khai, với mẫu boilerplate đã được loại bỏ tại thời điểm thu thập.
• Căn cứ web trực tiếp cho các tác nhân. Hiển thị các trang mà tác nhân cần tại thời điểm truy vấn và cung cấp Markdown sạch, để câu trả lời trích dẫn trang như nó đọc hôm nay.
• Thông tin cạnh tranh và thị trường. Biến các trang sản phẩm công cộng, bài viết blog và ghi chú phát hành thành một chỉ mục vector có thể tìm kiếm mà một nhà phân tích hoặc LLM có thể truy vấn.
• Giám sát tin tức và nghiên cứu. Tiếp nhận trang của nhà xuất bản và tạp chí theo lịch trình, chuẩn hóa thành Markdown, và nhúng cho tìm kiếm ngữ nghĩa trên một tập nguồn di động.
• Tìm kiếm ngữ nghĩa nội bộ. Xây dựng một lớp truy xuất riêng tư trên tài liệu tham khảo công khai mà đội của bạn dựa vào, được cập nhật thường xuyên theo lịch trình.

Tại Sao Chọn Trình Duyệt Scraping của Scrapeless

Trình duyệt Scraping không dính lỗi là một trình duyệt đám mây có thể tùy chỉnh, chống phát hiện, được thiết kế cho các trình thu thập dữ liệu web và các tác nhân AI. Đặc biệt dành cho các pipeline văn bản LLM và RAG, nó mang lại:

• Trích xuất Markdown sạch. scrape_markdown hiển thị một URL và trả về nội dung có thể đọc được dưới dạng Markdown — tiêu đề, đoạn văn, danh sách, bảng và liên kết được bảo tồn; điều hướng, tập lệnh, chỗ quảng cáo và định dạng nội tuyến được loại bỏ. Đó là định dạng mà mô hình nhúng đọc tốt nhất.
• Kết xuất JavaScript phía đám mây. Chromium đầy đủ cung cấp nước cho trang trước khi trích xuất, vì vậy các ứng dụng trang đơn, các phần tải lười và nội dung được chèn sau yêu cầu ban đầu được ghi lại thay vì bị bỏ lỡ.
• Proxy dân cư ở hơn 195 quốc gia. Các trang bị ràng buộc địa lý trả về nội dung mà người đọc địa phương sẽ thấy, và việc quay vòng là tự động trong mỗi phiên — sự khác biệt giữa một bài viết thực và một trang bị chặn địa phương.
• Chống phát hiện dấu vân tay trong mỗi phiên — UA, múi giờ, ngôn ngữ, độ phân giải màn hình, WebGL và canvas được ngẫu nhiên hóa theo phiên, vì vậy các nguồn có giá trị cao vẫn có thể truy cập mà không cần điều chỉnh dấu vân tay theo yêu cầu.
• Một công cụ nguyên thủy, hai bề mặt. Cùng một trình duyệt đám mây có thể truy cập như một công cụ MCP cho các pipeline do tác nhân điều khiển và như một phiên Python SDK cho các pipeline do kịch bản điều khiển, vì vậy bước trích xuất giống nhau có thể cấu thành vào cả hai kiến trúc.

Lấy khóa API của bạn trên gói miễn phí tại Scrapeless.

Điều kiện tiên quyết

• Python 3.10 hoặc mới hơn.
• Một tài khoản Scrapeless và khóa API — đăng ký tại app.scrapeless.com và sao chép khóa từ Cài đặt → Quản lý Khóa API.
• Một khóa API mô hình nhúng nếu bạn dự định nhúng (các ví dụ dưới đây sử dụng OpenAI; bất kỳ nhà cung cấp nhúng nào cũng hoạt động bằng cách hoán đổi một dòng).
• Quen thuộc cơ bản với pip và venv.

Tài liệu SDK và công cụ đầy đủ có tại docs.scrapeless.com.

Cài đặt

Có hai cách để truy cập cùng một trình duyệt đám mây. Chọn cách nào phù hợp với ai điều khiển pipeline — một tác nhân hoặc một kịch bản.

Tùy chọn A — SDK Python (do kịch bản điều khiển)

Đối với một kịch bản mà sở hữu vòng lặp khám phá → trích xuất → chia nhỏ → nhúng, cài đặt SDK Python Scrapeless cộng với các thư viện nhúng và lưu trữ vector mà bạn dự định sử dụng:

python -m venv .venv
source .venv/bin/activate          # Windows: .venv\Scripts\activate
pip install scrapeless openai chromadb tiktoken

Xuất khóa API của bạn cho shell hiện tại. SDK tự động đọc SCRAPELESS_API_KEY từ môi trường:

export SCRAPELESS_API_KEY="your_api_token_here"
export OPENAI_API_KEY="your_openai_token_here"

Tùy chọn B — máy chủ MCP (do tác nhân điều khiển)

Đối với một tác nhân AI gọi các công cụ, chạy máy chủ Scrapeless MCP. Nó cung cấp scrape_markdown, scrape_html, google_search, và một tập hợp các công cụ trình duyệt cho bất kỳ khách hàng nào hỗ trợ MCP:

npx -y scrapeless-mcp-server

Chỉ định khách hàng MCP của bạn vào lệnh và truyền khóa API như biến môi trường SCRAPELESS_KEY trong cấu hình máy chủ. Tác nhân sau đó có thể gọi scrape_markdown trực tiếp.

Pipeline trong nháy mắt

Khám phá URL            Trích xuất văn bản sạch         Chia nhỏ cho RAG            Nhúng + lưu trữ
┌──────────────┐         ┌──────────────────┐       ┌──────────────┐        ┌──────────────┐
│ google_search│         │ scrape_markdown   │       │ chia thành    │        │ nhúng mỗi    │
│ hoặc sitemap │  ────►   │ (trình duyệt đám mây│ ────► │ ~500–1000-tok │ ────►  │ phần, cập nhật │
│ hoặc danh sách hạt giống │  hiển thị + làm sạch)│       │ các phần chồng chéo│        │ vào CSDL vector │
└──────────────┘         └──────────────────┘       │       │        └──────────────┘
                                                     └──────────────┘

Bốn giai đoạn, phân tách sạch sẽ. Khám phá quyết định các trang nào vào tập hợp; trích xuất quyết định văn bản sạch như thế nào; chia nhỏ quyết định có thể truy xuất như thế nào; nhúng làm cho nó có thể tìm kiếm. Scrapeless sở hữu hai giai đoạn đầu tiên — những giai đoạn mà web trực tiếp phản kháng — và các thư viện tiêu chuẩn sở hữu hai giai đoạn cuối cùng.

Bước 1 — Khám phá các URL

Một tập hợp bắt đầu với danh sách các URL. Ba nguồn phổ biến bao phủ hầu hết mọi trường hợp:

• Danh sách hạt giống hoặc sitemap bạn đã có — trường hợp đơn giản nhất; bỏ qua ngay bước 2.
• Một cuộc thu thập dữ liệu trang — bắt đầu từ một phần gốc và theo dõi các liên kết trong miền đến độ sâu giới hạn.
• Khám phá tìm kiếm — khi các trang liên quan không được biết trước, tìm kiếm chúng.

Máy chủ Scrapeless MCP cung cấp một công cụ google_search trả về các kết quả hữu cơ dưới dạng các hàng cấu trúc, đây là một cách sạch để khám phá các URL nguồn cho một chủ đề. Mỗi hàng mang theo vị trí, tiêu đề, liên kết, trích dẫn và nguồn:

# discover.py — thu thập URL ứng cử viên từ một truy vấn tìm kiếm
# (tham số công cụ MCP là camelCase; điều này minh họa hình dạng trả về)
results = [

{"position": 1, "title": "Giải thích về Tạo Dữ Liệu Tăng Cường Tìm Kiếm",
     "link": "https://example.com/guides/rag-explained", "source": "example.com"},
    {"position": 2, "title": "Chiến Lược Phân Mảnh cho RAG",
     "link": "https://example.com/blog/chunking-strategies", "source": "example.com"},
    # ...
]

urls = [row["link"] for row in results]

Giữ cho giai đoạn khám phá trung thực: loại bỏ các URL trùng lặp, bỏ qua các miền không liên quan và giới hạn số lượng trước khi bạn chi tiêu bất kỳ ngân sách hiển thị nào cho mỗi trang. Một tập hợp 200 URL tập trung truy xuất tốt hơn nhiều so với một tập hợp 2.000 URL không rõ ràng.

Bước 2 — Trích xuất Markdown sạch với scrape_markdown

Đây là giai đoạn quyết định chất lượng tập dữ liệu. scrape_markdown sẽ render URL trong trình duyệt đám mây chống phát hiện — JavaScript chạy, trang được tải, đường truyền dân dụng giữ cho nội dung có thể truy cập — và trả lại phần nội dung có thể đọc được dưới dạng Markdown sạch. Các tiêu đề vẫn là tiêu đề, danh sách vẫn là danh sách, bảng vẫn là bảng, và mọi thứ không phải là nội dung sẽ bị loại bỏ.

Điều khiển qua đại lý (MCP)

Khi một đại lý gọi công cụ, nó nhận Markdown như là kết quả của công cụ. Một chi tiết quan trọng cho vệ sinh tập dữ liệu: các công cụ MCP không trạng thái tiền tố tải trọng văn bản của chúng bằng Response:\n\n. Loại bỏ tiêu đề đó trước khi văn bản vào tập dữ liệu của bạn, hoặc nó sẽ nằm ở đầu phần đầu tiên của bạn:

# clean_mcp_payload.py — chuẩn hóa kết quả công cụ MCP trước khi phân mảnh
PREFIX = "Response:\n\n"

def clean_markdown(tool_result: str) -> str:
    """Loại bỏ tiền tố 'Response:' của công cụ không trạng thái từ kết quả scrape_markdown của MCP."""
    if tool_result.startswith(PREFIX):
        tool_result = tool_result[len(PREFIX):]
    return tool_result.strip()

Điều khiển qua script (Python SDK)

Khi một script sở hữu vòng lặp, hãy tạo một phiên duyệt đám mây với SDK và render mỗi URL. SDK đọc SCRAPELESS_API_KEY từ môi trường; proxy_country chỉ định đường truyền dân dụng (snake_case trên SDK):

# extract.py — render mỗi URL đã phát hiện thành Markdown sạch
from scrapeless import Scrapeless
from scrapeless.types import ICreateBrowser

client = Scrapeless()  # đọc SCRAPELESS_API_KEY
session = client.browser.create(
    ICreateBrowser(proxy_country="US", session_ttl=240)
)

def fetch_markdown(url: str) -> str:
    """Render một URL trong trình duyệt đám mây và trả về văn bản Markdown sạch."""
    # Phiên này cung cấp một điểm cuối CDP tại session.browser_ws_endpoint;
    # điều khiển nó để điều hướng đến `url`, đợi trang tải, sau đó đọc
    # phần nội dung Markdown sạch cho tập dữ liệu.
    # `render_to_markdown` là một trợ giúp của riêng bạn: điều khiển điểm cuối CDP để điều hướng,
    # đợi tải, sau đó chuyển đổi HTML đã được làm sạch thành Markdown. Để có kết quả sẵn có
    # mà không cần viết trợ giúp, hãy sử dụng công cụ MCP `scrape_markdown` đã được nêu
    # ở trên, nó trả lại Markdown trực tiếp.
    markdown = render_to_markdown(session, url)
    return markdown.strip()

documents = []
for url in urls:
    text = fetch_markdown(url)
    if len(text) > 200:                # bỏ qua các trang gần như trống / trang chắn
        documents.append({"url": url, "text": text})

Một bảo vệ chiều dài ngắn ở cuối là điều đáng giữ: một trang chỉ trả về một vài chục ký tự Markdown thường là một bức tường chấp thuận hoặc một container trống, không phải là một bài viết, và nó không nên làm ô nhiễm tập dữ liệu.

Lấy khóa API của bạn trên gói miễn phí: Scrapeless

Markdown hay HTML?

scrape_markdown và scrape_html đều chạy cùng một render. Sự khác biệt là những gì quay trở lại và những gì bạn làm với nó:

Cho một tập dữ liệu LLM hoặc RAG, Markdown là mặc định. Nó cung cấp mô hình nhúng nội dung và không gì khác, nó sống sót tốt hơn trong việc xoay vòng DOM so với các selector CSS, và nó tốn ít token hơn ở mọi giai đoạn hạ nguồn. Chỉ nên lấy scrape_html khi bạn cần chạy các selector của riêng bạn chống lại một bố cục cụ thể.

Bước 3 — Phân mảnh cho RAG

Một mô hình nhúng có kích thước đầu vào hữu hạn, và việc truy xuất hoạt động tốt nhất khi mỗi đơn vị được lưu trữ là một đoạn văn liền mạch thay vì là một tài liệu đầy đủ. Phân mảnh sẽ chia Markdown sạch thành các cửa sổ chồng chéo. Một mặc định thực tế là 500–1000 token mỗi đoạn với 10–15% chồng chéo — đủ lớn để giữ một ý tưởng hoàn chỉnh, đủ nhỏ để giữ cho việc truy xuất chính xác, với chồng chéo để một câu bị chia cắt qua một ranh giới vẫn xuất hiện nguyên vẹn trong ít nhất một đoạn.

# chunk.py — chia Markdown sạch thành các đoạn chồng chéo, kích thước token
import tiktoken

enc = tiktoken.get_encoding("cl100k_base")

def chia_tea(text: str, max_tokens: int = 800, overlap: int = 100):
    """Trả về các cửa sổ token chồng chéo qua Markdown đã được làm sạch."""
    tokens = enc.encode(text)
    step = max_tokens - overlap
    for start in range(0, len(tokens), step):
        window = tokens[start:start + max_tokens]
        if not window:
            break
        yield enc.decode(window)

cac_manh = []
for doc in documents:
    for i, piece in enumerate(chia_tea(doc["text"])):
        cac_manh.append({
            "id": f"{doc['url']}#chunk-{i}",
            "url": doc["url"],
            "chunk_index": i,
            "text": piece,
        })

Vì đầu vào đã là Markdown sạch, nên chương trình chia nhỏ không bao giờ phải chiến đấu với các banner cookie hay các khối <script> làm tách một đoạn văn thành hai. Việc chia theo tiêu đề Markdown trước khi cửa sổ token giúp giữ các nội dung liên quan gần gũi hơn — chia nhỏ trong một phần, không chạy qua hai — khi các tài liệu nguồn có cấu trúc tiêu đề rõ ràng.

Một bản ghi chunk đơn lẻ trông như thế này:

{
  "id": "https://example.com/guides/rag-explained#chunk-0",
  "url": "https://example.com/guides/rag-explained",
  "chunk_index": 0,
  "token_count": 800,
  "text": "## Tạo ra thông tin gia tăng\n\nRAG gắn kết một mô hình ngôn ngữ với một tập hợp bên ngoài bằng cách lấy các đoạn liên quan nhất vào thời điểm truy vấn và truyền chúng cho mô hình như ngữ cảnh. Chất lượng lấy thông tin phụ thuộc trực tiếp vào cách mà văn bản nguồn đã được trích xuất và chia nhỏ một cách sạch sẽ ..."
}

Bước 4 — Nhúng và lưu trữ vào cơ sở dữ liệu vector

Giai đoạn cuối cùng biến mỗi mảnh thành một vector và lưu trữ nó để truy xuất. Ví dụ dưới đây sử dụng một cửa hàng Chroma cục bộ và nhúng OpenAI; hình dạng là giống nhau cho pgvector, Pinecone, hoặc bất kỳ cơ sở dữ liệu vector nào khác — chỉ cần thay đổi client và giữ nguyên các bản ghi:

# embed.py — nhúng mỗi chunk và cập nhật vào một cửa hàng vector
import chromadb
from openai import OpenAI

oai = OpenAI()
db = chromadb.PersistentClient(path=".chroma")
collection = db.get_or_create_collection("web_corpus")

def nhung(texts: list[str]) -> list[list[float]]:
    resp = oai.embeddings.create(model="text-embedding-3-small", input=texts)
    return [d.embedding for d in resp.data]

batch = cac_manh[:64]                                   # nhúng theo lô
collection.upsert(
    ids=[c["id"] for c in batch],
    documents=[c["text"] for c in batch],
    embeddings=nhung([c["text"] for c in batch]),
    metadatas=[{"url": c["url"], "chunk_index": c["chunk_index"]} for c in batch],
)

Tham số url và chunk_index đi theo mỗi vector, vì vậy khi truy xuất đưa ra một chunk, bạn có thể trích dẫn trang nguồn và ghép lại các chunk lân cận để có ngữ cảnh đầy đủ hơn. Tham số metadata cũng là điều cho phép bạn cập nhật theo id — làm mới một trang sẽ thay thế các chunk của nó tại chỗ thay vì nhân đôi chúng.

Những gì bạn nhận được

Tập hợp mà lên đến cơ sở dữ liệu vector là một danh sách các mảnh sạch, đã nhúng, liên kết nguồn. Một bản ghi đã được truy xuất trông như thế này:

{
  "id": "https://example.com/blog/chunking-strategies#chunk-2",
  "document": "### Chồng chéo\n\nMột sự chồng chéo từ 10–15% giữa các mảnh liền kề giữ cho một câu rơi vào một ranh giới vẫn nằm nguyên trong ít nhất một cửa sổ, điều này làm tăng khả năng nhớ cho các truy vấn nhắm vào chỗ rách giữa hai ý tưởng ...",
  "metadata": {
    "url": "https://example.com/blog/chunking-strategies",
    "chunk_index": 2
  },
  "distance": 0.18
}
// Lược đồ phản ánh chính xác những gì bước 4 đã cập nhật. Các giá trị trường là mẫu minh họa.

Một vài quan sát trung thực về những gì mong đợi khi điều này chạy trên web trực tiếp:

• Chất lượng Markdown theo dõi cấu trúc trang. Các trang có HTML ngữ nghĩa sạch sẽ chuyển đổi thành Markdown tuyệt vời; các trang được xây dựng từ soup <div> chung chuyển đổi chấp nhận được nhưng có thể hợp nhất một tiêu đề bên vào thân. Kiểm tra một mẫu của các trang đã chuyển đổi trước khi tin tưởng vào một tập hợp lớn.
• Thời gian làm đầy thay đổi theo trang. Hầu hết các trang đã được hoàn toàn hiển thị trước khi Markdown được đọc, nhưng một số làm đầy nội dung chính của họ thông qua một yêu cầu chậm; đối với những trang đó, cho phép trang có một chút thời gian để ổn định trước khi đọc.
• Loại bỏ trùng lặp ở hai cấp độ. Loại bỏ các URL trùng lặp ở giai đoạn khám phá và các chunk gần giống trước khi nhúng (một băm hoặc một ngưỡng tương tự) — các bài viết đã phát hành và phần chân trang boilerplate nếu không sẽ làm tăng kích thước tập hợp và thiên lệch việc truy xuất.
• Ghi lại khu vực thoát cho nội dung thay đổi theo khu vực địa lý. Các trang địa phương hóa nội dung trả về văn bản khác nhau theo vùng; đặt proxy_country thành khu vực mà bạn muốn phiên bản của nó trong tập hợp để dữ liệu duy trì tính nhất quán.
• Giữ lại kích thước bảo vệ. Một trang chỉ trả về vài chục ký tự thường là một tường đồng ý hoặc một chứa rỗng, không phải nội dung — lọc nó ra trước khi chia nhỏ.

Kết luận: xây dựng một quy trình văn bản sạch sẽ có thể mở rộng

Khám Phá → Trích Xuất → Phân Mảnh → Nhúng giảm xuống còn khoảng sáu mươi dòng mã Python. Giai đoạn chịu tải là trích xuất, và `scrape_markdown` thực hiện điều đó: trình duyệt đám mây chống phát hiện hiển thị trang, truy cập cư dân giữ cho nó có thể truy cập, và những gì trở về là thân bài có thể đọc được dưới dạng Markdown sạch — định dạng mà một mô hình nhúng đọc tốt nhất. Phân mảnh và nhúng sau đó là công việc thư viện chuẩn trên văn bản đã sạch.

Đối với cùng một nguyên thủy Trình Duyệt Trích Xuất Không Rác được kết nối vào một khung đại lý với đầu ra có kiểu và một kho vector, xem bài đăng tích hợp [LangChain](https://www.scrapeless.com/vi/blog/langchain-scrapeless-scraping-browser-2026). Đối với nhiều mô hình từ đầu đến cuối kết hợp tìm kiếm, hiển thị và trích xuất thành các hệ thống hoạt động, xem bài đăng [trường hợp sử dụng đại lý AI](https://www.scrapeless.com/vi/blog/ai-agent-use-cases-scrapeless-2026). Mô hình diễn ra trên tất cả chúng: ghim một khu vực, trả về Markdown chứ không phải HTML, phân mảnh với sự chồng chéo, và loại bỏ các bản sao trước khi bạn nhúng.

---

## Sẵn Sàng Xây Dựng Dòng Dữ Liệu AI-Powered Của Bạn?

Tham gia cộng đồng của chúng tôi để nhận một kế hoạch miễn phí và kết nối với các nhà phát triển xây dựng các dòng dữ liệu LLM và RAG trên Scrapeless: [Discord](https://discord.gg/VU2vtbq7Q2) · [Telegram](https://t.me/scrapeless).

Đăng ký tại [Scrapeless](https://app.scrapeless.com/passport/login/?utm_source=website&utm_medium=blog&utm_campaign=scrapingbrowser&utm_term=scrapeforllm) để nhận thời gian chạy Trình Duyệt Trích Xuất miễn phí và điều chỉnh các mẫu trên cho các nguồn, khu vực và kích thước phân mảnh mà dòng dữ liệu của bạn cần. Các kế hoạch và giới hạn có tại [scrapeless.com/en/pricing](https://www.scrapeless.com/vi/pricing).

---

## Câu Hỏi Thường Gặp

**Hỏi: Việc trích xuất văn bản từ website cho tập dữ liệu LLM hoặc RAG có hợp pháp không?**

Việc trích xuất dữ liệu công khai thường được phép ở hầu hết các khu vực pháp lý, nhưng quy tắc thay đổi theo từng quốc gia và theo điều khoản dịch vụ của từng trang. Xem xét các Điều Khoản Dịch Vụ của trang mục tiêu, tôn trọng `robots.txt` khi có thể, không thu thập dữ liệu cá nhân mà không có cơ sở hợp pháp và tham khảo luật sư cho các tập dữ liệu quy mô thương mại. Việc xây dựng một tập dữ liệu huấn luyện hoặc RAG không làm thay đổi nghĩa vụ cơ bản trong việc truy cập chỉ dữ liệu công khai một cách hợp pháp.

**Hỏi: Tại sao lại sử dụng Markdown thay vì HTML thô cho đầu vào LLM?**

HTML thô chủ yếu là đánh dấu — điều hướng, script, vị trí quảng cáo, kiểu inline — làm loãng tín hiệu nội dung, làm tăng chi phí token và ô nhiễm các nhúng. Markdown sạch từ `scrape_markdown` giữ lại các tiêu đề, đoạn văn, danh sách, bảng và liên kết mà trang thực sự liên quan và loại bỏ phần còn lại, vì vậy mô hình nhúng chỉ đọc nội dung và không gì khác. Markdown cũng sống sót tốt hơn sau các thay đổi DOM so với việc trích xuất bằng chọn CSS.

**Hỏi: Kích thước phân mảnh nào nên sử dụng cho RAG?**

Một mặc định thực tiễn là 500–1000 token cho mỗi phân mảnh với 10–15% chồng chéo. Các phân mảnh nhỏ hơn nâng cao độ chính xác của việc truy xuất nhưng có thể làm tách rời một ý tưởng; các phân mảnh lớn hơn giữ nhiều ngữ cảnh hơn nhưng làm loãng tính liên quan. Điều chỉnh phù hợp với kích thước đầu vào của mô hình nhúng và các truy vấn của bạn — các lượt truy cập thực tế ngắn ưa chuộng các phân mảnh nhỏ hơn, câu hỏi tổng hợp ưu tiên các phân mảnh lớn hơn. Việc chia tách theo tiêu đề Markdown trước khi cửa sổ token giúp giữ nội dung liên quan cùng nhau.

**Hỏi: Tôi có cần một proxy không?**

Có, đối với hầu hết các nguồn công khai xứng đáng để thu thập. Truy cập cư dân là thứ giữ các trang được định vị địa lý và bảo vệ chống bot có thể truy cập, và đó là điều làm cho một trang có nhiều JavaScript hiển thị nội dung thực thay vì một trang chặn. Trình Duyệt Trích Xuất Không Rác đi qua các proxy cư dân ở hơn 195 quốc gia; đặt `proxy_country` để ghim khu vực mà phiên bản nội dung bạn muốn.

**Hỏi: Làm thế nào để tôi loại bỏ các bản sao và làm sạch tập dữ liệu?**

Loại bỏ bản sao ở hai cấp độ: loại bỏ các URL trùng lặp khi phát hiện, và loại bỏ các phân mảnh gần giống trước khi nhúng bằng cách sử dụng một mã nội dung hoặc ngưỡng tương đồng. Bởi vì `scrape_markdown` đã loại bỏ tiêu đề rác, việc dọn dẹp còn lại chỉ là nhẹ — một bảo vệ độ dài để loại bỏ các trang gần như trống và việc tách nhận thức tiêu đề tùy chọn thường là đủ.

**Hỏi: Tại sao kết quả `scrape_markdown` từ MCP bắt đầu bằng `Response:`?**

Các công cụ không trạng thái trên máy chủ MCP Scrapeless thêm tiền tố `Response:\n\n` vào tải văn bản của chúng. Đây là một tiêu đề lớp vận chuyển, không phải là một phần của nội dung trang. Loại bỏ nó trước khi phân mảnh — bộ trợ giúp một dòng `clean_markdown` trong Bước 2 xử lý điều đó — để tiền tố không xuất hiện ở đầu phân mảnh đầu tiên của bạn.

**Hỏi: Tôi có thể chạy điều này mà không cần một đại lý AI không?**

Có. Đường dẫn SDK Python trong Bước 2 sở hữu vòng lặp khám phá → trích xuất → phân mảnh → nhúng từ đầu đến cuối mà không cần liên quan đến đại lý. Máy chủ MCP là con đường được đề xuất khi một đại lý quyết định các trang nào cần thu thập; SDK là con đường được đề xuất khi một kịch bản thực hiện.