Update app.py

app.py

@@ -17,7 +17,7 @@ load_dotenv()
 
 # Configura il logging
 logging.basicConfig(
-    level=logging.INFO,  # Ridotto da DEBUG per migliorare le prestazioni
+    level=logging.INFO,  # Mantiene INFO per ambiente di produzione
     format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[logging.FileHandler("app.log"), logging.StreamHandler()]
 )
@@ -34,118 +34,56 @@ BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 RDF_FILE = os.path.join(BASE_DIR, "Ontologia.rdf")
 HF_MODEL = "Qwen/Qwen2.5-72B-Instruct"  # Modello ottimizzato per seguire istruzioni
 
-MAX_CLASSES = 30
-MAX_PROPERTIES = 30
-
 # Percorsi dei file generati
 DOCUMENTS_FILE = os.path.join(BASE_DIR, "data", "documents.json")
 FAISS_INDEX_FILE = os.path.join(BASE_DIR, "data", "faiss.index")
 
+# Carica il modello di embedding una sola volta per migliorare le prestazioni
+try:
+    embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+    logger.info("Modello SentenceTransformer caricato con successo.")
+except Exception as e:
+    logger.error(f"Errore nel caricamento del modello SentenceTransformer: {e}")
+    raise e
+
 def create_data_directory():
     """Crea la directory 'data/' se non esiste."""
     os.makedirs(os.path.join(BASE_DIR, "data"), exist_ok=True)
     logger.info("Directory 'data/' creata o già esistente.")
 
-def extract_ontology(rdf_file: str, output_file: str):
+def extract_lines(rdf_file: str, output_file: str):
     """
-    Estrae classi, proprietà ed entità dall'ontologia RDF e le salva in un file JSON come un unico documento.
+    Estrae ogni riga dell'ontologia RDF e la salva in un file JSON.
+    Questo permette di indicizzare ogni riga singolarmente.
     """
-    logger.info(f"Inizio estrazione dell'ontologia da {rdf_file}.")
-    g = rdflib.Graph()
-    try:
-        g.parse(rdf_file, format="xml")
-        logger.info(f"Parsing RDF di {rdf_file} riuscito.")
-    except Exception as e:
-        logger.error(f"Errore nel parsing RDF: {e}")
-        raise e
-
-    # Estrai Classi
-    classes = []
-    for cls in g.subjects(RDF.type, OWL.Class):
-        label = g.value(cls, RDFS.label, default=str(cls))
-        description = g.value(cls, RDFS.comment, default="No description.")
-        classes.append({"class": str(cls), "label": str(label), "description": str(description)})
-
-    for cls in g.subjects(RDF.type, RDFS.Class):
-        label = g.value(cls, RDFS.label, default=str(cls))
-        description = g.value(cls, RDFS.comment, default="No description.")
-        classes.append({"class": str(cls), "label": str(label), "description": str(description)})
-
-    # Estrai Proprietà
-    properties = []
-    for prop in g.subjects(RDF.type, OWL.ObjectProperty):
-        label = g.value(prop, RDFS.label, default=str(prop))
-        description = g.value(prop, RDFS.comment, default="No description.")
-        properties.append({"property": str(prop), "label": str(label), "description": str(description)})
-
-    for prop in g.subjects(RDF.type, OWL.DatatypeProperty):
-        label = g.value(prop, RDFS.label, default=str(prop))
-        description = g.value(prop, RDFS.comment, default="No description.")
-        properties.append({"property": str(prop), "label": str(label), "description": str(description)})
-
-    for prop in g.subjects(RDF.type, RDF.Property):
-        label = g.value(prop, RDFS.label, default=str(prop))
-        description = g.value(prop, RDFS.comment, default="No description.")
-        properties.append({"property": str(prop), "label": str(label), "description": str(description)})
-
-    # Estrai Entità (NamedIndividuals)
-    entities = []
-    for entity in g.subjects(RDF.type, OWL.NamedIndividual):
-        label = g.value(entity, RDFS.label, default=str(entity))
-        description = g.value(entity, RDFS.comment, default="No description.")
-        # Se l'etichetta è un URI, estrai il fragment
-        if isinstance(label, URIRef):
-            label = label.split('#')[-1].replace('_', ' ')
-        else:
-            label = str(label)
-        # Estrai le proprietà dell'entità
-        entity_properties = {}
-        for predicate, obj in g.predicate_objects(entity):
-            if predicate not in [RDFS.label, RDFS.comment]:
-                entity_properties[str(predicate)] = str(obj)
-        entities.append({
-            "entity": str(entity),
-            "label": str(label),
-            "description": str(description),
-            "properties": entity_properties
-        })
-
-    # Crea un unico documento
-    ontology_summary = {
-        "title": "Ontologia Museo",
-        "classes": classes[:MAX_CLASSES],
-        "properties": properties[:MAX_PROPERTIES],
-        "entities": entities,  # Aggiungi le entità
-        "full_ontology": g.serialize(format="xml").decode('utf-8') if isinstance(g.serialize(format="xml"), bytes) else g.serialize(format="xml")  # Decodifica rimossa
-    }
-
-    # Salva il documento in JSON
+    logger.info(f"Inizio estrazione delle linee dall'ontologia da {rdf_file}.")
     try:
