ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← RAG & Agents

AI Builder

Chunking - Chia nhỏ tài liệu

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Kỹ thuật chia văn bản dài thành các đoạn nhỏ phù hợp để nhúng và truy xuất hiệu quả.

lesson94 minRAG & AgentsAI Engineer

Giới thiệu

Bạn có Bộ luật Lao động 200 trang. Embedding model chỉ xử lý tối đa 512 token/lần. Nhét cả 200 trang vào 1 lần được không?

Embedding model có giới hạn context. Cần chia 200 trang thành hàng trăm chunk nhỏ (256-512 token). Mỗi chunk được embed riêng, lưu vào vector database. Đó là Chunking!

Hãy tưởng tượng bạn đang biên tập một cuốn sách dày 500 trang để đưa lên một hệ thống tra cứu thông minh. Nếu bạn giao cả cuốn sách cho máy tìm kiếm, nó sẽ "ngộp" — không biết nên nhớ phần nào. Ngược lại, nếu bạn xé từng dòng ra làm thẻ nhớ, mỗi thẻ lại quá ngắn để người đọc hiểu nội dung.

Chunking là nghệ thuật chia văn bản dài thành các đoạn vừa vặn: đủ nhỏ để máy xử lý được, đủ lớn để vẫn mang trọn một ý hoàn chỉnh. Giống như cắt bánh mì — cắt quá dày thì khó ăn, cắt quá mỏng thì vụn và mất mùi vị.

Trong bối cảnh RAG (Retrieval-Augmented Generation), chunking là bước tiền xử lý quyết định chất lượng toàn hệ thống. Chunking kém → embedding kém → search trả ngữ cảnh sai → LLM đưa câu trả lời sai. Ngược lại, chunking khéo léo giúp mọi bước sau chạy trơn tru.

Ba chiến lược phổ biến nhất là Fixed-size (cắt đều), Semantic (cắt theo chủ đề), và Recursive (cắt theo ranh giới tự nhiên). Phần tương tác dưới đây cho bạn điều chỉnh chunk size, overlap và xem ngay điểm truy xuất thay đổi.

Phần dưới đây dùng một trích đoạn giả lập của Bộ luật Lao động để so sánh các chiến lược chunking.

Fixed-size Chunking

Chia văn bản thành các đoạn có độ dài cố định (theo ký tự hoặc token). Đơn giản, nhanh, nhưng có thể cắt giữa câu hoặc giữa ý.

Với chunk size 100 ký tự, một điều luật dài 300 ký tự sẽ ra sao?

Mẹo: chunk dưới 150 ký tự thường làm Context richness tụt xuống, vì mỗi đoạn không còn đủ ý để trả lời.

Ưu điểm

  • • Cực kỳ đơn giản — chỉ cần 1 vòng lặp
  • • Tốc độ xử lý nhanh, dễ song song hóa
  • • Kích thước chunk đồng đều → dễ quản lý bộ nhớ

Hạn chế

  • • Cắt cơ học, không quan tâm ranh giới câu/đoạn
  • • Thông tin ở rìa chunk thường bị mất ngữ cảnh
  • • Không phù hợp với tài liệu có cấu trúc rõ ràng

Ranh giới ý, parent-child và các chiến lược khác

Chunking giống chia cuốn sách thành bookmarks: mỗi bookmark đánh dấu 1 đoạn ý hoàn chỉnh. Chunk quá nhỏ = bookmark mỗi dòng (thiếu ngữ cảnh). Chunk quá lớn = bookmark mỗi chương (khó tìm chính xác). 256-512 token là sweet spot cho hầu hết bài toán RAG — đủ dài để nắm một ý, đủ ngắn để embedding tập trung.

Chunk_1 kết thúc: '...theo Điều 128'. Chunk_2 bắt đầu: 'Bộ luật Lao động, người sử dụng lao động phải...'. Vấn đề gì xảy ra?

Chunk_1 kết thúc ở '...theo Điều 128' và Chunk_2 bắt đầu bằng 'Bộ luật Lao động...'. Vấn đề nào xuất hiện?

Fixed-size chunking cắt cơ học, không quan tâm ranh giới ý. Giải pháp: overlap (chồng lấp) hoặc semantic chunking (cắt khi chủ đề thay đổi) hoặc recursive text splitting!

Bạn có một tài liệu pháp lý dài, truy vấn của người dùng thường là những câu hỏi ngắn gọn (ví dụ 'thời gian thử việc tối đa?'). Để cân bằng precision cho search và context đủ cho LLM, bạn nên dùng chiến lược nào?

Với tài liệu pháp lý dài và câu hỏi ngắn, cách nào hợp lý?

Parent-child là pattern kinh điển: chunk nhỏ (child) dùng cho embedding/search precision cao. Khi trúng 1 child, hệ thống trả về parent chunk lớn hơn chứa nó → LLM có đủ context để reason. Best of both worlds!

Chunking (chia nhỏ) là bước tiền xử lý trong pipeline RAG, chia văn bản dài thành các đoạn nhỏ (chunk) phù hợp với giới hạn context của embedding model. Mỗi chunk sau đó được nhúng thành vector và lưu trong vector database.

