RAG vs Long Context Window: Cosa Usare nel 2025?

Gemini 1.5 Pro arriva con 1 milione di token di context window. Claude 3.5 supporta 200K. GPT-4o arriva a 128K. La domanda che ogni team LLM si fa è legittima: se posso mettere l'intero knowledge base nel prompt, ha ancora senso costruire un sistema RAG complesso?

La risposta, come al solito, è "dipende". Ma dipende in modo molto specifico e misurabile.

---

I Numeri del Context Window

Prima di tutto, contestualizziamo cosa significano questi numeri nella pratica:

Quanto "entra" in un context window?

128K token (GPT-4o max):
- ~96.000 parole
- ~300 pagine di documento Word
- ~3 contratti medi (30 pagine ciascuno)
- 1 romanzo medio

200K token (Claude 3.5):
- ~150.000 parole
- ~500 pagine
- ~5 contratti medi

1M token (Gemini 1.5 Pro):
- ~750.000 parole
- ~2.500 pagine
- Un intero manuale tecnico + tutta la documentazione API

Per riferimento:
- Wikipedia italiana completa: ~500M token → non entra
- Codice base media startup: ~5-50M token → non entra
- Knowledge base HR media azienda: ~50K-500K token → alcuni entrano, altri no

---

Vantaggi del Long Context

1. Semplicità Operativa

Non c'è nulla di più semplice di passare il documento intero al modello:

# Long context approach: semplicissimo
def ask_about_document(document: str, question: str) -> str:
    response = client.chat.completions.create(
        model="gemini-1.5-pro",
        messages=[
            {
                "role": "user",
                "content": f"Documento:\n{document}\n\nDomanda: {question}"
            }
        ]
    )
    return response.choices[0].message.content

# vs RAG: chunking, embedding, indexing, retrieval, re-ranking...

Per prototipi, MVP, o analisi one-shot, il long context vince in semplicità.

2. No Lost Information

Il RAG dipende dalla qualità del retrieval. Se il chunk rilevante non viene recuperato, la risposta è sbagliata. Con long context, il modello vede tutto.

3. Ragionamento Cross-Document

Domande che richiedono incrociare informazioni da punti distanti del documento:

"Le clausole di penale all'articolo 12 sono in contraddizione
con le esenzioni dell'appendice D?"

→ RAG difficoltà: i chunk dell'articolo 12 e dell'appendice D
  potrebbero non essere recuperati insieme
→ Long context: il modello vede tutto e può ragionare sull'intero documento

---

Svantaggi del Long Context: Quelli Reali

1. Lost in the Middle: Il Problema Persistente

Ricerche pubblicate dimostrano che i modelli LLM degradano significativamente la loro accuratezza per informazioni posizionate nel mezzo di contesti lunghi. Il fenomeno si chiama "Lost in the Middle".

Esperimento (Dataset interno Rayo Consulting, Settembre 2024):
- Documento: 100K token
- 50 domande con risposta posizionata in punti diversi del documento
- Modello: GPT-4o

Accuratezza per posizione della risposta nel documento:
- Primo 10%:  94%
- 10-30%:     88%
- 30-70%:     71%  ← degrado significativo
- 70-90%:     83%
- Ultimo 10%: 92%

Conclusione: accuratezza media long context = 82%
vs RAG con retrieval preciso: 91%

2. Costo: Il Muro del Long Context

I modelli con pricing a token rendono il long context estremamente costoso a scala:

Scenario: 500 query/giorno su un documento di 50.000 token

Long Context (Gemini 1.5 Pro, $7/M input tokens):
- Token per query: 50.000 (documento) + 200 (query) + 500 (output) = 50.700
- Costo per query: 50.700 * $0.000007 = $0.355
- Costo giornaliero: 500 * $0.355 = $177.50
- Costo mensile: $5.325

RAG (GPT-4o, 5 chunk da 500 token + retrieval):
- Token per query: 2.500 (contesto) + 200 (query) + 500 (output) = 3.200
- Costo per query: 3.200 * $0.000015 = $0.048
- Costo giornaliero: 500 * $0.048 = $24
- Costo mensile: $720

Risparmio RAG: 86% ($4.605/mese)

3. Latenza: Contesto Lungo = Risposta Lenta

Latenza misurata per lunghezza contesto (GPT-4o, P50):
- 4K token:   1.2s
- 16K token:  2.1s
- 32K token:  3.8s
- 64K token:  7.2s
- 128K token: 14.5s

→ Per applicazioni interattive (chatbot, copilot), > 8K token
  di contesto diventa problematico per l'UX

4. Scalabilità: Non Funziona con Corpora Grandi

La legge fondamentale: il long context funziona quando un singolo documento risponde alla domanda. Non funziona quando la risposta potrebbe essere in qualsiasi documento di una collection di 100.000 file.

