BroadRouter

Chunk size e overlap nella RAG: effetti su retrieval e costi

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato · Aggiornato

Parti da chunk di circa 256-512 token, overlap dallo 0 al 15% e un top-k tarato sulle tue query. Chunk più grandi aumentano i token che ogni query invia all’LLM. L’overlap moltiplica i token da indicizzare e salvare per dimensione ÷ (dimensione − overlap), quindi un overlap del 50% raddoppia l’indice. I test pubblicati mostrano che chunk piccoli o senza overlap spesso hanno un recall pari o migliore.

Chunk size e overlap sono i due numeri che ogni pipeline RAG fissa all’inizio e raramente rivede. Decidono quanti vettori salvi, quanti token passi al modello di embedding, quanti token ogni domanda invia all’LLM e se il passaggio giusto viene trovato o no. Questo articolo mostra cosa hanno rilevato i test pubblicati, poi fa i conti sui token così puoi vedere il costo di ogni configurazione prima di calcolare un solo embedding.

Se stai ancora decidendo se usare la RAG, parti da contesto lungo o RAG. Per i documenti in arabo, leggi anche RAG in arabo e normalizzazione del testo arabo.

Cosa cambiano chunk size e overlap?

  • La chunk size è il numero di token che finiscono in ogni pezzo indicizzato e recuperato.
  • L’overlap è il numero di token condivisi da chunk consecutivi, così una frase tagliata su un confine compare intera in almeno un chunk.
  • Il top-k è il numero di chunk recuperati per domanda.

Insieme determinano quattro grandezze:

Grandezza Formula (documenti lunghi)
Chunk salvati token del corpus ÷ (dimensione − overlap)
Token indicizzati token del corpus × dimensione ÷ (dimensione − overlap)
Contesto per query top-k × dimensione
Input LLM per query top-k × dimensione + prompt di sistema + domanda

Le prime due si pagano una volta per ogni indicizzazione, e di nuovo ogni volta che rifai il chunking. L’ultima si paga a ogni domanda, per sempre.

Cosa dicono i test pubblicati sulla chunk size?

Vale la pena conoscere due valutazioni pubbliche, perché misurano cose diverse.

Chroma (Smith e Troynikov, luglio 2024) ha misurato il retrieval a livello di token: quanta parte del testo rilevante veniva recuperata (recall) e quanta parte del testo recuperato era rilevante. Ha usato cinque chunk recuperati e text-embedding-3-large di OpenAI. Alcune righe:

Splitter Dimensione (token) Overlap Recall IoU
Recursive 800 400 85,4% 1,5%
Token 800 400 87,9% 1,4%
Recursive 400 200 88,1% 3,3%
Recursive 400 0 89,5% 3,6%
Recursive 200 0 88,1% 6,9%

L’IoU (intersection over union) misura quanta parte del testo recuperato era rilevante, quindi indica anche i token sprecati. Le righe 800/400 corrispondono al default di OpenAI per il file search; ipotizzando uno splitter a token, Chroma ha rilevato che quella configurazione dava un recall leggermente sotto la media e i punteggi più bassi sulle altre metriche. Chunk più piccoli senza overlap recuperavano altrettanto o di più e trascinavano molto meno testo irrilevante.

NVIDIA (giugno 2025) ha misurato l’accuratezza end-to-end delle risposte su cinque dataset, con chunk da 128 a 2.048 token e overlap del 15%, più chunking a livello di pagina e di sezione. Il chunking per pagina ha avuto l’accuratezza media più alta (0,648) e la varianza più bassa. La dimensione migliore in token dipendeva dalle domande: i set fattuali favorivano 256-512 token, quelli analitici 1.024 token o pagine intere. Entrambi gli estremi, 128 e 2.048, di solito andavano peggio.

Le due valutazioni concordano su un punto: non esiste una dimensione migliore in assoluto, e chunk molto grandi con overlap elevato raramente sono il default giusto.

Quanto gonfia l’indice l’overlap?

Ogni chunk avanza di dimensione − overlap token, quindi l’indice contiene dimensione ÷ (dimensione − overlap) copie del corpus. Per un corpus da 2.000.000 di token fatto di documenti da 10.000 token:

Dimensione Overlap Chunk Token indicizzati Aumento
200 0 10.000 2.000.000 1,00×
400 0 5.000 2.000.000 1,00×
512 77 (15%) 4.600 2.338.800 1,17×
1.024 154 (15%) 2.400 2.338.800 1,17×
800 400 (50%) 4.800 3.840.000 1,92×
400 200 (50%) 9.800 3.920.000 1,96×

