Update app.py

app.py

@@ -12,97 +12,107 @@ import re
 # CONFIGURAZIONE LOGGING
 # ---------------------------------------------------------------------------
 logging.basicConfig(
-    level=logging.DEBUG,  # DEBUG per un log più dettagliato
+    level=logging.DEBUG,  # Utilizziamo il livello DEBUG per un log più dettagliato
     format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[logging.FileHandler("app.log"), logging.StreamHandler()]
 )
 logger = logging.getLogger(__name__)
 
-# Categorie di zero-shot classification
-CANDIDATE_LABELS = ["domanda_museo", "small_talk", "fuori_contesto"]
+# ---------------------------------------------------------------------------
+# 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_MODEL = "meta-llama/Llama-3.3-70B-Instruct"  # modello per query SPARQL e risposte
-ZERO_SHOT_MODEL = "facebook/bart-large-mnli"     # modello per zero-shot classification
-
 if not HF_API_KEY:
+    # Se la chiave API non è impostata, solleva un errore
     logger.error("HF_API_KEY non impostata.")
     raise EnvironmentError("HF_API_KEY non impostata.")
 
+# Nome del modello Hugging Face per generare query SPARQL e risposte finali
+HF_MODEL = "meta-llama/Llama-3.3-70B-Instruct"
+
+# Nome del modello Hugging Face per rilevamento lingua
+LANG_DETECT_MODEL = "papluca/xlm-roberta-base-language-detection"
+
+# Prefisso per i modelli di traduzione su Hugging Face
+TRANSLATOR_MODEL_PREFIX = "Helsinki-NLP/opus-mt"
+
 # ---------------------------------------------------------------------------
-# INIZIALIZZIAMO IL CLIENT PER ZERO-SHOT
+# INIZIALIZZAZIONE CLIENT HUGGING FACE (una volta sola)
 # ---------------------------------------------------------------------------
+"""
+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
+"""
 try:
-    logger.info("Inizializzazione del client per Zero-Shot Classification.")
-    client_cls = InferenceClient(
+    logger.info("[Startup] Inizializzazione client HF per generazione (modello di LLM).")
+    hf_generation_client = InferenceClient(
         token=HF_API_KEY,
-        model=ZERO_SHOT_MODEL
+        model=HF_MODEL
+    )
+    logger.info("[Startup] Inizializzazione client HF per rilevamento lingua.")
+    lang_detect_client = InferenceClient(
+        token=HF_API_KEY,
+        model=LANG_DETECT_MODEL
     )
-    logger.info("Client zero-shot creato con successo.")
 except Exception as ex:
-    logger.error(f"Errore nell'inizializzazione del client zero-shot: {ex}")
-    raise ex
+    logger.error(f"Errore inizializzazione dei client Hugging Face: {ex}")
+    raise HTTPException(status_code=500, detail="Impossibile inizializzare i modelli Hugging Face.")
 
 # ---------------------------------------------------------------------------
-# FUNZIONE DI CLASSIFICAZIONE
+# CARICAMENTO ONTOLOGIA
 # ---------------------------------------------------------------------------
-def classify_message_inference_api(text: str) -> str:
-    """
-    Usa client_cls.zero_shot_classification(...) per classificare
-    'domanda_museo', 'small_talk' o 'fuori_contesto'.
-    Restituisce la label top.
-    """
-    try:
-        hypothesis_template = "Questa domanda è inerente all'arte o all'ontologia di un museo ({}), oppure no?"
-
-        # multi_label=False => elegge UNA sola label top
-        results = client_cls.zero_shot_classification(
-            text=text,
-            candidate_labels=CANDIDATE_LABELS,
-            multi_label=False,
-            hypothesis_template=hypothesis_template
-        )
-        # results è una lista di ZeroShotClassificationOutputElement
-        # es: [ZeroShotClassificationOutputElement(label='domanda_museo', score=0.85), ...]
-        top_label = results[0].label
-        top_score = results[0].score
-        logger.info(f"[ZeroShot] top_label={top_label}, score={top_score}")
-        return top_label
-    except Exception as e:
-        logger.error(f"Errore nella zero-shot classification: {e}")
-        return "fuori_contesto"  # fallback in caso di errore
-
-# Inizializziamo la nostra ontologia
+"""
+Carichiamo il file RDF/XML contenente l'ontologia del museo. Questo file è 
+fondamentale per l'esecuzione di query SPARQL, in quanto definisce le classi,
+le proprietà e le istanze presenti nell'ontologia del museo.
+"""
 BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-RDF_FILE = os.path.join(BASE_DIR, "Ontologia_corretto.rdf")
-client_cls = InferenceClient(token=HF_API_KEY)
+RDF_FILE = os.path.join(BASE_DIR, "Ontologia_corretto-2.rdf")
+
 ontology_graph = rdflib.Graph()
 try:
-    # L'ontologia è in formato RDF/XML
     logger.info(f"Caricamento ontologia da file: {RDF_FILE}")
+    # Indichiamo che l'ontologia è in formato RDF/XML
     ontology_graph.parse(RDF_FILE, format="xml")
     logger.info("Ontologia RDF caricata correttamente (formato XML).")
 except Exception as e:
     logger.error(f"Errore nel caricamento dell'ontologia: {e}")
     raise e
-
 # ---------------------------------------------------------------------------
-# DEFINIZIONE DELL'APP FASTAPI
+# Pydantic Model per la richiesta
 # ---------------------------------------------------------------------------
-app = FastAPI()
-
-# Modello di request
 class AssistantRequest(BaseModel):
+    """
+    Questo modello Pydantic definisce lo schema della richiesta che 
+    riceverà l'endpoint /assistant. Contiene:
+    - message: la domanda del visitatore
+    - max_tokens: max di token per le risposte (di default 512)
+    - temperature: temperatura di generazione (di default 0.5)
+    """
     message: str
     max_tokens: int = 512
     temperature: float = 0.5
 
 # ---------------------------------------------------------------------------
-# FUNZIONI DI SUPPORTO (Prompts, validazione SPARQL, correzione)
+# FUNZIONI DI SUPPORTO (Prompts, validazione SPARQL, correzioni, ecc.)
 # ---------------------------------------------------------------------------
+
 def create_system_prompt_for_sparql(ontology_turtle: str) -> str:
     """
-    PRIMO PROMPT DI SISTEMA molto prolisso e stringente sulle regole SPARQL,
-    con i vari esempi (1-10) inclusi.
+    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.
+    
+    Parametri:
+    - ontology_turtle: una stringa con l'ontologia in formato Turtle (o simile).
+    
+    Ritorna:
+    - Il testo da usare come "system prompt" per il modello generativo.
     """
     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.
@@ -155,12 +165,13 @@ FINE ONTOLOGIA.
 """
     logger.debug("[create_system_prompt_for_sparql] Prompt generato con ESEMPI e regole SPARQL.")
     return prompt
-from huggingface_hub import InferenceClient
+
 
 def classify_and_translate(question_text: str, model_answer_text: str) -> str:
     """
     Classifica la lingua della domanda e della risposta, quindi traduce la risposta
-    nella lingua della domanda se sono diverse.
+    se la lingua è diversa da quella della domanda. L'idea è di restituire una 
+    risposta nella stessa lingua dell'utente.
     
     Parametri:
     - question_text: Testo della domanda dell'utente.
@@ -169,17 +180,12 @@ 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.
-    """
-    # Costanti
-    LANG_DETECT_MODEL = "papluca/xlm-roberta-base-language-detection"  # Modello per rilevamento lingua
-    TRANSLATOR_MODEL_PREFIX = "Helsinki-NLP/opus-mt"  # Prefisso dei modelli di traduzione
-
-    # Crea il client per il rilevamento delle lingue
-    lang_detect_client = InferenceClient(
-        token=HF_API_KEY,
-        model=LANG_DETECT_MODEL
-    )
 
+    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 
+    dalle due lingue effettive.
+    """
     # Rileva la lingua della domanda
     try:
         question_lang_result = lang_detect_client.text_classification(text=question_text)
@@ -187,7 +193,7 @@ def classify_and_translate(question_text: str, model_answer_text: str) -> str:
         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"  # Default fallback
+        question_lang = "en"  # Fallback se non riusciamo a rilevare la lingua
 
     # Rileva la lingua della risposta
     try:
@@ -196,95 +202,104 @@ def classify_and_translate(question_text: str, model_answer_text: str) -> str:
         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 = "en"  # Default fallback
+        answer_lang = "it"  # Fallback se non riusciamo a rilevare la lingua
 
-    # Se le lingue sono uguali, non tradurre
+    # Se domanda e risposta sono nella stessa lingua, non traduciamo
     if question_lang == answer_lang:
-        logger.info("[Translate] Lingue uguali, nessuna traduzione necessaria.")
+        logger.info("[Translate] Nessuna traduzione necessaria: stessa lingua.")
         return model_answer_text
 
-    # Prepara il modello di traduzione
+    # Altrimenti, costruiamo "al volo" il modello di traduzione appropriato 
+    # (es: "Helsinki-NLP/opus-mt-en-it", "Helsinki-NLP/opus-mt-fr-en", ecc.)
     translator_model = f"{TRANSLATOR_MODEL_PREFIX}-{answer_lang}-{question_lang}"
-
-    # Crea il client per la traduzione
     translator_client = InferenceClient(
         token=HF_API_KEY,
         model=translator_model
     )
 
-    # Traduci la risposta
+    # 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.")
     except Exception as e:
-        logger.error(f"Errore nella traduzione {answer_lang}->{question_lang}: {e}")
-        translated_answer = model_answer_text  # Fallback alla risposta originale
+        logger.error(f"Errore nella traduzione {answer_lang} -> {question_lang}: {e}")
+        # Se fallisce, restituiamo la risposta originale come fallback
+        translated_answer = model_answer_text
 
     return translated_answer
 
 
 def create_system_prompt_for_guide() -> str:
     """
-    SECONDO PROMPT DI SISTEMA:
-    - Risponde in stile "guida museale" in modo breve (max ~50 parole).
-    - Se c'è una query e risultati, descrive brevemente.
-    - Se non c'è query o non ci sono risultati, prova comunque a dare una risposta.
+    Genera un testo di prompt che istruisce il modello a rispondere 
+    come "guida museale virtuale", in modo breve (~50 parole), riassumendo 
+    i risultati SPARQL (se presenti) o fornendo comunque una risposta 
+    in base alle conoscenze pregresse.
     """
     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."
-)
+        "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."
+    )
     logger.debug("[create_system_prompt_for_guide] Prompt per la risposta guida museale generato.")
     return prompt
 
 
 def correct_sparql_syntax_advanced(query: str) -> str:
     """
-    Corregge in maniera più complessa gli errori sintattici comuni generati dal modello
-    nelle query SPARQL, tramite euristiche:
-      - Spazi dopo SELECT, WHERE
-      - Rimozione di '?autore' attaccato a 'progettoMuseo:autoreOpera?autore'
-      - Aggiunta di PREFIX se assente
-      - Rimozione newline (una riga)
-      - Aggiunta di '.' se manca a fine tripla
-      - Pulizia di spazi doppi
+    Applica correzioni sintattiche (euristiche) su una query SPARQL eventualmente
+    mal formattata, generata dal modello. 
+    Passi:
+      1. Rimuove newline.
+      2. Verifica l'esistenza di 'PREFIX progettoMuseo:' e lo aggiunge se mancante.
+      3. Inserisce spazi dopo SELECT, WHERE (se mancanti).
+      4. Se c'è 'progettoMuseo:autoreOpera?autore' lo trasforma in 'progettoMuseo:autoreOpera ?autore'.
+      5. Rimuove spazi multipli.
+      6. Aggiunge '.' prima di '}' se manca.
+      7. Aggiunge la clausola WHERE se non presente.
+    
+    Parametri:
+    - query: stringa con la query SPARQL potenzialmente mal formattata.
+
+    Ritorna:
+    - La query SPARQL corretta se possibile, in singola riga.
     """
     original_query = query
     logger.debug(f"[correct_sparql_syntax_advanced] Query originaria:\n{original_query}")
 
