Update app.py

app.py

@@ -1,163 +1,117 @@
 import os
 import logging
-from rdflib import Graph
+from typing import Optional
 from pydantic import BaseModel
 from fastapi import FastAPI, HTTPException
 from huggingface_hub import InferenceClient
-from typing import Optional
+import rdflib
 
 # Configurazione logging
 logging.basicConfig(
-    level=logging.DEBUG,  # Livello di log aumentato per maggiori dettagli
+    level=logging.DEBUG,
     format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[
-        logging.FileHandler("app.log"),  # Log su file
-        logging.StreamHandler()          # Log su console
+        logging.FileHandler("app.log"),
+        logging.StreamHandler()
     ]
 )
 logger = logging.getLogger(__name__)
 
-# Configurazione API Hugging Face
+# =========================================
+# PARAMETRI BASE
+# =========================================
 API_KEY = os.getenv("HF_API_KEY")
 if not API_KEY:
     logger.error("HF_API_KEY non impostata nell'ambiente.")
     raise EnvironmentError("HF_API_KEY non impostata nell'ambiente.")
 
-client = InferenceClient(api_key=API_KEY)
-
-# File RDF
+# Nome del file RDF
 RDF_FILE = "Ontologia.rdf"
 
-####################################
-# Caricamento RDF (riassunto)
-####################################
-def load_rdf_summary() -> str:
+# Inizializza il client
+client = InferenceClient(api_key=API_KEY)
+
+# =========================================
+# Carica e Preprocessa l'Ontologia
+# =========================================
+def load_ontology_as_text(rdf_file: str, max_triples: int = 300) -> str:
     """
-    Carica un riassunto dell'ontologia dal file RDF.
-    Estrae le classi e le proprietà presenti nell'ontologia.
+    Legge l'ontologia dal file RDF e costruisce
+    una stringa "knowledge_text" con un numero limitato di triple,
+    per non sforare i limiti di contesto.
+    max_triples limita quante triple includere.
     """
-    logger.info("Inizio caricamento del file RDF.")
-    if not os.path.exists(RDF_FILE):
-        logger.error("Nessun file RDF trovato.")
+    if not os.path.exists(rdf_file):
         return "Nessun file RDF trovato."
 
+    g = rdflib.Graph()
     try:
-        g = Graph()
-        g.parse(RDF_FILE, format="xml")
-
-        classes = set()
-        properties = set()
-        for s, p, o in g.triples((None, None, None)):
-            if "Class" in str(o):
-                classes.add(s)
-            if "Property" in str(o):
-                properties.add(s)
-
-        class_summary = "\n".join([f"- Classe: {cls}" for cls in classes])
-        prop_summary  = "\n".join([f"- Proprietà: {prop}" for prop in properties])
-
-        summary = f"Classi:\n{class_summary}\n\nProprietà:\n{prop_summary}"
-        logger.info("Caricamento RDF completato con successo.")
-        return summary
+        g.parse(rdf_file, format="xml")
     except Exception as e:
-        logger.error(f"Errore durante il parsing del file RDF: {e}")
-        return "Errore nel caricamento del file RDF."
-
-rdf_context = load_rdf_summary()
-logger.debug(f"RDF Summary:\n{rdf_context}")
-
-####################################
-# Validazione SPARQL
-####################################
-def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
-    """
-    Verifica la validità della query SPARQL.
+        logger.error(f"Errore parsing RDF: {e}")
+        return "Errore parsing RDF."
+
+    # Convertiamo un certo numero di triple in stringa
+    knowledge_lines = []
+    count = 0
+    for s, p, o in g:
+        # Troncamento se necessario (evita di incollare 10.000 triple)
+        if count >= max_triples:
+            break
+        # Abbreviamo s, p, o se sono lunghi
+        s_str = str(s)[:200]
+        p_str = str(p)[:200]
+        o_str = str(o)[:200]
+        line = f"- {s_str} | {p_str} | {o_str}"
+        knowledge_lines.append(line)
+        count += 1
+
+    knowledge_text = "\n".join(knowledge_lines)
+    return knowledge_text
+
+# Carichiamo e preprocessiamo la knowledge
+knowledge_text = load_ontology_as_text(RDF_FILE, max_triples=600)  # Aumenta/diminuisci se serve
+
+# =========================================
+# Creazione Prompt di Sistema
+# =========================================
+def create_system_message(knowledge_text: str) -> str:
     """
