Update app.py

app.py

@@ -7,95 +7,59 @@ from pydantic import BaseModel
 from fastapi import FastAPI, HTTPException
 import logging
 
-# Configurazione logging
 logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
 logger = logging.getLogger(__name__)
 
-# Configurazione API Hugging Face
 API_KEY = os.getenv("HF_API_KEY")
 client = InferenceClient(api_key=API_KEY)
 
-# File RDF
 RDF_FILE = "Ontologia.rdf"
 
-# Carica un riassunto del file RDF
-def load_rdf_summary():
-    if os.path.exists(RDF_FILE):
-        try:
-            g = Graph()
-            g.parse(RDF_FILE, format="xml")
-
-            classes = set()
-            properties = set()
-
-            for s, _, o in g.triples((None, None, None)):
-                # Si fa un controllo basilare per capire se l'oggetto
-                # è una definizione di classe o proprietà
-                # In RDF/OWL reali si userebbero approcci più rigorosi (rdfs:Class, rdf:Property, etc.)
-                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}"
-        except Exception as e:
-            logger.error(f"Errore durante il parsing del file RDF: {e}")
-            return "Errore nel caricamento del file RDF."
-    return "Nessun dato RDF trovato."
-
-rdf_context = load_rdf_summary()
-logger.info("RDF Summary: %s", rdf_context)
-
-# Valida le query SPARQL
-def validate_sparql_query(query, rdf_file_path):
+# Funzione di validazione
+def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
+    g = Graph()
     try:
-        g = Graph()
         g.parse(rdf_file_path, format="xml")
-        g.query(query)  # Prova ad eseguire la query
+        g.query(query)  # Se c'è un errore di sintassi o referenza, solleva eccezione
         return True
     except Exception as e:
         logger.error(f"Errore durante la validazione della query SPARQL: {e}")
         return False
 
-# FastAPI app
-app = FastAPI()
-
-# Modello di input per richieste POST
-class QueryRequest(BaseModel):
-    message: str
-    max_tokens: int = 2048
-    temperature: float = 0.7
-
-# Messaggio di sistema con RDF incluso
-def create_system_message(rdf_context):
+# Prompt di sistema "stringente"
+def create_system_message(rdf_context: str) -> str:
     return f"""
-Sei un assistente esperto nella generazione di query SPARQL basate su ontologie RDF.
+Sei un assistente esperto nella generazione di query SPARQL basate su un'ontologia RDF.
 Ecco un riassunto dell'ontologia su cui devi lavorare:
 {rdf_context}
 
-Il tuo compito:
-- Genera esclusivamente query SPARQL valide in UNA SOLA RIGA.
-- Usa SEMPRE il prefisso:
-  PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/2024/11/untitled-ontology-39/>
-  e fai seguire la SELECT sulla STESSA riga, per esempio:
-  PREFIX base: <...> SELECT ...
-- Usa i nomi abbreviati con 'base:' invece di URI complete. Esempio: base:Stanza, base:Contiene, ecc.
-- 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."
+Regole tassative:
+1. La query DEV'ESSERE in una sola riga.
+2. Usa SEMPRE il prefisso base: se l'ontologia è <http://example.org/onto#>, dovrai scrivere:
+   PREFIX base: <http://example.org/onto#> SELECT ...
+   TUTTO su un'unica riga, senza andare a capo.
+3. Se vuoi filtrare per classe, usa: ?entity a base:NomeClasse .
+4. Se vuoi usare una proprietà, usa: ?entity base:NomeProprieta ?altra .
+5. NON usare URI lunghe senza parentesi angolate e non inventare prefissi.
+6. Se la query non rispetta la sintassi SPARQL, verrà rifiutata.
+
+OBIETTIVO:
+- Genera una query SPARQL sintatticamente e semanticamente valida rispetto alle classi e proprietà riportate.
+- Se non puoi rispondere, dì: "Non posso generare una query SPARQL per questa richiesta."
 """
 
-async def generate_response(message, max_tokens, temperature):
-    system_message = create_system_message(rdf_context)
-    logger.debug("System Message: %s", system_message)
-    logger.info("User Message: %s", message)
+# Prompt di sistema "correttivo" per la seconda iterazione
+def create_correction_message(rdf_context: str, errore: str) -> str:
+    return f"""
+La query che hai fornito è risultata NON valida:
+{errore}
 
-    messages = [
-        {"role": "system", "content": system_message},
-        {"role": "user", "content": message}
-    ]
+Ricorda le regole tassative e ritenta la generazione di UNA SOLA query SPARQL valida in una riga.
+Riproponila corretta, sempre rispettando il prefisso base: e la sintassi di SELECT/ASK.
+"""
 
