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:
- 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.
- 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?
- 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.
- Fissa il budget di contesto. Tieni k × dimensione vicino a un valore, per esempio 2.000 token, mentre confronti le dimensioni.
- 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.
- 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.
- 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.
