Recupero e Generazione
In questa pagina
Dal Vettore alla Risposta
Sai come indicizzare i documenti e recuperare quelli più vicini a una domanda. Resta un ultimo passo: trasformare una lista di chunk in una risposta leggibile. Questo significa iniettare il contesto recuperato in un prompt affinché l’LLM formuli una risposta basata sui tuoi dati piuttosto che sulla sua memoria di addestramento. Bastano poche righe di codice, ma fanno una differenza decisiva nella qualità. Un contesto ben presentato e un’istruzione chiara contano tanto quanto la precisione del recupero.
Costruire il Prompt RAG
La struttura del prompt è semplice, ma ogni scelta ha delle conseguenze. Numera i chunk e annota la loro fonte in modo che il modello possa citare con precisione. Separa i chunk con un delimitatore visibile, ---, affinché il modello non fonda due documenti contraddittori in un’unica affermazione. Soprattutto, l’istruzione deve limitare esplicitamente la risposta al contesto fornito e permettere al modello di dire che non lo sa. Senza questo permesso, un LLM interrogato su informazioni mancanti colmerà il vuoto con qualsiasi cosa sembri plausibile. Questo è proprio il meccanismo dell’allucinazione.
def build_rag_prompt(question, retrieved_chunks):
"""Costruisce il prompt RAG con il contesto recuperato."""
# Formatta il contesto
context_parts = []
for i, chunk in enumerate(retrieved_chunks):
source = chunk.get("source", "fonte sconosciuta")
context_parts.append(f"[Documento {i+1} - {source}]\n{chunk['text']}")
context = "\n\n---\n\n".join(context_parts)
prompt = f"""Sei un assistente esperto. Rispondi alla domanda usando
SOLO il contesto fornito di seguito. Se l'informazione non è nel
contesto, dillo chiaramente.
## Contesto
{context}
## Domanda
{question}
## Risposta"""
return prompt
Generare la Risposta
La chiamata di generazione è diretta: un messaggio di sistema che ribadisce il ruolo e un messaggio utente che trasporta il prompt assemblato. Fai attenzione al parametro temperature, impostato qui a 0.1. Nella scrittura creativa vuoi varietà; nel RAG vuoi l’opposto. Vuoi che il modello rimanga il più possibile aderente a ciò che dice il contesto e vuoi che due esecuzioni sulla stessa domanda producano la stessa risposta. Una temperature alta spingerebbe il modello a riformulare, estrapolare e allontanarsi dalla fonte.
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
def generate_answer(question, retrieved_chunks, model="mistral-large-latest"):
"""Genera una risposta RAG con Mistral."""
prompt = build_rag_prompt(question, retrieved_chunks)
response = client.chat.complete(
model=model,
messages=[
{
"role": "system",
"content": "Sei un assistente preciso che risponde basandosi sul contesto fornito."
},
{
"role": "user",
"content": prompt,
}
],
temperature=0.1, # Temperatura bassa per risposte fattuali
)
return response.choices[0].message.content
# Esempio
question = "Quali sono i passaggi principali del RAG?"
results = search_index(question, index, chunks, k=3)
answer = generate_answer(question, results)
print(answer)
Incapsulare il Flusso in una Classe
Funzioni sparse funzionano per l’esplorazione, non per la produzione. La classe RAGPipeline raggruppa lo stato—i chunk, la matrice degli embedding e l’indice FAISS costruito una volta all’istanziazione—e tre operazioni: retrieve codifica la domanda e interroga l’indice, generate assembla il prompt e chiama il modello, e ask concatena le due. Nota cosa restituisce ask: non una stringa, ma un dizionario contenente la risposta, la lista delle fonti e il numero di chunk utilizzati. Questa tracciabilità è ciò che separa un assistente verificabile da una scatola nera. Il giorno in cui un utente contesta una risposta, saprai su quali passaggi si è basata.
import numpy as np
import faiss
from mistralai.client import Mistral
client = Mistral(api_key=api_key)
class RAGPipeline:
"""Pipeline RAG completa con Mistral e FAISS."""
def __init__(self, chunks, embeddings):
self.chunks = chunks
self.embeddings = embeddings.astype(np.float32)
# Crea l'indice FAISS
dimension = embeddings.shape[1]
self.index = faiss.IndexFlatL2(dimension)
self.index.add(self.embeddings)
def retrieve(self, question, k=3):
"""Passaggio 1: recupera i chunk rilevanti."""
response = client.embeddings.create(
model="mistral-embed",
inputs=[question],
)
query_vector = np.array(
[response.data[0].embedding], dtype=np.float32
)
distances, indices = self.index.search(query_vector, k)
results = []
for dist, idx in zip(distances[0], indices[0]):
if idx >= 0:
results.append({
"text": self.chunks[idx]["text"],
"source": self.chunks[idx].get("source", ""),
"distance": float(dist),
})
return results
def generate(self, question, context_chunks):
"""Passaggio 2: genera la risposta con il contesto."""
prompt = build_rag_prompt(question, context_chunks)
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1,
)
return response.choices[0].message.content
def ask(self, question, k=3):
"""Pipeline completa: domanda -> risposta con fonti."""
# Recupero
context = self.retrieve(question, k=k)
# Generazione
answer = self.generate(question, context)
return {
"question": question,
"answer": answer,
"sources": [c["source"] for c in context],
"n_chunks_used": len(context),
}
# Utilizzo
rag = RAGPipeline(chunks, embeddings)
result = rag.ask("Come funziona l'indicizzazione in FAISS?")
print(f"Domanda: {result['question']}")
print(f"Risposta: {result['answer']}")
print(f"Fonti: {result['sources']}")
Tre Varianti di Prompt per Caso d’Uso
Puoi specializzare il prompt di base in base a ciò che ti aspetti dall’assistente. Se i tuoi utenti devono verificare ogni affermazione, chiedi esplicitamente citazioni tra parentesi. Il modello allega così ogni frase a un documento numerato. Se la risposta alimenta un’interfaccia o un report, un formato strutturato impone sezioni stabili: una risposta concisa, dettagli, fonti e un livello di confidenza che riflette quanto bene il contesto copra la domanda. La terza variante svolge un ruolo diverso: insegna al modello a scomporre l’incertezza distinguendo ciò che può affermare, ciò che manca e dove cercare successivamente. Questo produce spesso gli assistenti più utili nella pratica, perché “Mi manca X” vale più di una risposta sicura ma errata.
# 1. Prompt con istruzione di citazione
prompt_cite = """Rispondi citando i documenti fonte tra parentesi.
Esempio: "Il RAG migliora l'accuratezza [Documento 1]."
Contesto: {context}
Domanda: {question}"""
# 2. Prompt con formato strutturato
prompt_structured = """Rispondi nel seguente formato:
**Risposta**: [la tua risposta concisa]
**Dettagli**: [spiegazione dettagliata]
**Fonti**: [lista dei documenti utilizzati]
**Confidenza**: [alta/media/bassa in base alla copertura del contesto]
Contesto: {context}
Domanda: {question}"""
# 3. Prompt con gestione delle informazioni mancanti
prompt_honest = """Se il contesto non contiene informazioni sufficienti per
rispondere completamente, dichiara chiaramente:
- Cosa puoi affermare con certezza
- Cosa manca nel contesto
- Suggerimenti per ottenere le informazioni mancanti
Contesto: {context}
Domanda: {question}"""
Dal lato dei parametri di chiamata, tre impostazioni governano il comportamento del RAG. Una temperature bassa blocca l’output fattuale, max_tokens impedisce risposte che degenerano in saggi e un top_p conservativo restringe il vocabolario campionato alle continuazioni più probabili.
# Per il RAG, usa una temperatura bassa
response = client.chat.complete(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}],
temperature=0.1, # Fattuale, bassa creatività
max_tokens=1024, # Limita la lunghezza della risposta
top_p=0.95, # Campionamento del nucleo conservativo
)
Punti chiave
- Il prompt RAG inietta il contesto recuperato prima della domanda
- Usa una temperatura bassa (0.1–0.3) per risposte fattuali
- Chiedi al modello di citare le fonti per la tracciabilità
- La classe RAGPipeline incapsula l’intero flusso: retrieve, generate, ask
- Gestisci i casi in cui il contesto non contiene informazioni sufficienti