Update app.py

app.py

@@ -7,7 +7,8 @@ import rdflib
 from rdflib.plugins.sparql.parser import parseQuery
 from huggingface_hub import InferenceClient
 import re
-
+import torch
+from transformers import DistilBertForSequenceClassification, DistilBertTokenizer
 # ---------------------------------------------------------------------------
 # CONFIGURAZIONE LOGGING
 # ---------------------------------------------------------------------------
@@ -18,11 +19,27 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
+
+# Determina il device (GPU se disponibile, altrimenti CPU)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+logger.info(f"Device per il classificatore: {device}")
+
+# Carica il modello e il tokenizer del classificatore fine-tuned
+try:
+    logger.info("Caricamento del modello di classificazione fine-tuned da 'finetuned-bert-model'.")
+    classifier_model = DistilBertForSequenceClassification.from_pretrained("finetuned-bert-model")
+    classifier_tokenizer = DistilBertTokenizer.from_pretrained("finetuned-bert-model")
+    classifier_model.to(device)
+    logger.info("Modello di classificazione caricato correttamente.")
+except Exception as e:
+    logger.error(f"Errore nel caricamento del modello di classificazione: {e}")
+    classifier_model = None
+explanation_dict = {}
 # ---------------------------------------------------------------------------
 # COSTANTI / CHIAVI / MODELLI
 # ---------------------------------------------------------------------------
 # Nota: HF_API_KEY deve essere impostata a una chiave valida di Hugging Face.
-HF_API_KEY = os.getenv("HF_API_KEY") 
+HF_API_KEY = os.getenv("HF_API_KEY")
 if not HF_API_KEY:
     # Se la chiave API non è impostata, solleva un errore
     logger.error("HF_API_KEY non impostata.")
@@ -43,7 +60,6 @@ TRANSLATOR_MODEL_PREFIX = "Helsinki-NLP/opus-mt"
 """
 Qui inizializziamo i client necessari. In questo modo, evitiamo di istanziare
 continuamente nuovi oggetti InferenceClient a ogni chiamata delle funzioni.
-
 - hf_generation_client: per generare query SPARQL e risposte stile "guida museale"
 - lang_detect_client: per rilevare la lingua della domanda e della risposta
 """
@@ -104,13 +120,29 @@ class AssistantRequest(BaseModel):
 # ---------------------------------------------------------------------------
 # FUNZIONI DI SUPPORTO (Prompts, validazione SPARQL, correzioni, ecc.)
 # ---------------------------------------------------------------------------
+def create_system_prompt_for_classification(ontology_turtle:str) -> str:
+    prompt = f"""
+SEI UN CLASSIFICATORE DI DOMANDE NEL CONTESTO DI UN MUSEO. 
+DEVI ANALIZZARE LA DOMANDA DELL'UTENTE E, BASANDOTI SUL CONTESTO DELL'ONTOLOGIA (CHE TI VIENE FORNITA QUI SOTTO), RISPONDERE SOLAMENTE CON "SI" SE LA DOMANDA È PERTINENTE AL MUSEO, O CON "NO" SE LA DOMANDA NON È PERTINENTE.
+RICORDA:
+- "PERTINENTE" SIGNIFICA CHE LA DOMANDA RIGUARDA OPERE D'ARTE, ESPOSTE, BIGLIETTI, VISITATORI, CURATORI, RESTAURI, STANZE E TUTTI GLI ASPETTI RELATIVI ALL'AMBIENTE MUSEALE.
+- "NON PERTINENTE" SIGNIFICA CHE LA DOMANDA RIGUARDA ARGOMENTI ESTERNI AL CONTESTO MUSEALE (PER ESEMPIO, TECNOLOGIA, SPORT, POLITICA, CUCINA, ECC.).
+NON FORNIRE ULTERIORI SPIEGAZIONI O COMMENTI: LA TUA RISPOSTA DEVE ESSERE ESCLUSIVAMENTE "SI" O "NO".
+
+ONTOLOGIA (TURTLE/XML/ALTRO FORMATO):
+{ontology_turtle}
 
+FINE ONTOLOGIA.
+
+"""
+    return prompt
 def create_system_prompt_for_sparql(ontology_turtle: str) -> str:
     """
     Genera il testo di prompt che istruisce il modello su come costruire
     SOLO UNA query SPARQL, in un'unica riga, o in alternativa 'NO_SPARQL' 
     se la domanda non è pertinente all'ontologia. Il prompt include regole 
-    di formattazione e alcuni esempi di domanda-risposta SPARQL.
+    di formattazione, esempi di domanda-risposta SPARQL e regole rigorose 
+    per la gestione della posizione dell'opera.
     
     Parametri:
     - ontology_turtle: una stringa con l'ontologia in formato Turtle (o simile).
@@ -121,7 +153,6 @@ def create_system_prompt_for_sparql(ontology_turtle: str) -> str:
     prompt = f"""SEI UN GENERATORE DI QUERY SPARQL PER L'ONTOLOGIA DI UN MUSEO.
 DEVI GENERARE SOLO UNA QUERY SPARQL (IN UNA SOLA RIGA) SE LA DOMANDA RIGUARDA INFORMAZIONI NELL'ONTOLOGIA.
 SE LA DOMANDA NON È ATTINENTE, RISPONDI 'NO_SPARQL'.
