Update app.py

app.py

@@ -1,438 +1,395 @@
 import os
 import logging
-from typing import List
-from pydantic import BaseModel
+import uvicorn
 from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
 import rdflib
-from rdflib import RDF, RDFS, OWL, URIRef
-from sentence_transformers import SentenceTransformer
-import faiss
-import json
-import numpy as np
-from dotenv import load_dotenv
+from rdflib.plugins.sparql.parser import parseQuery
 from huggingface_hub import InferenceClient
+import re
 
-# Carica le variabili d'ambiente
-load_dotenv()
-
-# Configura il logging
+# ---------------------------------------------------------------------------
+# CONFIGURAZIONE LOGGING
+# ---------------------------------------------------------------------------
 logging.basicConfig(
-    level=logging.INFO,  # Mantiene INFO per ambiente di produzione
+    level=logging.DEBUG,  # DEBUG per un log più dettagliato
     format="%(asctime)s - %(levelname)s - %(message)s",
     handlers=[logging.FileHandler("app.log"), logging.StreamHandler()]
 )
 logger = logging.getLogger(__name__)
 
-# Recupera la chiave API
+# Categorie di zero-shot classification
+CANDIDATE_LABELS = ["domanda_museo", "small_talk", "fuori_contesto"]
 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:
     logger.error("HF_API_KEY non impostata.")
     raise EnvironmentError("HF_API_KEY non impostata.")
 
-# Definisci i percorsi dei file
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-RDF_FILE = os.path.join(BASE_DIR, "Ontologia.rdf")
-HF_MODEL = "Qwen/Qwen2.5-72B-Instruct"  # Modello ottimizzato per seguire istruzioni
-
-# Percorsi dei file generati
-DOCUMENTS_FILE = os.path.join(BASE_DIR, "data", "documents.json")
-FAISS_INDEX_FILE = os.path.join(BASE_DIR, "data", "faiss.index")
-
-# Carica il modello di embedding una sola volta per migliorare le prestazioni
+# ---------------------------------------------------------------------------
+# INIZIALIZZIAMO IL CLIENT PER ZERO-SHOT
+# ---------------------------------------------------------------------------
 try:
-    embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
-    logger.info("Modello SentenceTransformer caricato con successo.")
-except Exception as e:
-    logger.error(f"Errore nel caricamento del modello SentenceTransformer: {e}")
-    raise e
+    logger.info("Inizializzazione del client per Zero-Shot Classification.")
+    client_cls = InferenceClient(
+        token=HF_API_KEY,
+        model=ZERO_SHOT_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
+
+# ---------------------------------------------------------------------------
+# FUNZIONE DI CLASSIFICAZIONE
+# ---------------------------------------------------------------------------
+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
 
-# Inizializza il client di Hugging Face
+# Inizializziamo la nostra ontologia
+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)
+ontology_graph = rdflib.Graph()
 try:
-    client = InferenceClient(model=HF_MODEL, token=HF_API_KEY)
-    logger.info("InferenceClient inizializzato correttamente.")
+    # L'ontologia è in formato RDF/XML
+    logger.info(f"Caricamento ontologia da file: {RDF_FILE}")
+    ontology_graph.parse(RDF_FILE, format="xml")
+    logger.info("Ontologia RDF caricata correttamente (formato XML).")
 except Exception as e:
-    logger.error(f"Errore nell'inizializzazione di InferenceClient: {e}")
+    logger.error(f"Errore nel caricamento dell'ontologia: {e}")
     raise e
 
-def create_data_directory():
-    """Crea la directory 'data/' se non esiste."""
-    os.makedirs(os.path.join(BASE_DIR, "data"), exist_ok=True)
-    logger.info("Directory 'data/' creata o già esistente.")
+# ---------------------------------------------------------------------------
+# DEFINIZIONE DELL'APP FASTAPI
+# ---------------------------------------------------------------------------
+app = FastAPI()
 
