Update app.py

app.py

@@ -6,11 +6,8 @@ from fastapi import FastAPI, HTTPException
 import rdflib
 from huggingface_hub import InferenceClient
 
-# ==============================
-# CONFIGURAZIONE LOGGING
-# ==============================
 logging.basicConfig(
-    level=logging.DEBUG,  # Se vuoi log dettagliato
+    level=logging.DEBUG,
     format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[
         logging.FileHandler("app.log"),
@@ -19,129 +16,131 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-# ==============================
-# PARAMETRI
-# ==============================
+# Imposta la tua HF_API_KEY
 API_KEY = os.getenv("HF_API_KEY")
 if not API_KEY:
-    logger.error("HF_API_KEY non impostata nell'ambiente.")
-    raise EnvironmentError("HF_API_KEY non impostata nell'ambiente.")
+    logger.error("HF_API_KEY non impostata.")
+    raise EnvironmentError("HF_API_KEY non impostata.")
 
 client = InferenceClient(api_key=API_KEY)
 
 RDF_FILE = "Ontologia.rdf"
-MAX_TRIPLES = 600  # Numero di triple da includere nel prompt
-HF_MODEL = "Qwen/Qwen2.5-72B-Instruct"  # Nome del modello Hugging Face
+MAX_TRIPLES = 300    # Se la tua ontologia è enorme, abbassa questo
+HF_MODEL = "Qwen/Qwen2.5-72B-Instruct"
 
-# ==============================
-# STEP 0: Caricamento e Preprocessing dell'Ontologia
-# ==============================
-def load_ontology_as_text(rdf_file: str, max_triples: int = 300) -> str:
+# Carica e "preprocessa" l'ontologia
+def load_ontology_as_text(rdf_file: str, max_triples: int=300) -> str:
     """
-    Legge un numero limitato di triple dall'ontologia
-    e le converte in una stringa 'knowledge_text'.
+    Legge un numero limitato di triple dal file RDF e le concatena in
+    una stringa. Limita i literal in lunghezza per non gonfiare troppo il prompt.
     """
     if not os.path.exists(rdf_file):
-        return "Nessun file RDF trovato."
+        logger.warning("File RDF non trovato.")
+        return "NO_RDF"
 
     g = rdflib.Graph()
     try:
         g.parse(rdf_file, format="xml")
     except Exception as e:
         logger.error(f"Errore parsing RDF: {e}")
-        return "Errore nel parsing RDF."
+        return "PARSING_ERROR"
 
     lines = []
     count = 0
-    for s, p, o in g:
+    for s,p,o in g:
         if count >= max_triples:
             break
-        s_str = str(s)[:200]
-        p_str = str(p)[:200]
-        o_str = str(o)[:200]
-        line = f"- {s_str} | {p_str} | {o_str}"
-        lines.append(line)
-        count += 1
-
-    knowledge_text = "\n".join(lines)
-    return knowledge_text
-
-knowledge_text = load_ontology_as_text(RDF_FILE, max_triples=MAX_TRIPLES)
-logger.debug(f"[ONTOLOGY TEXT] {knowledge_text[:1000]} ...")
-
-# ==============================
-#  FUNZIONI UTILI
-# ==============================
-def create_initial_system_message(knowledge_text: str) -> str:
+        # Taglia i literal in modo da non superare un tot di caratteri
+        s_str = str(s)[:100].replace("\n"," ")
+        p_str = str(p)[:100].replace("\n"," ")
+        o_str = str(o)[:100].replace("\n"," ")
+        lines.append(f"{s_str}|{p_str}|{o_str}")
+        count+=1
+
+    # Concateniamo le triple su righe separate (più facile da leggere).
+    # Se preferisci su un'unica riga, puoi usare " ".join(lines).
+    ontology_text = "\n".join(lines)
+    logger.debug(f"Caricate {count} triple.")
+    return ontology_text
+
+knowledge_text = load_ontology_as_text(RDF_FILE, MAX_TRIPLES)
+
+def create_system_message(ont_text: str) -> str:
     """
-    System prompt 'stringente' che ordina di generare SEMPRE una query SPARQL.
+    Prompt di sistema robusto e stringente.
+    - Forza query SPARQL in UNA sola riga
+    - Richiede secondi tentativi
+    - Domande generiche -> risposte brevi, ma se c'è un modo di fare query, farlo
     """
-    system_prompt = f"""
-Sei un assistente di un museo. Hai accesso a queste triple (max {MAX_TRIPLES}):
-{knowledge_text}
+    system_msg = f"""
+Sei un assistente museale. Hai a disposizione un estratto di triple RDF (massimo {MAX_TRIPLES}):
 
-REGOLE TASSATIVE:
-1) Per qualunque domanda riguardi il contenuto di queste triple, DEVI generare una query SPARQL
+--- TRIPLE ---
+{ont_text}
+--- FINE TRIPLE ---
+
+REGOLE STRINGENTI:
+1) Se l'utente chiede informazioni correlate alle triple, DEVI generare una query SPARQL in UNA SOLA RIGA,
    con il prefisso:
      PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
