Update app.py

app.py

@@ -27,10 +27,11 @@ HF_MODEL = "Qwen/Qwen2.5-72B-Instruct"
 MAX_CLASSES    = 30
 MAX_PROPERTIES = 30
 
+
 def extract_classes_and_properties(rdf_file:str) -> str:
     """
-    Carica l'ontologia e crea un 'sunto' solo di Classi e Proprietà
-    (senza riportare NamedIndividuals o triple).
+    Carica l'ontologia e crea un 'sunto' di Classi e Proprietà
+    (senza NamedIndividuals) per ridurre i token.
     """
     if not os.path.exists(rdf_file):
         return "NO_RDF_FILE"
@@ -74,41 +75,51 @@ def extract_classes_and_properties(rdf_file:str) -> str:
 """
     return summary
 
+
 knowledge_text = extract_classes_and_properties(RDF_FILE)
 
+
 def create_system_message(ont_text:str)->str:
     """
-    Prompt di sistema con regole stringenti e SENZA NamedIndividuals.
+    Prompt di sistema robusto, con regole su query in una riga.
+    Lasciamo un 'accenno' che, per parlare di 'materiale', potrebbe esserci
+    una proprietà simile a 'base:materialeOpera' o analoga, ma NON tassativo.
     """
     return f"""
-Sei un assistente museale. Hai un elenco di Classi e Proprietà dell'ontologia:
+Sei un assistente museale. Ecco un estratto di CLASSI e PROPRIETA' dell'ontologia (senza NamedIndividuals):
 
 --- ONTOLOGIA ---
 {ont_text}
 --- FINE ---
 
-Regole Fondamentali:
-1) Se l'utente fa una domanda correlata a queste Classi/Proprietà, genera SEMPRE una query SPARQL
-   in UNA SOLA RIGA, con prefix:
-   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
-2) Se la query produce 0 risultati o è invalida, devi fare un secondo tentativo (magari con FILTER).
-3) Se è una domanda generica (es. come stai?), rispondi breve.
-4) Se trovi risultati, la risposta finale è la query SPARQL su una singola riga.
-5) Se non trovi nulla, di' "Nessuna info".
-6) Non scrivere risposte multiline per la query. UNA SOLA RIGA.
+Suggerimento: se l'utente chiede il 'materiale' di un'opera, potresti usare qualcosa come
+'base:materialeOpera' o un'altra proprietà simile (se esiste). Non è tassativo: usa
+la proprietà che ritieni più affine se ci sono riferimenti in ontologia.
+
+REGOLE STRINGENTI:
+1) Se l'utente chiede info su questa ontologia, genera SEMPRE una query SPARQL in UNA SOLA RIGA,
+   con prefix:
+     PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
+2) Se la query produce 0 risultati o fallisce, ritenta con un secondo tentativo.
+3) Se la domanda è generica (tipo 'Ciao, come stai?'), rispondi breve.
+4) Se trovi risultati, risposta finale = la query SPARQL (una sola riga).
+5) Se non trovi nulla, di' 'Nessuna info.'
+6) Non multiline. Esempio:  PREFIX base: <...> SELECT ?x WHERE {{ ... }}.
 
 FINE REGOLE
 """
 
+
 def create_explanation_prompt(results_str:str)->str:
     return f"""
 Ho ottenuto questi risultati SPARQL:
 {results_str}
 
