Update app.py

app.py

@@ -1,7 +1,97 @@
-from fastapi import FastAPI
+import os
+from fastapi import FastAPI, HTTPException, Request
+from huggingface_hub import InferenceClient
+from rdflib import Graph
+from pydantic import BaseModel
 
+# Configurazione API Hugging Face
+API_KEY = os.getenv("HF_API_KEY")
+if not API_KEY:
+    raise ValueError("API Key non trovata. Assicurati che sia definita come variabile d'ambiente 'HF_API_KEY'.")
+
+client = InferenceClient(api_key=API_KEY)
+
+# File RDF
+RDF_FILE = "Progetto.rdf"
+
+# Carica il file RDF
+def load_rdf():
+    if os.path.exists(RDF_FILE):
+        with open(RDF_FILE, "r") as f:
+            return f.read()
+    return ""
+
+rdf_context = load_rdf()
+
+# Valida le query SPARQL
+def validate_sparql_query(query, rdf_data):
+    try:
+        g = Graph()
+        g.parse(data=rdf_data, format="xml")
+        g.query(query)
+        return True
+    except Exception as e:
+        return False
+
+# FastAPI app
 app = FastAPI()
 
+# Modello di input per richieste POST
+class QueryRequest(BaseModel):
+    message: str
+    max_tokens: int = 512
+    temperature: float = 0.7
+
+# Messaggio di sistema con RDF incluso
+def create_system_message(rdf_context):
+    return f"""
+Sei un assistente specializzato nella generazione e riscrittura di query SPARQL basate su dati RDF.
+La base di conoscenza RDF è la seguente:
+{rdf_context}
+Il tuo compito principale è:
+1. Analizzare lo schema RDF o i dati RDF forniti e la domanda in linguaggio naturale posta dall'utente.
+2. Generare una query SPARQL valida che recuperi le informazioni richieste dai dati RDF.
+3. Se l'utente fornisce una query SPARQL con una richiesta di spiegazione o correzione, riscrivila per renderla più efficiente o corretta.
+Regole:
+- Non generare nulla al di fuori di una query SPARQL, a meno che non sia esplicitamente richiesto.
+- Se la domanda non può essere soddisfatta con una query SPARQL, rispondi con: \"Non posso generare una query per questa domanda.\"
+"""
+
+# Funzione per inviare la richiesta al modello Hugging Face
+def generate_response(message, max_tokens, temperature):
+    system_message = create_system_message(rdf_context)
+    messages = [
+        {"role": "system", "content": system_message},
+        {"role": "user", "content": message}
+    ]
+
+    try:
+        completion = client.conversational(
+            model="Qwen/Qwen2.5-72B-Instruct",
+            messages=messages,
+            max_tokens=max_tokens,
+            temperature=temperature
+        )
+        response = completion.get("generated_text", "").strip()
+        return response
+    except Exception as 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):
+    # Genera risposta
+    response = generate_response(request.message, request.max_tokens, request.temperature)
+
+    # Valida la query se possibile
+    if response.startswith("SELECT") or response.startswith("ASK"):
+        is_valid = validate_sparql_query(response, rdf_context)
+        if not is_valid:
+            raise HTTPException(status_code=400, detail="La query generata non è valida rispetto al file RDF fornito.")
+
+    return {"query": response}
+
+# Endpoint per verificare se il server è attivo
 @app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
+async def root():
+    return {"message": "Il server è attivo e pronto a generare query SPARQL!"