-    # 1) Rimuoviamo newline e forziamo un'unica riga
+    # 1) Rimuoviamo newline e normalizziamo a una singola riga
     query = query.replace('\n', ' ').replace('\r', ' ')
 
-    # 2) Se manca il PREFIX, lo aggiungiamo in testa (solo se notiamo che non c'è "PREFIX progettoMuseo:")
+    # 2) Se manca il PREFIX museo, lo aggiungiamo in testa
     if 'PREFIX progettoMuseo:' not in query:
         logger.debug("[correct_sparql_syntax_advanced] Aggiungo PREFIX progettoMuseo.")
-        query = ("PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> "
-                 + query)
+        query = (
+            "PREFIX progettoMuseo: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> "
+            + query
+        )
 
-    # 3) Spazio dopo SELECT se manca
+    # 3) Spazio dopo SELECT se manca (SELECT?autore => SELECT ?autore)
     query = re.sub(r'(SELECT)(\?|\*)', r'\1 \2', query, flags=re.IGNORECASE)
 
-    # 4) Spazio dopo WHERE se manca
+    # 4) Spazio dopo WHERE se manca (WHERE{ => WHERE {)
     query = re.sub(r'(WHERE)\{', r'\1 {', query, flags=re.IGNORECASE)
 
-    # 5) Correggiamo i punti interrogativi attaccati alle proprietà:
-    #    "progettoMuseo:autoreOpera?autore" => "progettoMuseo:autoreOpera ?autore"
+    # 5) Correggiamo le incollature: progettoMuseo:autoreOpera?autore => progettoMuseo:autoreOpera ?autore
     query = re.sub(r'(progettoMuseo:\w+)\?(\w+)', r'\1 ?\2', query)
 
     # 6) Rimuoviamo spazi multipli
     query = re.sub(r'\s+', ' ', query).strip()
 
