RAG Basics

FASE 1 — INDICIZZAZIONE (una tantum)
Documenti PDF → Divisione in chunk → Calcolo embeddings → Salvataggio nel database vettoriale

FASE 2 — RETRIEVAL (ad ogni domanda)
Domanda utente → Embedding della domanda → Ricerca semantica → Top-K chunk rilevanti

FASE 3 — GENERATION (ad ogni domanda)
Chunk trovati + Domanda originale → Prompt aumentato → Risposta con citazioni

def crea_chunk(testo, dimensione=500, sovrapposizione=50):
    """
    Spezza un documento in chunk con overlap.
    L'overlap garantisce che nessun concetto venga tagliato a metà.
    """
    parole = testo.split()
    chunk_lista = []

    inizio = 0
    while inizio < len(parole):
        fine = inizio + dimensione
        chunk = " ".join(parole[inizio:fine])
        chunk_lista.append(chunk)
        # Avanza meno della dimensione per creare sovrapposizione
        inizio += dimensione - sovrapposizione

    return chunk_lista


# Esempio: linea guida ipertensione (circa 3000 parole)
with open("linea_guida_ipertensione.txt", "r") as file:
    testo_completo = file.read()

chunk = crea_chunk(testo_completo, dimensione=500, sovrapposizione=50)
print(f"Documento diviso in {len(chunk)} chunk")
# Risultato: circa 7 chunk con sovrapposizione

from openai import OpenAI

client = OpenAI(api_key="sk-la-tua-chiave")

def calcola_embedding(testo):
    """Converte un testo in un vettore numerico di 1536 dimensioni."""
    risposta = client.embeddings.create(
        model="text-embedding-3-small",
        input=testo
    )
    return risposta.data[0].embedding


# Indicizza tutti i chunk
database_vettoriale = []
for i, chunk in enumerate(chunk):
    vettore = calcola_embedding(chunk)
    database_vettoriale.append({
        "id": i,
        "testo": chunk,
        "embedding": vettore,
        "fonte": "linea_guida_ipertensione.pdf"
    })

print(f"Indicizzati {len(database_vettoriale)} chunk")

import numpy as np

def coseno_similarita(vec_a, vec_b):
    """Calcola la similarità tra due vettori (0 = diversi, 1 = identici)."""
    return np.dot(vec_a, vec_b) / (np.linalg.norm(vec_a) * np.linalg.norm(vec_b))

def cerca_e_rispondi(domanda, database, top_k=3):
    """Pipeline completa: ricerca semantica + generazione con contesto."""
    # Fase 2: Retrieval
    embedding_domanda = calcola_embedding(domanda)

    # Calcola similarità con ogni chunk
    risultati = []
    for record in database:
        score = coseno_similarita(embedding_domanda, record["embedding"])
        risultati.append((score, record))

    # Prendi i top-K chunk più rilevanti
    risultati.sort(key=lambda x: x[0], reverse=True)
    chunk_rilevanti = risultati[:top_k]

    # Costruisci il contesto
    contesto = ""
    for score, record in chunk_rilevanti:
        contesto += f"[Fonte: {record['fonte']}]\n{record['testo']}\n\n"

    # Fase 3: Generation con contesto
    risposta = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": """Rispondi SOLO in base al contesto fornito.
Se il contesto non contiene la risposta, dì "Non ho trovato informazioni su questo argomento nelle linee guida."
Cita sempre la fonte tra parentesi quadre."""},
            {"role": "user", "content": f"Contesto:\n{contesto}\nDomanda: {domanda}"}
        ]
    )

    return risposta.choices[0].message.content


# Uso reale nell'ambulatorio
risposta = cerca_e_rispondi(
    "Qual è il dosaggio iniziale consigliato per l'ipertensione resistente?",
    database_vettoriale
)
print(risposta)
# "Secondo le linee guida [linea_guida_ipertensione.pdf], il dosaggio
#  iniziale consigliato è..."

1. DIMENSIONE CHUNK: 300-500 parole è il range ottimale per la maggior parte dei documenti.
   Troppo piccolo = contesto perso. Troppo grande = rumore.

2. OVERLAP: 10-15% della dimensione del chunk. Garantisce che concetti
   a cavallo tra due chunk non vengano persi.

3. METADATA: Aggiungi fonte, data, categoria a ogni chunk. Permette di
   filtrare i risultati (es. "solo linee guida aggiornate dopo il 2024").

4. RELEVANCE THRESHOLD: Non usare tutti i top-K. Scarta i chunk con
   similarità sotto 0.75 — meglio dire "non so" che rispondere male.