-    logger.info("Inizio validazione della query SPARQL.")
-    g = Graph()
-    try:
-        g.parse(rdf_file_path, format="xml")
-        g.query(query)  # Solleva un'eccezione se la query non è valida
-        logger.info("Validazione della query SPARQL riuscita.")
-        return True
-    except Exception as e:
-        logger.error(f"Errore durante la validazione della query SPARQL: {e}")
-        return False
-
-####################################
-# Prompt di Sistema (Rafforzato)
-####################################
-def create_system_message(rdf_context: str) -> str:
+    Crea un prompt di sistema con l'ontologia (o una versione ridotta) inline,
+    obbligando il modello a cercare le info per la query SPARQL da qui.
     """
-    Crea il messaggio di sistema per il modello di linguaggio naturale.
-    Abbiamo rafforzato le istruzioni per gestire i literal con @it.
-    """
-    return f"""
-Sei un'assistente esperta nella generazione di query SPARQL basate su un'ontologia RDF,
-nell'interpretazione dei risultati delle query SPARQL in risposte naturali,
-e nel fare chatting minimale con i visitatori in diverse lingue (italiano, francese, inglese).
-
-In base alla domanda dell'utente, devi decidere se:
-  1) generare una query SPARQL
-  2) fornire una risposta naturale basata su una query SPARQL
-  3) rispondere con una chat minimale.
-
-ATTENZIONE IMPORTANTE:
-- L'ontologia è su: http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#
-- Alcuni literal (es. 'nomeOpera') hanno il tag di lingua '@it' (es. 'Amore e Psiche'@it).
-- Se vuoi confrontare una stringa come 'Amore e Psiche', DEVI usare:
-  - base:nomeOpera 'Amore e Psiche'@it
-  OPPURE
-  - un FILTER(STR(?label) = 'Amore e Psiche')
-  per ignorare il tag di lingua.
-- Se manca '@it', potresti non trovare risultati.
-
-Regole TASSATIVE:
-1. Se la domanda richiede una query SPARQL, restituisci SOLO la query SPARQL in testo semplice.
-2. Se la domanda richiede interpretazione di risultati, dai una risposta naturale che spieghi quei risultati.
-3. Se la domanda è una chat minimale, rispondi con una breve chat amichevole nella lingua dell'utente.
-4. DEVI usare ESCLUSIVAMENTE questo prefisso di base (e NON modificarlo in nessun modo):
+    # Nota: qui rafforziamo che deve SEMPRE consultare questi triple.
+    # E deve generare query SPARQL SOLO su questi triple, etc.
+    system_message = f"""
+Sei un assistente per un museo. Qui hai l'estratto dell'ontologia RDF in formato triple:
+(EntitaSoggetto, EntitaProprieta, EntitaOggetto).
+
+Devi usare ESCLUSIVAMENTE queste informazioni come knowledge base.
+
+Ecco la knowledge in forma di triple (max 600):
+{knowledge_text}
+
+REGOLE TASSATIVE:
+1. Se la domanda dell'utente richiede info su entità/opere ecc., DEVI generare una query SPARQL che si basa su questi triple.
+2. Se la domanda è chat semplice (saluto, ecc.), puoi rispondere brevemente, ma se serve una knowledge, la cerchi nei triple.
+3. Se i triple non contengono l'info, di' che non è disponibile.
+4. Il prefisso da usare:
    PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
-5. NON generare alcun altro prefisso o URI inventato.
-6. Se non riesci a rispondere con una query SPARQL, interpretare i risultati o fare chat,
-   scrivi: "Non posso generare una query SPARQL, interpretare i risultati o fare una risposta di chat per questa richiesta."
 