-    # 7) Aggiungiamo '.' a fine tripla prima del '}' se manca
+    # 7) Aggiungiamo '.' prima di '}' se manca
     query = re.sub(r'(\?\w+)\s*\}', r'\1 . }', query)
 
-    # 8) Se manca la clausola WHERE, proviamo ad aggiungerla
+    # 8) Se manca la clausola WHERE, la aggiungiamo
     if 'WHERE' not in query.upper():
         query = re.sub(r'(SELECT\s+[^\{]+)\{', r'\1 WHERE {', query, flags=re.IGNORECASE)
 
-    # 9) Pulizia finale di spazi
+    # 9) Pulizia spazi superflui
     query = re.sub(r'\s+', ' ', query).strip()
 
     logger.debug(f"[correct_sparql_syntax_advanced] Query dopo correzioni:\n{query}")
@@ -292,7 +307,10 @@ def correct_sparql_syntax_advanced(query: str) -> str:
 
 
 def is_sparql_query_valid(query: str) -> bool:
-    """Verifica la sintassi SPARQL tramite rdflib."""
+    """
+    Verifica la validità sintattica di una query SPARQL usando rdflib.
+    Ritorna True se la query è sintatticamente corretta, False altrimenti.
+    """
     logger.debug(f"[is_sparql_query_valid] Validazione SPARQL: {query}")
     try:
         parseQuery(query)
@@ -303,50 +321,63 @@ def is_sparql_query_valid(query: str) -> bool:
         return False
 
 # ---------------------------------------------------------------------------
-# ENDPOINT UNICO
+# ENDPOINT UNICO: /assistant
 # ---------------------------------------------------------------------------
 @app.post("/assistant")
 def assistant_endpoint(req: AssistantRequest):
     """
-    Endpoint UNICO con due step interni:
-    1) Genera la query SPARQL (prompt prolisso).
-    2) Esegue la query (se valida) e fornisce una risposta breve stile "guida museale",
-       anche se i risultati sono vuoti o la query non esiste.
+    Endpoint che gestisce l'intera pipeline:
+     1) Genera una query SPARQL dal messaggio dell'utente (prompt dedicato).
+     2) Verifica la validità della query e, se valida, la esegue sull'ontologia RDF.
+     3) Crea un "prompt da guida museale" e genera una risposta finale breve (max ~50 parole).
+     4) Eventualmente, traduce la risposta nella lingua dell'utente.
+    
+    Parametri:
+    - req (AssistantRequest): un oggetto contenente:
+       - message (str): la domanda dell'utente
+       - max_tokens (int, opzionale): numero massimo di token per la generazione
+       - temperature (float, opzionale): temperatura per la generazione
+    
+    Ritorna:
+    - Un JSON con:
+       {
+         "query": <la query SPARQL generata o None>,
+         "response": <la risposta finale in linguaggio naturale>
+       }
     """
     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
-    label = classify_message_inference_api(user_message)
-    logger.info(label)
+
     logger.debug(f"Parametri utente: message='{user_message}', max_tokens={max_tokens}, temperature={temperature}")
