Update app.py

app.py

@@ -24,22 +24,13 @@ client = InferenceClient(api_key=API_KEY)
 RDF_FILE = "Ontologia.rdf"
 HF_MODEL = "Qwen/Qwen2.5-72B-Instruct"
 
-# Limiti per non sforare la dimensione del prompt
-MAX_CLASSES         = 30
-MAX_PROPERTIES      = 30
-MAX_INDIVIDUALS     = 50
-MAX_TRIPLES_PER_IND = 20
-MAX_LITERAL_CHARS   = 100
-
-def extract_ontology_summaries(rdf_file: str) -> str:
+MAX_CLASSES    = 30
+MAX_PROPERTIES = 30
+
+def extract_classes_and_properties(rdf_file:str) -> str:
     """
-    1) Carica l'ontologia con rdflib.
-    2) Estrae:
-       - un elenco (massimo MAX_CLASSES) di classi
-       - un elenco (massimo MAX_PROPERTIES) di proprietà
-       - un estratto di triple relative alle istanze (NamedIndividual)
-         (massimo MAX_INDIVIDUALS individui, e MAX_TRIPLES_PER_IND triple per individuo).
-    3) Ritorna una stringa 'knowledge_text' che unisce questi contenuti.
+    Carica l'ontologia e crea un 'sunto' solo di Classi e Proprietà
+    (senza riportare NamedIndividuals o triple).
     """
     if not os.path.exists(rdf_file):
         return "NO_RDF_FILE"
@@ -51,21 +42,16 @@ def extract_ontology_summaries(rdf_file: str) -> str:
         logger.error(f"Parsing RDF error: {e}")
         return "PARSING_ERROR"
 
-    # ====== Troviamo le Classi ======
-    # Con un pattern: (s, RDF.type, OWL.Class) o RDFS.Class
-    # Alcune ontologie usano direct typing, altre no.
+    # Troviamo le classi
     classes_found = set()
     for s in g.subjects(RDF.type, OWL.Class):
         classes_found.add(s)
-    # Alcune volte ci sono (s, RDF.type, RDFS.Class)
     for s in g.subjects(RDF.type, RDFS.Class):
         classes_found.add(s)
-
     classes_list = sorted(str(c) for c in classes_found)
     classes_list = classes_list[:MAX_CLASSES]
 
-    # ====== Troviamo le Proprietà ======
-    # Cerchiamo soggetti con RDF.type in {OWL.ObjectProperty, OWL.DatatypeProperty, RDF.Property}
+    # Troviamo le proprietà
     props_found = set()
     for p in g.subjects(RDF.type, OWL.ObjectProperty):
         props_found.add(p)
@@ -76,92 +62,58 @@ def extract_ontology_summaries(rdf_file: str) -> str:
     props_list = sorted(str(x) for x in props_found)
     props_list = props_list[:MAX_PROPERTIES]
 
-    # ====== Troviamo NamedIndividuals e relative triple ======
-    named_inds = set()
-    for s in g.subjects(RDF.type, OWL.NamedIndividual):
-        named_inds.add(s)
-    logger.debug(f"Found {len(named_inds)} individuals.")
-    inds_list = sorted(named_inds)[:MAX_INDIVIDUALS]
-
-    # Costruisci un testo con le triple di ogni individuo
-    lines_inds = []
-    for ind in inds_list:
-        triple_count = 0
-        for p,o in g.predicate_objects(ind):
-            if triple_count >= MAX_TRIPLES_PER_IND:
-                break
-            s_str = str(ind)[:80]
-            p_str = str(p)[:80]
-            o_str = str(o)[:MAX_LITERAL_CHARS].replace("\n"," ")
-            lines_inds.append(f"{s_str}|{p_str}|{o_str}")
-            triple_count += 1
-
-    # Ora componiamo la stringa finale
     txt_classes = "\n".join([f"- CLASSE: {c}" for c in classes_list])
     txt_props   = "\n".join([f"- PROPRIETA': {p}" for p in props_list])
-    txt_inds    = "\n".join(lines_inds)
 
