Update app.py

app.py

@@ -47,7 +47,12 @@ except Exception as e:
     raise e
 
 # Inizializza il client di Hugging Face
-client = InferenceClient(api_key=HF_API_KEY)
+try:
+    client = InferenceClient(HF_MODEL, token=HF_API_KEY)
+    logger.info("InferenceClient inizializzato correttamente.")
+except Exception as e:
+    logger.error(f"Errore nell'inizializzazione di InferenceClient: {e}")
+    raise e
 
 def create_data_directory():
     """Crea la directory 'data/' se non esiste."""
@@ -207,38 +212,49 @@ def create_explanation_prompt(results_str: str) -> str:
 Ora fornisci una breve spiegazione museale (massimo ~10 righe), senza inventare oltre i risultati.
 """
 
-async def call_hf_model(prompt: str, temperature: float = 0.5, max_tokens: int = 150) -> str:
+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:
-        # Utilizza il metodo chat.completions.create per interagire con il modello
-        response = client.chat.completions.create(
-            model=HF_MODEL,
-            messages=[
-                {"role": "user", "content": prompt}
-            ],
-            temperature=temperature,
+        # Costruisci i messaggi per il modello
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": prompt}
+        ]
+
+        # Esegui la chat_completion
+        response = client.chat_completion(
+            messages=messages,
             max_tokens=max_tokens,
+            temperature=temperature,
             top_p=0.7,
-            stream=False  # Imposta su True se desideri gestire lo stream
+            stream=stream
         )
-        logger.debug(f"Risposta completa dal modello: {response}")
 
-        # Estrai il testo generato
-        if isinstance(response, list) and len(response) > 0 and "generated_text" in response[0]:
-            raw = response[0]["generated_text"]
-        elif "generated_text" in response:
-            raw = response["generated_text"]
+        if stream:
+            # Gestisci lo stream
+            generated_text = ""
+            async for token in response:
+                if token.choices and token.choices[0].delta.get("content"):
+                    generated_text += token.choices[0].delta["content"]
+                    print(token.choices[0].delta["content"], end="")
+            return generated_text.strip()
         else:
-            raise ValueError("Nessun campo 'generated_text' nella risposta.")
+            # Risposta non in streaming
+            if isinstance(response, list) and len(response) > 0 and "generated_text" in response[0]:
+                raw = response[0]["generated_text"]
+            elif "generated_text" in response:
+                raw = response["generated_text"]
+            else:
+                raise ValueError("Nessun campo 'generated_text' nella risposta.")
 
-        # Forza la risposta su una singola linea se multilinea
-        single_line = " ".join(raw.splitlines())
-        logger.debug(f"Risposta HF single-line: {single_line}")
-        return single_line.strip()
+            # Forza la risposta su una singola linea se multilinea
+            single_line = " ".join(raw.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))
@@ -290,9 +306,9 @@ async def generate_response(req: QueryRequest):
 
     if not is_ontology_related(user_input):
         # Prompt generico per domande non pertinenti all'ontologia
-        generic_prompt = f"Utente: {user_input}\nAssistente: Rispondi cortesemente, anche se la domanda non è legata all'ontologia."
+        generic_prompt = f"{user_input}"
         try:
-            response = await call_hf_model(generic_prompt, req.temperature, req.max_tokens)
+            response = await call_hf_model(generic_prompt, req.temperature, req.max_tokens, stream=False)
             return {
                 "type": "NATURAL",
                 "response": response.strip()
@@ -312,11 +328,11 @@ async def generate_response(req: QueryRequest):
         return {"type": "ERROR", "response": f"Errore nel recupero delle linee: {e}"}
 
     sys_msg = create_system_message(retrieved_docs)
-    prompt = f"{sys_msg}\nUtente: {user_input}\nAssistente:"
+    prompt = sys_msg + f"\nUtente: {user_input}\nAssistente:"
 
     # Primo tentativo
     try:
-        r1 = await call_hf_model(prompt, req.temperature, req.max_tokens)
+        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}")
@@ -325,9 +341,9 @@ async def generate_response(req: QueryRequest):
     # 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 = f"{sys_msg}\nAssistente: {r1}\nUtente: {sc}\nAssistente:"
+        fallback_prompt = sys_msg + f"\nAssistente: {r1}\nUtente: {sc}\nAssistente:"
         try:
-            r2 = await call_hf_model(fallback_prompt, req.temperature, req.max_tokens)
+            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
@@ -353,9 +369,9 @@ async def generate_response(req: QueryRequest):
         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 = f"{sys_msg}\nAssistente: {sparql_query}\nUtente: {fallback}\nAssistente:"
+        fallback_prompt = sys_msg + f"\nAssistente: {sparql_query}\nUtente: {fallback}\nAssistente:"
         try:
-            r3 = await call_hf_model(fallback_prompt, req.temperature, req.max_tokens)
+            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
@@ -386,7 +402,7 @@ async def generate_response(req: QueryRequest):
     # Spiegazione
     exp_prompt = create_explanation_prompt(results_str)
     try:
-        explanation = await call_hf_model(exp_prompt, req.temperature, req.max_tokens)
+        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}"}