Update app.py

app.py

@@ -10,6 +10,10 @@ from sentence_transformers import SentenceTransformer
 import faiss
 import json
 import numpy as np
+from dotenv import load_dotenv
+
+# Carica le variabili d'ambiente
+load_dotenv()
 
 logging.basicConfig(
     level=logging.DEBUG,
@@ -23,7 +27,7 @@ if not API_KEY:
     logger.error("HF_API_KEY non impostata.")
     raise EnvironmentError("HF_API_KEY non impostata.")
 
-client = InferenceClient(api_key=API_KEY)
+client = InferenceClient(token=API_KEY)
 
 RDF_FILE = "Ontologia.rdf"
 HF_MODEL = "Qwen/Qwen2.5-72B-Instruct"
@@ -137,7 +141,7 @@ async def call_hf_model(messages, temperature=0.5, max_tokens=1024)->str:
             max_tokens=max_tokens,
             top_p=0.9
         )
-        raw=resp["choices"][0]["message"]["content"]
+        raw = resp["choices"][0]["message"]["content"]
         # Forziamo la query su linea singola se multiline
         single_line = " ".join(raw.splitlines())
         logger.debug(f"Risposta HF single-line: {single_line}")
@@ -146,100 +150,101 @@ async def call_hf_model(messages, temperature=0.5, max_tokens=1024)->str:
         logger.error(f"HuggingFace error: {e}")
         raise HTTPException(status_code=500, detail=str(e))
 
-app=FastAPI()
+app = FastAPI()
 
 class QueryRequest(BaseModel):
-    message:str
-    max_tokens:int=1024
-    temperature:float=0.5
+    message: str
+    max_tokens: int = 1024
+    temperature: float = 0.5
 
 @app.post("/generate-response/")
-async def generate_response(req:QueryRequest):
-    user_input=req.message
+async def generate_response(req: QueryRequest):
+    user_input = req.message
     logger.info(f"Utente dice: {user_input}")
 
     # Recupera documenti rilevanti usando RAG
     relevant_docs = retrieve_relevant_documents(user_input, top_k=3)
     retrieved_text = "\n".join([doc['text'] for doc in relevant_docs])
 
-    sys_msg=create_system_message(knowledge_text, retrieved_text)
-    msgs=[
-        {"role":"system","content":sys_msg},
-        {"role":"user","content":user_input}
+    sys_msg = create_system_message(knowledge_text, retrieved_text)
+    msgs = [
+        {"role": "system", "content": sys_msg},
+        {"role": "user", "content": user_input}
     ]
+
     # Primo tentativo
-    r1=await call_hf_model(msgs, req.temperature, req.max_tokens)
+    r1 = await call_hf_model(msgs, req.temperature, req.max_tokens)
     logger.info(f"PRIMA RISPOSTA:\n{r1}")
 
     # 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}"
-        msgs2=[
-            {"role":"system","content":sys_msg},
-            {"role":"assistant","content":r1},
-            {"role":"user","content":sc}
+        sc = f"Non hai risposto con query SPARQL su una sola riga. Riprova. Domanda: {user_input}"
+        msgs2 = [
+            {"role": "system", "content": sys_msg},
+            {"role": "assistant", "content": r1},
+            {"role": "user", "content": sc}
         ]
-        r2=await call_hf_model(msgs2,req.temperature,req.max_tokens)
+        r2 = await call_hf_model(msgs2, req.temperature, req.max_tokens)
         logger.info(f"SECONDA RISPOSTA:\n{r2}")
         if r2.startswith("PREFIX base:"):
-            sparql_query=r2
+            sparql_query = r2
         else:
-            return {"type":"NATURAL","response": r2}
+            return {"type": "NATURAL", "response": r2}
     else:
-        sparql_query=r1
+        sparql_query = r1
 
     # Esegui la query con rdflib
-    g=rdflib.Graph()
+    g = rdflib.Graph()
     try:
-        g.parse(RDF_FILE,format="xml")
+        g.parse(RDF_FILE, format="xml")
     except Exception as e:
         logger.error(f"Parsing RDF error: {e}")
-        return {"type":"ERROR","response":f"Parsing RDF error: {e}"}
+        return {"type": "ERROR", "response": f"Parsing RDF error: {e}"}
 
     try:
-        results=g.query(sparql_query)
+        results = g.query(sparql_query)
     except Exception as e:
-        fallback=f"La query SPARQL ha fallito. Riprova. Domanda: {user_input}"
-        msgs3=[
-            {"role":"system","content":sys_msg},
-            {"role":"assistant","content":sparql_query},
-            {"role":"user","content":fallback}
+        fallback = f"La query SPARQL ha fallito. Riprova. Domanda: {user_input}"
+        msgs3 = [
+            {"role": "system", "content": sys_msg},
+            {"role": "assistant", "content": sparql_query},
+            {"role": "user", "content": fallback}
         ]
-        r3=await call_hf_model(msgs3,req.temperature,req.max_tokens)
+        r3 = await call_hf_model(msgs3, req.temperature, req.max_tokens)
         if r3.startswith("PREFIX base:"):
-            sparql_query=r3
+            sparql_query = r3
             try:
-                results=g.query(sparql_query)
+                results = g.query(sparql_query)
             except Exception as e2:
-                return {"type":"ERROR","response":f"Query fallita di nuovo: {e2}"}
+                return {"type": "ERROR", "response": f"Query fallita di nuovo: {e2}"}
         else:
-            return {"type":"NATURAL","response":r3}
+            return {"type": "NATURAL", "response": r3}
 
-    if len(results)==0:
-        return {"type":"NATURAL","sparql_query":sparql_query,"response":"Nessun risultato."}
+    if len(results) == 0:
+        return {"type": "NATURAL", "sparql_query": sparql_query, "response": "Nessun risultato."}
 
     # Confeziona risultati
-    row_list=[]
+    row_list = []
     for row in results:
-        row_str=", ".join([f"{k}:{v}" for k,v in row.asdict().items()])
+        row_str = ", ".join([f"{k}:{v}" for k, v in row.asdict().items()])
         row_list.append(row_str)
-    results_str="\n".join(row_list)
+    results_str = "\n".join(row_list)
 
     # Spiegazione
-    exp_prompt=create_explanation_prompt(results_str)
-    msgs4=[
-        {"role":"system","content":exp_prompt},
-        {"role":"user","content":""}
+    exp_prompt = create_explanation_prompt(results_str)
+    msgs4 = [
+        {"role": "system", "content": exp_prompt},
+        {"role": "user", "content": ""}
     ]
-    explanation=await call_hf_model(msgs4,req.temperature,req.max_tokens)
+    explanation = await call_hf_model(msgs4, req.temperature, req.max_tokens)
 
     return {
-        "type":"NATURAL",
-        "sparql_query":sparql_query,
-        "sparql_results":row_list,
-        "explanation":explanation
+        "type": "NATURAL",
+        "sparql_query": sparql_query,
+        "sparql_results": row_list,
+        "explanation": explanation
     }
 
 @app.get("/")
 def home():
-    return {"message":"Prompt lascia libertà su come chiamare la proprietà del materiale, ma suggerisce un possibile 'materialeOpera'."}
+    return {"message": "Prompt lascia libertà su come chiamare la proprietà del materiale, ma suggerisce un possibile 'materialeOpera'."}