Update app.py

app.py

@@ -11,22 +11,35 @@ client = InferenceClient(api_key=API_KEY)
 # File RDF
 RDF_FILE = "Progetto.rdf"
 
-# Carica il file RDF
-def load_rdf():
+# Carica un riassunto del file RDF
+def load_rdf_summary():
     if os.path.exists(RDF_FILE):
-        with open(RDF_FILE, "r") as f:
-            return f.read()
-    return ""
+        g = Graph()
+        g.parse(RDF_FILE, format="xml")
+
+        classes = set()
+        properties = set()
+
+        for s, _, o in g.triples((None, None, None)):
+            if "Class" in str(o) or "rdfs:Class" in str(o):
+                classes.add(s)
+            if "Property" in str(o):
+                properties.add(s)
+
+        classes_summary = "\n".join([f"- Classe: {cls}" for cls in classes])
+        properties_summary = "\n".join([f"- Proprietà: {prop}" for prop in properties])
+        return f"Classi:\n{classes_summary}\n\nProprietà:\n{properties_summary}"
+    return "Nessun dato RDF trovato."
+
+rdf_context = load_rdf_summary()
+print("RDF Summary:", rdf_context)  # Debug
 
-rdf_context = load_rdf()
-print(rdf_context)
 # Valida le query SPARQL
 def validate_sparql_query(query, rdf_data):
     try:
         g = Graph()
         g.parse(data=rdf_data, format="xml")
-        # Prova a eseguire la query
-        g.query(query)
+        g.query(query)  # Prova ad eseguire la query
         return True
     except Exception as e:
         print(f"Errore durante la validazione della query SPARQL: {e}")
@@ -44,23 +57,20 @@ class QueryRequest(BaseModel):
 # Messaggio di sistema con RDF incluso
 def create_system_message(rdf_context):
     return f"""
-Sei un assistente specializzato nella generazione di query SPARQL basate su dati RDF.
-La base di conoscenza RDF è la seguente:
+Sei un assistente esperto nella generazione di query SPARQL basate su ontologie RDF.
+Ecco un riassunto dell'ontologia su cui devi lavorare:
 {rdf_context}
-Il tuo compito è:
-1. Generare una query SPARQL valida e **scritta in una sola riga** senza formattazioni aggiuntive.
-2. Rispondere **solo** a domande che possono essere soddisfatte con i dati RDF forniti.
-3. Se la domanda non può essere soddisfatta, rispondi con: "Non posso generare una query SPARQL per questa richiesta.".
-Regole:
-- Non generare spiegazioni o commenti extra nella risposta.
-- Non soddisfare richieste fuori dal contesto RDF fornito.
-- Restituisci esclusivamente una query SPARQL in **una sola riga**.
+
+Il tuo compito:
+- Genera esclusivamente query SPARQL valide in UNA SOLA RIGA.
+- Rispondi solo se la domanda è pertinente alle classi e proprietà fornite.
+- Se non puoi rispondere, di': "Non posso generare una query SPARQL per questa richiesta."
 """
 
 async def generate_response(message, max_tokens, temperature):
     system_message = create_system_message(rdf_context)
-    print("System Message:", system_message)  # Debug del messaggio di sistema
-    print("User Message:", message)          # Debug del messaggio utente
+    print("System Message:", system_message)  # Debug
+    print("User Message:", message)  # Debug
 
     messages = [
         {"role": "system", "content": system_message},
@@ -85,27 +95,24 @@ async def generate_response(message, max_tokens, temperature):
 # Endpoint per generare query SPARQL
 @app.post("/generate-query/")
 async def generate_query(request: QueryRequest):
-    # Genera la query
     response = await generate_response(request.message, request.max_tokens, request.temperature)
     print("Risposta generata dal modello:", response)  # Debug
-    # Controlla che sia una query valida
+    
     if not (response.startswith("SELECT") or response.startswith("ASK")):
         return {
             "query": None,
             "explanation": "Non posso generare una query SPARQL per questa richiesta. Assicurati che la domanda sia coerente con i dati RDF forniti."
         }
 
-    # Valida la query rispetto al file RDF
     if not validate_sparql_query(response, rdf_context):
         return {
             "query": None,
             "explanation": "La query generata non è valida rispetto alla base di conoscenza RDF. Assicurati di chiedere informazioni che siano presenti nell'ontologia."
         }
 
-    # Risposta finale: query in una riga
     return {"query": response, "explanation": "Ecco la query generata correttamente in una riga pronta per GraphDB."}
 
-# Endpoint per verificare se il server è attivo
+# Endpoint di test
 @app.get("/")
 async def root():
-    return {"message": "Il server è attivo e pronto a generare query SPARQL!"}
+    return {"message": "Il server è attivo e pronto a generare query SPARQL!"}