-def extract_lines(rdf_file: str, output_file: str):
-    """
-    Estrae ogni riga dell'ontologia RDF e la salva in un file JSON.
-    Questo permette di indicizzare ogni riga singolarmente.
-    """
-    logger.info(f"Inizio estrazione delle linee dall'ontologia da {rdf_file}.")
-    try:
-        with open(rdf_file, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-        # Rimuovi spazi vuoti e newline
-        lines = [line.strip() for line in lines if line.strip()]
-        # Salva come lista di documenti
-        with open(output_file, "w", encoding="utf-8") as f:
-            json.dump({"lines": lines}, f, ensure_ascii=False, indent=2)
-        logger.info(f"Linee estratte e salvate in {output_file}")
-    except Exception as e:
-        logger.error(f"Errore nell'estrazione delle linee: {e}")
-        raise e
+# Modello di request
+class AssistantRequest(BaseModel):
+    message: str
+    max_tokens: int = 512
+    temperature: float = 0.5
 
-def create_faiss_index(documents_file: str, index_file: str, embedding_model_instance: SentenceTransformer):
+# ---------------------------------------------------------------------------
+# FUNZIONI DI SUPPORTO (Prompts, validazione SPARQL, correzione)
+# ---------------------------------------------------------------------------
+def create_system_prompt_for_sparql(ontology_turtle: str) -> str:
     """
-    Crea un indice FAISS a partire dalle linee estratte.
+    PRIMO PROMPT DI SISTEMA molto prolisso e stringente sulle regole SPARQL,
+    con i vari esempi (1-10) inclusi.
     """
-    logger.info(f"Inizio creazione dell'indice FAISS da {documents_file}.")
-    try:
-        # Carica il documento
-        with open(documents_file, "r", encoding="utf-8") as f:
-            document = json.load(f)
-        lines = document['lines']
-        logger.info(f"{len(lines)} linee caricate da {documents_file}.")
-
-        # Genera embedding
-        embeddings = embedding_model_instance.encode(lines, convert_to_numpy=True, show_progress_bar=True)
-        logger.info("Embedding generati con SentenceTransformer.")
-
-        # Crea l'indice FAISS
-        dimension = embeddings.shape[1]
-        index = faiss.IndexFlatL2(dimension)
-        index.add(embeddings)
-        logger.info(f"Indice FAISS creato con dimensione: {dimension}.")
-
-        # Salva l'indice
-        faiss.write_index(index, index_file)
-        logger.info(f"Indice FAISS salvato in {index_file}.")
-    except Exception as e:
-        logger.error(f"Errore nella creazione dell'indice FAISS: {e}")
-        raise e
-
-def prepare_retrieval(embedding_model_instance: SentenceTransformer):
-    """Prepara i file necessari per l'approccio RAG."""
-    logger.info("Inizio preparazione per il retrieval.")
-    create_data_directory()
-
-    # Verifica se Ontologia.rdf esiste
-    if not os.path.exists(RDF_FILE):
-        logger.error(f"File RDF non trovato: {RDF_FILE}")
-        raise FileNotFoundError(f"File RDF non trovato: {RDF_FILE}")
-    else:
-        logger.info(f"File RDF trovato: {RDF_FILE}")
+    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'.
 
-    # Verifica se documents.json esiste, altrimenti generarlo
-    if not os.path.exists(DOCUMENTS_FILE):
-        logger.info(f"File {DOCUMENTS_FILE} non trovato. Estrazione delle linee dell'ontologia.")
-        try:
-            extract_lines(RDF_FILE, DOCUMENTS_FILE)
-        except Exception as e:
-            logger.error(f"Errore nell'estrazione delle linee: {e}")
-            raise e
-    else:
-        logger.info(f"File {DOCUMENTS_FILE} trovato.")
+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
+3) Attento agli spazi:
+   - Dopo SELECT: es. SELECT ?autore
+   - Tra proprietà e variabile: es. progettoMuseo:autoreOpera ?autore .
+   - Non incollare il '?' a 'progettoMuseo:'.
+   - Ogni tripla termina con un punto.
+4) Se non puoi generare una query valida, rispondi solo 'NO_SPARQL'.
 