-
 REGOLE SINTATTICHE RIGOROSE:
 1) Usare: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
 2) Query in UNA SOLA RIGA (niente a capo), forma: PREFIX progettoMuseo: <...> SELECT ?x WHERE {{ ... }} LIMIT N
@@ -135,43 +166,51 @@ REGOLE SINTATTICHE RIGOROSE:
 Esempi di Domande Specifiche e relative Query:
 1) Utente: Chi ha creato l'opera 'Afrodite di Milo'?
    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?autore WHERE {{ progettoMuseo:AfroditeDiMilo progettoMuseo:autoreOpera ?autore . }} LIMIT 10
-
 2) Utente: Quali sono le tecniche utilizzate nelle opere?
    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera ?tecnica WHERE {{ ?opera progettoMuseo:tecnicaOpera ?tecnica . }} LIMIT 100
-
 3) Utente: Quali sono le dimensioni delle opere?
    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera ?dimensione WHERE {{ ?opera progettoMuseo:dimensioneOpera ?dimensione . }} LIMIT 100
-
 4) Utente: Quali opere sono esposte nella stanza Greca?
    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera WHERE {{ progettoMuseo:StanzaGrecia progettoMuseo:Espone ?opera . }} LIMIT 100
-
 5) Utente: Quali sono le proprietà e i tipi delle proprietà nell'ontologia?
    Risposta: PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> PREFIX owl: <http://www.w3.org/2002/07/owl#> PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT DISTINCT ?property ?type WHERE {{ ?property rdf:type ?type . FILTER(?type IN (owl:ObjectProperty, owl:DatatypeProperty)) }}
-
 6) Utente: Recupera tutti i biglietti e i tipi di biglietto.
    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?biglietto ?tipoBiglietto WHERE {{ ?biglietto rdf:type progettoMuseo:Biglietto . ?biglietto progettoMuseo:tipoBiglietto ?tipoBiglietto . }} LIMIT 100
-
 7) Utente: Recupera tutti i visitatori e i tour a cui partecipano.
    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?visitatore ?tour WHERE {{ ?visitatore progettoMuseo:Partecipazione_a_Evento ?tour . }} LIMIT 100
-
 8) Utente: Recupera tutte le stanze tematiche e le opere esposte.
    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?stanza ?opera WHERE {{ ?stanza rdf:type progettoMuseo:Stanza_Tematica . ?stanza progettoMuseo:Espone ?opera . }} LIMIT 100
-
 9) Utente: Recupera tutte le opere con materiale 'Marmo'.
    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera WHERE {{ ?opera progettoMuseo:materialeOpera "Marmo"@it . }} LIMIT 100
-
 10) Utente: Recupera tutti i visitatori con data di nascita dopo il 2000.
     Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?visitatore WHERE {{ ?visitatore rdf:type progettoMuseo:Visitatore_Individuale . ?visitatore progettoMuseo:dataDiNascitaVisitatore ?data . FILTER(?data > "2000-01-01T00:00:00"^^xsd:dateTime) . }} LIMIT 100
 
