1~
2I Large Language Model (LLM) come GPT-4 e Claude sono straordinariamente potenti, ma soffrono di un limite fondamentale: la loro conoscenza è congelata al momento del training. Non possono accedere ai tuoi documenti interni, al tuo database o a informazioni aggiornate in tempo reale. La **Retrieval-Augmented Generation (RAG)** risolve esattamente questo problema, combinando la potenza generativa degli LLM con la capacità di recuperare informazioni da fonti esterne.
3~
4## Il Problema: I Limiti degli LLM
5~
6Prima di parlare di RAG, è importante capire perché ne abbiamo bisogno.
7~
81.  **Conoscenza statica**: Un LLM sa solo quello che ha visto durante il training. Se gli chiedi informazioni su un evento avvenuto dopo il suo cutoff, non può rispondere.
92.  **Allucinazioni**: Quando un LLM non conosce la risposta, tende a inventarla, generando informazioni plausibili ma completamente false.
103.  **Nessun accesso a dati privati**: Un LLM generico non ha accesso alla documentazione interna della tua azienda, ai ticket, o al tuo codebase.
11~
12La RAG affronta tutti e tre questi problemi fornendo al modello un **contesto rilevante** recuperato da fonti esterne al momento della query.
13~
14## Cos'è la RAG?
15~
16La Retrieval-Augmented Generation è un'architettura che arricchisce il prompt inviato a un LLM con informazioni recuperate da un knowledge base esterno. Invece di affidarsi esclusivamente alla conoscenza parametrica del modello, la RAG **cerca** prima le informazioni rilevanti e poi le **inietta** nel prompt, permettendo al modello di generare risposte accurate e fondate.
17~
18```mermaid
19graph LR
20    User["Utente"] -- "Domanda" --> Retriever
21    Retriever -- "Cerca documenti\nrilevanti" --> VectorStore["Vector Store"]
22    VectorStore -- "Documenti\nrilevanti" --> Retriever
23    Retriever -- "Contesto + Domanda" --> LLM
24    LLM -- "Risposta\nfondata" --> User
25```
26~
27## Come Funziona la RAG in Dettaglio
28~
29L'architettura RAG si compone di due fasi principali: **Indexing** (offline) e **Retrieval + Generation** (online).
30~
31### Fase 1: Indexing (Ingestione dei Documenti)
32~
33La fase di indexing prepara i tuoi documenti per la ricerca semantica. Si compone di quattro passi.
34~
35```mermaid
36graph TD
37    A["Documenti\n(PDF, HTML, MD, DB)"] --> B["Document Loader"]
38    B --> C["Text Splitter"]
39    C --> D["Chunks di Testo"]
40    D --> E["Embedding Model"]
41    E --> F["Vettori Numerici"]
42    F --> G["Vector Store\n(ChromaDB, Pinecone, FAISS)"]
43```
44~
45#### 1. Document Loading
46~
47I documenti possono provenire da qualsiasi fonte: file PDF, pagine web, database, file Markdown, API. Il **Document Loader** si occupa di leggere questi documenti e convertirli in testo strutturato.
48~
49#### 2. Text Splitting (Chunking)
50~
51Gli LLM hanno una finestra di contesto limitata, e i documenti possono essere molto lunghi. Il **Text Splitter** divide i documenti in frammenti più piccoli chiamati _chunks_. La qualità del chunking è critica: chunk troppo piccoli perdono contesto, chunk troppo grandi diluiscono la rilevanza.
52~
53Le strategie più comuni sono:
54~
55- **Recursive Character Splitting**: Divide il testo ricorsivamente usando separatori come `\n\n`, `\n`, `. `, rispettando la struttura del documento.
56- **Semantic Splitting**: Usa gli embedding per trovare i punti di rottura naturali nel testo.
57- **Chunk Overlap**: Include una sovrapposizione tra chunk consecutivi per preservare il contesto ai confini.
58~
59#### 3. Embedding
60~
61Ogni chunk viene trasformato in un **vettore numerico** (embedding) tramite un modello di embedding (come `text-embedding-3-small` di OpenAI). Questi vettori catturano il significato semantico del testo: frasi con significati simili avranno vettori vicini nello spazio multidimensionale.
62~
63#### 4. Vector Store
64~
65I vettori vengono salvati in un **Vector Store** (o database vettoriale), come ChromaDB, Pinecone, Weaviate o FAISS. Questo database è ottimizzato per la **ricerca di similarità**: data una query, trova i vettori (e quindi i chunk di testo) più simili.
66~
67### Fase 2: Retrieval + Generation
68~
69Quando l'utente fa una domanda:
70~
711.  La domanda viene trasformata in un embedding usando lo stesso modello di embedding.
722.  Il Vector Store cerca i chunk più simili tramite **ricerca di similarità** (tipicamente cosine similarity o distanza euclidea).
733.  I chunk recuperati vengono inseriti nel prompt come contesto.
744.  L'LLM genera la risposta basandosi sul contesto fornito.
75~
76## Costruire una Pipeline RAG con LangChain
77~
78**LangChain** è il framework Python (e JavaScript) più popolare per costruire applicazioni basate su LLM. Offre astrazioni di alto livello per ogni componente della pipeline RAG.
79~
80### Installazione
81~
82```bash
83pip install langchain langchain-openai langchain-community chromadb
84```
85~
86### Step 1: Caricare i Documenti
87~
88LangChain fornisce decine di Document Loader per diverse fonti dati.
89~
90```python
91from langchain_community.document_loaders import (
92    PyPDFLoader,
93    WebBaseLoader,
94    DirectoryLoader,
95    TextLoader,
96)
97~
98# Caricare un PDF
99pdf_loader = PyPDFLoader("docs/manuale.pdf")
100pdf_docs = pdf_loader.load()
101~
102# Caricare una pagina web
103web_loader = WebBaseLoader("https://docs.example.com/guide")
104web_docs = web_loader.load()
105~
106# Caricare tutti i file .md da una directory
107dir_loader = DirectoryLoader("./knowledge_base", glob="**/*.md", loader_cls=TextLoader)
108md_docs = dir_loader.load()
109~
110all_docs = pdf_docs + web_docs + md_docs
111```
112~
113### Step 2: Dividere i Documenti in Chunk
114~
115```python
116from langchain.text_splitter import RecursiveCharacterTextSplitter
117~
118text_splitter = RecursiveCharacterTextSplitter(
119    chunk_size=1000,
120    chunk_overlap=200,
121    separators=["\n\n", "\n", ". ", " ", ""],
122)
123~
124chunks = text_splitter.split_documents(all_docs)
125print(f"Documenti originali: {len(all_docs)}, Chunks: {len(chunks)}")
126```
127~
128Il parametro `chunk_overlap` è fondamentale: crea una sovrapposizione tra chunk consecutivi in modo che il contesto non venga perso ai confini.
129~
130### Step 3: Creare gli Embedding e il Vector Store
131~
132```python
133from langchain_openai import OpenAIEmbeddings
134from langchain_community.vectorstores import Chroma
135~
136embedding_model = OpenAIEmbeddings(model="text-embedding-3-small")
137~
138vectorstore = Chroma.from_documents(
139    documents=chunks,
140    embedding=embedding_model,
141    persist_directory="./chroma_db",
142)
143```
144~
145### Step 4: Creare il Retriever
146~
147Il retriever è il componente che, data una query, recupera i chunk più rilevanti dal vector store.
148~
149```python
150retriever = vectorstore.as_retriever(
151    search_type="similarity",
152    search_kwargs={"k": 4},
153)
154~
155relevant_docs = retriever.invoke("Come funziona l'autenticazione?")
156for doc in relevant_docs:
157    print(doc.page_content[:200])
158    print("---")
159```
160~
161### Step 5: Costruire la Chain RAG
162~
163Ora mettiamo tutto insieme con un LLM e un prompt template.
164~
165```python
166from langchain_openai import ChatOpenAI
167from langchain_core.prompts import ChatPromptTemplate
168from langchain_core.runnables import RunnablePassthrough
169from langchain_core.output_parsers import StrOutputParser
170~
171llm = ChatOpenAI(model="gpt-4o", temperature=0)
172~
173prompt = ChatPromptTemplate.from_template("""
174Rispondi alla domanda basandoti esclusivamente sul contesto fornito.
175Se il contesto non contiene informazioni sufficienti, dì che non lo sai.
176~
177Contesto:
178{context}
179~
180Domanda: {question}
181~
182Risposta:
183""")
184~
185def format_docs(docs):
186    return "\n\n".join(doc.page_content for doc in docs)
187~
188rag_chain = (
189    {"context": retriever | format_docs, "question": RunnablePassthrough()}
190    | prompt
191    | llm
192    | StrOutputParser()
193)
194~
195response = rag_chain.invoke("Come funziona l'autenticazione nel sistema?")
196print(response)
197```
198~
199## Tecniche RAG Avanzate
200~
201La pipeline di base funziona bene, ma ci sono diverse tecniche per migliorare significativamente la qualità delle risposte.
202~
203### Multi-Query Retrieval
204~
205A volte la query dell'utente è ambigua o non allineata con il linguaggio usato nei documenti. Il **Multi-Query Retriever** genera automaticamente varianti della domanda originale per catturare più prospettive.
206~
207```python
208from langchain.retrievers import MultiQueryRetriever
209~
210multi_retriever = MultiQueryRetriever.from_llm(
211    retriever=vectorstore.as_retriever(),
212    llm=llm,
213)
214~
215docs = multi_retriever.invoke("Quali sono le best practice di sicurezza?")
216```
217~
218### Contextual Compression
219~
220Non tutto il contenuto di un chunk è rilevante per la query. Il **Contextual Compression Retriever** usa un LLM per estrarre solo le parti pertinenti da ogni chunk recuperato.
221~
222```python
223from langchain.retrievers import ContextualCompressionRetriever
224from langchain.retrievers.document_compressors import LLMChainExtractor
225~
226compressor = LLMChainExtractor.from_llm(llm)
227compression_retriever = ContextualCompressionRetriever(
228    base_compressor=compressor,
229    base_retriever=retriever,
230)
231```
232~
233### Hybrid Search
234~
235La ricerca puramente semantica non è sempre ottimale. L'**Hybrid Search** combina la ricerca semantica (embedding) con la ricerca lessicale (BM25, keyword matching) per ottenere risultati migliori.
236~
237```python
238from langchain.retrievers import EnsembleRetriever
239from langchain_community.retrievers import BM25Retriever
240~
241bm25_retriever = BM25Retriever.from_documents(chunks)
242bm25_retriever.k = 4
243~
244semantic_retriever = vectorstore.as_retriever(search_kwargs={"k": 4})
245~
246hybrid_retriever = EnsembleRetriever(
247    retrievers=[bm25_retriever, semantic_retriever],
248    weights=[0.4, 0.6],
249)
250```
251~
252### Conversational RAG (con Memoria)
253~
254Per costruire un chatbot RAG che ricordi il contesto della conversazione, è necessario aggiungere una memoria che riformuli le domande dell'utente tenendo conto della cronologia.
255~
256```python
257from langchain.chains import create_history_aware_retriever
258from langchain_core.prompts import MessagesPlaceholder
259~
260contextualize_prompt = ChatPromptTemplate.from_messages([
261    ("system", "Data la cronologia della chat e l'ultima domanda dell'utente, "
262               "riformula la domanda in modo che sia comprensibile senza la cronologia."),
263    MessagesPlaceholder("chat_history"),
264    ("human", "{input}"),
265])
266~
267history_aware_retriever = create_history_aware_retriever(
268    llm, retriever, contextualize_prompt
269)
270```
271~
272## Best Practice
273~
2741.  **Scegli la giusta dimensione dei chunk**: Sperimenta con diverse dimensioni (500-1500 token). Chunk più piccoli per risposte precise, più grandi per contesto ampio.
2752.  **Usa metadata nei documenti**: Aggiungi fonte, data, categoria come metadata ai chunk. Questo permette di filtrare i risultati in fase di retrieval.
2763.  **Valuta la qualità**: Usa framework come [RAGAS](https://docs.ragas.io/) per misurare metriche come _faithfulness_, _relevancy_ e _context precision_.
2774.  **Gestisci i documenti aggiornati**: Implementa una pipeline di re-ingestione per mantenere il vector store sincronizzato con le fonti dati.
2785.  **Aggiungi un re-ranker**: Dopo il retrieval iniziale, usa un modello di re-ranking (come Cohere Rerank) per riordinare i risultati in base alla rilevanza reale.
279~
280## Conclusione
281~
282La RAG è diventata l'architettura standard per costruire applicazioni AI che necessitano di accedere a conoscenze specifiche e aggiornate. LangChain semplifica enormemente l'implementazione, fornendo astrazioni per ogni componente della pipeline.
283~
284**Prossimi passi:**
285~
286- **Sperimenta in locale**: Inizia con ChromaDB e pochi documenti per prendere confidenza con la pipeline.
287- **Esplora LangSmith**: Usa [LangSmith](https://smith.langchain.com/) per monitorare e debuggare le tue chain in produzione.
288- **Prova diversi modelli di embedding**: Confronta modelli come `text-embedding-3-small`, `text-embedding-3-large` e modelli open-source come quelli di Sentence Transformers.
289- **Consulta la documentazione**: La [documentazione di LangChain](https://python.langchain.com/docs/) è una risorsa eccellente e in costante aggiornamento.
290~