-    # Verifica se faiss.index esiste, altrimenti crearlo
-    if not os.path.exists(FAISS_INDEX_FILE):
-        logger.info(f"File {FAISS_INDEX_FILE} non trovato. Creazione dell'indice FAISS.")
-        try:
-            create_faiss_index(DOCUMENTS_FILE, FAISS_INDEX_FILE, embedding_model_instance)
-        except Exception as e:
-            logger.error(f"Errore nella creazione dell'indice FAISS: {e}")
-            raise e
-    else:
-        logger.info(f"File {FAISS_INDEX_FILE} trovato.")
+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
 
-def retrieve_relevant_lines(query: str, top_k: int = 5, embedding_model_instance: SentenceTransformer = None):
-    """Recupera le linee rilevanti usando FAISS."""
-    logger.info(f"Recupero delle linee rilevanti per la query: {query}")
-    try:
-        # Carica il documento
-        with open(DOCUMENTS_FILE, "r", encoding="utf-8") as f:
-            document = json.load(f)
-        lines = document['lines']
-        logger.info(f"{len(lines)} linee caricate da {DOCUMENTS_FILE}.")
-
-        # Carica l'indice FAISS
-        index = faiss.read_index(FAISS_INDEX_FILE)
-        logger.info(f"Indice FAISS caricato da {FAISS_INDEX_FILE}.")
-
-        # Genera embedding della query
-        if embedding_model_instance is None:
-            embedding_model_instance = SentenceTransformer('all-MiniLM-L6-v2')
-            logger.info("Modello SentenceTransformer caricato per l'embedding della query.")
-
-        query_embedding = embedding_model_instance.encode([query], convert_to_numpy=True)
-        logger.info("Embedding della query generati.")
-
-        # Ricerca nell'indice
-        distances, indices = index.search(query_embedding, top_k)
-        logger.info(f"Ricerca FAISS completata. Risultati ottenuti: {len(indices[0])}")
-
-        # Recupera le linee rilevanti
-        relevant_texts = [lines[idx] for idx in indices[0] if idx < len(lines)]
-        retrieved_docs = "\n".join(relevant_texts)
-        logger.info(f"Linee rilevanti recuperate: {len(relevant_texts)}")
-        return retrieved_docs
-    except Exception as e:
-        logger.error(f"Errore nel recupero delle linee rilevanti: {e}")
-        raise e
+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
 
-def create_system_message(retrieved_docs: str) -> str:
-    """
-    Prompt di sistema robusto, con regole su query in una riga e
-    informazioni recuperate tramite RAG.
-    """
-    return f"""### Istruzioni ###
-Sei un assistente museale esperto in ontologie RDF. Utilizza le informazioni fornite per generare query SPARQL precise e pertinenti.
-
-### Ontologia ###
-{retrieved_docs}
-### FINE Ontologia ###
-
-### Regole Stringenti ###
-1) Se l'utente chiede informazioni su questa ontologia, genera SEMPRE una query SPARQL in UNA SOLA RIGA, con prefix:
-   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
-2) La query SPARQL deve essere precisa e cercare esattamente le entità specificate dall'utente. Ad esempio, se l'utente chiede "Chi ha creato l'opera 'Amore e Psiche'?", la query dovrebbe cercere l'opera esattamente con quel nome.
-3) Se la query produce 0 risultati o fallisce, ritenta con un secondo tentativo.
-4) Se la domanda è generica (tipo 'Ciao, come stai?'), rispondi brevemente.
-5) Se trovi risultati, la risposta finale deve essere la query SPARQL (una sola riga).
-6) Se non trovi nulla, rispondi con 'Nessuna info.'
-7) Non multiline. Esempio: PREFIX base: <...> SELECT ?x WHERE {{ ... }}.
-Esempio:
-Utente: Chi ha creato l'opera 'Amore e Psiche'?
-Risposta: PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#> SELECT ?creatore WHERE {{ ?opera base:hasName "Amore e Psiche" . ?opera base:creatoDa ?creatore . }}
-### FINE REGOLE ###
-
-### Conversazione ###
-"""
+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
 
