Hướng dẫn dùng AI

Chia tài liệu thành đoạn cho RAG: kích thước, chồng lấn, theo cấu trúc

Trong một hệ thống RAG, tài liệu phải được chia thành các đoạn nhỏ trước khi tạo embedding và tìm kiếm. Chia sai thì câu trả lời bị cắt đôi, đoạn mất ngữ cảnh, và mô hình nhận được thông tin không đầy đủ. Bài này so ba cách chia phổ biến: cắt theo độ dài cố định, ghép theo câu, và chia theo mục rồi theo câu, bằng một đoạn Python đo xem câu chứa đáp án có còn nguyên vẹn không, kèm lời khuyên từ tài liệu của Anthropic và LangChain.

Ý chính
  • Chia đoạn quyết định mô hình nhận được gì. Đoạn cắt ngang câu, hoặc mất tên mục, làm câu trả lời thiếu hoặc sai.
  • Ba họ cách chia: theo độ dài cố định, theo cấu trúc văn bản (đoạn, câu), và theo cấu trúc tài liệu (mục, tiêu đề, hàm trong code).
  • Trong ví dụ của bài, cắt cố định chỉ giữ nguyên câu đáp án 2/5 lần; ghép theo câu giữ 5/5; chia theo mục rồi theo câu giữ 5/5 và còn gắn được tên mục.
  • Kích thước, ranh giới và chồng lấn đều ảnh hưởng chất lượng tìm kiếm. Anthropic khuyên thử các lựa chọn trên chính dữ liệu của bạn.

Bài này dựa trên bài viết Contextual Retrieval của Anthropic, trang Text splitters của LangChain và trang Embeddings trong tài liệu của Anthropic, đọc ngày 11/11/2026. Nếu chưa rõ RAG là gì, đọc trước bài RAG là gì.

Vì sao phải chia

Một giáo trình vài trăm trang không thể biến thành một embedding duy nhất rồi so với câu hỏi: vector của cả cuốn sách quá chung chung, và đưa cả cuốn vào prompt thì tốn. Vì vậy tài liệu được chia thành nhiều đoạn, mỗi đoạn một embedding. Khi có câu hỏi, hệ thống tìm vài đoạn gần nhất và đưa cho mô hình.

Bài viết của Anthropic mô tả cách làm phổ biến là chia thành các đoạn thường không quá vài trăm token, và chỉ ra vấn đề lớn nhất: đoạn bị tách khỏi ngữ cảnh. Ví dụ trong bài là một câu nói doanh thu tăng 3% so với quý trước; đứng riêng, câu này không cho biết công ty nào, quý nào, nên khó tìm đúng và khó dùng đúng.

Ba họ cách chia

Trang tài liệu của LangChain chia các cách chia đoạn thành ba họ.

Theo độ dài. Cắt sao cho không đoạn nào vượt một kích thước, tính theo token hoặc số ký tự. Dễ làm, kích thước đều, nhưng không quan tâm câu kết thúc ở đâu.

Theo cấu trúc văn bản. Cố giữ nguyên các đơn vị tự nhiên: ưu tiên đoạn văn, nếu đoạn quá dài thì xuống câu, câu quá dài mới xuống từ. Trang tài liệu gọi bộ chia đệ quy theo kiểu này là lựa chọn mặc định nên dùng, chỉ chỉnh khi cần tối ưu cho ứng dụng cụ thể.

Theo cấu trúc tài liệu. Dùng định dạng sẵn có của tệp: tiêu đề Markdown, thẻ HTML, đối tượng JSON, hàm và lớp trong code. Hợp với tài liệu có tổ chức rõ như giáo trình có mục, tài liệu kỹ thuật, mã nguồn.

