app.py

import os
import logging
from rdflib import Graph
from pydantic import BaseModel
from fastapi import FastAPI, HTTPException
from huggingface_hub import InferenceClient
from typing import Optional

# Configurazione logging
logging.basicConfig(
    level=logging.DEBUG,  # Livello di log aumentato per maggiori dettagli
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[
        logging.FileHandler("app.log"),  # Log su file
        logging.StreamHandler()          # Log su console
    ]
)
logger = logging.getLogger(__name__)

# Configurazione API Hugging Face
API_KEY = os.getenv("HF_API_KEY")
if not API_KEY:
    logger.error("HF_API_KEY non impostata nell'ambiente.")
    raise EnvironmentError("HF_API_KEY non impostata nell'ambiente.")

client = InferenceClient(api_key=API_KEY)

# File RDF
RDF_FILE = "Ontologia.rdf"

####################################
# Caricamento RDF (riassunto)
####################################
def load_rdf_summary() -> str:
    """
    Carica un riassunto dell'ontologia dal file RDF.
    Estrae le classi e le proprietà presenti nell'ontologia.
    """
    logger.info("Inizio caricamento del file RDF.")
    if not os.path.exists(RDF_FILE):
        logger.error("Nessun file RDF trovato.")
        return "Nessun file RDF trovato."

    try:
        g = Graph()
        g.parse(RDF_FILE, format="xml")

        classes = set()
        properties = set()
        for s, p, o in g.triples((None, None, None)):
            if "Class" in str(o):
                classes.add(s)
            if "Property" in str(o):
                properties.add(s)

        class_summary = "\n".join([f"- Classe: {cls}" for cls in classes])
        prop_summary  = "\n".join([f"- Proprietà: {prop}" for prop in properties])

        summary = f"Classi:\n{class_summary}\n\nProprietà:\n{prop_summary}"
        logger.info("Caricamento RDF completato con successo.")
        return summary
    except Exception as e:
        logger.error(f"Errore durante il parsing del file RDF: {e}")
        return "Errore nel caricamento del file RDF."

rdf_context = load_rdf_summary()
logger.debug(f"RDF Summary:\n{rdf_context}")

####################################
# Validazione SPARQL
####################################
def validate_sparql_query(query: str, rdf_file_path: str) -> bool:
    """
    Verifica la validità della query SPARQL.
    """
    logger.info("Inizio validazione della query SPARQL.")
    g = Graph()
    try:
        g.parse(rdf_file_path, format="xml")
        g.query(query)  # Solleva un'eccezione se la query non è valida
        logger.info("Validazione della query SPARQL riuscita.")
        return True
    except Exception as e:
        logger.error(f"Errore durante la validazione della query SPARQL: {e}")
        return False

####################################
# Prompt di Sistema (Rafforzato)
####################################
def create_system_message(rdf_context: str) -> str:
    """
    Crea il messaggio di sistema per il modello di linguaggio naturale.
    Abbiamo rafforzato le istruzioni per gestire i literal con @it.
    """
    return f"""
Sei un'assistente esperta nella generazione di query SPARQL basate su un'ontologia RDF,
nell'interpretazione dei risultati delle query SPARQL in risposte naturali,
e nel fare chatting minimale con i visitatori in diverse lingue (italiano, francese, inglese).

In base alla domanda dell'utente, devi decidere se:
  1) generare una query SPARQL
  2) fornire una risposta naturale basata su una query SPARQL
  3) rispondere con una chat minimale.

ATTENZIONE IMPORTANTE:
- L'ontologia è su: http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#
- Alcuni literal (es. 'nomeOpera') hanno il tag di lingua '@it' (es. 'Amore e Psiche'@it).
- Se vuoi confrontare una stringa come 'Amore e Psiche', DEVI usare:
  - base:nomeOpera 'Amore e Psiche'@it
  OPPURE
  - un FILTER(STR(?label) = 'Amore e Psiche')
  per ignorare il tag di lingua.
- Se manca '@it', potresti non trovare risultati.

Regole TASSATIVE:
1. Se la domanda richiede una query SPARQL, restituisci SOLO la query SPARQL in testo semplice.
2. Se la domanda richiede interpretazione di risultati, dai una risposta naturale che spieghi quei risultati.
3. Se la domanda è una chat minimale, rispondi con una breve chat amichevole nella lingua dell'utente.
4. DEVI usare ESCLUSIVAMENTE questo prefisso di base (e NON modificarlo in nessun modo):
   PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
5. NON generare alcun altro prefisso o URI inventato.
6. Se non riesci a rispondere con una query SPARQL, interpretare i risultati o fare chat,
   scrivi: "Non posso generare una query SPARQL, interpretare i risultati o fare una risposta di chat per questa richiesta."

Esempi:
- Domanda: "Quali sono le statue esposte del periodo medievale?"
  Risposta SPARQL:
    PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
    SELECT ?statua WHERE {{
      ?statua a base:Statua ;
              base:periodoStoricoOpera "Medioevo"@it .
    }}

- Domanda: "Ciao!"
  Risposta (chat):
    Ciao! Benvenuto al nostro museo. Come posso aiutarti oggi?

- Domanda: "Da chi è stato scolpito Amore e Psiche?"
  (Se devi confrontare 'Amore e Psiche' con tag @it)
  Risposta SPARQL:
    PREFIX base: <http://www.semanticweb.org/lucreziamosca/ontologies/progettoMuseo#>
    SELECT ?autore WHERE {{
      ?opera a base:Statua ;
             base:nomeOpera "Amore e Psiche"@it ;
             base:autoreOpera ?autore .
    }}

Ecco un riassunto dell'ontologia su cui devi lavorare:
{rdf_context}

RISPONDI ESCLUSIVAMENTE CON IL FORMATO SPECIFICATO.
"""