-def create_explanation_prompt(results_str: str) -> str:
-    """Prompt per generare una spiegazione museale dei risultati SPARQL."""
-    return f"""Ho ottenuto questi risultati SPARQL:
-{results_str}
-Ora fornisci una breve spiegazione museale (massimo ~10 righe), senza inventare oltre i risultati.
+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
+
+ECCO L'ONTOLOGIA (TURTLE) PER CONTESTO:
+{ontology_turtle}
+FINE ONTOLOGIA.
 """
+    logger.debug("[create_system_prompt_for_sparql] Prompt generato con ESEMPI e regole SPARQL.")
+    return prompt
 
-async def call_hf_model(prompt: str, temperature: float = 0.5, max_tokens: int = 150, stream: bool = False) -> str:
-    """Chiama il modello Hugging Face tramite InferenceClient e gestisce la risposta."""
-    logger.debug("Chiamo HF con il seguente prompt:")
-    content_preview = (prompt[:300] + '...') if len(prompt) > 300 else prompt
-    logger.debug(f"PROMPT => {content_preview}")
 
-    try:
-        # Costruisci i messaggi per il modello
-        # Poiché stiamo usando text_generation, il prompt deve essere una stringa continua
-        full_prompt = prompt
-
-        # Esegui la text_generation
-        response = client.text_generation(
-            full_prompt,
-            max_new_tokens=max_tokens,
-            temperature=temperature,
-            top_p=0.7,
-            stream=stream
-        )
+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.
+    """
+    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."
+    )
+    logger.debug("[create_system_prompt_for_guide] Prompt per la risposta guida museale generato.")
+    return prompt
 
-        logger.debug(f"Risposta completa dal modello: {response}")
 
-        if stream:
-            # Gestisci lo stream
-            generated_text = ""
-            async for token in response:
-                if 'generated_text' in token:
-                    generated_text += token['generated_text']
-                    print(token['generated_text'], end="")
-            return generated_text.strip()
-        else:
-            # Risposta non in streaming
-            # Verifica la struttura della risposta
-            # La risposta dovrebbe contenere 'generated_text'
-            if isinstance(response, list) and len(response) > 0 and "generated_text" in response[0]:
-                generated_text = response[0]["generated_text"]
-            elif isinstance(response, dict) and "generated_text" in response:
-                generated_text = response["generated_text"]
-            else:
-                raise ValueError("Nessun campo 'generated_text' nella risposta.")
-
-            # Forza la risposta su una singola linea se multilinea
-            single_line = " ".join(generated_text.splitlines())
-            logger.debug(f"Risposta HF single-line: {single_line}")
-            return single_line.strip()
-    except Exception as e:
-        logger.error(f"Errore nella chiamata all'API Hugging Face tramite InferenceClient: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+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
+    """
+    original_query = query
+    logger.debug(f"[correct_sparql_syntax_advanced] Query originaria:\n{original_query}")
 
-# Variabile globale per le etichette delle entità
-entity_labels: List[str] = []
+    # 1) Rimuoviamo newline e forziamo un'unica riga
+    query = query.replace('\n', ' ').replace('\r', ' ')
 
-def load_entity_labels(rdf_file: str):
-    """Carica le etichette delle entità dall'ontologia RDF."""
-    global entity_labels
-    try:
-        g = rdflib.Graph()
-        g.parse(rdf_file, format="xml")
-        entities = set()
-        for s in g.subjects(RDF.type, OWL.NamedIndividual):
-            label = g.value(s, RDFS.label, default=str(s))
-            if isinstance(label, URIRef):
-                label = label.split('#')[-1].replace('_', ' ')
-            else:
-                label = str(label)
-            entities.add(label.lower())
-        entity_labels = list(entities)
-        logger.info(f"Elenco delle etichette delle entità caricato: {entity_labels}")
-    except Exception as e:
-        logger.error(f"Errore nel caricamento delle etichette delle entità: {e}")
-        entity_labels = []
-
-def is_ontology_related(query: str) -> bool:
-    """Determina se la domanda è pertinente all'ontologia."""
-    query_lower = query.lower()
-    keywords = ["opera", "museo", "stanza", "tour", "visitatore", "biglietto", "guida", "evento", "agente"]
-    if any(keyword in query_lower for keyword in keywords):
-        return True
-    if any(entity in query_lower for entity in entity_labels):
-        return True
-    return False
+    # 2) Se manca il PREFIX, lo aggiungiamo in testa (solo se notiamo che non c'è "PREFIX progettoMuseo:")
+    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)
 