Chia đoạn: ba cách, ba kết quả 5 câu hỏi; câu đáp án có nằm trọn trong một đoạn? Cắt cố địnhNguyên vẹn 2/5cắt ngang câu Ghép theo câuNguyên vẹn 5/5mất tên mục Theo mục, theo câuNguyên vẹn 5/5có tên mục 5/5 Còn lạiĐo trên dữ liệu thậtbằng bộ câu hỏi Giáo trình nhỏ tự soạn, đoạn tối đa 20 từ
Chia đoạn: ba cách, ba kết quả Cắt cố địnhNguyên vẹn 2/5cắt ngang câu Ghép theo câuNguyên vẹn 5/5mất tên mục Theo mục, theo câuNguyên vẹn 5/5có tên mục 5/5 Còn lạiĐo trên dữ liệu thậtbằng bộ câu hỏi Giáo trình nhỏ tự soạn, đoạn tối đa 20 từ
Hình 1. So ba cách chia một giáo trình nhỏ tự soạn với 5 câu hỏi, đoạn tối đa 20 từ: cắt cố định chỉ giữ nguyên câu đáp án 2/5 vì cắt ngang câu; ghép theo câu giữ 5/5 nhưng mất tên mục; chia theo mục rồi theo câu giữ 5/5 và có tên mục 5/5. Bước tiếp theo là đo trên dữ liệu thật bằng bộ câu hỏi.

Ví dụ: so ba cách trên một giáo trình nhỏ

Đoạn Python dưới đây có một giáo trình nhỏ ba mục (đệ quy, danh sách, từ điển) và năm câu hỏi, mỗi câu kèm câu văn chứa đáp án. Ba hàm chia: co_dinh cắt mỗi đoạn 20 từ, chồng lấn 5 từ; theo_cau ghép các câu nguyên vẹn tới khi gần 20 từ; theo_muc tách theo tiêu đề mục trước, rồi ghép câu trong từng mục, và gắn tên mục vào đầu mỗi đoạn. Hàm danh_gia đếm xem câu đáp án có nằm trọn trong một đoạn nào không, và đoạn đó có mang tên mục không.

"""So ba cách chia tài liệu thành đoạn cho RAG trên một giáo trình nhỏ.

- co_dinh: cắt theo số từ cố định, có chồng lấn.
- theo_cau: ghép các câu nguyên vẹn tới khi đủ độ dài.
- theo_muc: tách theo tiêu đề mục trước (dòng bắt đầu bằng '#'), rồi ghép câu trong từng mục, gắn tên mục vào đầu đoạn.
Đo: với mỗi câu hỏi mẫu, câu chứa đáp án có nằm NGUYÊN VẸN trong một đoạn không, và đoạn đó có tên mục không.
Giáo trình và câu hỏi là dữ liệu tự soạn để minh họa.
"""
import re

GIAO_TRINH = """# Đệ quy
Đệ quy là cách một hàm tự gọi lại chính nó với bài toán nhỏ hơn. Mỗi hàm đệ quy cần một trường hợp cơ sở để dừng. Nếu thiếu trường hợp cơ sở, chương trình gọi mãi cho tới khi tràn ngăn xếp. Ví dụ quen thuộc là tính giai thừa: n giai thừa bằng n nhân với giai thừa của n trừ một.
# Danh sách trong Python
Danh sách là kiểu dữ liệu lưu nhiều phần tử theo thứ tự. Phần tử được đánh số từ không. Hàm len trả về số phần tử của danh sách. Phương thức append thêm một phần tử vào cuối danh sách.
# Từ điển trong Python
Từ điển lưu các cặp khóa và giá trị. Tra một khóa trong từ điển thường rất nhanh vì Python dùng bảng băm. Khóa phải là kiểu không đổi được như số, chuỗi hoặc bộ.
"""

CAU_HOI = [  # (câu hỏi, câu chứa đáp án)
    ("Hàm đệ quy cần gì để dừng?", "Mỗi hàm đệ quy cần một trường hợp cơ sở để dừng."),
    ("Thiếu trường hợp cơ sở thì sao?", "Nếu thiếu trường hợp cơ sở, chương trình gọi mãi cho tới khi tràn ngăn xếp."),
    ("Làm sao biết danh sách có bao nhiêu phần tử?", "Hàm len trả về số phần tử của danh sách."),
    ("Vì sao tra khóa trong từ điển nhanh?", "Tra một khóa trong từ điển thường rất nhanh vì Python dùng bảng băm."),
    ("Khóa từ điển phải là kiểu gì?", "Khóa phải là kiểu không đổi được như số, chuỗi hoặc bộ."),
]


def tach_cau(van_ban):
    return [c.strip() for c in re.split(r"(?<=[.!?])\s+", van_ban) if c.strip()]


def co_dinh(van_ban, so_tu=20, chong=5):
    tu = " ".join(d for d in van_ban.splitlines() if not d.startswith("#")).split()
    buoc = so_tu - chong
    return [" ".join(tu[i:i + so_tu]) for i in range(0, max(len(tu) - chong, 1), buoc)]


