app.py

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

# Configurazione API Hugging Face
API_KEY = os.getenv("HF_API_KEY")
client = InferenceClient(api_key=API_KEY)

# File RDF
RDF_FILE = "Progetto.rdf"

# Carica un riassunto del file RDF
def load_rdf_summary():
    if os.path.exists(RDF_FILE):
        g = Graph()
        g.parse(RDF_FILE, format="xml")

        classes = set()
        properties = set()

        for s, _, o in g.triples((None, None, None)):
            if "Class" in str(o) or "rdfs:Class" in str(o):
                classes.add(s)
            if "Property" in str(o):
                properties.add(s)

        classes_summary = "\n".join([f"- Classe: {cls}" for cls in classes])
        properties_summary = "\n".join([f"- Proprietà: {prop}" for prop in properties])
        return f"Classi:\n{classes_summary}\n\nProprietà:\n{properties_summary}"
    return "Nessun dato RDF trovato."

rdf_context = load_rdf_summary()
print("RDF Summary:", rdf_context)  # Debug

# Valida le query SPARQL
def validate_sparql_query(query, rdf_file_path):
    try:
        g = Graph()
        # Caricamento del file RDF dal percorso
        g.parse(rdf_file_path, format="xml")
        g.query(query)  # Prova ad eseguire la query
        return True
    except Exception as e:
        print(f"Errore durante la validazione della query SPARQL: {e}")
        return False

# FastAPI app
app = FastAPI()

# Modello di input per richieste POST
class QueryRequest(BaseModel):
    message: str
    max_tokens: int = 2048
    temperature: float = 0.7

# Messaggio di sistema con RDF incluso
def create_system_message(rdf_context):
    return f"""
Sei un assistente esperto nella generazione di query SPARQL basate su ontologie RDF.
Ecco un riassunto dell'ontologia su cui devi lavorare:
{rdf_context}

Il tuo compito:
- Genera esclusivamente query SPARQL valide in UNA SOLA RIGA.
- Rispondi solo se la domanda è pertinente alle classi e proprietà fornite.
- Se non puoi rispondere, di': "Non posso generare una query SPARQL per questa richiesta."
"""

async def generate_response(message, max_tokens, temperature):
    system_message = create_system_message(rdf_context)
    print("System Message:", system_message)  # Debug
    print("User Message:", message)  # Debug

    messages = [
        {"role": "system", "content": system_message},
        {"role": "user", "content": message}
    ]

    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
        )
        print("Raw Response:", response)  # Debug risposta grezza
        return response['choices'][0]['message']['content'].replace("\n", " ").strip()
    except Exception as e:
        print(f"Errore nell'elaborazione: {str(e)}")
        raise HTTPException(status_code=500, detail=f"Errore nell'elaborazione: {str(e)}")

# Endpoint per generare query SPARQL
@app.post("/generate-query/")
async def generate_query(request: QueryRequest):
    response = await generate_response(request.message, request.max_tokens, request.temperature)
    print("Risposta generata dal modello:", response)  # Debug
    
    if not (response.startswith("SELECT") or response.startswith("ASK")):
        return {
            "query": None,
            "explanation": "Non posso generare una query SPARQL per questa richiesta. Assicurati che la domanda sia coerente con i dati RDF forniti."
        }

    if not validate_sparql_query(response, RDF_FILE):
        return {
            "query": None,
            "explanation": "La query generata non è valida rispetto alla base di conoscenza RDF. Assicurati di chiedere informazioni che siano presenti nell'ontologia."
        }

    return {"query": response, "explanation": "Ecco la query generata correttamente in una riga pronta per GraphDB."}

# Endpoint di test
@app.get("/")
async def root():
    return {"message": "Il server è attivo e pronto a generare query SPARQL!"}