Nhìn thoáng qua thì chunking đơn giản — chỉ là cắt chuỗi. Nhưng chất lượng chunking quyết định chất lượng toàn hệ thống RAG (số liệu recall theo nguồn bài, chưa kiểm chứng): chunk cắt kém → embedding thiếu ngữ cảnh → search trả chunk không liên quan → LLM hallucinate hoặc trả lời thiếu chính xác. Nghiên cứu thực nghiệm cho thấy chỉ cần thay đổi chunk_size từ 256 → 512, recall@10 có thể dao động 15-25% trên cùng một dataset.

Kích thước chunk tối ưu bị ràng buộc cứng bởi embedding model:

chunk_size≤max_seq_lengthmodel\text{chunk\_size} \leq \text{max\_seq\_length}_{\text{model}}

all-MiniLM-L6-v2: max 256 token. text-embedding-3-small: max 8192 token. bge-m3: max 8192 token. Thực tế, 256-1024 token/chunk thường cho kết quả tốt nhất cho RAG.

Overlap giữa các chunk giúp bảo toàn ngữ cảnh ở ranh giới. Nếu một câu quan trọng nằm vắt ngang 2 chunk, không có overlap thì nó bị chia đôi — cả 2 chunk đều mất ý. Với overlap O ký tự, câu đó xuất hiện trong ít nhất một chunk đầy đủ (miễn là câu ngắn hơn O). Công thức số chunk:

Nchunk=⌈L−OS−O⌉N_{\text{chunk}} = \left\lceil \frac{L - O}{S - O} \right\rceil

Trong đó L là độ dài tổng, S là chunk size, O là overlap. Overlap càng lớn, số chunk càng nhiều → chi phí lưu trữ và embedding tăng theo.

LangChain — RecursiveCharacterTextSplitter

from langchain.text_splitter import RecursiveCharacterTextSplitter

# Đọc Bộ luật Lao động
with open("bo_luat_lao_dong_2025.txt", encoding="utf-8") as f:
    text = f.read()  # ~200 trang

# Recursive Text Splitting (mặc định LangChain)
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,        # ~500 ký tự/chunk
    chunk_overlap=50,      # 50 ký tự chồng lấp (~10%)
    separators=[           # Thứ tự ưu tiên, từ lớn đến nhỏ
        "\n\n",          # Paragraph break
        "\n",             # Line break
        ". ",              # Sentence
        ", ",              # Clause
        " ",               # Word
        "",                # Fallback: cắt theo ký tự
    ],
    length_function=len,   # Có thể thay bằng tiktoken encoder
    is_separator_regex=False,
)

chunks = splitter.split_text(text)
print(f"Tổng {len(chunks)} chunks từ {len(text)} ký tự")
# Ví dụ: ~400 chunks, mỗi chunk ~500 ký tự

# Variant dùng token thay cho ký tự
from langchain.text_splitter import TokenTextSplitter

token_splitter = TokenTextSplitter(
    chunk_size=256,
    chunk_overlap=32,
    encoding_name="cl100k_base",  # tiktoken encoding của GPT-4
)
token_chunks = token_splitter.split_text(text)
# Đảm bảo chunk luôn ≤ 256 token thật, không lệch do tách từ

LangChain — SemanticChunker (experimental)

from langchain_experimental.text_splitter import SemanticChunker
from langchain_openai import OpenAIEmbeddings

# Semantic chunking dựa trên embedding của từng câu
semantic_splitter = SemanticChunker(
    OpenAIEmbeddings(model="text-embedding-3-small"),
    breakpoint_threshold_type="percentile",
    # Cắt khi similarity giảm xuống dưới percentile 95 của khoảng cách
    breakpoint_threshold_amount=95,
    # Có thể đổi sang "standard_deviation" hoặc "interquartile"
)
semantic_chunks = semantic_splitter.split_text(text)

# Kiểm tra độ dài chunk không đồng đều — đó là hành vi mong đợi
lengths = [len(c) for c in semantic_chunks]
print(f"min={min(lengths)}, max={max(lengths)}, avg={sum(lengths)//len(lengths)}")

# Biến thể parent-child: index chunk nhỏ, trả về parent lớn
from langchain.retrievers import ParentDocumentRetriever
from langchain.storage import InMemoryStore
from langchain_community.vectorstores import Chroma

parent_splitter = RecursiveCharacterTextSplitter(chunk_size=1600)
child_splitter  = RecursiveCharacterTextSplitter(chunk_size=256)

retriever = ParentDocumentRetriever(
    vectorstore=Chroma(embedding_function=OpenAIEmbeddings()),
    docstore=InMemoryStore(),
    child_splitter=child_splitter,
    parent_splitter=parent_splitter,
)
retriever.add_documents(docs)
# Search dùng child chunk (precision cao), trả về parent chunk (context đủ)

Chi tiết: chọn chunk_size tối ưu bằng grid search

