Update app.py

app.py

@@ -38,22 +38,23 @@ app = FastAPI()
 # Modello di input per richieste POST
 class QueryRequest(BaseModel):
     message: str
-    max_tokens: int = 512
+    max_tokens: int = 2048
     temperature: float = 0.7
 
 # Messaggio di sistema con RDF incluso
 def create_system_message(rdf_context):
     return f"""
-Sei un assistente specializzato nella generazione e spiegazione di query SPARQL basate su dati RDF.
+Sei un assistente specializzato nella generazione di query SPARQL basate su dati RDF.
 La base di conoscenza RDF è la seguente:
 {rdf_context}
-Il tuo compito principale è:
-1. Analizzare lo schema RDF o i dati RDF forniti e la domanda in linguaggio naturale posta dall'utente.
-2. Generare una query SPARQL valida che recuperi le informazioni richieste dai dati RDF.
-3. Spiegare in modo prolisso e naturale il significato dei risultati, come farebbe una guida in un museo.
+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:
-- Genera solo query SPARQL in una singola riga, senza formattazioni aggiuntive.
-- Se la domanda non può essere soddisfatta con una query SPARQL, rispondi con: \"Non posso generare una query per questa domanda.\"
+- 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**.
 """
 
 # Funzione per inviare la richiesta al modello Hugging Face
@@ -65,7 +66,7 @@ async def generate_response(message, max_tokens, temperature):
     ]
 
     try:
-        # Usa il metodo chat.completions.create per lo streaming dei risultati
+        # Invoca il modello Hugging Face
         stream = client.chat.completions.create(
             model="Qwen/Qwen2.5-72B-Instruct",
             messages=messages,
@@ -80,34 +81,36 @@ async def generate_response(message, max_tokens, temperature):
             if "choices" in chunk and len(chunk["choices"]) > 0:
                 response += chunk["choices"][0]["delta"]["content"]
 
-        return response.strip()
+        # Rimuovi formattazioni multilinea e restituisci in una sola riga
+        response = response.replace("\n", " ").strip()
+        return response
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Errore nell'elaborazione: {str(e)}")
 
 # Endpoint per generare query SPARQL
 @app.post("/generate-query/")
 async def generate_query(request: QueryRequest):
-    # Genera risposta
+    # Genera la query
     response = await generate_response(request.message, request.max_tokens, request.temperature)
 
-    # Valida la query se possibile
-    if response.startswith("SELECT") or response.startswith("ASK"):
-        is_valid = validate_sparql_query(response, rdf_context)
-        if not is_valid:
-            # Log e messaggio per il client
-            print("Query non valida rispetto al file RDF:")
-            print(response)
-            return {
-                "query": response.replace("\n", " ").strip(),
-                "explanation": "La query generata non è valida rispetto al file RDF fornito. Potrebbe essere necessario correggerla manualmente."
-            }
+    # 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."
+        }
 
-    explanation = "La query generata è: " + response.replace("\n", " ").strip() + ". "
-    explanation += "Questa query è stata progettata per estrarre informazioni specifiche dai dati RDF, consentendo di rispondere alla tua domanda. Risultati ottenuti da questa query possono includere dettagli come entità, relazioni o attributi collegati al contesto fornito."
+    # 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."
+        }
 
-    return {"query": response.replace("\n", " ").strip(), "explanation": explanation}
+    # 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
 @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!"}