-app = FastAPI()
+    # 3) Spazio dopo SELECT se manca
+    query = re.sub(r'(SELECT)(\?|\*)', r'\1 \2', query, flags=re.IGNORECASE)
 
-class QueryRequest(BaseModel):
-    message: str
-    max_tokens: int = 512  # Aumentato per risposte più dettagliate
-    temperature: float = 0.5
+    # 4) Spazio dopo WHERE se manca
+    query = re.sub(r'(WHERE)\{', r'\1 {', query, flags=re.IGNORECASE)
 
-@app.post("/generate-response/")
-async def generate_response(req: QueryRequest):
-    user_input = req.message
-    logger.info(f"Utente dice: {user_input}")
+    # 5) Correggiamo i punti interrogativi attaccati alle proprietà:
+    #    "progettoMuseo:autoreOpera?autore" => "progettoMuseo:autoreOpera ?autore"
+    query = re.sub(r'(progettoMuseo:\w+)\?(\w+)', r'\1 ?\2', query)
 
-    if not is_ontology_related(user_input):
-        # Prompt generico per domande non pertinenti all'ontologia
-        generic_prompt = f"{user_input}"
-        try:
-            response = await call_hf_model(generic_prompt, req.temperature, req.max_tokens, stream=False)
-            return {
-                "type": "NATURAL",
-                "response": response.strip()
-            }
-        except Exception as e:
-            logger.error(f"Errore nella chiamata al modello Hugging Face per domanda generica: {e}")
-            return {
-                "type": "ERROR",
-                "response": f"Errore nella generazione della risposta per domanda generica: {e}"
-            }
+    # 6) Rimuoviamo spazi multipli
+    query = re.sub(r'\s+', ' ', query).strip()
 
-    try:
-        # Recupera linee rilevanti usando FAISS
-        retrieved_docs = retrieve_relevant_lines(user_input, top_k=5, embedding_model_instance=embedding_model)
-    except Exception as e:
-        logger.error(f"Errore nel recupero delle linee rilevanti: {e}")
-        return {"type": "ERROR", "response": f"Errore nel recupero delle linee: {e}"}
+    # 7) Aggiungiamo '.' a fine tripla prima del '}' se manca
+    query = re.sub(r'(\?\w+)\s*\}', r'\1 . }', query)
 
-    sys_msg = create_system_message(retrieved_docs)
-    prompt = sys_msg + f"\nUtente: {user_input}\nAssistente:"
+    # 8) Se manca la clausola WHERE, proviamo ad aggiungerla
+    if 'WHERE' not in query.upper():
+        query = re.sub(r'(SELECT\s+[^\{]+)\{', r'\1 WHERE {', query, flags=re.IGNORECASE)
 
-    # Primo tentativo
-    try:
-        r1 = await call_hf_model(prompt, req.temperature, req.max_tokens, stream=False)
-        logger.info(f"PRIMA RISPOSTA:\n{r1}")
-    except Exception as e:
-        logger.error(f"Errore nella chiamata al modello Hugging Face: {e}")
-        return {"type": "ERROR", "response": f"Errore nella generazione della risposta: {e}"}
+    # 9) Pulizia finale di spazi
+    query = re.sub(r'\s+', ' ', query).strip()
 
-    # 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}"
-        fallback_prompt = sys_msg + f"\nAssistente: {r1}\nUtente: {sc}\nAssistente:"
-        try:
-            r2 = await call_hf_model(fallback_prompt, req.temperature, req.max_tokens, stream=False)
-            logger.info(f"SECONDA RISPOSTA:\n{r2}")
-            if r2.startswith("PREFIX base:"):
-                sparql_query = r2
-            else:
-                return {"type": "NATURAL", "response": r2}
-        except Exception as e:
-            logger.error(f"Errore nella seconda chiamata al modello Hugging Face: {e}")
-            return {"type": "ERROR", "response": f"Errore nella generazione della seconda risposta: {e}"}
-    else:
-        sparql_query = r1
+    logger.debug(f"[correct_sparql_syntax_advanced] Query dopo correzioni:\n{query}")
+    return query
 