+        with open(rdf_file, "r", encoding="utf-8") as f:
+            lines = f.readlines()
+        # Rimuovi spazi vuoti e newline
+        lines = [line.strip() for line in lines if line.strip()]
+        # Salva come lista di documenti
         with open(output_file, "w", encoding="utf-8") as f:
-            json.dump(ontology_summary, f, ensure_ascii=False, indent=2)
-        logger.info(f"Ontologia estratta e salvata in {output_file}")
+            json.dump({"lines": lines}, f, ensure_ascii=False, indent=2)
+        logger.info(f"Linee estratte e salvate in {output_file}")
     except Exception as e:
-        logger.error(f"Errore nel salvataggio di {output_file}: {e}")
+        logger.error(f"Errore nell'estrazione delle linee: {e}")
         raise e
 
-def create_faiss_index(documents_file: str, index_file: str, embedding_model: str = 'all-MiniLM-L6-v2'):
+def create_faiss_index(documents_file: str, index_file: str, embedding_model_instance: SentenceTransformer):
     """
-    Crea un indice FAISS a partire dal documento estratto.
+    Crea un indice FAISS a partire dalle linee estratte.
     """
     logger.info(f"Inizio creazione dell'indice FAISS da {documents_file}.")
     try:
         # Carica il documento
         with open(documents_file, "r", encoding="utf-8") as f:
             document = json.load(f)
-        logger.info(f"Documento caricato da {documents_file}.")
+        lines = document['lines']
+        logger.info(f"{len(lines)} linee caricate da {documents_file}.")
 
         # Genera embedding
-        model = SentenceTransformer(embedding_model)
-        # Concatenazione delle classi, proprietà e entità per l'embedding
-        texts = [f"Classe: {cls['label']}. Descrizione: {cls['description']}" for cls in document['classes']]
-        texts += [f"Proprietà: {prop['label']}. Descrizione: {prop['description']}" for prop in document['properties']]
-        texts += [f"Entità: {entity['label']}. Descrizione: {entity['description']}. Proprietà: {entity['properties']}" for entity in document.get('entities', [])]
-        embeddings = model.encode(texts, convert_to_numpy=True)
+        embeddings = embedding_model_instance.encode(lines, convert_to_numpy=True, show_progress_bar=True)
         logger.info("Embedding generati con SentenceTransformer.")
 
         # Crea l'indice FAISS