-Esempi:
-- Domanda: "Quali sono le statue esposte del periodo medievale?"
-  Risposta SPARQL:
-    PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
-    SELECT ?statua WHERE {{
-      ?statua a base:Statua ;
-              base:periodoStoricoOpera "Medioevo"@it .
-    }}
+5. Se hai generato la query e bisogna interpretare i risultati (es. autoreOpera?), puoi fornire la risposta. 
+   Ma l'info deve derivare dai triple sopra.
 
-- Domanda: "Ciao!"
-  Risposta (chat):
-    Ciao! Benvenuto al nostro museo. Come posso aiutarti oggi?
+Attenzione al fatto che le stringhe (es. <nomeOpera> ) possono avere @it o differenze minuscole/maiuscole. 
+Puoi usare FILTER( STR(?x) = "valore" ) se serve.
 
-- Domanda: "Da chi è stato scolpito Amore e Psiche?"
-  (Se devi confrontare 'Amore e Psiche' con tag @it)
-  Risposta SPARQL:
-    PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
-    SELECT ?autore WHERE {{
-      ?opera a base:Statua ;
-             base:nomeOpera "Amore e Psiche"@it ;
-             base:autoreOpera ?autore .
-    }}
-
-Ecco un riassunto dell'ontologia su cui devi lavorare:
-{rdf_context}
-
-RISPONDI ESCLUSIVAMENTE CON IL FORMATO SPECIFICATO.
-"""
+Buona fortuna!
+    """
+    return system_message
 
-####################################
-# Funzione per chiamare il modello
-####################################
+# =========================================
+# Funzione che chiama il modello
+# =========================================
 async def call_model(messages, temperature=0.7, max_tokens=2048):
-    """
-    Chiama il modello di linguaggio naturale con i messaggi forniti.
-    """
     logger.info("Chiamata al modello iniziata.")
     try:
         response = client.chat.completions.create(
@@ -165,120 +119,56 @@ async def call_model(messages, temperature=0.7, max_tokens=2048):
             messages=messages,
             temperature=temperature,
             max_tokens=max_tokens,
-            top_p=0.7,
+            top_p=0.9,  # puoi settare come vuoi
             stream=False
         )
         raw_text = response["choices"][0]["message"]["content"]