-    # Esegui la query con rdflib
-    g = rdflib.Graph()
+
+def is_sparql_query_valid(query: str) -> bool:
+    """Verifica la sintassi SPARQL tramite rdflib."""
+    logger.debug(f"[is_sparql_query_valid] Validazione SPARQL: {query}")
+    try:
+        parseQuery(query)
+        logger.debug("[is_sparql_query_valid] Query SPARQL sintatticamente corretta.")
+        return True
+    except Exception as ex:
+        logger.warning(f"[is_sparql_query_valid] Query non valida: {ex}")
+        return False
+
+# ---------------------------------------------------------------------------
+# ENDPOINT UNICO
+# ---------------------------------------------------------------------------
+@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.
+    """
+    logger.info("Ricevuta chiamata POST su /assistant")
+    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
     try:
-        g.parse(RDF_FILE, format="xml")
-        logger.info(f"Parsing RDF di {RDF_FILE} riuscito per l'esecuzione della query.")
+        logger.debug("Serializzazione dell'ontologia in formato Turtle per contesto nel prompt.")
+        ontology_turtle = ontology_graph.serialize(format="xml")
+        logger.debug("Ontologia serializzata con successo (XML).")
     except Exception as e:
-        logger.error(f"Parsing RDF error: {e}")
-        return {"type": "ERROR", "response": f"Parsing RDF error: {e}"}
+        logger.warning(f"Impossibile serializzare l'ontologia in Turtle: {e}")
+        ontology_turtle = ""
+    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)
     try:
-        results = g.query(sparql_query)
-        logger.info(f"Query SPARQL eseguita con successo. Risultati: {len(results)}")
-    except Exception as e:
-        fallback = f"La query SPARQL ha fallito. Riprova. Domanda: {user_input}"
-        fallback_prompt = sys_msg + f"\nAssistente: {sparql_query}\nUtente: {fallback}\nAssistente:"
+        logger.debug("[assistant_endpoint] Chiamata HF per generare la query SPARQL...")
+        gen_sparql_output = hf_client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": system_prompt_sparql},
+                {"role": "user", "content": user_message}
+            ],
+            max_tokens=512,
+            temperature=0.3
+        )
+        possible_query = gen_sparql_output["choices"][0]["message"]["content"].strip()
+        logger.info(f"[assistant_endpoint] Query generata dal modello: {possible_query}")
+    except Exception as ex:
+        logger.error(f"Errore nella generazione della query SPARQL: {ex}")
+        # Se fallisce la generazione, consideriamo la query come "NO_SPARQL"
+        possible_query = "NO_SPARQL"
+
+    # Verifica 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.")
+    else:
+        # Correggiamo in modo avanzato
+        advanced_corrected = correct_sparql_syntax_advanced(possible_query)
+        # Dopo la correzione, verifichiamo se è valida
+        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.")
+            generated_query = None
+
+    # STEP 2: Esecuzione query (se presente) e risposta guida
+    results = []
+    if generated_query:
+        logger.debug(f"[assistant_endpoint] Esecuzione della query SPARQL:\n{generated_query}")
         try:
-            r3 = await call_hf_model(fallback_prompt, req.temperature, req.max_tokens, stream=False)
-            logger.info(f"TERZA RISPOSTA (fallback):\n{r3}")
-            if r3.startswith("PREFIX base:"):
-                sparql_query = r3
-                try:
-                    results = g.query(sparql_query)
-                    logger.info(f"Seconda query SPARQL eseguita con successo. Risultati: {len(results)}")
-                except Exception as e2:
-                    logger.error(f"Seconda Query fallita: {e2}")
-                    return {"type": "ERROR", "response": f"Query fallita di nuovo: {e2}"}
-            else:
-                return {"type": "NATURAL", "response": r3}
-        except Exception as e:
-            logger.error(f"Errore nella chiamata al modello Hugging Face durante il fallback: {e}")
-            return {"type": "ERROR", "response": f"Errore durante il fallback della risposta: {e}"}
-
-    if len(results) == 0:
-        return {"type": "NATURAL", "sparql_query": sparql_query, "response": "Nessuna info."}
-
-    # Confeziona risultati
-    row_list = []
-    for row in results:
-        # Converti il risultato della query in un dizionario
-        row_dict = dict(row)
-        row_str = ", ".join([f"{k}: {v}" for k, v in row_dict.items()])
-        row_list.append(row_str)
-    results_str = "\n".join(row_list)
-
-    # Spiegazione
-    exp_prompt = create_explanation_prompt(results_str)
-    try:
-        explanation = await call_hf_model(exp_prompt, req.temperature, req.max_tokens, stream=False)
-    except Exception as e:
-        logger.error(f"Errore nella generazione della spiegazione: {e}")
-        return {"type": "ERROR", "response": f"Errore nella generazione della spiegazione: {e}"}
+            query_result = ontology_graph.query(generated_query)
+            results = list(query_result)
+            logger.info(f"[assistant_endpoint] Query eseguita con successo. Numero risultati = {len(results)}")
+        except Exception as ex:
+            logger.error(f"[assistant_endpoint] Errore nell'esecuzione della query: {ex}")
+            results = []
+    
+    # Creiamo il prompt di sistema "guida museale"
+    system_prompt_guide = create_system_prompt_for_guide()
+    if generated_query and results:
+        # Abbiamo query + risultati
+        # 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
+            )
+            for idx, row in enumerate(results)
+        )
 
-    return {
-        "type": "NATURAL",
-        "sparql_query": sparql_query,
-        "sparql_results": row_list,
-        "explanation": explanation
-    }
+        second_prompt = (
+            f"{system_prompt_guide}\n\n"
+            f"Domanda utente: {user_message}\n"
+            f"Query generata: {generated_query}\n"
+            f"Risultati:\n{results_str}\n"
+            "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
+        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.")
+    else:
+        # Nessuna query generata
+        second_prompt = (
+            f"{system_prompt_guide}\n\n"
+            f"Domanda utente: {user_message}\n"
+            "Nessuna query SPARQL generata. Rispondi come puoi, riarrangiando le tue conoscenze."
+        )
+        logger.debug("[assistant_endpoint] Prompt di risposta: nessuna query generata.")
 
-@app.post("/prova")
-async def prova(req: QueryRequest):
+    # Ultima chiamata al modello per la risposta finale
+    try:
+        logger.debug("[assistant_endpoint] Chiamata HF per la risposta guida museale...")
+        final_output = hf_client.chat.completions.create(
+            messages=[
+                {"role": "system", "content": second_prompt},
+                {"role": "user", "content": "Fornisci la risposta finale."}
+            ],
+            max_tokens=512,
+            temperature=0.7
+        )
+        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.")
+
+    # Risposta JSON
+    logger.debug("[assistant_endpoint] Fine elaborazione. Restituzione risposta.")
     return {
-        "type": "NATURAL",
-        "response": "Questa è una prova di richiesta"
+        "query": generated_query,
+        "response": final_answer
     }
 
+# ---------------------------------------------------------------------------
+# ENDPOINT DI TEST
+# ---------------------------------------------------------------------------
 @app.get("/")
 def home():
-    return {"message": "Assistente Museale con supporto SPARQL."}
+    logger.debug("Chiamata GET su '/' - home.")
+    return {
+        "message": "Endpoint con ESEMPI di query SPARQL + correzione avanzata + risposta guida museale."
+    }
 
-# Avvia la preparazione al caricamento delle linee e indicizzazione
-try:
-    create_data_directory()
-    prepare_retrieval(embedding_model)
-    load_entity_labels(RDF_FILE)
-    logger.info("Applicazione avviata e pronta per ricevere richieste.")
-except Exception as e:
-    logger.error(f"Errore durante la preparazione dell'applicazione: {e}")
-    raise e
+# ---------------------------------------------------------------------------
+# MAIN
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    logger.info("Avvio dell'applicazione FastAPI sulla porta 8000.")