-    # Il knowledge_text unisce tre sezioni
-    knowledge_text = f"""\
-# CLASSES (max {MAX_CLASSES})
+    summary = f"""\
+# CLASSI (max {MAX_CLASSES})
 {txt_classes}
 
-# PROPERTIES (max {MAX_PROPERTIES})
+# PROPRIETA' (max {MAX_PROPERTIES})
 {txt_props}
-
-# INDIVIDUALS
-{txt_inds}
 """
-    return knowledge_text
+    return summary
 
-knowledge_text = extract_ontology_summaries(RDF_FILE)
+knowledge_text = extract_classes_and_properties(RDF_FILE)
 
-def create_system_message(ont_text: str) -> str:
+def create_system_message(ont_text:str)->str:
     """
-    Prompt di sistema robusto con regole stringenti:
-    - Query SPARQL su una sola riga
-    - Se 0 results => secondo tentativo
-    - Chat generica => risposte brevi
+    Prompt di sistema con regole stringenti e SENZA NamedIndividuals.
     """
     return f"""
-Sei un assistente museale. Qui sotto c'è un riassunto dell'ontologia:
-(1) elenco di classi,
-(2) elenco di proprietà,
-(3) triple relative agli individui (NamedIndividual).
+Sei un assistente museale. Hai un elenco di Classi e Proprietà dell'ontologia:
 
 --- ONTOLOGIA ---
 {ont_text}
---- FINE ONTOLOGIA ---
-
-REGOLE FONDAMENTALI:
-1) Se la domanda dell'utente riguarda info contenute in questa ontologia, produci SEMPRE una query SPARQL in UNA SOLA RIGA,
-   con: PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
-   Esempio:  PREFIX base: <...> SELECT ?x WHERE {{ ... }}
-2) Se la query produce 0 risultati o fallisce, fai un secondo tentativo (magari con FILTER).
-3) Se la domanda è di chat generica (es. ciao come stai?), rispondi breve.
-4) Se trovi risultati, la tua risposta finale dev'essere la query SPARQL su una riga.
-5) Non inventare triple inesistenti. Se non c'è info, di' "Nessuna info."
-6) Non fare risposte multiline per la query. DEVI metterla su una singola riga.
-7) Usa i dati qui sopra. Se la domanda menziona 'David' o 'Amore e Psiche', controlla le triple Individuals.
+--- 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.
 
 FINE REGOLE
 """
 
 def create_explanation_prompt(results_str:str)->str:
     return f"""
-Risultati SPARQL:
+Ho ottenuto questi risultati SPARQL:
 {results_str}
 