Không có chunk_size "tốt nhất" phổ quát — luôn phụ thuộc vào embedding model, domain, và query distribution. Cách thực tế là grid search trên một eval set nhỏ (50-200 query) đã biết đáp án đúng:

Grid search chunk_size

import pandas as pd
from ragas.metrics import context_recall, context_precision
from ragas import evaluate

chunk_sizes = [128, 256, 512, 1024]
overlaps    = [0, 32, 64, 128]
results = []

for cs in chunk_sizes:
    for ov in overlaps:
        if ov >= cs: continue
        index = build_index(docs, chunk_size=cs, overlap=ov)
        score = evaluate(
            index, eval_queries,
            metrics=[context_recall, context_precision],
        )
        results.append({
            "chunk_size": cs, "overlap": ov,
            "recall": score["context_recall"],
            "precision": score["context_precision"],
        })

df = pd.DataFrame(results).sort_values("recall", ascending=False)
print(df.head())

Mẹo: với tiếng Việt, thường chunk_size 400-700 ký tự (~200-350 token) kèm overlap 10-15% là khởi điểm tốt. Với tài liệu có heading Markdown, thử dùng MarkdownHeaderTextSplitter trước rồi mới RecursiveCharacterTextSplitter.

Chi tiết: công thức ước lượng số token tiếng Việt

Với tokenizer của GPT-4 (cl100k_base), trung bình 1 ký tự tiếng Anh ≈ 0.25 token, còn tiếng Việt ≈ 0.6-0.9 token/ký tự do các dấu và cách tách từ khác biệt. Công thức ước lượng thực tế:

tokens≈0.75⋅len(text in Vietnamese)\text{tokens} \approx 0.75 \cdot \text{len}(\text{text in Vietnamese})

Ví dụ: một chunk 800 ký tự tiếng Việt ≈ 600 token → phù hợp với embedding model giới hạn 512 token nếu bạn giảm xuống 650 ký tự, hoặc chuyển sang bge-m3 (8192 token). Với embedding model đa ngôn ngữ (multilingual-e5, bge-m3), chênh lệch token/ký tự nhỏ hơn rõ rệt so với OpenAI tokenizer.

Ứng dụng thực tế

  • Trợ lý pháp lý: chunking Bộ luật theo điều/khoản rồi embed, cho phép luật sư hỏi nhanh "quy định hiện hành về thử việc?" và hệ thống trả về đúng điều khoản kèm số hiệu.
  • Wiki nội bộ: chia Wiki công ty thành chunk, nhân viên mới tra cứu chính sách ngay trên Slack bot mà không cần lục từng trang Confluence.
  • Y tế: chunking hồ sơ bệnh án + guidelines để hỗ trợ bác sĩ rà soát nhanh (luôn đi kèm audit trail và trích dẫn nguồn để tránh rủi ro pháp lý).
  • Nghiên cứu học thuật: chunking paper PDF, cho phép Semantic Scholar trả lời câu hỏi cụ thể thay vì chỉ list paper — chunk theo section (Abstract, Methods, Results).
  • Ngân hàng: chunking hợp đồng tín dụng + T&C; khi khách hỏi điều khoản, chatbot trích đúng đoạn và số điều, kèm confidence score.
  • E-commerce: chunking mô tả sản phẩm + review để xây dựng semantic search cho website — khách tìm "áo khoác chống nước đi phượt" sẽ trúng đúng sản phẩm.
  • Giáo dục: chunking giáo trình, bài giảng để xây tutor AI — học sinh hỏi "định lý Pythagoras áp dụng thế nào?", bot trích đúng ví dụ trong sách giáo khoa.

Các pitfall hay gặp

  • Đặt chunk_size bằng đơn vị ký tự nhưng embedding model tính theo token → chunk thực có thể vượt max_seq_length mà không hay.
  • Quên metadata (nguồn, section, page) → không trích được nguồn khi trả lời, giảm tin cậy.
  • Overlap quá lớn (> 40%) làm vector database phình to và chunk trùng lặp khi retrieve.
  • Chunking 1 lần rồi giữ nguyên cả đời; thực tế cần re-chunk khi đổi embedding model hoặc thêm loại tài liệu mới.
  • Bỏ qua bảng, công thức, code block — các đoạn này cần chiến lược riêng (giữ nguyên khối, không cắt).

Ghi nhớ về Chunking

  • Chunking chia tài liệu dài thành đoạn nhỏ vừa giới hạn embedding model (thường 256-1024 token).
  • Ba chiến lược chính: Fixed-size (đơn giản), Recursive (mặc định LangChain, tôn trọng cấu trúc), Semantic (cắt theo chủ đề).
  • Overlap 10-20% chunk_size đảm bảo thông tin ở ranh giới không bị mất.
  • Parent-child chunking: index chunk nhỏ cho precision, retrieve parent lớn cho context — kết hợp cả hai ưu điểm.
  • Đo bằng số thật (recall, precision trên eval set) — không chọn chunk_size theo cảm tính.
  • Luôn lưu kèm metadata (nguồn, trang, section) để trả lời có trích nguồn và audit được.

Continue the module

Lesson 8 of 16