+# Funzione per chiamare il modello su Hugging Face
+async def call_model(messages, temperature=0.7, max_tokens=2048):
     try:
         response = client.chat.completions.create(
             model="Qwen/Qwen2.5-72B-Instruct",
@@ -105,43 +69,68 @@ async def generate_response(message, max_tokens, temperature):
             top_p=0.7,
             stream=False
         )
-        logger.info("Raw Response: %s", response)
-        # Rimuoviamo eventuali a-capo così da avere una singola riga
-        return response['choices'][0]['message']['content'].replace("\n", " ").strip()
+        raw_text = response["choices"][0]["message"]["content"]
+        return raw_text.replace("\n", " ").strip()
     except Exception as e:
-        logger.error(f"Errore nell'elaborazione: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Errore nell'elaborazione: {str(e)}")
+        logger.error(f"Errore nel modello: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Caricamento di un riassunto dell'ontologia (semplificato per brevità)
+def load_rdf_summary() -> str:
+    # Qui un caricamento minimo o un testo statico
+    return "Classi e proprietà dell'ontologia: base:Stanza, base:Contiene, base:Opera, ecc."
+
+app = FastAPI()
+rdf_context = load_rdf_summary()
+
+class QueryRequest(BaseModel):
+    message: str
+    max_tokens: int = 2048
+    temperature: float = 0.7
 
-# Endpoint per generare query SPARQL
 @app.post("/generate-query/")
 async def generate_query(request: QueryRequest):
-    response = await generate_response(request.message, request.max_tokens, request.temperature)
-    logger.info("Risposta generata dal modello: %s", response)
-
-    # Controllo basilare: la query deve iniziare con 'PREFIX' (come da istruzioni)
-    # e successivamente con 'SELECT' o 'ASK'
-    if not response.startswith("PREFIX"):
-        return {
-            "query": None,
-            "explanation": "Non posso generare una query SPARQL per questa richiesta (manca il PREFIX)."
-        }
-
-    # Potresti anche voler controllare se c'è 'SELECT' o 'ASK' dopo 'PREFIX ...'
-    if "SELECT" not in response and "ASK" not in response:
-        return {
-            "query": None,
-            "explanation": "Non posso generare una query SPARQL per questa richiesta (manca SELECT/ASK)."
-        }
-
-    if not validate_sparql_query(response, RDF_FILE):
-        return {
-            "query": None,
-            "explanation": "La query generata non è valida rispetto alla base di conoscenza RDF. Assicurati di chiedere informazioni che siano presenti nell'ontologia."
-        }
-
-    return {"query": response, "explanation": "Ecco la query generata correttamente in una riga pronta per GraphDB."}
-
-# Endpoint di test
+    # 1) Prima iterazione
+    system_msg = create_system_message(rdf_context)
+    user_msg = request.message
+    messages = [
+        {"role": "system", "content": system_msg},
+        {"role": "user", "content": user_msg},
+    ]
+    response1 = await call_model(messages, request.temperature, request.max_tokens)
+    logger.info(f"[Prima iterazione] Risposta generata dal modello: {response1}")
+
+    # 2) Validazione
+    if not (response1.startswith("PREFIX") and ("SELECT" in response1 or "ASK" in response1)):
+        # Fallimento immediato
+        return {"query": None, "explanation": "La query non rispetta le regole base (PREFIX + SELECT/ASK)."}
+    
+    if validate_sparql_query(response1, RDF_FILE):
+        # Query valida! Restituisco la prima
+        return {"query": response1, "explanation": "Query valida alla prima iterazione."}
+    else:
+        # 3) Seconda iterazione “correttiva”
+        correction_msg = create_correction_message(rdf_context, "Errore di validazione (prima iterazione).")
+        messages2 = [
+            {"role": "system", "content": system_msg},  # Sistema invariato
+            {"role": "assistant", "content": response1}, # Metti la risposta errata in contesto
+            {"role": "system", "content": correction_msg}, # Istruzione di correzione
+        ]
+        response2 = await call_model(messages2, request.temperature, request.max_tokens)
+        logger.info(f"[Seconda iterazione] Risposta generata dal modello: {response2}")
+
+        if not (response2.startswith("PREFIX") and ("SELECT" in response2 or "ASK" in response2)):
+            return {"query": None, "explanation": "Anche la seconda query non rispetta le regole (PREFIX + SELECT/ASK)."}
+        
+        if validate_sparql_query(response2, RDF_FILE):
+            return {"query": response2, "explanation": "Query valida alla seconda iterazione (corretta)."}
+        else:
+            return {
+                "query": None,
+                "explanation": "Anche la seconda iterazione ha prodotto una query non valida. Interrompo."
+            }
+
 @app.get("/")
 async def root():
-    return {"message": "Il server è attivo e pronto a generare query SPARQL!"}
+    return {"message": "Server attivo per generare query SPARQL"}
+