+NUOVE REGOLE RIGUARDANTI LA POSIZIONE DELL'OPERA:
+- SE la domanda include richieste come "fammi vedere l'opera X", "mi fai vedere l'opera X", "portami all'opera X", "voglio vedere l'opera X" o simili, la query SPARQL DEVE restituire la posizione dell'opera includendo la proprietà progettoMuseo:posizioneOpera.
+- SE la domanda include espressioni come "dove si trova l'opera X", "ubicazione dell'opera X" o simili, la query SPARQL NON deve restituire la proprietà progettoMuseo:posizioneOpera, limitandosi al massimo a riportare la relazione esistente.
+
+Esempi Aggiuntivi:
+11) Utente: Fammi vedere l'opera 'Discobolo'.
+    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera ?posizione WHERE {{ progettoMuseo:Discobolo progettoMuseo:posizioneOpera ?posizione . }} LIMIT 10
+12) Utente: Mi fai vedere l'opera 'Gioconda'?
+    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera ?posizione WHERE {{ progettoMuseo:Gioconda progettoMuseo:posizioneOpera ?posizione . }} LIMIT 10
+13) Utente: Portami all'opera 'Autoritratto'.
+    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera ?posizione WHERE {{ progettoMuseo:Autoritratto progettoMuseo:posizioneOpera ?posizione . }} LIMIT 10
+14) Utente: Dove si trova l'opera 'La Notte Stellata'?
+    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera WHERE {{ progettoMuseo:LaNotteStellata ?rel ?info . FILTER(?rel != progettoMuseo:posizioneOpera) }} LIMIT 10
+15) Utente: Qual è l'ubicazione dell'opera 'Ramo Di Mandorlo Fiorito'?
+    Risposta: PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?opera WHERE {{ progettoMuseo:RamoDiMandorloFiorito ?rel ?info . FILTER(?rel != progettoMuseo:posizioneOpera) }} LIMIT 10
+
 ECCO L'ONTOLOGIA (TURTLE) PER CONTESTO:
 {ontology_turtle}
 FINE ONTOLOGIA.
 """
-    logger.debug("[create_system_prompt_for_sparql] Prompt generato con ESEMPI e regole SPARQL.")
+    logger.debug("[create_system_prompt_for_sparql] Prompt generato con esempi originali e nuove regole rigorose sulla posizione.")
     return prompt
 
 
-def classify_and_translate(question_text: str, model_answer_text: str) -> str:
+
+def classify_and_translate(question_text: str, model_answer_text: str):
     """
     Classifica la lingua della domanda e della risposta, quindi traduce la risposta
     se la lingua è diversa da quella della domanda. L'idea è di restituire una 
@@ -184,7 +223,6 @@ def classify_and_translate(question_text: str, model_answer_text: str) -> str:
     Restituisce:
     - La risposta tradotta nella lingua della domanda o la risposta originale
       se entrambe le lingue coincidono.
-
     NB: Qui l'oggetto 'lang_detect_client' (per rilevamento lingua) è già 
     stato inizializzato all'avvio dell'app. Mentre il 'translator_client'
     viene creato 'al volo' poiché la direzione di traduzione dipende 
@@ -194,23 +232,27 @@ def classify_and_translate(question_text: str, model_answer_text: str) -> str:
     try:
         question_lang_result = lang_detect_client.text_classification(text=question_text)
         question_lang = question_lang_result[0]['label']
+        explanation_dict['language_detection'] = f"Domanda in: {question_lang}."
         logger.info(f"[LangDetect] Lingua della domanda: {question_lang}")
     except Exception as e:
         logger.error(f"Errore nel rilevamento della lingua della domanda: {e}")
         question_lang = "en"  # Fallback se non riusciamo a rilevare la lingua
-
+        explanation_dict['language_detection'] = "Lingua domanda non rilevata, impostata a 'en'."
     # Rileva la lingua della risposta
     try:
         answer_lang_result = lang_detect_client.text_classification(text=model_answer_text)
         answer_lang = answer_lang_result[0]['label']
+        explanation_dict['language_detection'] += f" Risposta in: {answer_lang}."
         logger.info(f"[LangDetect] Lingua della risposta: {answer_lang}")
     except Exception as e:
         logger.error(f"Errore nel rilevamento della lingua della risposta: {e}")
         answer_lang = "it"  # Fallback se non riusciamo a rilevare la lingua
+        explanation_dict['language_detection'] += " Lingua risposta non rilevata, impostata a 'it'."
 
     # Se domanda e risposta sono nella stessa lingua, non traduciamo
     if question_lang == answer_lang:
         logger.info("[Translate] Nessuna traduzione necessaria: stessa lingua.")