####################################
# Funzione per chiamare il modello
####################################
async def call_model(messages, temperature=0.7, max_tokens=2048):
    """
    Chiama il modello di linguaggio naturale con i messaggi forniti.
    """
    logger.info("Chiamata al modello iniziata.")
    try:
        response = client.chat.completions.create(
            model="Qwen/Qwen2.5-72B-Instruct",
            messages=messages,
            temperature=temperature,
            max_tokens=max_tokens,
            top_p=0.7,
            stream=False
        )
        raw_text = response["choices"][0]["message"]["content"]
        logger.debug(f"Risposta del modello ricevuta: {raw_text}")
        # Rimuoviamo eventuali newline per forzare una singola riga
        return raw_text.replace("\n", " ").strip()
    except Exception as e:
        logger.error(f"Errore durante la chiamata al modello: {e}")
        raise HTTPException(status_code=500, detail=str(e))

####################################
# Funzione di Interpretazione dei Risultati SPARQL
####################################
async def interpret_sparql_results(results):
    """
    Invia i risultati delle query SPARQL al modello per ottenere una risposta naturale.
    """
    logger.info("Inizio interpretazione dei risultati SPARQL.")
    if not results:
        logger.info("Nessun risultato trovato per la query SPARQL.")
        return "Mi dispiace, non sono riuscita a trovare le informazioni che stavi cercando."

    # Converti i risultati in una stringa leggibile
    results_str = "\n".join([
        ", ".join([f"{k}: {v}" for k, v in row.asdict().items()])
        for row in results
    ])
    logger.debug(f"Risultati SPARQL:\n{results_str}")

    # Prompt per interpretare i risultati come una guida museale femminile
    interpret_prompt = f"""
Mi hai fornito i seguenti risultati di una query SPARQL:
{results_str}

Per favore, interpreta questi risultati e fornisci una risposta naturale ed enfatica
come farebbe una guida museale femminile (in italiano).
"""

    messages = [
        {"role": "system", "content": interpret_prompt},
        {"role": "user", "content": ""}
    ]
    logger.info("Invio dei risultati SPARQL al modello per l'interpretazione.")
    natural_response = await call_model(messages, temperature=0.7, max_tokens=2048)
    logger.info(f"Risposta interpretata ricevuta dal modello: {natural_response}")
    return natural_response

####################################
# FastAPI
####################################
app = FastAPI()

class QueryRequest(BaseModel):
    message: str
    max_tokens: int = 2048
    temperature: float = 0.7

@app.post("/generate-response/")
async def generate_response(request: QueryRequest):
    user_msg = request.message
    logger.info(f"Ricevuta richiesta: {user_msg}")

    # 1) Generazione della risposta (SPARQL, INTERPRET o CHAT)
    system_msg = create_system_message(rdf_context)
    messages = [
        {"role": "system", "content": system_msg},
        {"role": "user", "content": user_msg}
    ]
    response_text = await call_model(messages, request.temperature, request.max_tokens)
    logger.info(f"Risposta generata dal modello: {response_text}")

    # 2) Determinazione se la risposta è una query SPARQL
    if response_text.startswith("PREFIX base:"):
        sparql_query = response_text
        logger.info("La risposta è stata identificata come una query SPARQL.")

        # Validazione della query SPARQL
        if validate_sparql_query(sparql_query, RDF_FILE):
            logger.info("La query SPARQL è valida. Inizio esecuzione della query.")
            try:
                g = Graph()
                g.parse(RDF_FILE, format="xml")
                results = g.query(sparql_query)
                logger.info(f"Query SPARQL eseguita con successo. Numero di risultati: {len(results)}")

                # Interpreta i risultati in una risposta naturale
                interpreted_response = await interpret_sparql_results(results)
                logger.info(f"Risposta naturale interpretata: {interpreted_response}")
                return {"type": "NATURAL", "response": interpreted_response}

            except Exception as e:
                logger.error(f"Errore durante l'esecuzione della query SPARQL: {e}")
                return {
                    "type": "ERROR",
                    "response": "Mi dispiace, c'è stato un errore nell'esecuzione della tua richiesta."
                }
        else:
            logger.warning("La query SPARQL generata non è valida.")
            return {
                "type": "ERROR",
                "response": "La query SPARQL generata non è valida. Per favore, riprova con una domanda diversa."
            }

    elif "Non posso generare una query SPARQL" in response_text:
        # Risposta di errore dal modello
        logger.warning("Il modello ha risposto con un messaggio di errore.")
        return {"type": "ERROR", "response": response_text}

    else:
        # Presumiamo che sia una risposta naturale o di chat
        logger.info("La risposta è stata identificata come una risposta naturale o di chat.")
        return {"type": "NATURAL", "response": response_text}

@app.get("/")
async def root():
    return {"message": "Server attivo e pronto a generare risposte!"}