Чанкинг документов для RAG (Recursive, Semantic, Sentence-level)

Чанкинг документов для RAG (Recursive, Semantic, Sentence-level)

Чанкинг — разбивка документов на фрагменты для индексации в векторную БД. Размер и границы чанков критически влияют на качество RAG: слишком маленькие фрагменты теряют контекст, слишком большие — снижают точность поиска и превышают context window модели.

Стратегии чанкинга

Fixed-size chunking — самый простой, самый плохой:

def fixed_size_chunk(text: str, chunk_size: int = 500,
                     overlap: int = 50) -> list[str]:
    tokens = text.split()  # Упрощённо
    chunks = []
    for i in range(0, len(tokens), chunk_size - overlap):
        chunk = ' '.join(tokens[i:i + chunk_size])
        chunks.append(chunk)
    return chunks

Проблема: разрезает предложения и абзацы посередине.

Recursive character text splitter (LangChain) — разбивает по иерархии разделителей:

from langchain.text_splitter import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,      # ~250 слов
    chunk_overlap=200,     # 50-слово перекрытие
    separators=[
        "\n\n",  # Параграфы (приоритет)
        "\n",    # Строки
        ". ",    # Предложения
        ", ",    # Части предложений
        " ",     # Слова (последний resort)
        ""       # Символы
    ]
)

chunks = splitter.create_documents(
    texts=[document_text],
    metadatas=[{"source": "document.pdf", "page": 1}]
)

Semantic chunking — разбивка по смысловым границам:

from sentence_transformers import SentenceTransformer
import numpy as np

class SemanticChunker:
    def __init__(self, model_name: str = 'all-MiniLM-L6-v2',
                 threshold: float = 0.7):
        self.model = SentenceTransformer(model_name)
        self.threshold = threshold

    def chunk(self, text: str) -> list[str]:
        # Разбивка на предложения
        sentences = self._split_into_sentences(text)
        if len(sentences) < 2:
            return [text]

        # Эмбеддинги предложений
        embeddings = self.model.encode(sentences)

        # Поиск семантических разрывов
        chunks = []
        current_chunk = [sentences[0]]

        for i in range(1, len(sentences)):
            # Косинусное сходство соседних предложений
            sim = np.dot(embeddings[i], embeddings[i-1]) / (
                np.linalg.norm(embeddings[i]) * np.linalg.norm(embeddings[i-1])
            )

            if sim < self.threshold:
                # Семантический разрыв — создаём новый чанк
                chunks.append(' '.join(current_chunk))
                current_chunk = []

            current_chunk.append(sentences[i])

        if current_chunk:
            chunks.append(' '.join(current_chunk))

        # Объединение слишком маленьких чанков
        return self._merge_small_chunks(chunks, min_words=50)

Document structure-aware chunking — сохранение иерархии документа:

class StructureAwareChunker:
    def chunk_markdown(self, text: str, max_chunk_tokens: int = 300) -> list[dict]:
        """Разбивка с учётом заголовков Markdown"""
        sections = re.split(r'\n(#{1,3}\s+.+)', text)
        chunks = []
        current_section_header = "Introduction"

        for part in sections:
            if re.match(r'#{1,3}\s+', part):
                current_section_header = part.strip()
            else:
                # Разбиваем раздел на под-чанки если он большой
                sub_chunks = self._split_section(part, max_chunk_tokens)
                for sub_chunk in sub_chunks:
                    if sub_chunk.strip():
                        chunks.append({
                            'text': sub_chunk,
                            'section': current_section_header,
                            # Хлебные крошки для атрибуции
                            'breadcrumb': current_section_header
                        })

        return chunks

Оптимальные параметры чанкинга по типу контента

Chunk metadata и parent-child индексация

Small-to-big retrieval — индексируем маленькие чанки для точного поиска, но в контекст передаём большие родительские чанки:

class ParentChildIndexer:
    def index(self, document: str) -> list[dict]:
        # Родительские чанки (большие, для контекста)
        parent_splitter = RecursiveCharacterTextSplitter(
            chunk_size=2000, chunk_overlap=200
        )
        parents = parent_splitter.split_text(document)

        all_chunks = []
        for p_idx, parent in enumerate(parents):
            # Дочерние чанки (маленькие, для поиска)
            child_splitter = RecursiveCharacterTextSplitter(
                chunk_size=300, chunk_overlap=50
            )
            children = child_splitter.split_text(parent)

            for child in children:
                all_chunks.append({
                    'child_text': child,       # Для эмбеддинга и поиска
                    'parent_text': parent,     # Для передачи в LLM
                    'parent_idx': p_idx
                })

        return all_chunks

Правильный выбор стратегии чанкинга улучшает relevance retrieval на 15-30% по сравнению с наивным fixed-size подходом.