Przejdź do głównej treści
Polski— Wybierz język
Menu

Chunking: Inteligentny podział dokumentów

Lekcja 12 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Cele
  2. Dlaczego dzielić dokumenty?
  3. Strategia 1: Chunking o stałym rozmiarze
  4. Strategia 2: Chunking oparty na separatorach
  5. Strategia 3: Chunking sekcji Markdown
  6. Strategia 4: Chunking semantyczny
  7. Wzbogacanie chunków o kontekst
  8. Jaki rozmiar chunka wybrać?
  9. Kluczowe wnioski

Cele

  • Zrozumienie, dlaczego chunking jest kluczowy dla jakości RAG
  • Opanowanie różnych strategii podziału tekstu
  • Dobór odpowiedniego rozmiaru chunka i overlappu

Dlaczego dzielić dokumenty?

Modele embeddingowe mają limit tokenów: 8191 dla OpenAI. To pierwszy powód dzielenia dokumentów, ale nie najważniejszy. Nawet dokument znacznie krótszy od tego limitu da słabe wyniki, jeśli zostanie zakodowany jako jeden blok, ponieważ powstały wektor uśredni całą treść i straci szczegóły. Weźmy 40-stronicowy podręcznik HR obejmujący politykę urlopową, pracę zdalną, raporty wydatków i ubezpieczenie zdrowotne: jego pojedynczy embedding nie przypomina naprawdę żadnego z tych czterech tematów, a wyszukiwanie frazy „ile dni urlopu“ uplasuje go poniżej znacznie krótszego, ale znacznie bardziej ukierunkowanego dokumentu.

Chunking rozwiązuje ten problem, dzieląc dokument na spójne fragmenty, z których każdy chwytuje konkretną myśl lub akapit. To etap, na którym potok RAG zyskuje lub traci najwięcej na jakości – jeszcze zanim wybierzesz model embeddingowy.

Strategia 1: Chunking o stałym rozmiarze

Najprostsza metoda liczy słowa i tnie w regularnych odstępach. Całkowicie ignoruje strukturę tekstu, przez co jest brutalna, ale wymaga trzech linii kodu i służy jako niezbędna baza odniesienia: każda bardziej wyrafinowana strategia musi udowodnić, że działa lepiej niż ta.

def chunker_fixed_size(
    text: str,
    size: int = 500,
    overlap: int = 100
) -> list[str]:
    """Splits text into fixed-size chunks with overlap."""
    words = text.split()
    chunks = []

    for i in range(0, len(words), size - overlap):
        chunk = " ".join(words[i:i + size])
        if chunk.strip():
            chunks.append(chunk)

    return chunks

long_text = "A very long document... " * 500
chunks = chunker_fixed_size(long_text, size=300, overlap=50)
print(f"{len(chunks)} chunks generated")

Parametr overlap zasługuje na uwagę. Bez overlappu cięcie w końcu trafi w środek wyjaśnienia: zdanie „okres wypowiedzenia wynosi trzy miesiące“ znajdzie się w jednym chunku, a „z wyjątkiem okresu próbnego“ w następnym. Żadne z nich nie odpowie poprawnie na pytanie, a drugie jest wręcz mylące. Nakładając na siebie chunki w zakresie 10–20% ich rozmiaru, gwarantujesz, że każda myśl istnieje nienaruszona przynajmniej raz gdzieś w indeksie. To dobry punkt wyjścia; dostosuj go później w zależności od gęstości Twoich dokumentów.

Strategia 2: Chunking oparty na separatorach

Zamiast ciąć słowo po słowie, możesz uszanować naturalne granice tekstu. Idea polega na wypróbowaniu najpierw najsilniejszego separatora – podwójnego znaku nowej linii oddzielającego dwa akapity – a następnie przechodzeniu do coraz słabszych separatorów, dopóki powstały fragment przekracza maksymalny rozmiar. Wpis na blogu zostanie więc podzielony akapit po akapicie, a jedynie monstrualny akapit zostanie pofragmentowany na zdania.

import re

def chunker_separators(
    text: str,
    separators: list[str] = ["\n\n", "\n", ". ", " "],
    max_size: int = 1000
) -> list[str]:
    """Splits text while respecting natural separators."""
    chunks = []
    current_chunk = ""

    # Split by the strongest separator first
    segments = [text]
    for sep in separators:
        new_segments = []
        for segment in segments:
            parts = segment.split(sep)
            for part in parts:
                if len(part.split()) > max_size:
                    new_segments.append(part)
                else:
                    if (current_chunk and
                        len((current_chunk + sep + part).split()) > max_size):
                        chunks.append(current_chunk.strip())
                        current_chunk = part
                    else:
                        current_chunk = (
                            current_chunk + sep + part
                            if current_chunk else part
                        )
        segments = new_segments

    if current_chunk.strip():
        chunks.append(current_chunk.strip())

    return chunks

Strategia 3: Chunking sekcji Markdown

Gdy Twój korpus składa się ze strukturyzowanej dokumentacji, nagłówki wykonują już pracę za Ciebie: autor już wyznaczył jednostki znaczeniowe. Podział na poziomie nagłówków # i ## tworzy chunki odpowiadające dokładnie sekcjom, a poniższa funkcja zachowuje nagłówek wraz z tekstem, co wykorzystamy natychmiast potem do wzbogacenia.