-        # STEP 1: Generazione SPARQL
+
+    # -----------------------------------------------------------------------
+    # STEP 1: Generazione della query SPARQL
+    # -----------------------------------------------------------------------
     try:
-        logger.debug("Serializzazione dell'ontologia in formato Turtle per contesto nel prompt.")
+        # 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).")
     except Exception as e:
-        logger.warning(f"Impossibile serializzare l'ontologia in Turtle: {e}")
+        logger.warning(f"Impossibile serializzare l'ontologia in formato XML: {e}")
         ontology_turtle = ""
+
+    # Creiamo il prompt di sistema per la generazione SPARQL
     system_prompt_sparql = create_system_prompt_for_sparql(ontology_turtle)
-    # Inizializziamo client Hugging Face
-    try:
-        logger.debug(f"Inizializzazione InferenceClient con modello='{HF_MODEL}'.")
-        hf_client = InferenceClient(model=HF_MODEL, token=HF_API_KEY)
-    except Exception as ex:
-        logger.error(f"Errore inizializzazione HF client: {ex}")
-        raise HTTPException(status_code=500, detail="Impossibile inizializzare il modello Hugging Face.")
 
-    # Chiediamo al modello la query SPARQL (fase interna 1)
+    # Chiamata al modello per generare la query SPARQL
     try:
         logger.debug("[assistant_endpoint] Chiamata HF per generare la query SPARQL...")
