Bắt đầu nhanh: RAPTOR RAG trong 5 phút
RAG thông thường hoạt động rất tệ với tài liệu dài. Bạn chia một file PDF 200 trang thành các đoạn, nhét vào vector store, và khi người dùng đặt câu hỏi mang tính tổng quan, bộ truy xuất kéo về ba đoạn văn ngẫu nhiên từ trang 47. Không có ngữ cảnh. Không có cấu trúc. Chỉ toàn nhiễu.
RAPTOR (Recursive Abstractive Processing for Tree-Organized Retrieval) khắc phục điều này bằng cách xây dựng một cây gồm các bản tóm tắt ngày càng trừu tượng hơn. Bộ truy xuất có thể lấy cả chi tiết cụ thể lẫn ngữ cảnh tổng quan — tùy theo những gì câu hỏi thực sự cần.
Tài liệu kỹ thuật, hợp đồng pháp lý, bài báo nghiên cứu — đây là những loại tài liệu mà truy xuất phẳng sẽ thất bại trong môi trường production. Nếu bạn đã từng vật lộn với một bản đặc tả 200 trang và tự hỏi tại sao câu trả lời lại tệ đến vậy, đây chính là kỹ thuật bạn đang thiếu.
Cài đặt các dependencies trước:
pip install anthropic sentence-transformers scikit-learn numpy tiktoken umap-learn
Sau đó chạy kiểm tra nhanh để xác nhận mọi thứ hoạt động:
import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.mixture import GaussianMixture
model = SentenceTransformer('all-MiniLM-L6-v2')
test_emb = model.encode(["RAPTOR test"])
print(f"Embedding shape: {test_emb.shape}") # Phải là (1, 384)
Nếu chạy không có lỗi, bạn đã sẵn sàng xây dựng cây.
Tìm hiểu sâu: Cách RAPTOR thực sự hoạt động
Vấn đề với việc chia đoạn phẳng
Khi đọc một tài liệu kiến trúc 100 trang, bạn tự nhiên xây dựng mô hình tư duy ở nhiều cấp độ — chủ đề của từng chương, lập luận của từng phần, chi tiết của từng đoạn. RAG thông thường chỉ lưu trữ các đoạn ở cấp đoạn văn, nên bỏ sót hoàn toàn sự hiểu biết ở cấp chương. Hỏi “chiến lược database tổng thể là gì?”, bạn nhận về một đoạn về connection pooling từ trang 63.
RAPTOR phản chiếu cách bạn thực sự đọc. Nó tạo ra một cây trong đó các nút lá là các đoạn gốc, và mỗi nút cha là bản tóm tắt của các nút con. Khi truy vấn, bạn tìm kiếm trên toàn bộ cây — không chỉ các nút lá.
Vòng lặp xây dựng ba bước
Thuật toán chạy trong một vòng lặp cho đến khi cây thu gọn về một nút gốc duy nhất:
- Nhúng (Embed) — mã hóa tất cả các đoạn ở cấp hiện tại thành vector
- Phân cụm (Cluster) — nhóm các đoạn tương đồng bằng Gaussian Mixture Models
- Tóm tắt (Summarize) — tạo một bản tóm tắt cho mỗi cụm bằng LLM
Các bản tóm tắt đó trở thành các “đoạn” mới cho vòng lặp tiếp theo. Tiếp tục lặp cho đến khi còn một nút duy nhất.
import anthropic
from dataclasses import dataclass, field
from typing import List, Optional
@dataclass
class TreeNode:
text: str
level: int
embedding: Optional[np.ndarray] = None
children: List['TreeNode'] = field(default_factory=list)
node_id: str = ""
client = anthropic.Anthropic() # đọc ANTHROPIC_API_KEY từ biến môi trường
def summarize_cluster(texts: List[str]) -> str:
combined = "\n\n---\n\n".join(texts)
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=512,
system="Bạn là chuyên gia tóm tắt kỹ thuật. Hãy tạo bản tóm tắt súc tích, giàu thông tin, nắm bắt các điểm chính từ tất cả các đoạn văn bản được cung cấp.",
messages=[{
"role": "user",
"content": f"Hãy tóm tắt các đoạn văn bản liên quan này thành một đoạn văn mạch lạc:\n\n{combined}"
}]
)
return response.content[0].text
Phân cụm bằng Gaussian Mixture Models
Khác với K-Means, GMM cho phép gán cụm mềm — một đoạn có thể thuộc một phần về nhiều cụm, điều này quan trọng khi một đoạn văn nằm giữa hai chủ đề. K-Means ép gán cứng và đánh mất sự tinh tế đó.
def cluster_embeddings(embeddings: np.ndarray, max_clusters: int = 10) -> np.ndarray:
n_samples = len(embeddings)
n_clusters = min(max(2, n_samples // 3), max_clusters)
if n_samples <= 2:
return np.zeros(n_samples, dtype=int)
# Giảm chiều trước khi phân cụm — GMM hoạt động kém trong không gian nhiều chiều
from sklearn.decomposition import PCA
n_components = min(10, n_samples - 1, embeddings.shape[1])
reduced = PCA(n_components=n_components).fit_transform(embeddings)
gmm = GaussianMixture(n_components=n_clusters, random_state=42)
gmm.fit(reduced)
return gmm.predict(reduced)
Nâng cao: Xây dựng cây RAPTOR hoàn chỉnh
Đây là một implementation hoàn chỉnh nhận văn bản thô, xây dựng cây và cung cấp hàm truy xuất:
import uuid
from collections import defaultdict
class RAPTORIndex:
def __init__(self, embed_model='all-MiniLM-L6-v2'):
self.embedder = SentenceTransformer(embed_model)
self.all_nodes: List[TreeNode] = []
def _chunk_text(self, text: str, chunk_size: int = 400) -> List[str]:
words = text.split()
chunks = []
for i in range(0, len(words), chunk_size):
chunk = " ".join(words[i:i + chunk_size])
if chunk.strip():
chunks.append(chunk)
return chunks
def build(self, document: str, max_levels: int = 3) -> None:
# Cấp 0: các đoạn lá từ tài liệu gốc
chunks = self._chunk_text(document)
current_nodes = []
for i, chunk in enumerate(chunks):
emb = self.embedder.encode([chunk])[0]
node = TreeNode(
text=chunk,
level=0,
embedding=emb,
node_id=str(uuid.uuid4())
)
current_nodes.append(node)
self.all_nodes.extend(current_nodes)
# Xây dựng lặp lên các cấp cao hơn
for level in range(1, max_levels + 1):
if len(current_nodes) < 2:
break
embeddings = np.array([n.embedding for n in current_nodes])
cluster_labels = cluster_embeddings(embeddings)
# Nhóm các node theo cụm
clusters = defaultdict(list)
for node, label in zip(current_nodes, cluster_labels):
clusters[label].append(node)
next_nodes = []
for label, cluster_nodes in clusters.items():
# Tóm tắt cụm này
cluster_texts = [n.text for n in cluster_nodes]
summary = summarize_cluster(cluster_texts)
summary_emb = self.embedder.encode([summary])[0]
parent_node = TreeNode(
text=summary,
level=level,
embedding=summary_emb,
children=cluster_nodes,
node_id=str(uuid.uuid4())
)
next_nodes.append(parent_node)
self.all_nodes.append(parent_node)
print(f"Cấp {level}: {len(current_nodes)} đoạn → {len(next_nodes)} bản tóm tắt")
current_nodes = next_nodes
def retrieve(self, query: str, top_k: int = 5) -> List[TreeNode]:
query_emb = self.embedder.encode([query])[0]
# Tính điểm tất cả các node trên toàn bộ cấp cây
scores = []
for node in self.all_nodes:
if node.embedding is not None:
similarity = np.dot(query_emb, node.embedding) / (
np.linalg.norm(query_emb) * np.linalg.norm(node.embedding) + 1e-9
)
scores.append((similarity, node))
scores.sort(key=lambda x: x[0], reverse=True)
return [node for _, node in scores[:top_k]]
def answer(self, query: str, top_k: int = 5) -> str:
relevant_nodes = self.retrieve(query, top_k=top_k)
context = "\n\n".join([
f"[Cấp {n.level}] {n.text}" for n in relevant_nodes
])
response = client.messages.create(
model="claude-sonnet-4-6",
max_tokens=1024,
system="Trả lời câu hỏi dựa hoàn toàn vào ngữ cảnh được cung cấp. Hãy chỉ rõ câu trả lời lấy từ cấp nào (chi tiết lá hay bản tóm tắt).",
messages=[{
"role": "user",
"content": f"Ngữ cảnh:\n{context}\n\nCâu hỏi: {query}"
}]
)
return response.content[0].text
Kiểm tra với một tài liệu thực:
with open("your_document.txt", "r") as f:
doc_text = f.read()
index = RAPTORIndex()
index.build(doc_text, max_levels=3)
print(f"Tổng số node trong cây: {len(index.all_nodes)}")
print(f" Node lá: {sum(1 for n in index.all_nodes if n.level == 0)}")
print(f" Node tóm tắt: {sum(1 for n in index.all_nodes if n.level > 0)}")
answer = index.answer("Phương pháp tiếp cận kiến trúc tổng thể là gì?")
print(answer)
Mẹo thực tiễn cho môi trường Production
Điều chỉnh kích thước đoạn theo loại tài liệu
Các đoạn 400 từ hoạt động tốt với tài liệu kỹ thuật. Với hợp đồng pháp lý có nhiều điều khoản tham chiếu chéo dày đặc, hãy giảm xuống 150-200 từ để mỗi đoạn vẫn mang tính nguyên tử về mặt ngữ nghĩa. Với văn bản tự sự (báo cáo, whitepaper), 600-800 từ cho phép bộ tóm tắt có nhiều hơn để làm việc trên mỗi cụm.
Cache cây lại — đừng xây dựng lại mỗi request
Việc xây dựng cây RAPTOR gọi LLM API cho mỗi bản tóm tắt cụm ở mỗi cấp. Với tài liệu 200 trang, đó là 50-100 lần gọi API. Hãy xây dựng một lần, serialize cây bằng pickle hoặc ghi text+embeddings của node vào SQLite, và tải lại khi khởi động.
import pickle
# Lưu
with open("raptor_index.pkl", "wb") as f:
pickle.dump(index.all_nodes, f)
# Tải
with open("raptor_index.pkl", "rb") as f:
index.all_nodes = pickle.load(f)
Kết hợp trọng số theo cấp khi truy xuất
Khi truy xuất, hãy ưu tiên nhẹ hơn cho các bản tóm tắt cấp cao với câu hỏi rộng, và ưu tiên các nút lá khi tìm kiếm sự kiện cụ thể. Một heuristic đơn giản: nếu truy vấn dưới 8 từ, tăng điểm nút lá lên 1.1×. Nếu trên 15 từ, tăng điểm nút tóm tắt.
Kiểm soát ngân sách token
Vòng lặp tóm tắt tích lũy nhanh. Đặt giới hạn cứng max_tokens cho mỗi lần gọi tóm tắt — 512 thường là đủ. Dùng model rẻ hơn cho các cấp trung gian. Dành model tốt nhất cho bản tóm tắt gốc và bước QA cuối cùng. Cách này cắt giảm chi phí 60-70% với tài liệu lớn.
Kiểm tra chất lượng cây trước khi triển khai
Sau khi xây dựng, hãy kiểm tra thủ công một vài cặp cha-con. Bản tóm tắt cha phải thực sự nắm bắt được các điểm chính từ tất cả các nút con — nếu nó chỉ đọc như bản sao của một nút con duy nhất, các cụm của bạn đang quá mất cân bằng. Hãy tăng max_clusters hoặc thêm kiểm tra kích thước cụm tối thiểu.