---

Quando Usare Long Context

Il long context vince in questi scenari:

Analisi Documento Singolo One-Shot

# Analisi completa di un contratto: long context è perfetto
def analyze_contract(contract_path: str) -> dict:
    with open(contract_path) as f:
        contract_text = f.read()

    # Se il contratto è < 50K token, long context è ideale
    token_estimate = len(contract_text.split()) * 1.3

    if token_estimate > 100_000:
        raise ValueError("Contratto troppo lungo per long context, usa RAG")

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user",
            "content": f"""Analizza questo contratto e fornisci:
1. Parti coinvolte
2. Obbligazioni principali
3. Penali e condizioni di rescissione
4. Rischi principali
5. Clausole inusuali o critiche

Contratto:
{contract_text}"""
        }]
    )
    return parse_contract_analysis(response.choices[0].message.content)

Debugging e Code Review

# Review di una codebase piccola-media: long context eccellente
def review_codebase(files: list[str]) -> str:
    all_code = "\n\n---\n\n".join([
        f"# File: {f['path']}\n{f['content']}"
        for f in files
    ])

    token_estimate = len(all_code.split()) * 1.3
    if token_estimate > 80_000:
        print(f"Warning: codebase grande ({token_estimate:.0f} token), possibile degradazione")

    response = client.chat.completions.create(
        model="claude-3-5-sonnet",  # Ottimo per codice, 200K context
        messages=[{
            "role": "user",
            "content": f"Analizza questa codebase e identifica bug, problemi di sicurezza e aree di miglioramento:\n\n{all_code}"
        }]
    )
    return response.choices[0].message.content

---

Quando Usare RAG

Knowledge Base Aziendale (> 10.000 documenti)

Non c'è context window che regga un intero knowledge base aziendale. RAG è l'unica opzione.

Chatbot Interattivo con Latenza SLA

Se hai SLA < 3 secondi, il long context non è un'opzione sopra i 20K token.

Cost Sensitivity

Se il costo per query conta, RAG a parità di qualità è 5-10x più economico.

Dati Aggiornati Frequentemente

Il RAG si aggiorna in tempo reale (indicizza nuovi documenti). Il long context deve essere ricaricato ad ogni query.

---

L'Approccio Ibrido: Il Meglio dei Due Mondi

La soluzione più sofisticata combina entrambi:

def hybrid_retrieval_long_context(
    query: str,
    document_collection: list[str],
    max_context_tokens: int = 20_000
) -> str:
    """
    1. RAG per identificare i documenti più rilevanti
    2. Long context per analizzare i documenti rilevanti nella loro interezza
    """

    # Step 1: RAG per filtro iniziale
    # Recupera i top-3 documenti più rilevanti (non solo chunk)
    relevant_doc_ids = rag_retrieve_documents(query, top_k=3)
    relevant_docs = [document_collection[doc_id] for doc_id in relevant_doc_ids]

    # Step 2: Controlla se i documenti entrano nel context
    total_tokens = sum(estimate_tokens(doc) for doc in relevant_docs)

    if total_tokens > max_context_tokens:
        # Fallback a RAG standard con chunk
        return rag_with_chunks(query, relevant_docs)

    # Step 3: Long context sugli interi documenti rilevanti
    combined_context = "\n\n---DOCUMENTO SEPARATORE---\n\n".join(relevant_docs)

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{
            "role": "user",
            "content": f"Documenti rilevanti:\n{combined_context}\n\nDomanda: {query}"
        }]
    )
    return response.choices[0].message.content

---

Tabella Decisionale

| Scenario | Raccomandazione | Motivo | |----------|-----------------|--------| | Singolo documento < 50K token, query one-shot | Long Context | Semplicità, no lost-in-middle | | Knowledge base > 1.000 documenti | RAG | Unica opzione scalabile | | Chatbot interattivo, SLA < 3s | RAG | Latenza | | Budget limitato, > 1.000 query/giorno | RAG | Costo 5-10x inferiore | | Cross-document reasoning, 2-5 documenti | Ibrido | Il meglio dei due | | Analisi codice, refactoring | Long Context | Contesto coerente necessario | | Domande multi-hop su documenti distanti | Long Context | Se entrano nel context |

---

Conclusioni

Il long context non uccide il RAG. Li rende complementari in modo più chiaro:

• Long context per analisi profonde di documenti noti e limitati
• RAG per ricerca su corpora grandi, applicazioni interattive, e uso cost-sensitive
• Ibrido per i casi complessi che richiedono il meglio di entrambi

La risposta alla domanda "RAG o long context?" dipende da tre numeri: dimensione del corpus, latenza SLA, costo per query. Se hai questi tre numeri, la scelta è meccanica.

---

Stai progettando un sistema documentale e non sai quale approccio scegliere? Contattaci.