Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Chunking: Pametno dijeljenje vaših dokumenata

Lekcija 12 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Ciljevi
  2. Zašto dijeliti dokumente?
  3. Strategija 1: Chunking fiksne veličine
  4. Strategija 2: Chunking temeljen na separatorima
  5. Strategija 3: Chunking Markdown sekcija
  6. Strategija 4: Semantički chunking
  7. Obogaćivanje chunkova kontekstom
  8. Koju veličinu chunka odabrati?
  9. Ključne točke

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)PrednostiNedostaci
100–200Vrlo precizno, dobra granulacijaGubi kontekst
300–500Dobar kompromisStandard
500–1000Bogat kontekstManje precizno, skupo
1000+Maksimalni kontekstRazrjeđ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