Salt la conținutul principal
Română— Alege o limbă
Meniu

Chunking: Divizarea inteligentă a documentelor

Lecția 12 din 22 Actualizată 29 iulie 2026 Dezvoltator
Pe această pagină
  1. Obiective
  2. De ce să divizați documentele?
  3. Strategia 1: Chunking cu dimensiune fixă
  4. Strategia 2: Chunking bazat pe separatori
  5. Strategia 3: Chunking pe secțiuni Markdown
  6. Strategia 4: Chunking semantic
  7. Îmbogățirea chunk-urilor cu context
  8. Ce dimensiune de chunk să alegeți?
  9. Puncte cheie

Obiective

  • Înțelegeți de ce chunking-ul este critic pentru calitatea RAG
  • Stăpâniți diferite strategii de divizare
  • Alegeți dimensiunea corectă a chunk-ului și suprapunerea optimă

De ce să divizați documentele?

Modelele de embedding au o limită de tokeni: 8.191 pentru OpenAI. Această limită este primul motiv pentru a diviza documentele, dar nu este cel mai important. Chiar și un document mult sub această plafonare produce rezultate slabe atunci când este codificat ca un singur bloc, deoarece vectorul rezultat face o medie a întregului conținut și pierde detaliile. Luați un manual de Resurse Umane de 40 de pagini care acoperă politicile de concediu, munca la distanță, rapoartele de cheltuieli și asigurările de sănătate: embedding-ul său unic nu seamănă cu adevărat cu niciunul dintre aceste patru subiecte, iar o căutare după „câte zile de concediu“ îl va clasifica sub un document mult mai scurt, dar mult mai țintit.

Chunking-ul rezolvă această problemă prin fragmentarea documentului în piese coerente, fiecare capturând o idee specifică sau un paragraf. Acesta este pasul în care un pipeline RAG câștigă sau pierde cea mai mare parte din calitate—chiar înainte de a alege un model de embedding.

Strategia 1: Chunking cu dimensiune fixă

Metoda cea mai simplă numără cuvintele și taie la intervale regulate. Ignoră complet structura textului, ceea ce o face brutală, dar necesită doar trei linii de cod și servește drept linie de bază esențială: orice strategie mai sofisticată trebuie să dovedească că performează mai bine decât aceasta.

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

Parametrul overlap merită atenție. Fără suprapunere, o tăietură va ajunge inevitabil la mijlocul unei explicații: propoziția „perioada de preaviz este de trei luni“ ajunge într-un chunk, iar „exceptând perioada de probă“ în următorul. Niciunul nu răspunde corect la întrebare, iar al doilea este chiar înșelător. Prin suprapunerea chunk-urilor cu 10–20% din dimensiunea lor, garantați că fiecare idee există intactă cel puțin o dată undeva în index. Acesta este un punct de plecare bun; ajustați-l ulterior în funcție de densitatea documentelor dumneavoastră.

Strategia 2: Chunking bazat pe separatori

În loc să tăiați cuvânt cu cuvânt, puteți respecta limitele naturale ale textului. Ideea este să încercați mai întâi separatorul cel mai puternic—dubla linie nouă care separă două paragrafe—apoi să coborâți la separatori progresiv mai slabi atâta timp cât piesa rezultată depășește dimensiunea maximă. Un articol de blog va fi astfel divizat paragraf cu paragraf, iar doar un paragraf monstruos va fi fragmentat pe propoziții.

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

Strategia 3: Chunking pe secțiuni Markdown

Când corpusul dumneavoastră constă în documentație structurată, titlurile fac deja munca pentru dumneavoastră: autorul a delimitat deja unitățile de sens. Divizarea la nivelurile de titlu # și ## produce chunk-uri care corespund exact secțiunilor, iar funcția de mai jos păstrează titlul alături de text, ceea ce vom folosi imediat după pentru îmbogățire.

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

Strategia 4: Chunking semantic

Pentru textul fără structură explicită—un rezumat de ședință, o transcriere de apel—nici dimensiunea, nici separatorii nu știu unde se schimbă subiectul. Embedding-urile știu. Codificați fiecare propoziție, comparați fiecare propoziție cu cea anterioară și tăiați acolo unde similaritatea se prăbușește: exact acolo vorbitorul a trecut de la buget la recrutare. Rețineți că text-embedding-3-small este suficient aici, deoarece nu căutați o precizie absolută, ci o ruptură relativă.

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

Îmbogățirea chunk-urilor cu context

Un chunk izolat pierde adesea informația care îl făcea interpretabil. „Durata este de trei ani“ nu înseamnă nimic dacă cititorul—sau modelul de embedding—nu știe că provine din capitolul despre garanția producătorului. Adăugarea unui prefix fiecărui chunk cu titlul documentului și titlul secțiunii restaurează acest context direct în vectorul însuși, iar o căutare după „durata garanției“ va găsi apoi pasajul.

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

Ce dimensiune de chunk să alegeți?

Alegerea implică un compromis între precizie și context: un chunk scurt țintește fin, dar este amputat, în timp ce un chunk lung înțelege totul, dar diluează semnalul.

Dimensiune (tokeni)AvantajeDezavantaje
100–200Foarte precis, granularitate bunăPierde contextul
300–500Compromis bunStandard
500–1000Context bogatMai puțin precis, costisitor
1000+Context maximDiluează informația

Nu există o valoare universală: dimensiunea ideală depinde de documentele și interogările dumneavoastră. Singura metodă fiabilă este să indexați același corpus cu două sau trei dimensiuni, apoi să măsurați folosind metricile din lecția 10 pe un set de întrebări reale. O bază de cunoștințe pentru suport formată din răspunsuri scurte tolerează 200 de tokeni; un corpus juridic va necesita 800.

Puncte cheie

  • Chunking-ul este cel mai impactant pas în pipeline-ul RAG
  • Folosiți dimensiunea fixă ca linie de bază, separatorii pentru a respecta structura
  • Chunking-ul semantic detectează automat schimbările de subiect
  • Suprapunerea și îmbogățirea contextuală îmbunătățesc calitatea
  • Testați diferite dimensiuni și măsurați cu metrici de căutare