Chunking: Pametno dijeljenje vaših dokumenata
Na ovoj stranici
Ciljevi
- Razumjeti zašto je chunking ključan za kvalitetu RAG-a
- Savladati različite strategije dijeljenja teksta
- Odabrati pravu veličinu chunka i preklapanje
Zašto dijeliti dokumente?
Modeli za ugradnju (embedding) imaju ograničenje broja tokena: 8191 za OpenAI. To je prvi razlog za dijeljenje dokumenata, ali nije ni najvažniji. Čak i dokument znatno ispod tog limita daje loše rezultate ako se kodira kao jedan blok jer rezultirajući vektor usrednjuje sav sadržaj i gubi detalje. Uzmi priručnik za ljudske resurse od 40 stranica koji pokriva politike dopusta, rad na daljinu, izvještaje o troškovima i zdravstveno osiguranje: njegova pojedinačna ugradnja ne nalikuje stvarno ni jednoj od te četiri teme, a pretraga za „koliko dana dopusta“ rangirat će ga ispod mnogo kraćeg, ali daleko ciljanijeg dokumenta.
Chunking rješava ovaj problem razbijanjem dokumenta na koherentne dijelove, od kojih svaki obuhvaća specifičnu ideju ili odlomak. Ovo je korak u kojem RAG pipeline dobiva ili gubi najviše na kvaliteti – čak i prije nego što odabereš model za ugradnju.
Strategija 1: Chunking fiksne veličine
Najjednostavnija metoda broji riječi i reže u pravilnim intervalima. Potpuno ignorira strukturu teksta, što je brutalno, ali zahtijeva samo tri reda koda i služi kao bitna osnova: svaka sofisticiranija strategija mora dokazati da radi bolje od ove.
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")
Parametar overlap zaslužuje pozornost. Bez preklapanja, rez će eventualno pasti usred objašnjenja: rečenica „otkazni rok je tri mjeseca“ završit će u jednom chunku, a „osim tijekom probnog rada“ u sljedećem. Niti jedna ne odgovara ispravno na pitanje, a druga je čak zavaravajuća. Preklapanjem chunkova za 10–20% njihove veličine jamčiš da svaka ideja postoji netaknuta barem jednom negdje u indeksu. To je dobra početna točka; kasnije je prilagodi na temelju gustoće svojih dokumenata.
Strategija 2: Chunking temeljen na separatorima
Umjesto rezanja riječ po riječ, možeš poštovati prirodne granice teksta. Ideja je prvo isprobati najjači separator – dvostruki prijelom retka koji odvaja dva odlomka – zatim silaziti na progresivno slabije separatore sve dok rezultirajući dio premašuje maksimalnu veličinu. Blog post će se tako dijeliti odlomak po odlomak, a samo će se monstruozni odlomak fragmentirati po rečenicama.
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
Strategija 3: Chunking Markdown sekcija
Kada se tvoj korpus sastoji od strukturirane dokumentacije, naslovi već obavljaju posao za tebe: autor je već omeđio jedinice značenja. Dijeljenjem na razinama naslova # i ## dobivaš chunkove koji točno odgovaraju sekcijama, a donja funkcija zadržava naslov uz tekst, što ćemo odmah nakon toga iskoristiti za obogaćivanje.
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
Strategija 4: Semantički chunking
Za tekst bez eksplicitne strukture – sažetak sastanka, transkript poziva – ni veličina ni separatori ne znaju gdje se tema mijenja. Ugradnje (embeddings) znaju. Kodiraš svaku rečenicu, usporediš svaku rečenicu s prethodnom i režeš tamo gdje sličnost naglo padne: točno je to mjesto gdje je govornik prešao s proračuna na zapošljavanje. Imaj na umu da je text-embedding-3-small ovdje dovoljan jer ne tražiš apsolutnu preciznost već relativni prijelom.
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
Obogaćivanje chunkova kontekstom
Izolirani chunk često gubi informaciju koja ga je činila interpretabilnim. „Trajanje je tri godine“ ne znači ništa ako čitatelj – ili model za ugradnju – ne zna da je to iz poglavlja o jamstvu proizvođača. Dodavanjem prefiksa s naslovom dokumenta i naslovom sekcije svakom chunku vraćaš taj kontekst izravno u sam vektor, pa će pretraga za „trajanje jamstva“ tada pronaći taj odlomak.
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}"
Koju veličinu chunka odabrati?
Izbor uključuje kompromis između preciznosti i konteksta: kratak chunk precizno cilja, ali je osakaćen, dok dugi chunk razumije sve, ali razrjeđuje signal.
| Veličina (tokeni) | Prednosti | Nedostaci |
|---|---|---|
| 100–200 | Vrlo precizno, dobra granulacija | Gubi kontekst |
| 300–500 | Dobar kompromis | Standard |
| 500–1000 | Bogat kontekst | Manje precizno, skupo |
| 1000+ | Maksimalni kontekst | Razrjeđuje informacije |
Ne postoji univerzalna vrijednost: idealna veličina ovisi o tvojim dokumentima i upitima. Jedina pouzdana metoda je indeksirati isti korpus s dvije ili tri veličine, a zatim mjeriti pomoću metrika iz lekcije 10 na skupu stvarnih pitanja. Baza znanja za podršku sastavljena od kratkih odgovora podnosi 200 tokena; pravni korpus zahtijevat će 800.
Ključne točke
- Chunking je najutjecajniji korak u RAG pipelineu
- Koristi fiksnu veličinu kao osnovu, separatore za poštovanje strukture
- Semantički chunking automatski detektira promjene tema
- Preklapanje i kontekstualno obogaćivanje poboljšavaju kvalitetu
- Testiraj različite veličine i mjeri pomoću metrika pretrage