def ghep_cau(cac_cau, so_tu=20, tien_to=""):
    doan, hien_tai = [], []
    for cau in cac_cau:
        if hien_tai and len(" ".join(hien_tai + [cau]).split()) > so_tu:
            doan.append(tien_to + " ".join(hien_tai))
            hien_tai = []
        hien_tai.append(cau)
    if hien_tai:
        doan.append(tien_to + " ".join(hien_tai))
    return doan


def theo_cau(van_ban, so_tu=20):
    than = " ".join(d for d in van_ban.splitlines() if not d.startswith("#"))
    return ghep_cau(tach_cau(than), so_tu)


def theo_muc(van_ban, so_tu=20):
    doan, muc, dong = [], None, []
    for d in van_ban.splitlines() + ["# "]:
        if d.startswith("#"):
            if muc is not None:
                doan += ghep_cau(tach_cau(" ".join(dong)), so_tu, tien_to=f"[{muc}] ")
            muc, dong = d.lstrip("# ").strip(), []
        elif d.strip():
            dong.append(d)
    return doan


def danh_gia(cac_doan):
    nguyen_ven = sum(any(dap in d for d in cac_doan) for _, dap in CAU_HOI)
    co_muc = sum(any(dap in d and d.startswith("[") for d in cac_doan) for _, dap in CAU_HOI)
    return nguyen_ven, co_muc


def chay_thu():
    dong = []
    for ten, ham in [("Cố định 20 từ, chồng 5", co_dinh), ("Theo câu, tối đa 20 từ", theo_cau),
                     ("Theo mục rồi theo câu", theo_muc)]:
        cac_doan = ham(GIAO_TRINH)
        nv, cm = danh_gia(cac_doan)
        dong.append(f"{ten}: {len(cac_doan)} đoạn; câu đáp án nguyên vẹn {nv}/{len(CAU_HOI)}; có tên mục {cm}/{len(CAU_HOI)}")
    print("\n".join(dong))
    return dong


if __name__ == "__main__":
    chay_thu()

Kết quả cho thấy rõ khác biệt. Cắt cố định cho 10 đoạn nhưng chỉ 2/5 câu đáp án còn nguyên vẹn; ba câu còn lại bị cắt đôi giữa hai đoạn, nên dù tìm đúng đoạn, mô hình cũng chỉ thấy nửa câu. Chồng lấn 5 từ không đủ cứu những câu dài hơn 5 từ. Ghép theo câu giữ được cả 5/5 câu đáp án, nhưng không đoạn nào biết mình thuộc mục nào. Chia theo mục rồi theo câu giữ được 5/5 và mỗi đoạn có tên mục ở đầu, ví dụ đoạn "Mỗi hàm đệ quy cần một trường hợp cơ sở để dừng" được ghi kèm "[Đệ quy]".

Một cách kiểm nhanh mà ai cũng nên làm: in ra mười đoạn ngẫu nhiên sau khi chia và đọc bằng mắt. Nếu chính bạn đọc một đoạn mà không hiểu nó nói về cái gì, mô hình cũng sẽ khó dùng nó.

Ví dụ này cố ý nhỏ, đoạn chỉ 20 từ, để thấy rõ cơ chế. Với tài liệu thật, đoạn thường dài hơn nhiều và tỷ lệ câu bị cắt thấp hơn, nhưng vấn đề vẫn còn.

Chọn kích thước và chồng lấn

Không có con số đúng cho mọi trường hợp. Đoạn nhỏ cho embedding sắc nét, tìm chính xác, nhưng dễ thiếu ngữ cảnh; đoạn lớn đủ ngữ cảnh nhưng embedding bị pha loãng, và tốn token khi đưa vào prompt. Bài viết của Anthropic nói kích thước, ranh giới và chồng lấn đều ảnh hưởng hiệu quả tìm kiếm, và khuyên thử trên chính trường hợp của bạn; ví dụ tính chi phí trong bài đó giả định đoạn 800 token.

Chồng lấn là lặp lại một phần cuối đoạn trước ở đầu đoạn sau, để ý ở ranh giới không bị mất hẳn. Chồng lấn giúp với cắt theo độ dài, nhưng tốn thêm chỗ lưu và có thể khiến cùng một ý xuất hiện hai lần trong kết quả tìm. Với cách chia theo câu, chồng lấn ít quan trọng hơn vì câu đã nguyên vẹn.