I documenti corti gonfiano un po’ meno, perché l’ultimo chunk di ciascuno è parziale. La formula dà il limite: un overlap del 15% costa circa il 18% in più, e uno del 50% circa il 100% in più, in token di embedding, spazio per i vettori e tempo di reindicizzazione.

L’overlap costa anche al momento della query. Con un overlap del 50%, due chunk vicini recuperati per la stessa domanda ripetono metà del testo. Paghi quei token duplicati, e spingono fuori dal top-k altri passaggi rilevanti.

BroadNet non vende embedding, quindi questa parte della fattura va al tuo provider di embedding. Stimala con il calcolatore del costo degli embedding.

Cosa fa la chunk size alla fattura dell’LLM?

Ogni domanda invia top-k chunk più il prompt. Prendi 100.000 domande al mese, 600 token tra prompt di sistema e domanda, e ogni volta la stessa risposta da 300 token:

Dimensione × top-k Contesto per query Input per query Input al mese
200 × 10 2.000 2.600 260 milioni
400 × 5 2.000 2.600 260 milioni
512 × 5 2.560 3.160 316 milioni
800 × 5 4.000 4.600 460 milioni
1.024 × 5 5.120 5.720 572 milioni
1.024 × 8 8.192 8.792 879 milioni

L’output è di 30 milioni di token al mese in ogni riga, quindi cambia solo l’input. Con un prezzo per 1M di token, il costo mensile dell’input è il numero di milioni nell’ultima colonna per quel prezzo. Su Gemma 4 VL 26B a $0.10 per 1M di token di input, la configurazione 1.024 × 8 costa in input 879 × $0.10 al mese contro 260 × $0.10 per 400 × 5. Sono 3,4 volte tanto, per una configurazione che nei test pubblicati non mostra un recall migliore. Su Qwen3.8 27B ($0.175 di input) o GLM 5.3 ($0.78 di input) il rapporto è lo stesso e i totali sono più alti.

Due leve contano più del prezzo del modello:

  1. Abbassa k quando aumenti la dimensione. 200 × 10 e 400 × 5 inviano lo stesso contesto. Tieni il contesto per query più o meno fisso mentre provi le dimensioni, così confronti la qualità del retrieval, non il budget di contesto.
  2. Metti in cache la parte fissa. Metti il prompt di sistema per primo e tienilo identico byte per byte, così può essere fatturato alla tariffa dell’input in cache sui modelli che ne hanno una. I chunk recuperati cambiano a ogni domanda e raramente finiscono in cache.

Contano anche i limiti di contesto. Gemma 4 VL 26B accetta 32.768 token per richiesta, più che sufficienti per ogni riga qui sopra. Se spingi k × dimensione verso decine di migliaia di token, sei passato dalla RAG verso il contesto lungo, e quel confronto ha i suoi conti. Il calcolatore di chunking RAG applica queste formule al tuo corpus, chunk size, overlap e top-k.

Come fare il chunking in token senza spezzare le parole?

Conta in token, ma taglia sulla struttura. Il RecursiveCharacterTextSplitter di LangChain misura la dimensione con la sua length_function, che per impostazione predefinita è la lunghezza in caratteri. Una “dimensione” di 512 diventa allora 512 caratteri, circa 100-150 token di inglese, e un numero ancora diverso per l’arabo; vedi token per parola in arabo. I limiti degli embedding e le fatture degli LLM sono in token.

Questo chunker riempie ogni chunk con paragrafi interi fino a un budget di token e riporta in avanti gli ultimi paragrafi come overlap. Tagliare ai confini dei paragrafi evita di spezzare parole o caratteri arabi multibyte, cosa che le finestre di token grezze possono fare.

import tiktoken

enc = tiktoken.get_encoding("o200k_base")    # an estimate: count with your embedder's tokenizer
count = lambda s: len(enc.encode(s))

def chunk(text, size=512, overlap=64):
    """Pack whole paragraphs up to `size` tokens; repeat trailing paragraphs up to `overlap` tokens."""
    chunks, cur, cur_len = [], [], 0
    for para in (p.strip() for p in text.split("\n\n")):
        if not para:
            continue
        n = count(para)
        if cur and cur_len + n > size:
            chunks.append("\n\n".join(cur))
            tail, t = [], 0
            for q in reversed(cur):                  # carry the end of this chunk forward
                if t + count(q) > overlap:
                    break
                tail.insert(0, q); t += count(q)
            cur, cur_len = tail, t
        cur.append(para); cur_len += n              # a paragraph over `size` stays whole
    if cur:
        chunks.append("\n\n".join(cur))
    return chunks