+        explanation_dict['translation'] = "Nessuna traduzione necessaria."
         return model_answer_text
 
     # Altrimenti, costruiamo "al volo" il modello di traduzione appropriato 
@@ -220,15 +262,17 @@ def classify_and_translate(question_text: str, model_answer_text: str) -> str:
         token=HF_API_KEY,
         model=translator_model
     )
-
+    explanation_dict['translation'] = f"Usato modello: {translator_model}."
     # Traduzione della risposta
     try:
         translation_result = translator_client.translation(text=model_answer_text)
         translated_answer = translation_result["translation_text"]
-        logger.info("[Translate] Risposta tradotta con successo.")
+        explanation_dict['translation'] += " Traduzione riuscita."
     except Exception as e:
         logger.error(f"Errore nella traduzione {answer_lang} -> {question_lang}: {e}")
+        explanation_dict['translation'] += " Traduzione fallita, risposta originale usata."
         # Se fallisce, restituiamo la risposta originale come fallback
+        explanation_dict['translation'] = "Errore inizializzazione traduttore."
         translated_answer = model_answer_text
 
     return translated_answer
@@ -243,9 +287,12 @@ def create_system_prompt_for_guide() -> str:
     """
     prompt = (
         "SEI UNA GUIDA MUSEALE VIRTUALE. "
-        "RISPONDI IN MODO BREVE (~50 PAROLE), SENZA SALUTI O INTRODUZIONI PROLISSE. "
-        "SE HAI RISULTATI SPARQL, USALI. "
-        "SE NON HAI RISULTATI O NON HAI UNA QUERY, RISPONDI COMUNQUE CERCANDO DI RIARRANGIARE LE TUE CONOSCENZE."
+        "RISPONDI IN MODO DISCORSIVO E NATURALE (circa 100 parole), SENZA SALUTI O INTRODUZIONI PROLISSE. "
+        "SE HAI RISULTATI SPARQL, USALI; SE NON CI SONO, RISPONDI BASANDOTI SULLE TUE CONOSCENZE. "
+        "QUALORA LA DOMANDA CONTENGA ESPRESSIONI COME 'fammi vedere', 'portami', 'mi fai vedere', O SIMILI, "
+        "TRADUCI LA RICHIESTA IN UN INVITO ALL'AZIONE, AD ESEMPIO 'Adesso ti accompagno all'opera', "
+        "SENZA RIPETERE DETTAGLI SPAZIALI O TECNICI (ES. COORDINATE, DISTANZE, POSITIONI FISICHE). "
+        "PER ALTRE DOMANDE, RISPONDI IN MODO DESCRITTIVO MA SENZA INCLUDERE INFORMAZIONI TECNICHE SULLA POSIZIONE."
     )
     logger.debug("[create_system_prompt_for_guide] Prompt per la risposta guida museale generato.")
     return prompt
@@ -266,7 +313,6 @@ def correct_sparql_syntax_advanced(query: str) -> str:
     
     Parametri:
     - query: stringa con la query SPARQL potenzialmente mal formattata.
-
     Ritorna:
     - La query SPARQL corretta se possibile, in singola riga.
     """
@@ -329,6 +375,7 @@ def is_sparql_query_valid(query: str) -> bool:
 # ---------------------------------------------------------------------------
 @app.post("/assistant")
 def assistant_endpoint(req: AssistantRequest):
+    explanation_dict = {}
     """
     Endpoint che gestisce l'intera pipeline:
      1) Genera una query SPARQL dal messaggio dell'utente (prompt dedicato).
@@ -350,14 +397,37 @@ def assistant_endpoint(req: AssistantRequest):
        }
     """
     logger.info("Ricevuta chiamata POST su /assistant")
-
     # Estraggo i campi dal body della richiesta
     user_message = req.message
     max_tokens = req.max_tokens
     temperature = req.temperature
-
     logger.debug(f"Parametri utente: message='{user_message}', max_tokens={max_tokens}, temperature={temperature}")
