RAG e Vector Database: la nostra guerra (vinta) contro le allucinazioni della IA

Il problema non è l'IA. È la sua memoria da pesce rosso.

Abbiamo visto progetti di IA generativa costati quanto un monolocale a Milano andare a gambe all'aria per un motivo ridicolo: l'IA non si ricordava le cose. O peggio, se le inventava. Il termine tecnico è "allucinazione", ma a Rosignano lo chiamiamo in un altro modo: fare il giro del fumo. L'azienda carica documenti, policy, manuali... e l'IA risponde basandosi sul suo addestramento generalista, ignorando bellamente la conoscenza specifica che dovrebbe aver assimilato. Risultato? Informazioni imprecise, clienti furiosi e un team di sviluppo che deve mettere una pezza dietro l'altra.

Il punto è questo: un Large Language Model (LLM) standard è come un neolaureato talentuoso ma senza esperienza. Sa un sacco di cose a livello teorico, ma non conosce i dettagli del *tuo* business. E quando non sa, improvvisa. Un disastro annunciato.

La soluzione non era più training. Era un'imbeccata.

All'inizio, come tanti, abbiamo pensato: "Dobbiamo riaddestrare il modello!". Sbagliato. È un processo costoso, lento e che va ripetuto ogni volta che i dati cambiano. Un vicolo cieco. La vera svolta è arrivata quando abbiamo smesso di pensare a come insegnare tutto all'IA e abbiamo iniziato a pensare a come suggerirle la risposta giusta al momento giusto. Qui entra in gioco la Retrieval-Augmented Generation, o RAG.

Invece di sparare una domanda direttamente all'LLM, il sistema RAG fa prima una mossa intelligente: cerca la risposta nei documenti aziendali. Funziona così:
1. L'Interrogatorio: L'utente fa una domanda al sistema (es. "Qual è la nostra policy sui rimborsi per il prodotto X?").
2. La Caccia al Tesoro: Il sistema non va dall'IA. Va prima in un archivio super-organizzato, un "Vector Database", dove tutti i documenti aziendali sono stati sminuzzati e trasformati in vettori numerici. Qui cerca i pezzi di testo più simili semanticamente alla domanda.
3. L'Imbeccata: Il sistema prende i documenti che ha trovato e li mette davanti all'IA, dicendole: "Ok, genio. Rispondi a questa domanda, ma usando *solo* le informazioni che ti do io".
4. La Risposta Corretta (finalmente): L'IA genera una risposta basandosi su quel contesto specifico. Niente più invenzioni, niente più voli pindarici. Solo fatti, presi dai documenti ufficiali.

È un cambio di paradigma. Brutalmente efficace.

Qdrant e i Vector Database: l'archivio per cervelli artificiali

Il cuore di un sistema RAG è il Vector Database. Immaginatelo come una biblioteca dove i libri non sono in ordine alfabetico, ma per affinità di concetto. È qui che entra in gioco Qdrant. A ThinkPink lo usiamo perché è veloce, scalabile e, onestamente, ci ha dato meno mal di testa di altre soluzioni. È scritto in Rust, che per i nostri smanettoni a Kampala è una garanzia di performance e sicurezza.

Il processo di "vettorizzazione" è la chiave di tutto. Prendiamo un documento, lo dividiamo in pezzi (chunks) e usiamo un modello di embedding (come quelli di OpenAI o Cohere) per trasformare ogni pezzo in una serie di numeri, un vettore. Questo vettore rappresenta il significato semantico di quel testo. Quando un utente fa una domanda, trasformiamo anche quella in un vettore e cerchiamo nel database i vettori di testo più "vicini". Semplice a dirsi, un inferno da implementare correttamente se non hai gli strumenti giusti.

Ecco un esempio di codice (commentato alla nostra maniera) per farvi capire il concetto con il client Python di Qdrant:

# Qui importiamo i pezzi da novanta. Qdrant per il database, # e qualcosa per trasformare le parole in numeri (l'encoder). from qdrant_client import QdrantClient, models from sentence_transformers import SentenceTransformer # Creiamo il nostro "cervello" per la vettorizzazione. # 'all-MiniLM-L6-v2' è un buon punto di partenza, un mulo da soma affidabile. encoder = SentenceTransformer('all-MiniLM-L6-v2') # Ci colleghiamo al database. Se non c'è, lo tiriamo su in memoria. # Comodo per i test, ma in produzione usate un'istanza seria, mi raccomando. qdrant_client = QdrantClient(':memory:') # Creiamo una "collezione", che è come una tabella in un database normale. # La parte critica è `VectorParams`: diciamo a Qdrant quanto sono lunghi i nostri # vettori numerici e come calcolare la distanza tra loro (Cosine similarity è lo standard de facto). qdrant_client.recreate_collection( collection_name="manuali_prodotto", vectors_config=models.VectorParams( size=encoder.get_sentence_embedding_dimension(), distance=models.Distance.COSINE ) ) # Ora gli diamo in pasto i nostri documenti. # Immaginate che questi siano pezzi dei vostri PDF o del vostro sito. documenti = [ {"name": "Manuale Prodotto A", "content": "La garanzia sul Prodotto A copre i difetti di fabbricazione per 24 mesi."}, {"name": "Policy Rimborsi", "content": "I rimborsi sono processati entro 15 giorni lavorativi dalla richiesta."}, {"name": "FAQ Prodotto B", "content": "Per resettare il Prodotto B, tenere premuto il pulsante rosso per 10 secondi."} ] # Facciamo il "lavoro sporco": trasformiamo ogni documento in un vettore e lo carichiamo su Qdrant. qdrant_client.upload_records( collection_name="manuali_prodotto", records=[ models.Record( id=idx, vector=encoder.encode(doc["content"]).tolist(), payload=doc ) for idx, doc in enumerate(documenti) ] ) # Ed ecco la magia. L'utente chiede qualcosa. user_query = "Come chiedo un rimborso?" # Trasformiamo la sua domanda nello stesso linguaggio numerico. query_vector = encoder.encode(user_query).tolist() # Cerchiamo nel database i documenti che "risuonano" di più con la domanda. hits = qdrant_client.search( collection_name="manuali_prodotto", query_vector=query_vector, limit=1 # Vogliamo solo il risultato più pertinente ) # Ora 'hits' contiene il pezzo di testo esatto da dare in pasto all'LLM. # Qui è dove di solito scoppia tutto se non stai attento: la qualità # di questo risultato determina la qualità della risposta finale. for hit in hits: print(f"Trovato documento: {hit.payload['name']}, con punteggio: {hit.score}") print(f"Contenuto: {hit.payload['content']}") 

La lezione che abbiamo imparato (a nostre spese)

Implementare RAG non è un gioco da ragazzi. Ci siamo scontrati con problemi di chunking (come dividere i documenti senza perdere il contesto?), di ottimizzazione della ricerca vettoriale e di orchestrazione del flusso. Ma ogni "accrocchio" che abbiamo tirato su, ogni notte passata a fare debug, ci ha insegnato una cosa: la IA non è magia, è ingegneria. E con gli strumenti giusti, come RAG e Qdrant, si possono costruire sistemi che funzionano davvero. Non che fanno solo scena.

A Rosignano abbiamo visto clienti passare dalla frustrazione più totale all'avere un chatbot che finalmente rispondeva a tono, senza inventarsi le policy aziendali. Quella, per noi, è la vera innovazione. Non i titoloni sui giornali, ma un sistema che fa il suo sporco lavoro. E lo fa bene.