-        gen_sparql_output = hf_client.chat.completions.create(
+        gen_sparql_output = hf_generation_client.chat.completions.create(
             messages=[
                 {"role": "system", "content": system_prompt_sparql},
                 {"role": "user", "content": user_message}
             ],
-            max_tokens=512,
-            temperature=0
+            max_tokens=512,       # max_tokens per la generazione della query
+            temperature=0.2       # temperatura bassa per avere risposte più "deterministiche"
         )
         possible_query = gen_sparql_output["choices"][0]["message"]["content"].strip()
         logger.info(f"[assistant_endpoint] Query generata dal modello: {possible_query}")
@@ -355,22 +386,24 @@ def assistant_endpoint(req: AssistantRequest):
         # Se fallisce la generazione, consideriamo la query come "NO_SPARQL"
         possible_query = "NO_SPARQL"
 
-    # Verifica se la query è NO_SPARQL
+    # Verifichiamo se la query è "NO_SPARQL"
     if possible_query.upper().startswith("NO_SPARQL"):
         generated_query = None
-        logger.debug("[assistant_endpoint] Modello indica 'NO_SPARQL', nessuna query generata.")
+        logger.debug("[assistant_endpoint] Modello indica 'NO_SPARQL', quindi nessuna query generata.")
     else:
-        # Correggiamo in modo avanzato
+        # Applichiamo la correzione avanzata
         advanced_corrected = correct_sparql_syntax_advanced(possible_query)
-        # Dopo la correzione, verifichiamo se è valida
+        # 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}")
         else:
-            logger.debug("[assistant_endpoint] Query SPARQL non valida dopo correzione avanzata. La ignoriamo.")
+            logger.debug("[assistant_endpoint] Query SPARQL non valida. Verrà ignorata.")
             generated_query = None
 
-    # STEP 2: Esecuzione query (se presente) e risposta guida
+    # -----------------------------------------------------------------------
+    # STEP 2: Esecuzione della query, se disponibile
+    # -----------------------------------------------------------------------
     results = []
     if generated_query:
         logger.debug(f"[assistant_endpoint] Esecuzione della query SPARQL:\n{generated_query}")
@@ -381,17 +414,17 @@ def assistant_endpoint(req: AssistantRequest):
         except Exception as ex:
             logger.error(f"[assistant_endpoint] Errore nell'esecuzione della query: {ex}")
             results = []
-    
-    # Creiamo il prompt di sistema "guida museale"
+
+    # -----------------------------------------------------------------------
+    # STEP 3: Generazione della risposta finale stile "guida museale"
+    # -----------------------------------------------------------------------
     system_prompt_guide = create_system_prompt_for_guide()
+
     if generated_query and results:
-        # Abbiamo query + risultati
+        # Caso: query generata + risultati SPARQL
         # Convertiamo i risultati in una stringa più leggibile
         results_str = "\n".join(
-            f"{idx+1}) " + ", ".join(
-                f"{var}={row[var]}"
-                for var in row.labels
-            )
+            f"{idx+1}) " + ", ".join(f"{var}={row[var]}" for var in row.labels)
             for idx, row in enumerate(results)
         )
         second_prompt = (
@@ -402,17 +435,19 @@ def assistant_endpoint(req: AssistantRequest):
             "Rispondi in modo breve (max ~50 parole)."
         )
         logger.debug("[assistant_endpoint] Prompt di risposta con risultati SPARQL.")
+
     elif generated_query and not results:
-        # Query valida ma 0 risultati
+        # Caso: query valida ma 0 risultati
         second_prompt = (
             f"{system_prompt_guide}\n\n"
             f"Domanda utente: {user_message}\n"
             f"Query generata: {generated_query}\n"
             "Nessun risultato dalla query. Prova comunque a rispondere con le tue conoscenze."
         )
-        logger.debug("[assistant_endpoint] Prompt di risposta: query valida ma nessun risultato.")
+        logger.debug("[assistant_endpoint] Prompt di risposta: query valida ma senza risultati.")
+
     else:
-        # Nessuna query generata
+        # Caso: nessuna query generata
         second_prompt = (
             f"{system_prompt_guide}\n\n"
             f"Domanda utente: {user_message}\n"
@@ -420,42 +455,56 @@ def assistant_endpoint(req: AssistantRequest):
         )
         logger.debug("[assistant_endpoint] Prompt di risposta: nessuna query generata.")
 
-    # Ultima chiamata al modello per la risposta finale
+    # Chiamata finale al modello per la risposta "guida museale"
     try:
-        logger.debug("[assistant_endpoint] Chiamata HF per la risposta guida museale...")
-        final_output = hf_client.chat.completions.create(
+        logger.debug("[assistant_endpoint] Chiamata HF per generare la risposta finale...")
+        final_output = hf_generation_client.chat.completions.create(
             messages=[
                 {"role": "system", "content": second_prompt},
                 {"role": "user", "content": "Fornisci la risposta finale."}
             ],
-            max_tokens=512,
-            temperature=0.2
+            max_tokens=max_tokens,
+            temperature=temperature
         )
         final_answer = final_output["choices"][0]["message"]["content"].strip()
         logger.info(f"[assistant_endpoint] Risposta finale generata: {final_answer}")
     except Exception as ex:
         logger.error(f"Errore nella generazione della risposta finale: {ex}")
         raise HTTPException(status_code=500, detail="Errore nella generazione della risposta in linguaggio naturale.")
+
+    # -----------------------------------------------------------------------
+    # STEP 4: Traduzione (se necessario)
+    # -----------------------------------------------------------------------
     final_ans = classify_and_translate(user_message, final_answer)
-    # Risposta JSON
-    logger.debug("[assistant_endpoint] Fine elaborazione. Restituzione risposta.")
+    final_ans = final_ans.replace('\\"', "").replace('\"', "")
+    # -----------------------------------------------------------------------
+    # Restituzione in formato JSON
+    # -----------------------------------------------------------------------
+    logger.debug("[assistant_endpoint] Fine elaborazione, restituzione risposta JSON.")
     return {
         "query": generated_query,
         "response": final_ans
     }
 
 # ---------------------------------------------------------------------------
-# ENDPOINT DI TEST
+# ENDPOINT DI TEST / HOME
 # ---------------------------------------------------------------------------
 @app.get("/")
 def home():
+    """
+    Endpoint di test per verificare se l'applicazione è in esecuzione.
+    """
     logger.debug("Chiamata GET su '/' - home.")
     return {
-        "message": "Endpoint con ESEMPI di query SPARQL + correzione avanzata + risposta guida museale."
+        "message": "Endpoint attivo. Esempio di backend per generare query SPARQL e risposte guida museale."
     }
 
 # ---------------------------------------------------------------------------
 # MAIN
 # ---------------------------------------------------------------------------
 if __name__ == "__main__":
-    logger.info("Avvio dell'applicazione FastAPI.")
+    """
+    Avvio dell'applicazione FastAPI sulla porta 8000, 
+    utile se eseguito come script principale.
+    """
+    logger.info("Avvio dell'applicazione FastAPI.")