Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Chunking: Dokumentumaid intelligens felosztása

12. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Célok
  2. Miért osszuk fel a dokumentumokat?
  3. 1. stratégia: Fix méretű chunking
  4. 2. stratégia: Elválasztójeleken alapuló chunking
  5. 3. stratégia: Markdown szakaszok szerinti chunking
  6. 4. stratégia: Szemantikai chunking
  7. Chunkok dúsítása kontextussal
  8. Mekkora chunk-méretet válassz?
  9. Főbb megállapítások

Célok

  • Értsd meg, miért kritikus a chunking a RAG minősége szempontjából
  • Sajátítsd el a különböző felosztási stratégiákat
  • Válaszd ki a megfelelő chunk-méretet és átfedést

Miért osszuk fel a dokumentumokat?

A beágyazási (embedding) modelleknek van tokenkorlátjuk: az OpenAI esetében ez 8191. Ez a korlát az első ok a dokumentumok felosztására, de nem a legfontosabb. Még egy olyan dokumentum is gyenge eredményt produkál, amely jól a határérték alatt van, ha egyetlen blokkként kódoljuk be, mert a kapott vektor az összes tartalmat átlagolja, és elveszíti a részleteket. Vegyünk egy 40 oldalas HR-kézikönyvet, amely a szabadságolási szabályzatot, a távmunkát, a költségtérítéseket és az egészségbiztosítást tárgyalja: egyetlen beágyazása nem hasonlít igazán e négy téma egyikére sem, és a „hány szabadságnap jár“ keresés során ez a dokumentum hátrébb sorolódik, mint egy sokkal rövidebb, de célzottabb anyag.

A chunking ezt a problémát úgy oldja meg, hogy a dokumentumot koherens darabokra töri, amelyek mindegyike egy konkrét gondolatot vagy bekezdést ragad meg. Ez az a lépés, ahol egy RAG-folyamat a legtöbb minőséget nyeri vagy veszíti el – még mielőtt kiválasztanád a beágyazási modellt.

1. stratégia: Fix méretű chunking

A legegyszerűbb módszer megszámolja a szavakat, és rendszeres időközönként vág. Teljesen figyelmen kívül hagyja a szöveg szerkezetét, így brutális megoldás, de mindössze három sor kódot igényel, és alapvető alapvonalnak (baseline) szolgál: minden kifinomultabb stratégiának be kell bizonyítania, hogy jobban teljesít ennél.

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

Az overlap paraméter külön figyelmet érdemel. Átfedés nélkül a vágás előbb-utóbb egy magyarázat közepébe esik: a „a felmondási idő három hónap“ mondat az egyik chunkba kerül, míg a „kivéve a próbaidő alatt“ a következőbe. Egyik sem válaszolja meg helyesen a kérdést, sőt, a második félrevezető lehet. A chunkok 10–20%-os átfedésével garantálod, hogy minden gondolat legalább egyszer sértetlenül szerepeljen az indexben. Ez jó kiindulópont; később a dokumentumaid sűrűsége alapján finomíthatsz rajta.

2. stratégia: Elválasztójeleken alapuló chunking

A szó szerinti vágás helyett tiszteletben tarthatod a szöveg természetes határait. Az ötlet az, hogy először a legerősebb elválasztót próbáld meg – a két bekezdést elválasztó dupla sortörést –, majd haladj lefelé a progressively gyengébb elválasztók felé mindaddig, amíg a kapott darab meghaladja a maximális méretet. Egy blogbejegyzést így bekezdésenként osztasz fel, és csak egy szörnyeteg méretű bekezdést törsz fel mondatokra.

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

3. stratégia: Markdown szakaszok szerinti chunking

Ha a korpuszod strukturált dokumentációból áll, a címsorok már elvégzik helyetted a munkát: a szerző már lehatárolta a jelentésegységeket. A # és ## szintű címsoroknál történő felosztás olyan chunkokat eredményez, amelyek pontosan megfelelnek a szakaszoknak, és az alábbi függvény a címsort is megtartja a szöveg mellett, amit rögtön ezután felhasználhatsz a dúsításhoz.

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

4. stratégia: Szemantikai chunking

Olyan szövegeknél, amelyeknek nincs explicit szerkezetük – például egy értekezlet összefoglalója vagy egy hívás átirata –, sem a méret, sem az elválasztójelek nem tudják, hol változik a téma. A beágyazások viszont igen. Kódold be minden mondatot, hasonlítsd össze az egyes mondatokat az előzővel, és ott vágj, ahol a hasonlóság összeomlik: pontosan ott váltott a beszélő a költségvetésről a toborzásra. Ne feledd, hogy itt a text-embedding-3-small is elegendő, mivel nem abszolút pontosságot keresel, hanem egy relatív töréspontot.

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

Chunkok dúsítása kontextussal

Egy elszigetelt chunk gyakran elveszíti azt az információt, amely értelmezhetővé tette. A „az időtartam három év“ semmit sem jelent, ha az olvasó – vagy a beágyazási modell – nem tudja, hogy ez a gyártói garancia fejezetből származik. Ha minden chunk elé odailleszted a dokumentum címét és a szakasz címét, ezzel közvetlenül a vektorba építed vissza ezt a kontextust, és a „garancia időtartama“ keresés ezután megtalálja a megfelelő részt.

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

Mekkora chunk-méretet válassz?

A választás a pontosság és a kontextus közötti kompromisszumot jelenti: egy rövid chunk finoman céloz, de csonka, míg egy hosszú chunk mindent ért, de hígítja a jelet.

Méret (token)ElőnyökHátrányok
100–200Nagyon pontos, jó szemcsézettségElveszíti a kontextust
300–500Jó kompromisszumSzabványos
500–1000Gazdag kontextusKevésbé pontos, drága
1000+Maximális kontextusHígítja az információt

Nincs univerzális érték: az ideális méret a dokumentumaidtól és a lekérdezéseidtől függ. Az egyetlen megbízható módszer, ha ugyanazt a korpuszt két vagy három különböző mérettel indexeled, majd a 10. leckében tárgyalt metrikák segítségével méred az eredményt valós kérdések halmazán. Egy rövid válaszokból álló támogatási tudásbázis elviseli a 200 tokent; egy jogi korpuszhoz 800 szükséges.

Főbb megállapítások

  • A chunking a legjelentősebb hatású lépés a RAG-folyamatban
  • Használd a fix méretet alapvonalnak, az elválasztójeleket a szerkezet tiszteletben tartására
  • A szemantikai chunking automatikusan érzékeli a témaváltásokat
  • Az átfedés és a kontextuális dúsítás javítja a minőséget
  • Tesztelj különböző méreteket, és mérd az eredményt keresési metrikákkal