def chunker_markdown(text: str, max_level: int = 2) -> list[dict]:
    """Splits a Markdown document by sections."""
    chunks = []
    current_section = {"title": "", "content": "", "level": 0}

    for line in text.split("\n"):
        # Detect headings
        match = re.match(r"^(#{1,6})\s+(.+)$", line)
        if match:
            level = len(match.group(1))
            title = match.group(2)

            if level <= max_level and current_section["content"].strip():
                chunks.append({
                    "title": current_section["title"],
                    "text": current_section["content"].strip(),
                    "level": current_section["level"]
                })

            if level <= max_level:
                current_section = {
                    "title": title,
                    "content": "",
                    "level": level
                }
            else:
                current_section["content"] += line + "\n"
        else:
            current_section["content"] += line + "\n"

    if current_section["content"].strip():
        chunks.append({
            "title": current_section["title"],
            "text": current_section["content"].strip(),
            "level": current_section["level"]
        })

    return chunks

Strategia 4: Chunking semantyczny

W przypadku tekstu bez wyraźnej struktury – podsumowania spotkania, transkrypcji rozmowy – ani rozmiar, ani separatory nie wiedzą, gdzie zmienia się temat. Wiedzą to embeddingi. Kodujesz każde zdanie, porównujesz każde zdanie z poprzednim i tniesz tam, gdzie podobieństwo gwałtownie spada: to dokładnie moment, w którym mówca przeszedł z budżetu na rekrutację. Pamiętaj, że text-embedding-3-small wystarczy tutaj, ponieważ nie szukasz absolutnej precyzji, lecz względnego punktu przerwania.

from openai import OpenAI
import numpy as np

client = OpenAI()

def chunker_semantic(
    text: str,
    similarity_threshold: float = 0.75,
    min_sentence_length: int = 20
) -> list[str]:
    """Groups sentences by semantic similarity."""
    # Split into sentences
    sentences = re.split(r"(?<=[.!?])\s+", text)
    sentences = [s for s in sentences if len(s) > min_sentence_length]

    if len(sentences) <= 1:
        return [text]

    # Embeddings for each sentence
    resp = client.embeddings.create(
        input=sentences,
        model="text-embedding-3-small"  # small is sufficient here
    )
    embs = np.array([d.embedding for d in sorted(resp.data, key=lambda x: x.index)])

    # Find break points
    chunks = []
    chunk_sentences = [sentences[0]]

    for i in range(1, len(sentences)):
        sim = float(np.dot(embs[i], embs[i - 1]))
        if sim < similarity_threshold:
            # Semantic break detected
            chunks.append(" ".join(chunk_sentences))
            chunk_sentences = [sentences[i]]
        else:
            chunk_sentences.append(sentences[i])

    if chunk_sentences:
        chunks.append(" ".join(chunk_sentences))

    return chunks

Wzbogacanie chunków o kontekst

Izolowany chunk często traci informacje, które czyniły go zrozumiałym. „Czas trwania wynosi trzy lata“ nie znaczy nic, jeśli czytelnik – lub model embeddingowy – nie wie, że pochodzi to z rozdziału o gwarancji producenta. Dodanie prefiksu z tytułem dokumentu i tytułem sekcji do każdego chunka przywraca ten kontekst bezpośrednio do samego wektora, a wyszukiwanie frazy „czas trwania gwarancji“ odnajdzie wtedy ten fragment.

def enrich_chunk(chunk: str, doc_title: str, section: str = "") -> str:
    """Adds context to the chunk for better embedding."""
    prefix = f"Document: {doc_title}"
    if section:
        prefix += f" | Section: {section}"
    return f"{prefix}\n\n{chunk}"

Jaki rozmiar chunka wybrać?

Wybór wiąże się z kompromisem między precyzją a kontekstem: krótki chunk celuje precyzyjnie, ale jest okrojony, podczas gdy długi chunk rozumie wszystko, ale rozcieńcza sygnał.

Rozmiar (tokeny)ZaletyWady
100–200Bardzo precyzyjne, dobra granulacjaUtrata kontekstu
300–500Dobry kompromisStandard
500–1000Bogaty kontekstMniejsza precyzja, droższe
1000+Maksymalny kontekstRozcieńczenie informacji

Nie ma uniwersalnej wartości: idealny rozmiar zależy od Twoich dokumentów i zapytań. Jedyną niezawodną metodą jest zaindeksowanie tego samego korpusu z dwoma lub trzema rozmiarami, a następnie zmierzenie wyników przy użyciu metryk z lekcji 10 na zestawie rzeczywistych pytań. Baza wiedzy wsparcia składająca się z krótkich odpowiedzi toleruje 200 tokenów; korpus prawny będzie wymagał 800.

Kluczowe wnioski

  • Chunking to najbardziej wpływowy etap w potoku RAG
  • Użyj stałego rozmiaru jako bazy, a separatorów do poszanowania struktury
  • Chunking semantyczny automatycznie wykrywa zmiany tematyczne
  • Overlapp i wzbogacenie kontekstem poprawiają jakość
  • Testuj różne rozmiary i mierz je metrykami wyszukiwania