-
+    # -------------------------------
+    # CLASSIFICAZIONE DEL TESTO RICEVUTO
+    # -------------------------------
+    if classifier_model is not None:
+        try:
+            # Prepara l'input per il modello di classificazione
+            inputs = classifier_tokenizer(user_message, return_tensors="pt", truncation=True, padding=True)
+            inputs = {k: v.to(device) for k, v in inputs.items()}
+
+            # Disattiva il calcolo del gradiente per velocizzare l'inferenza
+            with torch.no_grad():
+                outputs = classifier_model(**inputs)
+                logits = outputs.logits
+                pred = torch.argmax(logits, dim=1).item()
+
+            # Mappa l'etichetta numerica a una stringa (modifica secondo la tua logica)
+            label_mapping = {0: "NON PERTINENTE", 1: "PERTINENTE"}
+            classification_result = label_mapping.get(pred, f"Etichetta {pred}")
+            logger.info(f"[Classificazione] La domanda classificata come: {classification_result}")
+            explanation_dict['classification'] = f"Risultato classificazione: {classification_result}"
+        except Exception as e:
+            logger.error(f"Errore durante la classificazione della domanda: {e}")
+            explanation_dict['classification'] = f"Errore classificazione: {e}"
+    else:
+        logger.warning("Modello di classificazione non disponibile.")
+        explanation_dict['classification'] = "Modello di classificazione non disponibile."
     # -----------------------------------------------------------------------
     # STEP 1: Generazione della query SPARQL
     # -----------------------------------------------------------------------
@@ -365,16 +435,19 @@ def assistant_endpoint(req: AssistantRequest):
         # Serializziamo l'ontologia in XML per fornirla al prompt (anche se si chiama 'turtle' va bene così).
         ontology_turtle = ontology_graph.serialize(format="xml")
         logger.debug("Ontologia serializzata con successo (XML).")
+        explanation_dict['ontology'] = "Ontologia serializzata."
     except Exception as e:
         logger.warning(f"Impossibile serializzare l'ontologia in formato XML: {e}")
+        explanation_dict['ontology'] = f"Errore serializzazione: {e}."
         ontology_turtle = ""
 
     # Creiamo il prompt di sistema per la generazione SPARQL
     system_prompt_sparql = create_system_prompt_for_sparql(ontology_turtle)
-
+    explanation_dict['sparql_prompt'] = "Prompt SPARQL creato."
     # Chiamata al modello per generare la query SPARQL
     try:
         logger.debug("[assistant_endpoint] Chiamata HF per generare la query SPARQL...")
+        explanation_dict['sparql_generation'] = "Generazione query SPARQL iniziata."
         gen_sparql_output = hf_generation_client.chat.completions.create(
             messages=[
                 {"role": "system", "content": system_prompt_sparql},
@@ -385,8 +458,10 @@ def assistant_endpoint(req: AssistantRequest):
         )
         possible_query = gen_sparql_output["choices"][0]["message"]["content"].strip()
         logger.info(f"[assistant_endpoint] Query generata dal modello: {possible_query}")
+        explanation_dict['sparql_generation'] += f" Query: {possible_query}."
     except Exception as ex:
         logger.error(f"Errore nella generazione della query SPARQL: {ex}")
+        explanation_dict['sparql_generation'] = f"Errore generazione SPARQL: {ex}."
         # Se fallisce la generazione, consideriamo la query come "NO_SPARQL"
         possible_query = "NO_SPARQL"
 
@@ -397,12 +472,15 @@ def assistant_endpoint(req: AssistantRequest):
     else:
         # Applichiamo la correzione avanzata
         advanced_corrected = correct_sparql_syntax_advanced(possible_query)
+        explanation_dict['sparql_correction'] = "Sintassi SPARQL corretta."
         # Verifichiamo la validità della query
         if is_sparql_query_valid(advanced_corrected):
             generated_query = advanced_corrected
             logger.debug(f"[assistant_endpoint] Query SPARQL valida dopo correzione avanzata: {generated_query}")
+            explanation_dict['sparql_validation'] = "Query SPARQL valida."
         else:
             logger.debug("[assistant_endpoint] Query SPARQL non valida. Verrà ignorata.")
+            explanation_dict['sparql_validation'] = "Query SPARQL non valida."
             generated_query = None
 
     # -----------------------------------------------------------------------
@@ -411,19 +489,23 @@ def assistant_endpoint(req: AssistantRequest):
     results = []
     if generated_query:
         logger.debug(f"[assistant_endpoint] Esecuzione della query SPARQL:\n{generated_query}")
+        explanation_dict['sparql_execution'] = "Esecuzione query SPARQL."
         try:
             query_result = ontology_graph.query(generated_query)
             results = list(query_result)
             logger.info(f"[assistant_endpoint] Query eseguita con successo. Numero risultati = {len(results)}")
+            explanation_dict['sparql_execution'] += f" Risultati: {len(results)}."
         except Exception as ex:
             logger.error(f"[assistant_endpoint] Errore nell'esecuzione della query: {ex}")
+            explanation_dict['sparql_execution'] = f"Errore esecuzione: {ex}."
             results = []
-
+    else:
+        explanation_dict['sparql_execution'] = "Nessuna query eseguita."
     # -----------------------------------------------------------------------
     # STEP 3: Generazione della risposta finale stile "guida museale"
     # -----------------------------------------------------------------------
     system_prompt_guide = create_system_prompt_for_guide()
-
+    explanation_dict['guide_prompt'] = "Prompt guida museale creato."
     if generated_query and results:
         # Caso: query generata + risultati SPARQL
         # Convertiamo i risultati in una stringa più leggibile
@@ -439,7 +521,7 @@ def assistant_endpoint(req: AssistantRequest):
             "Rispondi in modo breve (max ~50 parole)."
         )
         logger.debug("[assistant_endpoint] Prompt di risposta con risultati SPARQL.")