-2) Se la query produce 0 risultati o fallisce, devi provare una seconda volta
-   cambiando la sintassi (ad es. usando FILTER(STR(?nome)) o @it).
-3) Se la domanda è chat generica, rispondi brevemente, ma se appare una parte di knowledge
-   potresti tentare comunque una query.
-4) Se trovi almeno un risultato, fornisci la query SPARQL come tua risposta.
-5) NON inventare triple che non esistono in questo testo.
-6) Usa esclusivamente i dati contenuti qui. Se non trovi nulla, di' "Non ci sono info".
-7) Se la query è generata ma produce 0 results, prova un secondo tentativo.
-
-Buona fortuna! 
+   Esempio: PREFIX base: <...> SELECT ?x WHERE {{ ... }} (tutto su una sola riga).
+2) Se la query produce 0 risultati o fallisce, devi ritentare con un secondo tentativo,
+   magari usando FILTER(STR(...)) o @it, o cambiando minuscole/maiuscole.
+3) Se la domanda è una chat generica, rispondi breve (saluto, ecc.). Ma se c'è qualcosa
+   di correlato, prova comunque la query.
+4) Se generi la query e trovi risultati, la risposta finale deve essere la query SPARQL
+   (una sola riga). Non inventare triple inesistenti.
+5) Se non trovi nulla, rispondi 'Non ci sono informazioni in queste triple.'
+6) Non ignorare: se l'utente fa domanda su 'David', 'Amore e Psiche', etc., devi
+   estrarre dai triple tutti i dettagli possibili con SPARQL. 
+7) Se la query produce 0, prova un secondo tentativo con sintassi differente.
+8) Non fare risposte su più righe per la query: una sola riga.
+
+FINE REGOLE.
     """
-    return system_prompt
+    return system_msg
 
 def create_explanation_prompt(results_str: str) -> str:
     """
-    Prompt da passare al modello per spiegare i risultati.
+    Prompt per spiegazione finale, robusto:
+    - Spiega i risultati come guida museale
+    - Non inventare
+    - 10-15 righe max
     """
-    # Chiedi una spiegazione dettagliata ma non prolissa.
-    explanation_prompt = f"""
-Abbiamo ottenuto questi risultati SPARQL:
-
+    msg = f"""
+Ho ottenuto questi risultati SPARQL:
 {results_str}
 
-Per favore spiega in modo dettagliato (ma non eccessivamente lungo) i risultati
-come farebbe una guida museale. Cita, se serve, periodi storici o materiali
-trovati, e fa' un breve richiamo all'ontologia. Non inventare nulla oltre.
+Ora fornisci una spiegazione come guida museale, in modo comprensibile e dettagliato (max ~10-15 righe).
+Cita eventuali materiali, periodi storici, autore, facendo riferimento al contesto RDF (ma senza contraddizioni).
+Non inventare nulla oltre ciò che appare nei risultati.
     """
-    return explanation_prompt
+    return msg
 
-async def call_model(messages, temperature=0.7, max_tokens=2048) -> str:
+async def call_hf_model(messages, temperature=0.7, max_tokens=1024) -> str:
     """
-    Chiama HuggingFace Inference endpoint con i messaggi forniti.
-    Logga diversi step per debugging.
+    Funzione di chiamata al modello su HuggingFace,
+    con log e robustezza. max_tokens=1024 come richiesto.
     """
-    logger.debug("[call_model] MESSAGGI INVIATI AL MODELLO:")
-    for msg in messages:
-        logger.debug(f"ROLE={msg['role']} CONTENT={msg['content'][:500]}")
+    logger.debug("Chiamo HF con i seguenti messaggi:")
+    for m in messages:
+        logger.debug(f"ROLE={m['role']} -> {m['content'][:500]}")
 