-Fornisci una breve spiegazione museale (massimo 10 righe), coerente e senza inventare.
+Ora fornisci una breve spiegazione museale (massimo ~10 righe), senza inventare oltre i risultati.
 """
 
-async def call_hf_model(messages, temperature=0.7, max_tokens=1024)->str:
+
+async def call_hf_model(messages, temperature=0.5, max_tokens=1024)->str:
     logger.debug("Chiamo HF con i seguenti messaggi:")
     for m in messages:
         logger.debug(f"ROLE={m['role']} => {m['content'][:300]}")
@@ -121,11 +132,15 @@ async def call_hf_model(messages, temperature=0.7, max_tokens=1024)->str:
             top_p=0.9
         )
         raw=resp["choices"][0]["message"]["content"]
-        return raw.replace("\n"," ").strip()
+        # Forziamo la query su linea singola se multiline
+        single_line = " ".join(raw.splitlines())
+        logger.debug(f"Risposta HF single-line: {single_line}")
+        return single_line.strip()
     except Exception as e:
         logger.error(f"HuggingFace error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
+
 from fastapi import FastAPI
 
 app=FastAPI()
@@ -145,57 +160,59 @@ async def generate_response(req:QueryRequest):
         {"role":"system","content":sys_msg},
         {"role":"user","content":user_input}
     ]
-    first=await call_hf_model(msgs, req.temperature, req.max_tokens)
-    logger.info(f"PRIMA RISPOSTA:\n{first}")
+    # Primo tentativo
+    r1=await call_hf_model(msgs, req.temperature, req.max_tokens)
+    logger.info(f"PRIMA RISPOSTA:\n{r1}")
 
-    if not first.startswith("PREFIX base:"):
-        second_msg=f"Non hai fatto query SPARQL su una riga. Ritenta. Domanda: {user_input}"
+    # Se non parte con "PREFIX base:"
+    if not r1.startswith("PREFIX base:"):
+        sc=f"Non hai risposto con query SPARQL su una sola riga. Riprova. Domanda: {user_input}"
         msgs2=[
             {"role":"system","content":sys_msg},
-            {"role":"assistant","content":first},
-            {"role":"user","content":second_msg}
+            {"role":"assistant","content":r1},
+            {"role":"user","content":sc}
         ]
-        second=await call_hf_model(msgs2, req.temperature, req.max_tokens)
-        logger.info(f"SECONDA RISPOSTA:\n{second}")
-        if second.startswith("PREFIX base:"):
-            sparql_query=second
+        r2=await call_hf_model(msgs2,req.temperature,req.max_tokens)
+        logger.info(f"SECONDA RISPOSTA:\n{r2}")
+        if r2.startswith("PREFIX base:"):
+            sparql_query=r2
         else:
-            return {"type":"NATURAL","response": second}
+            return {"type":"NATURAL","response": r2}
     else:
-        sparql_query=first
+        sparql_query=r1
 
-    # Eseguiamo la query
+    # Esegui la query con rdflib
     import rdflib
     g=rdflib.Graph()
     try:
         g.parse(RDF_FILE,format="xml")
     except Exception as e:
-        logger.error(f"Parse error: {e}")
-        return {"type":"ERROR","response":"Parsing RDF error"}
+        logger.error(f"Parsing RDF error: {e}")
+        return {"type":"ERROR","response":f"Parsing RDF error: {e}"}
 
     try:
         results=g.query(sparql_query)
     except Exception as e:
-        # fallback
-        fallback=f"Query fallita. Riprova. Domanda: {user_input}"
+        fallback=f"La query SPARQL ha fallito. Riprova. Domanda: {user_input}"
         msgs3=[
             {"role":"system","content":sys_msg},
             {"role":"assistant","content":sparql_query},
             {"role":"user","content":fallback}
         ]
-        res3=await call_hf_model(msgs3,req.temperature,req.max_tokens)
-        if res3.startswith("PREFIX base:"):
-            sparql_query=res3
+        r3=await call_hf_model(msgs3,req.temperature,req.max_tokens)
+        if r3.startswith("PREFIX base:"):
+            sparql_query=r3
             try:
                 results=g.query(sparql_query)
             except Exception as e2:
-                return {"type":"ERROR","response":f"Query fallita ancora: {e2}"}
+                return {"type":"ERROR","response":f"Query fallita di nuovo: {e2}"}
         else:
-            return {"type":"NATURAL","response":res3}
+            return {"type":"NATURAL","response":r3}
 
     if len(results)==0:
         return {"type":"NATURAL","sparql_query":sparql_query,"response":"Nessun risultato."}
 
+    # Confeziona risultati
     row_list=[]
     for row in results:
         row_str=", ".join([f"{k}:{v}" for k,v in row.asdict().items()])
@@ -219,4 +236,4 @@ async def generate_response(req:QueryRequest):
 
 @app.get("/")
 def home():
-    return {"message":"Ok con sole classi e proprietà. Se l'utente cerca istanze, non le trova."}
+    return {"message":"Prompt lascia libertà su come chiamare la proprietà del materiale, ma suggerisce un possibile 'materialeOpera'."}