# RAG spiegati: Origini e Fondamenti

Hai mai cercato una "guida alla distribuzione" e non hai ottenuto nulla, anche se c'è un articolo su "pubblicare alla produzione"? RAG (Retrieval-Augmented Generation) risolve questo problema con la comprensione del significato, non solo parole chiave. Questa serie mostra come RAG è venuto fuori, come funziona sotto il cofano, e come costruire sistemi di produzione. Dalla ricerca semantica ai Q&A ad AI-powered con citazioni.

<datetime class="hidden">2025-11-22T09:00</datetime>

<!-- category -- AI, RAG, Machine Learning, Semantic Search, LLM, AI-Article -->
# Introduzione

**Navigazione in serie:** Questa è la parte 1 della serie RAG (Retrieval-Augmented Generation)

- **Parte 1: Origini e fondamenti degli orientamenti** (questo articolo) - Che cosa sono le inserzioni, perché hanno importanza
- [Parte 2: Architettura e interni RAG](/blog/rag-architecture) - Chunking, tokenisation, database vettoriali
- [Parte 3: RAG nella pratica](/blog/rag-practical-applications) - Costruire sistemi RAG completi
- [Parte 4a: Implementazione di ONNX & Qdrant](/blog/semantic-search-with-onnx-and-qdrant) - CPU-friendly fondazione di ricerca semantica
- [Parte 4b: Ricerca semantica in azione](/blog/semantic-search-in-action) - Typeahead, ricerca ibrida e componenti UI
- [Parte 5: Ricerca ibrida e integrazione automatica](/blog/rag-hybrid-search-and-indexing) - Modelli di integrazione della produzione
- [Parte 6: GraphRAG](/blog/graphrag-knowledge-graphs-for-rag) - Grafici della conoscenza per la comprensione a livello di corpus

RAG (Retrieval-Augmented Generation) è stato sviluppato per rendere AI più intelligente LLM di accesso alle informazioni su cui non sono stati addestrati.Ma ecco cosa c'è di interessante: la tecnologia apre opportunità ben oltre AI chatbots. Potere ricerca semantica su siti web, raccomandazioni di contenuti, assistenza alla scrittura, e gestione della conoscenza.

**La duplice natura:** RAG può aiutare i clienti (ricerca migliore, risposte accurate con citazioni) o sfruttarli (raccomandazioni manipolative, seppellire recensioni negative, affacciarsi al contenuto upsell). La differenza non è l'intento della tecnologia. Una ricerca semantica che aiuta gli utenti a trovare ciò di cui hanno bisogno? Grande. Uno che dà priorità a ciò che ti rende il maggior numero di soldi mentre apparisci utile? Questo è territorio modello scuro, ed è per questo che capire come funziona conta.

**Ecco la verità su RAG:** Sembra intimidatorio. Vector incorpora? Transformer models? KV caches? Ma come tutto il resto del software, si tratta solo di capire come funziona. Non c'è bisogno di conoscere la matematica dietro le architetture dei trasformatori più di quanto tu debba capire il montaggio per scrivere C#.

**RAG in tre fasi:**

1. Trasforma il testo in numeri (inserzioni)
2. Trova numeri simili (ricerca vettori)
3. Usa quello che hai trovato (display results or feed to LLM)

Il resto sono dettagli sull'attuazione.

Questa serie mostra come costruire i sistemi RAG con codice C# funzionante. Nessuna ondata a mano. Nessuna ipotesi. Solo i pezzi e come si adattano insieme.

**Quello che imparerai in questa serie:**

- **Parte 1 (questo articolo)**: Come RAG è venuto e perché importa
- **Parte 2**: Completa architettura tecnica e interni LLM
- **Parte 3**: Costruire sistemi reali con esempi di codice

Più tardi, vi mostrerò anche come costruire sistemi RAG completi tra cui:

- [CPU-friendly ricerca semantica con incorporazioni ONNX](/blog/semantic-search-with-onnx-and-qdrant) (Parte 4)
- [Database vettoriali self-hosted con Qdrant](/blog/semantic-search-with-onnx-and-qdrant) (Parte 4)
- [Ricerca ibrida e indicizzazione automatica](/blog/rag-hybrid-search-and-indexing) (Parte 5)

[TOC]

# Che cos'è RAG?

**Retrieval-Augmented Generation:** Trovare informazioni pertinenti, poi usarlo.