-    logger.info("[call_model] Chiamata al modello Hugging Face...")
     try:
-        response = client.chat.completions.create(
+        resp = client.chat.completions.create(
             model=HF_MODEL,
             messages=messages,
             temperature=temperature,
             max_tokens=max_tokens,
             top_p=0.9
         )
-        raw_text = response["choices"][0]["message"]["content"]
-        logger.debug("[call_model] Risposta raw del modello HF:\n" + raw_text)
-        return raw_text.replace("\n", " ").strip()
-
+        raw = resp["choices"][0]["message"]["content"]
+        logger.debug(f"Risposta HF: {raw}")
+        return raw.replace("\n"," ").strip()
     except Exception as e:
-        logger.error(f"[call_model] Errore durante la chiamata: {e}")
+        logger.error(f"Errore HF: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-# ==============================
-#  FASTAPI
-# ==============================
 app = FastAPI()
 
 class QueryRequest(BaseModel):
@@ -152,117 +151,91 @@ class QueryRequest(BaseModel):
 @app.post("/generate-response/")
 async def generate_response(req: QueryRequest):
     user_input = req.message
-    logger.info(f"[REQUEST] Ricevuta richiesta: {user_input}")
-
-    # 1) Creiamo system message con l'ontologia
-    system_prompt = create_initial_system_message(knowledge_text)
-    logger.debug("[SYSTEM PROMPT] " + system_prompt[:1000] + "...")
+    logger.info(f"Utente chiede: {user_input}")
 
-    # 2) Prima chiamata => generare query SPARQL
+    system_msg = create_system_message(knowledge_text)
     messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": user_input}
+        {"role":"system","content":system_msg},
+        {"role":"user","content":user_input}
     ]
-    response_text = await call_model(messages, req.temperature, req.max_tokens)
-    logger.info(f"[PRIMA RISPOSTA MODELLO] {response_text}")
-
-    # 3) Se non abbiamo "PREFIX base:" => second attempt
-    if not response_text.startswith("PREFIX base:"):
-        second_try_prompt = f"""
-Non hai fornito una query SPARQL. Ricorda di generarla SEMPRE.
-Riprova con un approccio differente per questa domanda:
-{user_input}
-        """
-        second_messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "assistant", "content": response_text},
-            {"role": "user", "content": second_try_prompt}
+    # Prima risposta
+    first_response = await call_hf_model(messages, req.temperature, req.max_tokens)
+    logger.info(f"Prima risposta generata:\n{first_response}")
+
+    # Se non inizia con 'PREFIX base:' => second attempt
+    if not first_response.startswith("PREFIX base:"):
+        second_prompt = f"Non hai risposto con query SPARQL in una sola riga. Riprova. Domanda: {user_input}"
+        second_msgs = [
+            {"role":"system","content":system_msg},
+            {"role":"assistant","content":first_response},
+            {"role":"user","content":second_prompt}
         ]
-        response_text_2 = await call_model(second_messages, req.temperature, req.max_tokens)
-        logger.info(f"[SECONDA RISPOSTA MODELLO] {response_text_2}")
-
-        if response_text_2.startswith("PREFIX base:"):
-            response_text = response_text_2
+        second_response = await call_hf_model(second_msgs, req.temperature, req.max_tokens)
+        logger.info(f"Seconda risposta:\n{second_response}")
+        if second_response.startswith("PREFIX base:"):
+            sparql_query = second_response
         else:
-            # Neanche al secondo tentativo => restituiamo come "chat"
-            logger.info("[FALLBACK] Nessuna query generata anche al secondo tentativo.")
-            return {
-                "type": "NATURAL",
-                "response": response_text_2
-            }
-
-    # 4) Ora dovremmo avere una query SPARQL in 'response_text'
-    sparql_query = response_text
-    logger.info(f"[FINAL QUERY] {sparql_query}")
+            return {"type":"NATURAL","response": second_response}
+    else:
+        sparql_query = first_response
 
-    # 5) Eseguiamo la query con rdflib
+    # Eseguiamo la query con rdflib
     g = rdflib.Graph()
     try:
         g.parse(RDF_FILE, format="xml")
     except Exception as e:
-        logger.error(f"[ERROR] Parsing RDF: {e}")
-        return {"type": "ERROR", "response": "Errore nel parsing dell'ontologia."}
+        logger.error("Errore parse RDF: ", e)
+        return {"type":"ERROR","response":"Parsing RDF fallito."}
 