-Fornisci una spiegazione come guida museale, in ~10 righe, riferendo a materiali, autori, periodi,
-senza inventare nulla che non sia presente. 
+Fornisci una breve spiegazione museale (massimo 10 righe), coerente e senza inventare.
 """
 
 async def call_hf_model(messages, temperature=0.7, max_tokens=1024)->str:
-    logging.debug("Chiamo modello HF con i seguenti msg:")
+    logger.debug("Chiamo HF con i seguenti messaggi:")
     for m in messages:
-        logging.debug(f"ROLE={m['role']} => {m['content'][:300]}")
+        logger.debug(f"ROLE={m['role']} => {m['content'][:300]}")
     try:
-        resp=client.chat.completions.create(
+        resp = client.chat.completions.create(
             model=HF_MODEL,
             messages=messages,
             temperature=temperature,
@@ -171,8 +123,11 @@ async def call_hf_model(messages, temperature=0.7, max_tokens=1024)->str:
         raw=resp["choices"][0]["message"]["content"]
         return raw.replace("\n"," ").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()
 
 class QueryRequest(BaseModel):
@@ -183,77 +138,77 @@ class QueryRequest(BaseModel):
 @app.post("/generate-response/")
 async def generate_response(req:QueryRequest):
     user_input=req.message
-    logging.info(f"Utente dice: {user_input}")
-    # 1) Prompt di sistema
+    logger.info(f"Utente dice: {user_input}")
+
     sys_msg=create_system_message(knowledge_text)
     msgs=[
         {"role":"system","content":sys_msg},
         {"role":"user","content":user_input}
     ]
-    # 2) Prima risposta
-    r1=await call_hf_model(msgs, req.temperature, req.max_tokens)
-    logging.info(f"PRIMA RISPOSTA:\n{r1}")
+    first=await call_hf_model(msgs, req.temperature, req.max_tokens)
+    logger.info(f"PRIMA RISPOSTA:\n{first}")
 
-    # Se non inizia con "PREFIX base:"
-    if not r1.startswith("PREFIX base:"):
-        second_q=f"Non hai risposto con query SPARQL su una sola riga. Ritenta. Domanda: {user_input}"
+    if not first.startswith("PREFIX base:"):
+        second_msg=f"Non hai fatto query SPARQL su una riga. Ritenta. Domanda: {user_input}"
         msgs2=[
             {"role":"system","content":sys_msg},
-            {"role":"assistant","content":r1},
-            {"role":"user","content":second_q}
+            {"role":"assistant","content":first},
+            {"role":"user","content":second_msg}
         ]
-        r2=await call_hf_model(msgs2,req.temperature,req.max_tokens)
-        logging.info(f"SECONDA RISPOSTA:\n{r2}")
-        if r2.startswith("PREFIX base:"):
-            sparql_query=r2
+        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
         else:
-            return {"type":"NATURAL","response": r2}
+            return {"type":"NATURAL","response": second}
     else:
-        sparql_query=r1
+        sparql_query=first
 
-    # 3) Esegui la query su rdflib
+    # Eseguiamo la query
+    import rdflib
     g=rdflib.Graph()
     try:
         g.parse(RDF_FILE,format="xml")
     except Exception as e:
-        return {"type":"ERROR","response":f"Parsing RDF error: {e}"}
+        logger.error(f"Parse error: {e}")
+        return {"type":"ERROR","response":"Parsing RDF error"}
+
     try:
         results=g.query(sparql_query)
     except Exception as e:
         # fallback
-        fallback=f"Query fallita. Riprova con altra sintassi. Domanda: {user_input}"
+        fallback=f"Query fallita. Riprova. Domanda: {user_input}"
         msgs3=[
             {"role":"system","content":sys_msg},
             {"role":"assistant","content":sparql_query},
             {"role":"user","content":fallback}
         ]
-        r3=await call_hf_model(msgs3,req.temperature,req.max_tokens)
-        if r3.startswith("PREFIX base:"):
-            sparql_query=r3
+        res3=await call_hf_model(msgs3,req.temperature,req.max_tokens)
+        if res3.startswith("PREFIX base:"):
+            sparql_query=res3
             try:
                 results=g.query(sparql_query)
             except Exception as e2:
                 return {"type":"ERROR","response":f"Query fallita ancora: {e2}"}
         else:
-            return {"type":"NATURAL","response":r3}
+            return {"type":"NATURAL","response":res3}
 
     if len(results)==0:
         return {"type":"NATURAL","sparql_query":sparql_query,"response":"Nessun risultato."}
 
-    # 4) Costruisci i result row
     row_list=[]
     for row in results:
-        row_txt=", ".join([f"{k}:{v}" for k,v in row.asdict().items()])
-        row_list.append(row_txt)
+        row_str=", ".join([f"{k}:{v}" for k,v in row.asdict().items()])
+        row_list.append(row_str)
     results_str="\n".join(row_list)
 
-    # 5) Spiegazione
+    # Spiegazione
     exp_prompt=create_explanation_prompt(results_str)
-    exp_msgs=[
+    msgs4=[
         {"role":"system","content":exp_prompt},
         {"role":"user","content":""}
     ]
-    explanation=await call_hf_model(exp_msgs,req.temperature,req.max_tokens)
+    explanation=await call_hf_model(msgs4,req.temperature,req.max_tokens)
 
     return {
         "type":"NATURAL",
@@ -264,4 +219,4 @@ async def generate_response(req:QueryRequest):
 
 @app.get("/")
 def home():
-    return {"msg":"Ok con sunto di classi, proprietà e triple di NamedIndividuals."}
+    return {"message":"Ok con sole classi e proprietà. Se l'utente cerca istanze, non le trova."}