-
+        explanation_dict['guide_prompt'] += " Inclusi risultati SPARQL."
     elif generated_query and not results:
         # Caso: query valida ma 0 risultati
         second_prompt = (
@@ -449,7 +531,7 @@ def assistant_endpoint(req: AssistantRequest):
             "Nessun risultato dalla query. Prova comunque a rispondere con le tue conoscenze."
         )
         logger.debug("[assistant_endpoint] Prompt di risposta: query valida ma senza risultati.")
-
+        explanation_dict['guide_prompt'] += " Query valida senza risultati."
     else:
         # Caso: nessuna query generata
         second_prompt = (
@@ -458,22 +540,25 @@ def assistant_endpoint(req: AssistantRequest):
             "Nessuna query SPARQL generata. Rispondi come puoi, riarrangiando le tue conoscenze."
         )
         logger.debug("[assistant_endpoint] Prompt di risposta: nessuna query generata.")
-
+        explanation_dict['guide_prompt'] += " Nessuna query generata."
     # Chiamata finale al modello per la risposta "guida museale"
     try:
         logger.debug("[assistant_endpoint] Chiamata HF per generare la risposta finale...")
+        explanation_dict['response_generation'] = "Generazione risposta finale iniziata."
         final_output = hf_generation_client.chat.completions.create(
             messages=[
                 {"role": "system", "content": second_prompt},
                 {"role": "user", "content": "Fornisci la risposta finale."}
             ],
-            max_tokens=max_tokens,
-            temperature=temperature
+            max_tokens=1024,
+            temperature=0.8
         )
         final_answer = final_output["choices"][0]["message"]["content"].strip()
         logger.info(f"[assistant_endpoint] Risposta finale generata: {final_answer}")
+        explanation_dict['response_generation'] += " Risposta generata."
     except Exception as ex:
         logger.error(f"Errore nella generazione della risposta finale: {ex}")
+        explanation_dict['response_generation'] = f"Errore generazione risposta finale: {ex}."
         raise HTTPException(status_code=500, detail="Errore nella generazione della risposta in linguaggio naturale.")
 
     # -----------------------------------------------------------------------
@@ -481,15 +566,16 @@ def assistant_endpoint(req: AssistantRequest):
     # -----------------------------------------------------------------------
     final_ans = classify_and_translate(user_message, final_answer)
     final_ans = final_ans.replace('\\"', "").replace('\"', "")
+    explanation_dict['translation_completion'] = "Traduzione completata."
     # -----------------------------------------------------------------------
     # Restituzione in formato JSON
     # -----------------------------------------------------------------------
     logger.debug("[assistant_endpoint] Fine elaborazione, restituzione risposta JSON.")
     return {
         "query": generated_query,
-        "response": final_ans
+        "response": final_ans,
+        "explanation": explanation_dict
     }
-
 # ---------------------------------------------------------------------------
 # ENDPOINT DI TEST / HOME
 # ---------------------------------------------------------------------------