```mermaid
flowchart LR
    A[User Question] --> B[Retrieve Relevant Info]
    B --> C[Retrieved Documents/Context]
    C --> D[Generate Response]
    A --> D
    D --> E[Grounded, Accurate Answer]

    style B stroke:#f9f,stroke-width:2px
    style D stroke:#bbf,stroke-width:2px
```

**Senza RAG:** L'utente chiede → LLM indovina dalla memoria → potrebbe avere allucinazioni

**Con RAG:** L'utente chiede → Trova documenti pertinenti → Risposte LLM utilizzando quei documenti → fondati in realtà

```csharp
// Without RAG: Hope the LLM knows
var answer = await llm.GenerateAsync("How do I deploy Docker?");
// Risk: Might make up outdated or wrong steps

// With RAG: Give it the docs
var relevantDocs = await vectorSearch.FindSimilar("How do I deploy Docker?");
var context = string.Join("\n", relevantDocs.Select(d => d.Text));
var answer = await llm.GenerateAsync($"Context: {context}\n\nQuestion: How do I deploy Docker?");
// Result: Answer based on YOUR actual Docker deployment docs
```

**Intuizione chiave:** Memorizzazione della conoscenza separata (ricerca) dal ragionamento (LLM). Aggiorna i tuoi documenti, la ricerca rimane attuale. Non è necessaria alcuna riqualificazione.

# Da dove viene RAG?

RAG si basa su decenni di ricerca e ricerca NLP. Capire questa storia aiuta a capire perché RAG è progettato il modo in cui è e quali problemi risolve.

## Ricerca tradizionale (pre-2010)

**Ricerca basata su parole chiave:**

- **TF-IDF**: Frequenza del termine × frequenza inversa del documento - le parole comuni contano meno
- **BM25**: Probabilistic ranking - ancora la linea di base per la ricerca di parole chiave
- **Corrispondenza sfocata**:
  - **SoundexCity name (optional, probably does not need a translation)**: Algoritmo fonetico ("Smith" corrisponde a "Smythe")
  - **Distanza Levenshtein**: Modifica distanza (quante inserzioni/delezioni/sostituzioni)
  - **N-GramsCity name (optional, probably does not need a translation)**: Sequenze caratteri/parole per corrispondenza parziale

**Il problema:** Questi corrispondono *caratteri*, non *significato*. Cerca "orchestrazione contenitore" e non troverai "Docker Swarm" a meno che non compaiono quelle parole esatte. Potrebbero gestire errori di battitura ma non semantica.

## Risposta iniziale alle domande (2010s)

**Watson (IBM, 2011):**

- Recupero combinato con ragionamento basato sulle regole
- Won Jeopardy! ma richiedeva un'enorme ingegneria della conoscenza artigianale
- Ancora contare pesantemente sulla corrispondenza delle parole chiave

**Modelli di comprensione della lettura:**

- Potrebbe estrarre le risposte dai passaggi forniti
- Ma prima dovevi dargli il giusto passaggio.
- Nessuna ricerca semantica per trovare quel passaggio

## La rivoluzione dell'apprendimento profondo (2017+)

**Transformers (2017):** "[L'attenzione è tutto ciò di cui hai bisogno](https://arxiv.org/abs/1706.03762)"

- Reti neurali in grado di comprendere il contesto
- Fondazione per tutto ciò che è seguito

**BERT (2018):**

- Comprensione contestuale del linguaggio
- "Banca" significa cose diverse in "banca fiume" contro "banca di risparmio"
- Potrebbe generare inserzioni che catturano il significato

**GPT-2/3 (2019/2020):**

- Grandi modelli linguistici che potrebbero generare testo coerente
- Ma limitato ai loro dati di formazione
- Emergono problemi di allucinazione

**Rappresentazioni vettoriali dense:**

- Testo → numeri significativi nello spazio ad alta dimensione
- Significati simili → vettori vicini
- Questo ha reso possibile la ricerca semantica

**BART (Facebook AI, ottobre 2019):**

- Trasformatore bidirezionale e auto-regressivo di Mike Lewis et al.
- Encoder combinato BERT-like con decoder GPT-like
- Denoising autoencoder addestrato da corrompere il testo poi ricostruirlo
- Eccellente per la generazione di testo e le attività di comprensione
- Divenne la base per i RAG

