Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Chunking: Inteligentní rozdělování dokumentů

Lekce 12 z 22 Aktualizováno 29. července 2026 Vývojář
Na této stránce
  1. Cíle
  2. Proč dokumenty rozdělovat?
  3. Strategie 1: Rozdělování na pevnou velikost
  4. Strategie 2: Rozdělování podle oddělovačů
  5. Strategie 3: Rozdělování podle sekcí Markdown
  6. Strategie 4: Sémantické chunkování
  7. Obohacení chunků o kontext
  8. Jakou velikost chunku zvolit?
  9. Klíčové poznatky

Cíle

  • Pochopit, proč je chunking klíčový pro kvalitu RAG
  • Zvládnout různé strategie rozdělování textu
  • Vybrat správnou velikost chunku a překryv

Proč dokumenty rozdělovat?

Modely pro vytváření embeddingů mají limit na počet tokenů: pro OpenAI je to 8 191. Tento limit je prvním důvodem k rozdělování dokumentů, ale není tím nejdůležitějším. I dokument, který je hluboko pod tímto stropem, přináší špatné výsledky, pokud je zakódován jako jeden blok, protože výsledný vektor průměruje celý obsah a ztrácí detaily. Vezmi si 40stránkovou příručku HR pokrývající dovolené, práci na dálku, cestovní náhrady a zdravotní pojištění: její jediný embedding skutečně neodpovídá žádnému z těchto čtyř témat a vyhledávání dotazu „kolik dní dovolené“ ji zařadí níže než mnohem kratší, ale cílenější dokument.

Chunking tento problém řeší rozbitím dokumentu na soudržné části, z nichž každá zachycuje konkrétní myšlenku nebo odstavec. Právě v tomto kroku získává nebo ztrácí pipeline RAG nejvíce na kvalitě – ještě předtím, než zvolíš model pro embeddingy.

Strategie 1: Rozdělování na pevnou velikost

Nejjednodušší metoda počítá slova a řeže v pravidelných intervalech. Úplně ignoruje strukturu textu, což je brutální, ale stačí k tomu tři řádky kódu a slouží jako zásadní baseline: jakákoli sofistikovanější strategie musí prokázat, že funguje lépe než tato.

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 si zaslouží pozornost. Bez překryvu se řez dříve či později trefí doprostřed vysvětlení: věta „výpovědní lhůta jsou tři měsíce“ skončí v jednom chunku a „kromě zkušební doby“ v dalším. Ani jeden neodpoví na otázku správně a ten druhý je dokonce zavádějící. Překryvem chunků o 10–20 % jejich velikosti zajistíš, že každá myšlenka existuje alespoň jednou intactně někde v indexu. To je dobrý výchozí bod; později ho upravíš podle hustoty tvých dokumentů.

Strategie 2: Rozdělování podle oddělovačů

Místo řezání slovo po slově můžeš respektovat přirozené hranice textu. Myšlenka spočívá v tom, že nejprve zkusíš nejsilnější oddělovač – dvojitý konec řádku oddělující dva odstavce – a poté sestupuješ k progressively slabším oddělovačům, dokud výsledný kus překračuje maximální velikost. Blogový příspěvek se tak rozdělí odstavec po odstavci a pouze monstrózní odstavec bude rozdělen na věty.

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

Strategie 3: Rozdělování podle sekcí Markdown

Pokud se tvůj korpus skládá ze strukturované dokumentace, nadpisy už udělaly práci za tebe: autor již vymezil jednotky významu. Rozdělení na úrovních nadpisů # a ## vytvoří chunky, které přesně odpovídají sekcím, a funkce níže ponechává nadpis spolu s textem, což hned vzápětí využijeme pro obohacení.

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

Strategie 4: Sémantické chunkování

U textu bez explicitní struktury – shrnutí schůzky, přepis hovoru – neví ani velikost, ani oddělovače, kde se mění téma. Vědí to embeddingy. Zakóduješ každou větu, porovnáš každou větu s předchozí a řežeš tam, kde klesne podobnost: přesně tam, kde mluvčí přešel z rozpočtu na nábor. Všimni si, že text-embedding-3-small zde stačí, protože nehledáš absolutní přesnost, ale relativní 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

Obohacení chunků o kontext

Izolovaný chunk často ztrácí informace, které ho činily srozumitelným. „Doba trvání jsou tři roky“ neznamená nic, pokud čtenář – nebo model pro embeddingy – neví, že je to z kapitoly o záruce výrobce. Prefixování každého chunku názvem dokumentu a názvem sekce obnoví tento kontext přímo ve vektoru a vyhledávání „délka záruky“ pak daný úsek najde.

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

Jakou velikost chunku zvolit?

Volba zahrnuje kompromis mezi přesností a kontextem: krátký chunk cílí jemně, ale je useknutý, zatímco dlouhý chunk chápe vše, ale řídký signál.

Velikost (tokeny)VýhodyNevýhody
100–200Velmi přesné, dobrá granularitaZtrácí kontext
300–500Dobrý kompromisStandard
500–1000Bohatý kontextMéně přesné, dražší
1000+Maximální kontextŘedí informace

Neexistuje žádná univerzální hodnota: ideální velikost závisí na tvých dokumentech a dotazech. Jediná spolehlivá metoda je indexovat stejný korpus se dvěma nebo třemi velikostmi a poté měřit pomocí metrik z lekce 10 na sadě reálných otázek. Znalostní báze podpory složená z krátkých odpovědí snese 200 tokenů; právní korpus bude vyžadovat 800.

Klíčové poznatky

  • Chunking je nejdopadovějším krokem v pipeline RAG
  • Použij pevnou velikost jako baseline, oddělovače pro respektování struktury
  • Sémantické chunkování automaticky detekuje změny témat
  • Překryv a kontextuální obohacení zlepšují kvalitu
  • Testuj různé velikosti a měř pomocí metrik vyhledávání