-    # 6) Validazione + esecuzione
+    # Se la query è malformata, second attempt
     try:
         results = g.query(sparql_query)
     except Exception as e:
-        logger.warning(f"[QUERY FAIL] {e}")
-        # Tenta un 2° fallback in caso la query non sia valida
-        second_try_prompt2 = f"""
-La query SPARQL che hai fornito non è valida o non produce risultati.
-Riprova con una sintassi differente.
-Domanda utente: {user_input}
-        """
-        second_messages2 = [
-            {"role": "system", "content": system_prompt},
-            {"role": "assistant", "content": sparql_query},
-            {"role": "user", "content": second_try_prompt2}
+        logger.warning(f"La query SPARQL ha fallito: {e}")
+        fallback_prompt = f"La query SPARQL è fallita. Riprova con altra sintassi. Domanda: {user_input}"
+        fallback_msgs = [
+            {"role":"system","content":system_msg},
+            {"role":"assistant","content":sparql_query},
+            {"role":"user","content":fallback_prompt}
         ]
-        second_response2 = await call_model(second_messages2, req.temperature, req.max_tokens)
-        logger.info(f"[TERZO TENTATIVO MODELLO] {second_response2}")
-        if second_response2.startswith("PREFIX base:"):
-            # eseguiamo di nuovo
-            sparql_query = second_response2
+        fallback_resp = await call_hf_model(fallback_msgs, req.temperature, req.max_tokens)
+        if fallback_resp.startswith("PREFIX base:"):
+            sparql_query = fallback_resp
             try:
                 results = g.query(sparql_query)
             except Exception as e2:
-                logger.error(f"[QUERY FAIL 2] {e2}")
-                return {"type": "ERROR", "response": "Query fallita di nuovo."}
+                return {"type":"ERROR","response":f"Query fallita di nuovo: {e2}"}
         else:
-            return {"type": "NATURAL", "response": second_response2}
+            return {"type":"NATURAL","response": fallback_resp}
 
-    # 7) Se 0 results => fine
-    if len(results) == 0:
-        logger.info("[SPARQL RESULT] 0 risultati.")
-        return {"type": "NATURAL", "response": "Nessun risultato trovato nella nostra ontologia."}
+    if len(results)==0:
+        logger.info("0 risultati SPARQL.")
+        return {"type":"NATURAL","sparql_query": sparql_query,"response":"Nessun risultato."}
 
-    # 8) Ok => costruiamo una stringa con i risultati e facciamo un NUOVO prompt di interpretazione
+    # Prepara i risultati per la spiegazione
     row_list = []
     for row in results:
-        row_str = ", ".join([f"{k}:{v}" for k, v in row.asdict().items()])
-        row_list.append(row_str)
+        row_list.append(", ".join([f"{k}:{v}" for k,v in row.asdict().items()]))
     results_str = "\n".join(row_list)
+    logger.info(f"Risultati trovati ({len(results)}):\n{results_str}")
 
-    logger.info(f"[SPARQL OK] Trovati {len(results)} risultati.\n{results_str}")
-
-    # 9) Creiamo prompt di interpretazione
-    explain_prompt = create_explanation_prompt(results_str)
-    explain_messages = [
-        {"role": "system", "content": explain_prompt},
-        {"role": "user", "content": ""}
+    # Prompt di interpretazione
+    explain_sys = create_explanation_prompt(results_str)
+    explain_msgs = [
+        {"role":"system","content":explain_sys},
+        {"role":"user","content":""}
     ]
-    explanation_text = await call_model(explain_messages, req.temperature, req.max_tokens)
-    logger.info(f"[EXPLANATION RESPONSE] {explanation_text}")
+    explanation = await call_hf_model(explain_msgs, req.temperature, req.max_tokens)
+    logger.info(f"Spiegazione:\n{explanation}")
 
-    # 10) Restituiamo i risultati e la spiegazione finale
+    # Ritorniamo query, risultati e spiegazione
     return {
-        "type": "NATURAL",
+        "type":"NATURAL",
         "sparql_query": sparql_query,
-        "sparql_results": row_list,  # Lista di stringhe
-        "explanation": explanation_text
+        "sparql_results": row_list,
+        "explanation": explanation
     }
 
 @app.get("/")
-async def root():
-    return {"message": "Server con ontologia in system prompt, doppio tentativo SPARQL e interpretazione."}
+def home():
+    return {"message":"OK robusto con regole rigide e doppio tentativo."}