Chunking: Inteligentní rozdělování dokumentů
Na této stránce
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ýhody | Nevýhody |
|---|---|---|
| 100–200 | Velmi přesné, dobrá granularita | Ztrácí kontext |
| 300–500 | Dobrý kompromis | Standard |
| 500–1000 | Bohatý kontext | Mé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í