Update app.py

app.py

@@ -21,7 +21,9 @@ client = InferenceClient(api_key=API_KEY)
 # File RDF
 RDF_FILE = "Ontologia.rdf"
 
+####################################
 # Caricamento RDF (riassunto)
+####################################
 def load_rdf_summary():
     """
     Carica un riassunto dell'ontologia dal file RDF.
@@ -53,7 +55,9 @@ def load_rdf_summary():
 rdf_context = load_rdf_summary()
 logger.info("RDF Summary: %s", rdf_context)
 
+####################################
 # Validazione SPARQL
+####################################
 def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
     """
     Verifica la validità della query SPARQL.
@@ -67,18 +71,23 @@ def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
         logger.error(f"Errore durante la validazione della query SPARQL: {e}")
         return False
 
+####################################
 # Prompt di Sistema
+####################################
 def create_system_message(rdf_context: str) -> str:
+    """
+    Crea il messaggio di sistema per il modello di linguaggio naturale.
+    """
     return f"""
-Sei un assistente esperto 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 base alla domanda dell'utente, devi decidere se:
-
+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 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.
-
+    
 Ecco un riassunto dell'ontologia su cui devi lavorare:
 {rdf_context}
-
+    
 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.
@@ -88,25 +97,30 @@ Regole TASSATIVE:
 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."
-
+    
 Esempi:
 - Domanda: "Quali sono le statue esposte del periodo medievale?"
   Risposta:
-  PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> SELECT ?statua WHERE { ?statua a base:Statua . ?statua base:Periodo_Storico "Medioevo" . }
-
+  PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/> SELECT ?statua WHERE {{ ?statua a base:Statua . ?statua base:Periodo_Storico "Medioevo" . }}
+    
 - Domanda: "La query ha restituito 5 statue. Puoi descriverle?"
   Risposta:
   Ecco le 5 statue medievali trovate: Statua1, Statua2, Statua3, Statua4, Statua5.
-
+    
 - Domanda: "Ciao!"
   Risposta:
   Ciao! Come posso aiutarti oggi?
-
+    
 RISPONDI ESCLUSIVAMENTE CON IL FORMATO SPECIFICATO.
 """
 
+####################################
 # Funzione per chiamare il modello
+####################################
 async def call_model(messages, temperature=0.7, max_tokens=2048):
+    """
+    Chiama il modello di linguaggio naturale con i messaggi forniti.
+    """
     try:
         response = client.chat.completions.create(
             model="Qwen/Qwen2.5-72B-Instruct",
@@ -123,24 +137,38 @@ async def call_model(messages, temperature=0.7, max_tokens=2048):
         logger.error(f"Errore nel modello: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
+####################################
 # Funzione di Interpretazione dei Risultati SPARQL
-def interpret_sparql_results(results):
+####################################
+async def interpret_sparql_results(results):
     """
-    Trasforma i risultati di una query SPARQL in una risposta naturale.
+    Invia i risultati delle query SPARQL al modello per ottenere una risposta naturale.
     """
     if not results:
-        return "Non sono state trovate informazioni corrispondenti alla tua richiesta."
+        return "Mi dispiace, non sono riuscita a trovare le informazioni che stavi cercando."
     
-    # Esempio semplice: elenca gli elementi trovati
-    interpreted = "Ecco i risultati trovati: "
-    items = []
-    for row in results:
-        items.append(", ".join([f"{k}: {v}" for k, v in row.asdict().items()]))
-    interpreted += "; ".join(items) + "."
+    # 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])
+    
+    # Crea un prompt per il modello per interpretare i risultati
+    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.
+"""
+
+    messages = [
+        {"role": "system", "content": interpret_prompt},
+        {"role": "user", "content": ""}
+    ]
     
-    return interpreted
+    natural_response = await call_model(messages, temperature=0.7, max_tokens=2048)
+    return natural_response
 
+####################################
 # FastAPI
+####################################
 app = FastAPI()
 
 class QueryRequest(BaseModel):
@@ -171,14 +199,14 @@ async def generate_response(request: QueryRequest):
                 g = Graph()
                 g.parse(RDF_FILE, format="xml")
                 results = g.query(sparql_query)
-                # Interpreta i risultati in una risposta naturale
-                interpreted_response = interpret_sparql_results(results)
-                return {"type": "SPARQL", "response": interpreted_response}
+                # Interpreta i risultati in una risposta naturale tramite il modello
+                interpreted_response = await interpret_sparql_results(results)
+                return {"type": "NATURAL", "response": interpreted_response}
             except Exception as e:
                 logger.error(f"Errore durante l'esecuzione della query SPARQL: {e}")
-                return {"type": "SPARQL", "response": "Errore nell'esecuzione della query SPARQL."}
+                return {"type": "ERROR", "response": "Mi dispiace, c'è stato un errore nell'esecuzione della tua richiesta."}
         else:
-            return {"type": "SPARQL", "response": "Query SPARQL 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