Update app.py

app.py

@@ -45,14 +45,11 @@ def load_rdf_summary() -> str:
         g = Graph()
         g.parse(RDF_FILE, format="xml")
 
-        # Estrazione semplificata di classi e proprietà
         classes = set()
         properties = set()
         for s, p, o in g.triples((None, None, None)):
-            # Se l'oggetto è 'Class', lo aggiungiamo a classes
             if "Class" in str(o):
                 classes.add(s)
-            # Se l'oggetto è 'Property', lo aggiungiamo a properties
             if "Property" in str(o):
                 properties.add(s)
 
@@ -88,68 +85,68 @@ def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
         return False
 
 ####################################
-# Prompt di Sistema
+# Prompt di Sistema (Rafforzato)
 ####################################
 def create_system_message(rdf_context: str) -> str:
     """
     Crea il messaggio di sistema per il modello di linguaggio naturale.
-    NOTA: Cambiato il prefisso per riflettere la tua ontologia 'progettoMuseo#'.
+    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 (ad esempio, italiano, francese, inglese).
+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 per interrogare la base di conoscenza.
-2. Fornire una risposta naturale basata sui risultati di una query SPARQL.
-3. Rispondere con una risposta di chat minimale nella stessa lingua dell'utente.
-
-Ecco un riassunto dell'ontologia su cui devi lavorare:
-{rdf_context}
+  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 la query SPARQL come testo semplice.
-2. Se la domanda richiede l'interpretazione di risultati SPARQL, restituisci una risposta naturale basata sui risultati.
-3. Se la domanda è una chat minimale, restituisci una risposta di chat nella stessa lingua dell'utente.
+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):
    PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
 5. NON generare alcun altro prefisso o URI inventato.
-6. Se non puoi rispondere con una query SPARQL valida, interpretare i risultati
-   o fare chatting, scrivi:
-   "Non posso generare una query SPARQL, interpretare i risultati o fare una risposta di chat per questa richiesta."
+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:
-  PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
-  SELECT ?statua WHERE {{ ?statua a base:Statua . ?statua base:periodoStoricoOpera "Medioevo" . }}
-
-- Domanda: "La query ha restituito 5 statue. Puoi descriverle?"
-  Risposta:
-  Ecco le 5 statue medievali trovate: Statua1, Statua2, Statua3, Statua4, Statua5.
+  Risposta SPARQL:
+    PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
+    SELECT ?statua WHERE {{
+      ?statua a base:Statua ;
+              base:periodoStoricoOpera "Medioevo"@it .
+    }}
 
 - Domanda: "Ciao!"
-  Risposta:
-  Ciao! Benvenuto al nostro museo. Come posso aiutarti oggi?
-
-- Domanda: "Bonjour! Comment ça va?"
-  Risposta:
-  Bonjour! Bienvenue dans notre musée. Comment puis-je vous aider aujourd'hui?
+  Risposta (chat):
+    Ciao! Benvenuto al nostro museo. Come posso aiutarti oggi?
+
+- 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 .
+    }}
 
-- Domanda: "Qual è la tua opinione sull'arte moderna?"
-  Risposta:
-  L'arte moderna è un'espressione affascinante e varia che riflette le dinamiche sociali e culturali contemporanee.
-
-- Domanda: "How does this installation work?"
-  Risposta:
-  This interactive installation allows you to explore various artworks through digital interactions.
-  Simply approach and follow the on-screen instructions.
-
-- Domanda: "Come funziona questa installazione?"
-  Risposta:
-  Questa installazione interattiva ti permette di esplorare diverse opere d'arte attraverso interazioni digitali.
-  Basta avvicinarti e seguire le istruzioni sullo schermo.
+Ecco un riassunto dell'ontologia su cui devi lavorare:
+{rdf_context}
 
 RISPONDI ESCLUSIVAMENTE CON IL FORMATO SPECIFICATO.
 """
@@ -173,7 +170,7 @@ async def call_model(messages, temperature=0.7, max_tokens=2048):
         )
         raw_text = response["choices"][0]["message"]["content"]
         logger.debug(f"Risposta del modello ricevuta: {raw_text}")
-        # Rimuoviamo eventuali newline per forzare la singola riga
+        # Rimuoviamo eventuali newline per forzare una singola riga
         return raw_text.replace("\n", " ").strip()
     except Exception as e:
         logger.error(f"Errore durante la chiamata al modello: {e}")
@@ -198,13 +195,13 @@ async def interpret_sparql_results(results):
     ])
     logger.debug(f"Risultati SPARQL:\n{results_str}")
 
-    # Crea un prompt per il modello per interpretare i risultati
+    # 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.
+come farebbe una guida museale femminile (in italiano).
 """
 
     messages = [
@@ -249,13 +246,12 @@ async def generate_response(request: QueryRequest):
         if validate_sparql_query(sparql_query, RDF_FILE):
             logger.info("La query SPARQL è valida. Inizio esecuzione della query.")
             try:
-                # Esegui la query su RDF
                 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 tramite il modello
+                # 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}
@@ -285,4 +281,4 @@ async def generate_response(request: QueryRequest):
 
 @app.get("/")
 async def root():
-    return {"message": "Server attivo e pronto a generare risposte!"}
+    return {"message": "Server attivo e pronto a generare risposte!"}