---
title: "Chunk size e overlap nella RAG: retrieval e costo | BroadRouter"
description: "Come chunk size e overlap cambiano recall, dimensione dell’indice, costo degli embedding e token inviati all’LLM a ogni query, con risultati pubblicati e calcoli."
url: https://broadrouter.com/it/blog/rag-chunk-size-overlap/
lang: it
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Tradotto dall’inglese con l’aiuto dell’IA. [Leggi l’originale in inglese](https://broadrouter.com/blog/rag-chunk-size-overlap/) (aggiornato il 2026-11-16).

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

A cura del team di BroadNet Inference · 7 min di lettura · Pubblicato 2026-11-15 · Aggiornato 2026-11-16

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.

## Punti chiave

-   L’input per query è circa top-k × chunk size + prompt. Passare da 5 × 400 a 8 × 1.024 token invia circa 3,4 volte l’input a ogni query.
-   L’overlap gonfia l’indice di dimensione ÷ (dimensione − overlap): un overlap del 15% aggiunge fino a circa il 18% (il 17% sui documenti da 10.000 token misurati qui), uno del 50% lo raddoppia.
-   Nella valutazione di Chroma del 2024, chunk da 200 a 400 token senza overlap hanno eguagliato o superato i chunk da 800 token con 400 di overlap, che è il default del file search di OpenAI.
-   I test di NVIDIA del 2025 non hanno trovato una dimensione migliore in assoluto: le domande fattuali favorivano 256-512 token, quelle analitiche 1.024 token o una pagina.
-   Misura la chunk size in token del tuo modello di embedding. Alcuni splitter contano i caratteri per impostazione predefinita.

**In questa pagina**

1.  Cosa cambiano chunk size e overlap?
2.  Cosa dicono i test pubblicati sulla chunk size?
3.  Quanto gonfia l’indice l’overlap?
4.  Cosa fa la chunk size alla fattura dell’LLM?
5.  Come fare il chunking in token senza spezzare le parole?
6.  Come scegliere i numeri per i tuoi dati?
7.  Dove si inserisce BroadNet Inference

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](https://broadrouter.com/it/blog/long-context-vs-rag/). Per i documenti in arabo, leggi anche [RAG in arabo](https://broadrouter.com/it/blog/arabic-rag-search/) e [normalizzazione del testo arabo](https://broadrouter.com/it/blog/arabic-text-normalization-search/).

## 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](https://broadrouter.com/tools/embedding-cost-calculator/).

## 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](https://broadrouter.com/it/models/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](https://broadrouter.com/it/models/qwen3.8-27b/) ($0.175 di input) o [GLM 5.3](https://broadrouter.com/it/models/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](https://broadrouter.com/it/blog/cached-input-tokens-explained/) 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](https://broadrouter.com/it/blog/long-context-vs-rag/), e quel confronto ha i suoi conti. Il [calcolatore di chunking RAG](https://broadrouter.com/tools/rag-chunking-calculator/) 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](https://broadrouter.com/it/blog/tokens-per-word-arabic-english/). 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.

```python
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](https://broadrouter.com/it/blog/evaluate-llm-before-switching/) 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](https://broadrouter.com/it/blog/estimate-llm-api-cost-before-launch/).

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](https://broadrouter.com/it/blog/long-context-vs-rag/) può battere del tutto il chunking.

Strumenti gratuiti sul tema (in inglese)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Strumenti gratuiti (in inglese)](https://broadrouter.com/tools/)

## Termini in questo articolo

[Token](https://broadrouter.com/it/glossary/token/)

Un token è l’unità di testo che un modello linguistico legge e scrive: una parola, una parte di parola, un segno di punteggiatura o una sequenza di byte prodotta dal tokenizer del modello. Le API LLM contano, limitano e di solito fatturano l’uso in token.

[Embedding (embeddings)](https://broadrouter.com/it/glossary/embeddings/)

Gli embedding sono liste di numeri in virgola mobile (vettori) che un modello produce per rappresentare un testo, un’immagine o un altro input. Input con significato simile ottengono vettori vicini tra loro, quindi la distanza tra vettori serve a ordinare i risultati di ricerca, raggruppare documenti o trovare elementi correlati.

[Chunking (RAG)](https://broadrouter.com/it/glossary/chunking/)

Il chunking è il passaggio di una pipeline di retrieval che divide i documenti in pezzi più piccoli, detti chunk, prima di trasformarli in embedding e indicizzarli. La chunk size fissa quanto testo contiene ogni pezzo, e il chunk overlap ripete parte del testo tra chunk vicini, così le idee tagliate su un confine non si perdono.

[System prompt (prompt di sistema)](https://broadrouter.com/it/glossary/system-prompt/)

Il system prompt è il testo di istruzioni che un’applicazione invia a un modello linguistico prima della conversazione, di solito come messaggio con ruolo system o developer. Stabilisce ruolo, regole, tono e formato di output del modello, che dovrebbe seguirlo anche quando i messaggi dell’utente lo contraddicono.

[Eval (valutazione degli LLM)](https://broadrouter.com/it/glossary/eval/)

Una eval (abbreviazione di evaluation, valutazione) è un test ripetibile di un modello linguistico o di un prompt: un insieme fisso di input, una descrizione di come deve essere un buon output e un valutatore (codice, una persona o un altro modello) che assegna un punteggio a ogni output, così da poter confrontare le versioni.

[Tool calling (chiamata di strumenti)](https://broadrouter.com/it/glossary/tool-calling/)

Il tool calling, detto anche function calling, è una funzionalità delle API LLM in cui il modello restituisce una richiesta strutturata di eseguire una funzione definita dallo sviluppatore, con argomenti JSON. L’applicazione esegue la funzione e rimanda il risultato; il modello non esegue mai codice da solo.

[Credito prepagato (prepaid credit)](https://broadrouter.com/it/glossary/prepaid-credit/)

Il credito prepagato è denaro aggiunto a un account API prima dell’uso. Ogni richiesta scala il proprio costo dal saldo e, quando il saldo si esaurisce, le richieste a consumo si fermano finché non ricarichi. Limita la spesa a quanto hai versato.

[Database vettoriale (vector database)](https://broadrouter.com/it/glossary/vector-database/)

Un database vettoriale è un archivio dati che conserva vettori di embedding, spesso con il testo di origine e i metadati, e risponde a query di nearest neighbour: dato un vettore di query, restituisce i vettori memorizzati più simili, di solito per distanza coseno, distanza euclidea o prodotto scalare.

## 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.

## Continua a leggere

-   [Contesto lungo o RAG: quando 1M di token sostituisce un DB vettoriale](https://broadrouter.com/it/blog/long-context-vs-rag/)
-   [RAG in arabo: normalizzazione, chunking e retrieval che funzionano](https://broadrouter.com/it/blog/arabic-rag-search/)
-   [Normalizzare il testo arabo per ricerca e RAG: cosa cambiare, cosa no](https://broadrouter.com/it/blog/arabic-text-normalization-search/)
-   [Come stimare il costo delle API LLM prima di lanciare una funzione](https://broadrouter.com/it/blog/estimate-llm-api-cost-before-launch/)
-   [Token di input in cache: come ridurre la bolletta delle API LLM](https://broadrouter.com/it/blog/cached-input-tokens-explained/)
-   [Hardware GPU e serving di BroadNet, come li descrive BroadNet](https://broadrouter.com/it/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache delle risposte delle API LLM: una cache esatta in Python](https://broadrouter.com/it/blog/cache-llm-responses-cut-cost/)
-   [Guida: Usare l’SDK Python di OpenAI con BroadNet Inference](https://broadrouter.com/it/guides/openai-python-sdk/)

Provalo sul tuo carico di lavoro reale. I nuovi account partono con USD 5 di credito per Gemma e trascrizione. DeepSeek, GLM e Qwen3.8 richiedono una ricarica.

[Inizia](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-rag-chunk-size-overlap&utm_content=page-cta) ·

**Fonti**

-   [Smith e Troynikov, Evaluating Chunking Strategies for Retrieval, report tecnico di Chroma, luglio 2024 (verifica del 2026-11-15)](https://research.trychroma.com/evaluating-chunking)
-   [NVIDIA Technical Blog, Finding the Best Chunking Strategy for Accurate AI Responses, giugno 2025 (verifica del 2026-11-15)](https://developer.nvidia.com/blog/finding-the-best-chunking-strategy-for-accurate-ai-responses/)
-   [Guida di OpenAI al retrieval: chunk predefiniti da 800 token con overlap di 400, limiti di chunking\_strategy (verifica del 2026-11-15)](https://developers.openai.com/api/docs/guides/retrieval)
-   [Documentazione di LangChain, RecursiveCharacterTextSplitter: chunk size misurata da length\_function, in caratteri per impostazione predefinita (verifica del 2026-11-15)](https://docs.langchain.com/oss/python/integrations/splitters/recursive_text_splitter)
-   [Prezzi e riferimento API di BroadNet Inference: modelli, lunghezze di contesto, input in cache (verifica del 2026-11-15) (in inglese)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=it-blog-rag-chunk-size-overlap&utm_content=sources)
