Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Chunking: Inteligentné rozdelenie dokumentov

Lekcia 12 z 22 Aktualizované 29. júla 2026 Vývojár
Na tejto strane
  1. Ciele
  2. Prečo rozdeľovať dokumenty?
  3. Stratégia 1: Chunking s pevnou veľkosťou
  4. Stratégia 2: Chunking podľa oddeľovačov
  5. Stratégia 3: Chunking podľa sekcií Markdown
  6. Stratégia 4: Sémantický chunking
  7. Obohatenie chunkov o kontext
  8. Akú veľkosť chunku zvoliť?
  9. Kľúčové poznatky

Ciele

  • Pochopiť, prečo je chunking kľúčový pre kvalitu RAG
  • Ovládať rôzne stratégie rozdelenia textu
  • Zvoliť správnu veľkosť chunku a prekrytie

Prečo rozdeľovať dokumenty?

Modely na vytváranie vektorových reprezentácií (embedding models) majú limit počtu tokenov: pre OpenAI je to 8 191. Tento limit je prvým dôvodom na rozdelenie dokumentov, no nie tým najdôležitejším. Aj dokument, ktorý je výrazne pod týmto stropom, prináša slabé výsledky, ak je zakódovaný ako jeden celok, pretože výsledný vektor spriemeruje celý obsah a stratí detaily. Predstav si 40-stranovú príručku pre ľudské zdroje, ktorá pokrýva dovolenky, prácu na diaľku, vyúčtovanie výdavkov a zdravotné poistenie: jej jediné vektorové zakódovanie skutočne nezodpovedá žiadnej z týchto štyroch tém a vyhľadávanie „koľko dní dovolenky“ ju zaradí až za oveľa kratší, no oveľa cielenější dokument.

Chunking tento problém rieši rozbitím dokumentu na súvislé časti, z ktorých každá zachytáva konkrétnu myšlienku alebo odsek. Práve v tomto kroku pipeline RAG najviac získa alebo stratí na kvalite – ešte predtým, než si vyberieš model na vytváranie vektorov.

Stratégia 1: Chunking s pevnou veľkosťou

Najjednoduchšia metóda počíta slová a režie v pravidelných intervaloch. Úplne ignoruje štruktúru textu, čo je brutálne, no stačia na to tri riadky kódu a slúži ako nevyhnutný základ: každá sofistikovanejšia stratégia musí dokázať, že funguje lepšie než táto.

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")

Parameter overlap si zaslúži pozornosť. Bez prekrytia sa rez nakoniec ocitne uprostred vysvetlenia: veta „výpovedná lehota sú tri mesiace“ skončí v jednom chunku a „okrem skúšobnej doby“ v ďalšom. Ani jeden neodpovie na otázku správne a druhý je dokonca zavádzajúci. Prekrytím chunkov o 10 – 20 % ich veľkosti zabezpečíš, že každá myšlienka existuje neporušená aspoň raz niekde v indexe. Je to dobrý východiskový bod; neskôr ho upravíš podľa hustoty tvojich dokumentov.

Stratégia 2: Chunking podľa oddeľovačov

Namiesto rezania slovo po slove môžeš rešpektovať prirodzené hranice textu. Myšlienkou je najprv vyskúšať najsilnejší oddeľovač – dvojitý riadok, ktorý oddeľuje dva odseky – a potom zostupovať k progressively slabším oddeľovačom, kým výsledný kus presahuje maximálnu veľkosť. Blogový príspevok sa tak rozdelí odsek po odseku a iba obludný odsek sa roztriešti na vety.

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

Stratégia 3: Chunking podľa sekcií Markdown

Keď tvoje korpus tvoria štruktúrované dokumentácie, nadpisy už urobili prácu za teba: autor už vymedzil jednotky významu. Rozdelenie na úrovniach nadpisov # a ## vytvorí chunky, ktoré presne zodpovedajú sekciám, a funkcia nižšie ponecháva nadpis spolu s textom, čo hneď využijeme na obohatenie.

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

Stratégia 4: Sémantický chunking

Pri texte bez explicitnej štruktúry – zhrnutie schôdzky, prepis hovoru – ani veľkosť, ani oddeľovače nevedia, kde sa mení téma. Vedia to vektory. Zakóduješ každú vetu, porovnáš každú vetu s predchádzajúcou a odrežeš tam, kde klesne podobnosť: presne tam hovorca prešiel z rozpočtu na nábor. Všimni si, že text-embedding-3-small tu stačí, keďže nehľadáš absolútnu presnosť, ale relatívny zlom.

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

Obohatenie chunkov o kontext

Izolovaný chunk často stráca informáciu, ktorá ho robila zrozumiteľným. „Trvanie sú tri roky“ neznamená nič, ak čitateľ – alebo model na vytváranie vektorov – nevie, že je to z kapitoly o záruke výrobcu. Pridaním názvu dokumentu a názvu sekcie pred každý chunk obnovíš tento kontext priamo vo vektore a vyhľadávanie „dĺžka záruky“ potom nájde daný úsek.

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}"

Akú veľkosť chunku zvoliť?

Voľba zahŕňa kompromis medzi presnosťou a kontextom: krátky chunk cieli presne, no je ochudobnený, zatiaľ čo dlhý chunk chápe všetko, no zrieďuje signál.

Veľkosť (tokeny)VýhodyNevýhody
100–200Veľmi presné, dobrá granularitaStráca kontext
300–500Dobrý kompromisŠtandard
500–1000Bohatý kontextMenej presné, drahšie
1000+Maximálny kontextZrieďuje informácie

Neexistuje univerzálna hodnota: ideálna veľkosť závisí od tvojich dokumentov a dopytov. Jediná spoľahlivá metóda je indexovať rovnaký korpus s dvoma alebo tromi veľkosťami a potom merať pomocou metrík z lekcie 10 na sade reálnych otázok. Znalostná databáza podpory zložená z krátkych odpovedí znáša 200 tokenov; právny korpus bude vyžadovať 800.

Kľúčové poznatky

  • Chunking je najvplyvnejším krokom v pipeline RAG
  • Použi pevnú veľkosť ako základ, oddeľovače na rešpektovanie štruktúry
  • Sémantický chunking automaticky detekuje zmeny tém
  • Prekrytie a kontextové obohatenie zlepšujú kvalitu
  • Testuj rôzne veľkosti a meraj pomocou metrík vyhľadávania