def plan(corpus_tokens, size, overlap, k, queries_per_month, prompt_tokens=600):
    index_tokens = corpus_tokens * size / (size - overlap)   # long-document limit
    per_query = k * size + prompt_tokens
    return {"chunks": round(index_tokens / size), "tokens_to_embed": round(index_tokens),
            "input_per_query": per_query, "input_per_month": per_query * queries_per_month}

print(plan(2_000_000, 512, 64, 5, 100_000))
# {'chunks': 4464, 'tokens_to_embed': 2285714, 'input_per_query': 3160, 'input_per_month': 316000000}

Qui l’overlap è “fino a”: un paragrafo più lungo del budget di overlap non viene ripetuto. Un singolo paragrafo più lungo di size resta intero; se i tuoi documenti hanno paragrafi così, dividili prima per frasi. Fai precedere ogni chunk dal titolo del documento e dall’intestazione della sezione, così un chunk recuperato dice ancora di cosa parla. Aggiunge pochi token per chunk e spesso aiuta più dell’overlap.

Come scegliere i numeri per i tuoi dati?

  1. Costruisci un set di valutazione. Da 50 a 200 domande reali, ognuna con il passaggio che la risponde. La guida alla valutazione degli LLM spiega come dare i punteggi.
  2. Fissa il budget di contesto. Tieni k × dimensione vicino a un valore, per esempio 2.000 token, mentre confronti le dimensioni.
  3. Prova tre dimensioni e due overlap. Per esempio 256, 512 e 1.024 token, ciascuna con overlap 0 e 15%. Misura il recall del passaggio giusto a k.
  4. Prova la struttura. Se i tuoi documenti hanno pagine o sezioni numerate, confronta chunk per pagina o per sezione con le dimensioni in token. NVIDIA ha trovato il chunking per pagina il più costante.
  5. Scegli la configurazione più economica entro un punto o due dal recall migliore, poi stimane il costo al tuo volume di query con il metodo del costo mensile.

Fallo su un campione prima di indicizzare l’intero corpus. Cambiare il chunking dopo significa ricalcolare tutti gli embedding.

Dove si inserisce BroadNet Inference

BroadNet Inference serve il passaggio di risposta della RAG, non il retrieval. Non vende embedding né spazio per i vettori, quindi abbinalo a un provider di embedding e a un database vettoriale a tua scelta. Per la risposta, Gemma 4 VL 26B è l’opzione a basso costo e funziona con il credito iniziale di $5. Qwen3.8 27B (contesto da 262.144 token) e GLM 5.3 (1.048.576) sono adatti a top-k più ampi o a documenti lunghi, dopo una ricarica. Prompt e passaggi recuperati non vengono conservati dopo la richiesta. Se il tuo corpus è abbastanza piccolo e stabile da stare nella finestra di contesto, il contesto lungo può battere del tutto il chunking.

Domande frequenti

Qual è una buona chunk size per la RAG?

Parti da circa 256-512 token e fai dei test. La valutazione di Chroma ha rilevato buone prestazioni con 200-400 token senza overlap. NVIDIA ha rilevato che 256-512 token sono adatti alle domande fattuali, mentre quelle analitiche andavano meglio con chunk da 1.024 token o a livello di pagina.

Quanto overlap tra i chunk devo usare?

Meno della maggior parte dei default. NVIDIA ha trovato il 15% migliore tra il 10, il 15 e il 20% provati su un dataset. Chroma ha rilevato che le configurazioni senza overlap spesso ottenevano punteggi pari o migliori. Ogni punto di overlap aggiunge token da indicizzare, salvare e inviare.

Una chunk size più grande costa di più?

Non per gli embedding, senza overlap: il corpus ha lo stesso numero di token. Costa di più per query, perché ogni chunk recuperato è più lungo, quindi top-k × chunk size cresce. Abbassa k quando aumenti la dimensione.

La chunk size si misura in token o in caratteri?

Dipende dallo splitter. Il RecursiveCharacterTextSplitter di LangChain misura con la sua length_function, che per impostazione predefinita è la lunghezza in caratteri. I limiti degli embedding e le fatture degli LLM sono in token, quindi passa un contatore di token.

Devo ricalcolare gli embedding se cambio chunk size?

Sì. Nuovi confini producono nuovi chunk, e ognuno richiede un nuovo vettore. Ricalcolare gli embedding costa di nuovo l’intero indice, quindi definisci il chunking su un campione prima di indicizzare tutto il corpus.

Leggi in MarkdownChiedi a ChatGPTChiedi a ClaudeChiedi a Perplexity