**M2M-100 (Facebook AI, ottobre 2020):**

- Primo modello di traduzione multilingue da molti a molti
- Traduzione diretta tra 100 lingue senza perno inglese
- 2.200 direzioni linguistiche (10x più dei modelli precedenti)
- Trasformatori mostrati in grado di gestire enormi attività cross-lingue

**Esempio del mondo reale:** Mio [strumento di traduzione automatica neurale](https://github.com/scottgal/mostlyucid-nmt) utilizza BART come modello di traduzione ripiego quando i servizi primari non sono disponibili, dimostrando come questi modelli basati sui trasformatori siano diventati pratici elementi costitutivi per i sistemi di produzione.

## La nascita di RAG moderni (maggio 2020)

Il giornale seminale "[Generazione aumentata di recupero per attività NLP intensive della conoscenza](https://arxiv.org/abs/2005.11401)" di Patrick Lewis et al. (Facebook AI Research) ha presentato formalmente RAG, costruendo direttamente su BART:

**Che cosa hanno combinato:**

- Dense Passage Retrieval (DPR) - rappresentazioni vettoriali imparate, non parole chiave
- Generatore BART - il modello segg2seq dal 2019
- Architettura end-to-end diversiabile - recuperare e generare insieme

**Risultati:** I sistemi RAG hanno superato i modelli molto più ampi sulle attività ad alta intensità di conoscenza pur essendo più efficienti e aggiornati. Si potrebbe aggiornare la base di conoscenze senza riqualificare il modello.

## Perché RAG è esploso (2023-Present)

ChatGPT, GPT-4 e Claude hanno reso RAG essenziali:

1. **Problema di allucinazione** - I LLM inventano con fiducia i fatti. RAG motiva le risposte in documenti reali.
2. **Cutoff della conoscenza** - LLMs addestrati su dati 2021 non sanno di 2024 eventi. RAG utilizza i documenti attuali.
3. **Dati privati** I LLM non possono accedere ai documenti interni della tua azienda.
4. **Costo** - LLM di fine-tuning è costoso ($10K-100K+). RAG è a buon mercato (storage + embeddings).
5. **Spiegabilità** - RAG può citare le fonti, rendendolo verificabile e affidabile.

**Oggi (2024-2025):** RAG è lo standard de facto per i sistemi di produzione AI che necessitano di precisione e auditability. Ogni grande azienda AI offre RAG tooling.

# Come funziona RAG: Il grande quadro

Prima di tuffarsi nei dettagli tecnici (che copriamo nella parte 2), capiamo il flusso di lavoro ad alto livello.

## Le tre fasi

I sistemi RAG operano in tre fasi distinte:

### Fase 1: indicizzazione (configurazione una tantum)

```mermaid
flowchart LR
    A[Your Documents] --> B[Split into Chunks]
    B --> C[Generate Embeddings]
    C --> D[Store in Vector DB]

    style C stroke:#f9f,stroke-width:2px
    style D stroke:#bbf,stroke-width:2px
```

**Cosa succede?**

1. Prendere la vostra base di conoscenze (docs, post del blog, manuali)
2. Dividi in pezzi gestibili (punti, sezioni)
3. Converti ogni pezzo in un vettore che incorpora (array di numeri)
4. Memorizza vettori in un database ottimizzato per la ricerca di similarità

**Concetto chiave:** Significati simili producono vettori simili, così "Docker container" e "piattaforma di containerizzazione" finiscono insieme nello spazio vettoriale.

### Fase 2: recupero (ogni domanda)

```mermaid
flowchart LR
    A[User Question] --> B[Generate Query Embedding]
    B --> C[Search Vector DB]
    C --> D[Top K Most Similar Chunks]

    style B stroke:#f9f,stroke-width:2px
    style C stroke:#bbf,stroke-width:2px
```

**Cosa succede?**

1. L'utente pone una domanda
2. Converti domanda in un vettore (stesso modello utilizzato per l'indicizzazione)
3. Trova la maggior parte dei vettori simili nel database
4. Restituisci la parte superiore di K più rilevante (solitamente 3-10)

**Perché funziona:** "Come faccio a distribuire i container?" (query) è semanticamente simile ai pezzi sulla distribuzione di Docker, anche se le parole esatte differiscono.

### Fase 3: Generazione (ogni domanda)

```mermaid
flowchart TB
    A[User Question] --> B[Build Prompt]
    C[Retrieved Context] --> B
    B --> D[LLM]
    D --> E[Generated Answer with Citations]

    style B stroke:#f9f,stroke-width:2px
    style D stroke:#bbf,stroke-width:2px
```

**Cosa succede?**

1. Accetta la domanda dell'utente
2. Prendi i pezzi di contesto recuperati
3. Costruisci un prompt: "Dato questo contesto..., rispondi a questa domanda..."
4. Invia a LLM per la generazione
5. LLM produce una risposta fondata nel contesto previsto

**La magia:** L'LLM non puo' avere allucinazioni che non siano nel contesto, puo' solo sintetizzare e spiegare cio' che e' stato fornito.

## Un esempio semplice

Tracciamo una query attraverso il sistema:

**L'utente chiede:** "Come posso usare Docker Compose?"

**Fase 1 - Recupero:**

```
Query embedding: [0.234, -0.891, 0.567, ...]

Search vector DB for similar embeddings...

Retrieved chunks:
1. "Docker Compose is a tool for defining multi-container applications..." (similarity: 0.92)
2. "To use Docker Compose, create a docker-compose.yml file..." (similarity: 0.87)
3. "The docker-compose up command starts all services..." (similarity: 0.83)
```

**Fase 2 - Generazione:**

```
Prompt to LLM:
"Context:
[1] Docker Compose is a tool for defining multi-container applications...
[2] To use Docker Compose, create a docker-compose.yml file...
[3] The docker-compose up command starts all services...

Question: How do I use Docker Compose?

Answer (use the context above):"

LLM Response:
"To use Docker Compose [1], start by creating a docker-compose.yml file [2] that
defines your services. Then run 'docker-compose up' to start all services [3]..."
```

**Risultato:** Risposta accurata con citazioni implicite dalla documentazione.

# RAG contro altri approcci

Comprendere quando utilizzare RAG (e quando non) richiede il confronto con alternative.

## RAG vs. Fine-Tuning

| Aspect | RAG | Fine-Tuning |
|--------|-----|-------------|
| **Aggiornamenti della conoscenza** | Instant (just update the knowledge base) | Richiede riqualificazione |
| **Costo** | Basso (immagazzinamento + inserimento) | Alto (tempo di allenamento della GPU) |
| **Precisione** |Macinato a terra in sorgenti |Può avere allucinazioni |
| **Personalizzazione** | Limitato al recupero | Adattamento profondo del modello |
| **Spiegabilità** | Alto (può citare sorgenti) | Basso (scatola nera) |
| **Meglio per** | Attività ad alta intensità di conoscenza | Adattamento stile/formato |

**Quando usare Fine-Tuning:**

- Hai bisogno del modello per imparare uno specifico **stile** oppure **formato**
- Hai un grande set di dati pulito
- Hai bisogno del modello per interiorizzare **modelli**, non fatti
- Esempio: Fare scrivere GPT come Shakespeare

**Quando usare RAG:**

- Hai bisogno di **Precisione di fatto** con citazioni
- La vostra base di conoscenze cambia frequentemente
- Hai dati privati/proprietari
- Costi e semplicità
- Esempio: Supporto clienti chatbot (i documenti della mia azienda cambiano settimanalmente)

**Puoi combinare entrambi?** Sì! Fine-tune per lo stile, RAG per i fatti.

## RAG vs. Finestre di contesto lunghe

I moderni LLM vantano enormi finestre di contesto (GPT-4: 128K tokens, Claude: 200K tokens). Perché non scaricare tutti i documenti nel contesto?

**Problemi con un contesto lungo:**

1. **Costo**: Tariffe scale con gettoni - $10-100 per query aggiunge veloce
2. **Latenza**: L'elaborazione di gettoni 100K richiede tempo
3. **Perso nel mezzo**: LLMs lotta per utilizzare le informazioni nel mezzo di contesti lunghi
4. **Diluizione**: Informazioni rilevanti viene sepolto nel rumore
5. **Limiti pratici**: Non puoi adattare i documenti di tutta la tua azienda nel contesto

**Quando il contesto lungo ha senso:**

- Un unico documento di grandi dimensioni (ad esempio, l'analisi di un contratto)
- Tutto è rilevante (non c'è bisogno di filtrare)
- Il costo non è un problema
- Basso volume delle interrogazioni

**Quando RAG ha senso:**

- Ampia base di conoscenze (milioni di documenti)
- Necessità di trovare un sottoinsieme pertinente
- Elevato volume delle interrogazioni (in materia di costi)
- Aggiornamenti in tempo reale alla conoscenza

**Migliori pratiche:** Utilizzare RAG per selezionare il contenuto più pertinente, quindi utilizzare un contesto lungo per tale sottoinsieme.

## RAG vs. Prompting con esempi

Pochi colpi di suggerimento (che forniscono esempi nel prompt) è una semplice linea di base.

**Prompt esempio:**

```
Examples:
Q: What is Docker?
A: Docker is a containerization platform...

Q: How does Kubernetes work?
A: Kubernetes orchestrates containers...

Q: What is my new question?
A: [LLM generates answer]
```

**Limitazioni:**

- Limitato a ciò che si inserisce nella finestra di contesto
- Cura manuale degli esempi
- Non scala a grandi basi di conoscenza
- Nessuna ricerca semantica - si sceglie manualmente esempi

**Miglioramento degli orientamenti:**

- Trova automaticamente i migliori esempi (tramite la ricerca di somiglianza)
- Scala ad esempi illimitati (solo in alto K inviato a LLM)
- Adatta alla query (le query diverse recuperano diversi esempi)

Si può pensare a RAG come "automatizzato pochi colpi di spinta in scala."

## Ricerca ibrida: RAG + Ricerca tradizionale

È possibile combinare i RAG con la ricerca full-text tradizionale utilizzando la Reciproca Rank Fusion (RRF).

**Perché ibrido?**

- **Ricerca semantica**: Ottimo per le partite concettuali ("la gestione degli errori" trova "la gestione delle eccezioni")
- **Ricerca parole chiave**: Ottimo per termini esatti ("Docker Compose," "Entity Framework")
- **Ibrido**: Il meglio di entrambi i mondi

```csharp
public async Task<List<SearchResult>> HybridSearchAsync(string query)
{
    // Run both searches in parallel
    var semanticTask = SemanticSearchAsync(query, limit: 20);
    var keywordTask = KeywordSearchAsync(query, limit: 20);

    await Task.WhenAll(semanticTask, keywordTask);

    var semanticResults = await semanticTask;
    var keywordResults = await keywordTask;

    // Combine using Reciprocal Rank Fusion
    return ApplyRRF(semanticResults, keywordResults);
}

private List<SearchResult> ApplyRRF(
    List<SearchResult> list1,
    List<SearchResult> list2,
    int k = 60)
{
    var scores = new Dictionary<string, double>();

    // Score from first list
    for (int i = 0; i < list1.Count; i++)
    {
        var id = list1[i].Id;
        scores[id] = scores.GetValueOrDefault(id, 0) + 1.0 / (k + i + 1);
    }

    // Score from second list
    for (int i = 0; i < list2.Count; i++)
    {
        var id = list2[i].Id;
        scores[id] = scores.GetValueOrDefault(id, 0) + 1.0 / (k + i + 1);
    }

    // Merge and sort by combined score
    var allResults = list1.Concat(list2)
        .GroupBy(r => r.Id)
        .Select(g => g.First())
        .OrderByDescending(r => scores[r.Id])
        .ToList();

    return allResults;
}
```

# Perché gli orientamenti in materia di aiuti di Stato

Ora che capisci cos'è RAG, da dove viene, e come si confronta con le alternative, ecco perché conta:

**1. Democrazia dell'IA**

- Non hai bisogno di un budget di 100K $ fine-tuning
- Non hai bisogno di un team di ingegneri ML
- Qualsiasi sviluppatore può costruire sistemi RAG con strumenti esistenti

**2. Precisione pratica**

- L'allucinazione è il problema #1 con i LLM in produzione
- RAG la risolve fondando le risposte in documenti reali
- Le citazioni lo rendono verificabile e affidabile

**3. Sempre up-to-date**

- IA tradizionale: treno una volta, la conoscenza è congelata
- RAG: Aggiorna i tuoi documenti, aggiornamenti di conoscenza istantaneamente
- Critica per i domini in rapida evoluzione (tecnologia, notizie, regolamenti)

**4. Privacy e controllo**

- I tuoi dati rimangono nella tua infrastruttura
- Può essere eseguito interamente localmente (embeddings locali + LLM locale + vettore locale DB)
- Nessun dato inviato a OpenAI o altri provider di cloud

**5. Costo-efficace**

- Lo storage è economico (pennies per GB)
- Le inserzioni sono a buon mercato (frazioni di un centesimo per 1000 documenti)
- Molto più economico di fine-tuning o finestre di contesto lungo

**6. Applicazioni versatili**

- Ricerca semantica (non serve LLM!)
- Sistemi Q&A con citazioni
- Raccomandazione per il contenuto
- Assistenti alla scrittura
- Gestione delle conoscenze
- Supportatori di documentazione
- Assistenti alla ricerca

# Conclusione: Dalla storia all'implementazione

Abbiamo rintracciato l'evoluzione di RAG:

- **Pre-2010**: Ricerca di parole chiave (caratteri, non significato)
- **2010**: Comprensione della lettura (necessaria il giusto passaggio)
- **2017-2020**: Trasformatori e incorporazioni (significato → vettori)
- **2020**: RAG moderni (recuperare + generare)
- **2023-Present**: Standard di produzione (allucinazione + costo + privacy)

**Principali intuizioni della Parte 1:**

- RAG separati **Archiviazione delle conoscenze** (vettore DB) da **ragionamento** (LLM)
- Risolve il problema dell'allucinazione mettendo a terra le risposte in documenti reali
- E 'più economico e più flessibile di fine-tuning
- Funziona meglio di un lungo contesto per le grandi basi di conoscenza
- E 'fondamentalmente "automatizzato pochi colpi di suggerimento in scala"

**Il modello mentale in tre fasi:**

1. Trasforma il testo in numeri (inserzioni)
2. Trova numeri simili (ricerca vettori)
3. Usa quello che hai trovato (display o feed a LLM)

Tutto il resto è ottimizzazione.

# Continuare alla Parte 2: Architettura e Interni

Ora capisci. **cosa** RAG è, **perché** ha importanza, e **dove** Ma come funziona davvero sotto il cofano?

Dentro **[Parte 2: Architettura e interni RAG](/blog/rag-architecture)**, ci immergiamo nei dettagli tecnici:

**Gasdotto completo RAG:**

- Fase 1: Indicizzazione (estrazione del testo, strategie di chunking, generazione di embedding, storage vettoriale)
- Fase 2: Retrieval (imbeddings query, metriche di somiglianza, riranking)
- Fase 3: Generazione (pronta costruzione, parametri LLM, post-elaborazione)

**Interni LLM:**

- Quali sono i gettoni e perché sono importanti per i RAG
- La cache di KV: come gli LLM ricordano il contesto
- Finestre di contesto e strategie di gestione token
- Ottimizzazione degli orientamenti per l'efficienza e il costo del token

**Immersioni tecniche profonde:**

- Database vettoriali e algoritmi di ricerca di similarità
- Incorporazione di modelli e normalizzazione
- Strategie di riflessione che preservano il contesto
- Esempi pratici di codice in C#

**[Continuare alla Parte 2: Architettura e Interni →](/blog/rag-architecture)**

Dopo la Parte 2, sarete pronti per la Parte 3, dove costruiremo sistemi reali, risolveremo le sfide comuni ed esploreremo tecniche avanzate come HyDE, RAG multi-query e compressione contestuale.

## Risorse

**Documenti di fondazione:**

- [Generazione aumentata di recupero per attività NLP intensive della conoscenza](https://arxiv.org/abs/2005.11401) - La carta originale RAG
- [Recupero del passaggio denso per la risposta alle domande open-domain](https://arxiv.org/abs/2004.04906) - DPR (fondazione retrievale)
- [Attenzione è tutto ciò di cui hai bisogno](https://arxiv.org/abs/1706.03762) - Trasformatori (fondazione di montaggio)

**Ulteriore lettura:**

- [Come funziona la traduzione automatica neurale](/blog/how-neural-machine-translation-works) - Capire i modelli AI dietro le inserzioni

**Avanti in questa serie:**

- [Parte 2: Architettura e interni RAG](/blog/rag-architecture) - Immersione tecnica profonda
- [Parte 3: RAG nella pratica](/blog/rag-practical-applications) - Costruzione di sistemi reali

**[Continua alla parte 2 →](/blog/rag-architecture)**