Cách chọn thực tế: lấy vài chục câu hỏi có đáp án từ tài liệu thật, thử ba bốn cấu hình, đo tỷ lệ tìm được đoạn chứa đáp án. Bài đánh giá hệ thống RAG hướng dẫn cách đo này.

Gắn ngữ cảnh cho đoạn

Gắn tên mục vào đầu đoạn là cách đơn giản nhất để đoạn không mồ côi. Có thể gắn thêm tên tài liệu, chương, ngày ban hành. Anthropic đi xa hơn với Contextual Retrieval: dùng mô hình đọc cả tài liệu rồi viết một đoạn ngữ cảnh ngắn riêng cho từng đoạn, thường 50 đến 100 token, đặt trước đoạn trước khi tạo embedding và chỉ mục tìm theo từ. Theo bài viết, cách này giảm đáng kể tỷ lệ tìm hụt; bài RAG là gì có trích các con số đó.

Trang Embeddings của Anthropic còn giới thiệu loại mô hình embedding có ngữ cảnh, tạo vector cho từng đoạn có tính tới cả tài liệu, không cần tự gắn thêm thông tin. Đây là một lựa chọn khác nếu nhà cung cấp bạn dùng có hỗ trợ.

Lưu gì kèm mỗi đoạn

Ngoài nội dung, mỗi đoạn nên lưu kèm vài thông tin: mã tài liệu gốc, vị trí trong tài liệu (trang, mục, số thứ tự đoạn), ngày cập nhật, và phiên bản cách chia đã dùng. Những thông tin này có ba công dụng. Chatbot trích được nguồn cụ thể cho người dùng kiểm tra lại. Khi tìm được một đoạn, hệ thống có thể lấy thêm đoạn liền trước và liền sau để đủ ngữ cảnh. Và khi tài liệu gốc được sửa, bạn biết chính xác những đoạn nào cần chia lại và tạo lại embedding, thay vì làm lại cả kho.

Những loại tài liệu cần chú ý

Bảng biểu: cắt ngang bảng làm mất tiêu đề cột; nên giữ cả bảng trong một đoạn hoặc lặp lại tiêu đề cột. Code: chia theo hàm, lớp, không cắt giữa hàm. Hỏi đáp, quy chế: mỗi câu hỏi, mỗi điều khoản nên là một đơn vị. Văn bản tiếng Việt quét từ ảnh: làm sạch lỗi nhận dạng chữ trước khi chia, vì dấu câu sai làm tách câu sai.

Cẩn thận
  • Cắt theo số ký tự cố định cho mọi loại tài liệu mà không xem đoạn ra trông thế nào.
  • Bỏ mất tiêu đề mục, tên tài liệu khỏi đoạn.
  • Cắt ngang bảng hoặc giữa một hàm code.
  • Chọn kích thước đoạn theo thói quen, không đo bằng câu hỏi thật.
  • Đổi cách chia mà quên tạo lại toàn bộ embedding.

Câu hỏi thường gặp

Đoạn nên dài bao nhiêu?

Không có con số chung. Bài viết của Anthropic mô tả đoạn thường không quá vài trăm token. Thử vài kích thước trên dữ liệu của bạn và đo.

Có nên dùng mô hình để chia đoạn?

Có thể, mô hình hiểu ý tốt hơn quy tắc, nhưng tốn tiền và chậm hơn. Bắt đầu với cách chia theo cấu trúc, chỉ dùng mô hình khi số đo cho thấy cần.

Chồng lấn bao nhiêu là đủ?

Đủ để một câu ở ranh giới không bị mất hẳn. Nếu đã chia theo câu, có thể không cần chồng lấn.

Tài liệu ngắn có cần chia không?

Nếu cả tài liệu vừa trong prompt và chi phí chấp nhận được, có thể đưa nguyên tài liệu vào thay vì dựng RAG.

Học tiếp

Nếu bạn muốn học Python và AI bài bản cùng giảng viên, tham khảo khóa học AI của Big-O Coding.

Muốn học bài bản cùng giảng viên?

Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.

Xem Khóa AI

Nguồn tham khảo

Chia sẻ: Facebook LinkedIn
Nhắn Zalo tư vấnZalo Gọi 0937 401 483