@@ -161,7 +99,7 @@ def create_faiss_index(documents_file: str, index_file: str, embedding_model: st
         logger.error(f"Errore nella creazione dell'indice FAISS: {e}")
         raise e
 
-def prepare_retrieval():
+def prepare_retrieval(embedding_model_instance: SentenceTransformer):
     """Prepara i file necessari per l'approccio RAG."""
     logger.info("Inizio preparazione per il retrieval.")
     create_data_directory()
@@ -175,11 +113,11 @@ def prepare_retrieval():
 
     # Verifica se documents.json esiste, altrimenti generarlo
     if not os.path.exists(DOCUMENTS_FILE):
-        logger.info(f"File {DOCUMENTS_FILE} non trovato. Estrazione dell'ontologia.")
+        logger.info(f"File {DOCUMENTS_FILE} non trovato. Estrazione delle linee dell'ontologia.")
         try:
-            extract_ontology(RDF_FILE, DOCUMENTS_FILE)
+            extract_lines(RDF_FILE, DOCUMENTS_FILE)
         except Exception as e:
-            logger.error(f"Errore nell'estrazione dell'ontologia: {e}")
+            logger.error(f"Errore nell'estrazione delle linee: {e}")
             raise e
     else:
         logger.info(f"File {DOCUMENTS_FILE} trovato.")
@@ -188,144 +126,80 @@ def prepare_retrieval():
     if not os.path.exists(FAISS_INDEX_FILE):
         logger.info(f"File {FAISS_INDEX_FILE} non trovato. Creazione dell'indice FAISS.")
         try:
-            create_faiss_index(DOCUMENTS_FILE, FAISS_INDEX_FILE)
+            create_faiss_index(DOCUMENTS_FILE, FAISS_INDEX_FILE, embedding_model_instance)
         except Exception as e:
             logger.error(f"Errore nella creazione dell'indice FAISS: {e}")
             raise e
     else:
         logger.info(f"File {FAISS_INDEX_FILE} trovato.")
 
-def extract_classes_and_properties(rdf_file: str) -> str:
-    """
-    Carica l'ontologia e crea un 'sunto' di Classi, Proprietà ed Entità
-    (senza NamedIndividuals) per ridurre i token.
-    """
-    logger.info(f"Inizio estrazione di classi, proprietà ed entità da {rdf_file}.")
-    g = rdflib.Graph()
-    try:
-        g.parse(rdf_file, format="xml")
-        logger.info(f"Parsing RDF di {rdf_file} riuscito.")
-    except Exception as e:
-        logger.error(f"Errore nel parsing RDF: {e}")
-        return "PARSING_ERROR"
-
-    # Troviamo le classi
-    classes_found = set()
-    for s in g.subjects(RDF.type, OWL.Class):
-        classes_found.add(s)
-    for s in g.subjects(RDF.type, RDFS.Class):
-        classes_found.add(s)
-    classes_list = sorted(str(c) for c in classes_found)
-    classes_list = classes_list[:MAX_CLASSES]
-
-    # Troviamo le proprietà
-    props_found = set()
-    for p in g.subjects(RDF.type, OWL.ObjectProperty):
-        props_found.add(p)
-    for p in g.subjects(RDF.type, OWL.DatatypeProperty):
-        props_found.add(p)
-    for p in g.subjects(RDF.type, RDF.Property):
-        props_found.add(p)
-    props_list = sorted(str(x) for x in props_found)
-    props_list = props_list[:MAX_PROPERTIES]
-
-    # Troviamo le entità
-    entities_found = set()
-    for e in g.subjects(RDF.type, OWL.NamedIndividual):
-        entities_found.add(e)
-    entities_list = sorted(str(e) for e in entities_found)
-    entities_list = entities_list[:MAX_CLASSES]  # Puoi impostare un limite adeguato
-
-    txt_classes = "\n".join([f"- CLASSE: {c}" for c in classes_list])
-    txt_props = "\n".join([f"- PROPRIETÀ: {p}" for p in props_list])
-    txt_entities = "\n".join([f"- ENTITÀ: {e}" for e in entities_list])
-
-    summary = f"""\
-# CLASSI (max {MAX_CLASSES})
-{txt_classes}
-# PROPRIETÀ (max {MAX_PROPERTIES})
-{txt_props}
-# ENTITÀ (max {MAX_CLASSES})
-{txt_entities}
-"""
-    logger.info("Estrazione di classi, proprietà ed entità completata.")
-    return summary
-
-def retrieve_relevant_documents(query: str, top_k: int = 5):
-    """Recupera i documenti rilevanti usando FAISS."""
-    logger.info(f"Recupero dei documenti rilevanti per la query: {query}")
+def retrieve_relevant_lines(query: str, top_k: int = 5, embedding_model_instance: SentenceTransformer = None):
+    """Recupera le linee rilevanti usando FAISS."""
+    logger.info(f"Recupero delle linee rilevanti per la query: {query}")
     try:
         # Carica il documento
         with open(DOCUMENTS_FILE, "r", encoding="utf-8") as f:
             document = json.load(f)
-        logger.info(f"Documento caricato da {DOCUMENTS_FILE}.")
+        lines = document['lines']
+        logger.info(f"{len(lines)} linee caricate da {DOCUMENTS_FILE}.")
 
         # Carica l'indice FAISS
         index = faiss.read_index(FAISS_INDEX_FILE)
         logger.info(f"Indice FAISS caricato da {FAISS_INDEX_FILE}.")
 
         # Genera embedding della query
-        model = SentenceTransformer('all-MiniLM-L6-v2')
-        query_embedding = model.encode([query], convert_to_numpy=True)
+        if embedding_model_instance is None:
+            embedding_model_instance = SentenceTransformer('all-MiniLM-L6-v2')
+            logger.info("Modello SentenceTransformer caricato per l'embedding della query.")
+
+        query_embedding = embedding_model_instance.encode([query], convert_to_numpy=True)
         logger.info("Embedding della query generati.")
 
         # Ricerca nell'indice
         distances, indices = index.search(query_embedding, top_k)
         logger.info(f"Ricerca FAISS completata. Risultati ottenuti: {len(indices[0])}")
 
-        # Concatenazione delle descrizioni per la ricerca
-        texts = [f"Classe: {cls['label']}. Descrizione: {cls['description']}" for cls in document['classes']]
-        texts += [f"Proprietà: {prop['label']}. Descrizione: {prop['description']}" for prop in document['properties']]
-        texts += [f"Entità: {entity['label']}. Descrizione: {entity['description']}. Proprietà: {entity['properties']}" for entity in document.get('entities', [])]
-
-        # Recupera i testi rilevanti
-        relevant_texts = [texts[idx] for idx in indices[0] if idx < len(texts)]
+        # Recupera le linee rilevanti
+        relevant_texts = [lines[idx] for idx in indices[0] if idx < len(lines)]
         retrieved_docs = "\n".join(relevant_texts)
-        logger.info(f"Documenti rilevanti recuperati: {len(relevant_texts)}")
+        logger.info(f"Linee rilevanti recuperate: {len(relevant_texts)}")
         return retrieved_docs
     except Exception as e:
-        logger.error(f"Errore nel recupero dei documenti rilevanti: {e}")
+        logger.error(f"Errore nel recupero delle linee rilevanti: {e}")
         raise e
 
-def create_system_message(ont_text: str, retrieved_docs: str) -> str:
+def create_system_message(retrieved_docs: str) -> str:
     """
     Prompt di sistema robusto, con regole su query in una riga e
     informazioni recuperate tramite RAG.
     """
-    return f"""\
-### Istruzioni ###
+    return f"""### Istruzioni ###
 Sei un assistente museale esperto in ontologie RDF. Utilizza le informazioni fornite per generare query SPARQL precise e pertinenti.
 
 ### Ontologia ###
-{ont_text}
-### FINE Ontologia ###
-
-Ecco alcune informazioni rilevanti recuperate dalla base di conoscenza:
 {retrieved_docs}
+### FINE Ontologia ###
 
 ### Regole Stringenti ###
 1) Se l'utente chiede informazioni su questa ontologia, genera SEMPRE una query SPARQL in UNA SOLA RIGA, con prefix:
-   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettomuseo#>
-2) La query SPARQL deve essere precisa e cercare esattamente le entità specificate dall'utente. Ad esempio, se l'utente chiede "Chi ha creato l'opera 'Amore e Psiche'?", la query dovrebbe cercare l'opera esattamente con quel nome.
+   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
+2) La query SPARQL deve essere precisa e cercare esattamente le entità specificate dall'utente. Ad esempio, se l'utente chiede "Chi ha creato l'opera 'Amore e Psiche'?", la query dovrebbe cercere l'opera esattamente con quel nome.
 3) Se la query produce 0 risultati o fallisce, ritenta con un secondo tentativo.
-4) Se la domanda è generica (tipo 'Ciao, come stai?'), rispondi breve.
+4) Se la domanda è generica (tipo 'Ciao, come stai?'), rispondi brevemente.
 5) Se trovi risultati, la risposta finale deve essere la query SPARQL (una sola riga).
 6) Se non trovi nulla, rispondi con 'Nessuna info.'
-7) Non multiline. Esempio: PREFIX base: <...> SELECT ?x WHERE {{ ... }}.
+7) Non multiline. Esempio: PREFIX base: <...> SELECT ?x WHERE { ... }.
 Esempio:
 Utente: Chi ha creato l'opera 'Amore e Psiche'?
-Risposta: PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettomuseo#> SELECT ?creatore WHERE {{ ?opera base:hasName "Amore e Psiche" . ?opera base:creatoDa ?creatore . }}
-FINE REGOLE
+Risposta: PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?creatore WHERE { ?opera base:hasName "Amore e Psiche" . ?opera base:creatoDa ?creatore . }
+### FINE REGOLE ###
 
 ### Conversazione ###
-Utente: che ore sono?
-Assistente:
 """
 
 def create_explanation_prompt(results_str: str) -> str:
     """Prompt per generare una spiegazione museale dei risultati SPARQL."""
-    return f"""\
-Ho ottenuto questi risultati SPARQL:
+    return f"""Ho ottenuto questi risultati SPARQL:
 {results_str}
 Ora fornisci una breve spiegazione museale (massimo ~10 righe), senza inventare oltre i risultati.
 """