@@ -502,7 +588,78 @@ def home():
     return {
         "message": "Endpoint attivo. Esempio di backend per generare query SPARQL e risposte guida museale."
     }
-
+# ---------------------------------------------------------------------------
+# ENDPOINT QUERY STANZE /QUERY_STANZE
+# ---------------------------------------------------------------------------
+@app.get("/query_stanze")
+def query_stanze_endpoint():
+    """
+    Endpoint per restituire le stanze con le opere esposte e relativi punti.
+    La query restituisce, per ogni triple, la stanza, l'opera e il valore della proprietà 
+    progettoMuseo:posizioneOpera (facoltativo). Successivamente, in Python, si raggruppa 
+    per stanza in un dizionario. Per ogni stanza, viene creata una lista di dizionari, 
+    dove ogni dizionario rappresenta un'opera e contiene:
+      - "nome": il localName dell'opera (la parte dopo il simbolo "#")
+      - "punto": il valore della proprietà progettoMuseo:posizioneOpera (se presente, altrimenti una stringa vuota)
+    
+    Query usata (in una riga):
+    PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> 
+    SELECT ?stanza ?opera ?p 
+    WHERE { 
+      ?opera progettoMuseo:èEsposto ?stanza. 
+      OPTIONAL { ?opera progettoMuseo:posizioneOpera ?p. }
+    }
+    """
+    # Definiamo la query in una singola riga
+    query_str = (
+        "PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> "
+        "SELECT ?stanza ?opera ?p WHERE { ?opera progettoMuseo:èEsposto ?stanza. "
+        "OPTIONAL { ?opera progettoMuseo:posizioneOpera ?p. } }"
+    )
+    
+    # Applichiamo eventuali correzioni sintattiche
+    corrected_query = correct_sparql_syntax_advanced(query_str)
+    logger.debug(f"[query_stanze_endpoint] Query corretta:\n{corrected_query}")
+    
+    # Verifichiamo la validità della query utilizzando il parser di rdflib
+    if not is_sparql_query_valid(corrected_query):
+        logger.error("[query_stanze_endpoint] Query SPARQL non valida.")
+        raise HTTPException(status_code=400, detail="Query SPARQL non valida.")
+    
+    try:
+        query_result = ontology_graph.query(corrected_query)
+        
+        # Costruiamo un dizionario: per ogni stanza (localName), una lista di dizionari 
+        # con chiavi "nome" (localName dell'opera) e "punto" (valore di progettoMuseo:posizioneOpera)
+        dict_stanze = {}
+        for row in query_result:
+            # Estraiamo il localName della stanza
+            stanza_uri = str(row["stanza"])
+            stanza_local = stanza_uri.split("#")[-1].strip() if "#" in stanza_uri else stanza_uri
+            
+            # Estraiamo il localName dell'opera
+            opera_uri = str(row["opera"])
+            opera_local = opera_uri.split("#")[-1].strip() if "#" in opera_uri else opera_uri
+            
+            # Estraiamo il punto (se presente)
+            punto = str(row["p"]) if row["p"] is not None else ""
+            
+            # Costruiamo il dizionario per l'opera
+            opera_dict = {"nome": opera_local, "punto": punto}
+            
+            # Raggruppiamo per stanza
+            if stanza_local not in dict_stanze:
+                dict_stanze[stanza_local] = []
+            dict_stanze[stanza_local].append(opera_dict)
+        
+        logger.info(f"[query_stanze_endpoint] Trovate {len(dict_stanze)} stanze.")
+    except Exception as ex:
+        logger.error(f"[query_stanze_endpoint] Errore nell'esecuzione della query: {ex}")
+        raise HTTPException(status_code=500, detail="Errore nell'esecuzione della query SPARQL.")
+    
+    return {
+        "stanze": dict_stanze
+    }
 # ---------------------------------------------------------------------------
 # MAIN
 # ---------------------------------------------------------------------------
@@ -511,4 +668,5 @@ if __name__ == "__main__":
     Avvio dell'applicazione FastAPI sulla porta 8000, 
     utile se eseguito come script principale.
     """
-    logger.info("Avvio dell'applicazione FastAPI.")
+    logger.info("Avvio dell'applicazione FastAPI.")
+    uvicorn.run(app, host="0.0.0.0", port=8000)