-        logger.debug(f"Risposta del modello ricevuta: {raw_text}")
-        # Rimuoviamo eventuali newline per forzare una singola riga
+        logger.debug(f"Risposta del modello: {raw_text}")
+        # Togli newline
         return raw_text.replace("\n", " ").strip()
     except Exception as e:
         logger.error(f"Errore durante la chiamata al modello: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-####################################
-# Funzione di Interpretazione dei Risultati SPARQL
-####################################
-async def interpret_sparql_results(results):
-    """
-    Invia i risultati delle query SPARQL al modello per ottenere una risposta naturale.
-    """
-    logger.info("Inizio interpretazione dei risultati SPARQL.")
-    if not results:
-        logger.info("Nessun risultato trovato per la query SPARQL.")
-        return "Mi dispiace, non sono riuscita a trovare le informazioni che stavi cercando."
-
-    # Converti i risultati in una stringa leggibile
-    results_str = "\n".join([
-        ", ".join([f"{k}: {v}" for k, v in row.asdict().items()])
-        for row in results
-    ])
-    logger.debug(f"Risultati SPARQL:\n{results_str}")
-
-    # Prompt per interpretare i risultati come una guida museale femminile
-    interpret_prompt = f"""
-Mi hai fornito i seguenti risultati di una query SPARQL:
-{results_str}
-
-Per favore, interpreta questi risultati e fornisci una risposta naturale ed enfatica
-come farebbe una guida museale femminile (in italiano).
-"""
+# =========================================
+# FASTAPI
+# =========================================
+from fastapi import FastAPI
 
-    messages = [
-        {"role": "system", "content": interpret_prompt},
-        {"role": "user", "content": ""}
-    ]
-    logger.info("Invio dei risultati SPARQL al modello per l'interpretazione.")
-    natural_response = await call_model(messages, temperature=0.7, max_tokens=2048)
-    logger.info(f"Risposta interpretata ricevuta dal modello: {natural_response}")
-    return natural_response
-
-####################################
-# FastAPI
-####################################
 app = FastAPI()
 
 class QueryRequest(BaseModel):
     message: str
-    max_tokens: int = 2048
-    temperature: float = 0.7
+    max_tokens: int = 1024
+    temperature: float = 0.5
 
 @app.post("/generate-response/")
-async def generate_response(request: QueryRequest):
-    user_msg = request.message
+async def generate_response(req: QueryRequest):
+    user_msg = req.message
     logger.info(f"Ricevuta richiesta: {user_msg}")
 
-    # 1) Generazione della risposta (SPARQL, INTERPRET o CHAT)
-    system_msg = create_system_message(rdf_context)
+    # 1) Creiamo un system_msg che contiene TUTTI i triple (preprocessati)
+    system_msg = create_system_message(knowledge_text)
+
     messages = [
         {"role": "system", "content": system_msg},
         {"role": "user", "content": user_msg}
     ]
-    response_text = await call_model(messages, request.temperature, request.max_tokens)
-    logger.info(f"Risposta generata dal modello: {response_text}")
 
-    # 2) Determinazione se la risposta è una query SPARQL
-    if response_text.startswith("PREFIX base:"):
-        sparql_query = response_text
-        logger.info("La risposta è stata identificata come una query SPARQL.")
+    # 2) Chiamiamo il modello
+    response_text = await call_model(
+        messages,
+        temperature=req.temperature,
+        max_tokens=req.max_tokens
+    )
 
-        # Validazione della query SPARQL
-        if validate_sparql_query(sparql_query, RDF_FILE):
-            logger.info("La query SPARQL è valida. Inizio esecuzione della query.")
-            try:
-                g = Graph()
-                g.parse(RDF_FILE, format="xml")
-                results = g.query(sparql_query)
-                logger.info(f"Query SPARQL eseguita con successo. Numero di risultati: {len(results)}")
-
-                # Interpreta i risultati in una risposta naturale
-                interpreted_response = await interpret_sparql_results(results)
-                logger.info(f"Risposta naturale interpretata: {interpreted_response}")
-                return {"type": "NATURAL", "response": interpreted_response}
-
-            except Exception as e:
-                logger.error(f"Errore durante l'esecuzione della query SPARQL: {e}")
-                return {
-                    "type": "ERROR",
-                    "response": "Mi dispiace, c'è stato un errore nell'esecuzione della tua richiesta."
-                }
-        else:
-            logger.warning("La query SPARQL generata non è valida.")
-            return {
-                "type": "ERROR",
-                "response": "La query SPARQL generata non è valida. Per favore, riprova con una domanda diversa."
-            }
-
-    elif "Non posso generare una query SPARQL" in response_text:
-        # Risposta di errore dal modello
-        logger.warning("Il modello ha risposto con un messaggio di errore.")
-        return {"type": "ERROR", "response": response_text}
+    logger.info(f"Risposta generata dal modello: {response_text}")
 
-    else:
-        # Presumiamo che sia una risposta naturale o di chat
-        logger.info("La risposta è stata identificata come una risposta naturale o di chat.")
-        return {"type": "NATURAL", "response": response_text}
+    # (Opzionale) Se vuoi, qui potresti controllare se la risposta inizia con "PREFIX base:"
+    # e se sì, eseguire su un Graph locale la query, interpretarla, ecc.
+    # Ma in questo esempio, ci fermiamo e inviamo la raw response:
+    return {"type": "NATURAL", "response": response_text}
 
 @app.get("/")
 async def root():
-    return {"message": "Server attivo e pronto a generare risposte!"}
+    return {"message": "Server con ontologia in prompt di sistema!"}