@@ -377,22 +251,21 @@ async def call_hf_model(prompt: str, temperature: float = 0.5, max_tokens: int =
 # Variabile globale per le etichette delle entità
 entity_labels: List[str] = []
 
-def load_entity_labels(documents_file: str):
-    """Carica le etichette delle entità dal file documents.json."""
+def load_entity_labels(rdf_file: str):
+    """Carica le etichette delle entità dall'ontologia RDF."""
     global entity_labels
     try:
-        with open(documents_file, "r", encoding="utf-8") as f:
-            document = json.load(f)
-        # Estrai etichette vere e proprie
-        entity_labels = []
-        for entity in document.get('entities', []):
-            label = entity.get('label', '')
-            if label.startswith("http://") or label.startswith("https://"):
-                # Estrai il fragment dell'URI
+        g = rdflib.Graph()
+        g.parse(rdf_file, format="xml")
+        entities = set()
+        for s in g.subjects(RDF.type, OWL.NamedIndividual):
+            label = g.value(s, RDFS.label, default=str(s))
+            if isinstance(label, URIRef):
                 label = label.split('#')[-1].replace('_', ' ')
             else:
-                label = label.replace('_', ' ')
-            entity_labels.append(label.lower())
+                label = str(label)
+            entities.add(label.lower())
+        entity_labels = list(entities)
         logger.info(f"Elenco delle etichette delle entità caricato: {entity_labels}")
     except Exception as e:
         logger.error(f"Errore nel caricamento delle etichette delle entità: {e}")
@@ -408,21 +281,13 @@ def is_ontology_related(query: str) -> bool:
         return True
     return False
 
-# Prepara i file necessari per RAG
-prepare_retrieval()
-
-# Carica il 'sunto' di classi, proprietà ed entità
-knowledge_text = extract_classes_and_properties(RDF_FILE)
-
-# Carica le etichette delle entità
-load_entity_labels(DOCUMENTS_FILE)
-
 app = FastAPI()
 
 class QueryRequest(BaseModel):
     message: str
-    max_tokens: int = 150  # Ridotto per risposte concise
+    max_tokens: int = 512  # Aumentato per risposte più dettagliate
     temperature: float = 0.5
+
 @app.post("/generate-response/")
 async def generate_response(req: QueryRequest):
     user_input = req.message
@@ -445,13 +310,13 @@ async def generate_response(req: QueryRequest):
             }
 
     try:
-        # Recupera documenti rilevanti usando RAG
-        retrieved_docs = retrieve_relevant_documents(user_input, top_k=3)
+        # Recupera linee rilevanti usando FAISS
+        retrieved_docs = retrieve_relevant_lines(user_input, top_k=5, embedding_model_instance=embedding_model)
     except Exception as e:
-        logger.error(f"Errore nel recupero dei documenti rilevanti: {e}")
-        return {"type": "ERROR", "response": f"Errore nel recupero dei documenti: {e}"}
+        logger.error(f"Errore nel recupero delle linee rilevanti: {e}")
+        return {"type": "ERROR", "response": f"Errore nel recupero delle linee: {e}"}
 
-    sys_msg = create_system_message(knowledge_text, retrieved_docs)
+    sys_msg = create_system_message(retrieved_docs)
     prompt = f"{sys_msg}\nUtente: {user_input}\nAssistente:"
 
     # Primo tentativo
@@ -512,12 +377,13 @@ async def generate_response(req: QueryRequest):
             return {"type": "ERROR", "response": f"Errore durante il fallback della risposta: {e}"}
 
     if len(results) == 0:
-        return {"type": "NATURAL", "sparql_query": sparql_query, "response": "Nessun risultato."}
+        return {"type": "NATURAL", "sparql_query": sparql_query, "response": "Nessuna info."}
 
     # Confeziona risultati
     row_list = []
     for row in results:
-        row_dict = row.asdict()
+        # Converti il risultato della query in un dizionario
+        row_dict = dict(row)
         row_str = ", ".join([f"{k}: {v}" for k, v in row_dict.items()])
         row_list.append(row_str)
     results_str = "\n".join(row_list)
@@ -540,3 +406,13 @@ async def generate_response(req: QueryRequest):
 @app.get("/")
 def home():
     return {"message": "Assistente Museale con supporto SPARQL."}
+
+# Avvia la preparazione al caricamento delle linee e indicizzazione
+try:
+    create_data_directory()
+    prepare_retrieval(embedding_model)
+    load_entity_labels(RDF_FILE)
+    logger.info("Applicazione avviata e pronta per ricevere richieste.")
+except Exception as e:
+    logger.error(f"Errore durante la preparazione dell'applicazione: {e}")
+    raise e