Update agent.py

agent.py

@@ -1,51 +1,62 @@
 import os
 import openai
 import wikipedia
-from duckduckgo_search import DDGS
+from tavily import TavilyClient # Importa TavilyClient
 import arxiv
 import json
 import re
 
-# Carica la chiave API di OpenAI dalla variabile d'ambiente
+# Carica le chiavi API dalle variabili d'ambiente
 # Per i test locali, puoi usare python-dotenv e un file .env
 # from dotenv import load_dotenv
 # load_dotenv()
-# openai.api_key = os.getenv("OPENAI_API_KEY") # La libreria OpenAI >1.0.0 lo gestisce automaticamente
 
-# Se la chiave API non è impostata tramite variabile d'ambiente,
-# la libreria OpenAI cercherà di trovarla.
-# È buona pratica assicurarsi che sia disponibile.
+# La libreria OpenAI >1.0.0 gestisce automaticamente OPENAI_API_KEY
+# La chiave Tavily deve essere caricata esplicitamente o passata al client
+
+TAVILY_API_KEY = os.getenv("TAVILY_API_KEY")
+
 if not os.getenv("OPENAI_API_KEY"):
     print("ATTENZIONE: La variabile d'ambiente OPENAI_API_KEY non è impostata.")
     print("L'agente potrebbe non funzionare correttamente senza una chiave API OpenAI valida.")
 
+if not TAVILY_API_KEY:
+    print("ATTENZIONE: La variabile d'ambiente TAVILY_API_KEY non è impostata.")
+    print("La ricerca Tavily non funzionerà senza una chiave API valida.")
+
 
 MAX_WIKIPEDIA_RESULTS = 3
-MAX_DDG_RESULTS = 4
+MAX_TAVILY_RESULTS = 5 # Tavily può restituire risultati più ricchi
 MAX_ARXIV_RESULTS = 3
-MAX_TOOL_ITERATIONS = 7 # Numero massimo di cicli di chiamata agli strumenti
+MAX_TOOL_ITERATIONS = 7
 
 class GaiaAgent:
     def __init__(self, model_name="gpt-4o"):
         self.model_name = model_name
-        self.client = openai.OpenAI() # Inizializza il client OpenAI qui
+        self.openai_client = openai.OpenAI() # Inizializza il client OpenAI
+        if TAVILY_API_KEY:
+            self.tavily_client = TavilyClient(api_key=TAVILY_API_KEY)
+        else:
+            self.tavily_client = None
+            print("Cliente Tavily non inizializzato a causa della mancanza di TAVILY_API_KEY.")
+        
         print(f"GaiaAgent initialized with model: {self.model_name}")
-        if not self.client.api_key: # Verifica se la chiave è stata caricata dal client
+        if not self.openai_client.api_key:
              print("WARNING: OpenAI API key not found by the client. Ensure OPENAI_API_KEY is set.")
 
+
     def _call_openai_api(self, messages, tools=None, tool_choice=None):
         try:
-            response = self.client.chat.completions.create(
+            response = self.openai_client.chat.completions.create(
                 model=self.model_name,
                 messages=messages,
                 tools=tools,
                 tool_choice=tool_choice,
-                temperature=0.1, # Bassa temperatura per risposte più deterministiche e fattuali
+                temperature=0.1,
             )
             return response
         except openai.APIError as e:
             print(f"Errore API OpenAI: {e}")
-            # Potresti voler restituire un messaggio di errore specifico o sollevare l'eccezione
             return f"Errore durante la chiamata all'API OpenAI: {str(e)}"
         except Exception as e:
             print(f"Errore imprevisto durante la chiamata OpenAI API: {e}")
@@ -53,24 +64,17 @@ class GaiaAgent:
 
 
     def _execute_python_code(self, code_string: str) -> str:
-        """Esegue codice Python e restituisce l'output o un errore."""
         print(f"Esecuzione codice Python (primi 200 caratteri): {code_string[:200]}...")
         try:
-            # Rimuovi i backtick e 'python' se presenti (comune nell'output LLM)
             code_string = re.sub(r"^```python\n", "", code_string)
             code_string = re.sub(r"\n```$", "", code_string)
             code_string = code_string.strip()
-
-            # Prepara un ambiente per l'esecuzione del codice
-            # Reindirizza stdout per catturare i print
             import io
             from contextlib import redirect_stdout
             f = io.StringIO()
             with redirect_stdout(f):
-                exec(code_string, {}) # Usa un dizionario vuoto per globals per un minimo di isolamento
+                exec(code_string, {})
             s = f.getvalue()
-
-            # Se non c'è output esplicito da print(), indica che l'esecuzione è avvenuta
             if not s:
                 s = "Codice eseguito con successo, nessun output esplicito (print)."
             print(f"Esecuzione codice riuscita. Output (primi 200 caratteri): {s[:200]}")
@@ -82,7 +86,7 @@ class GaiaAgent:
     def _search_wikipedia(self, query: str) -> str:
         print(f"Ricerca Wikipedia per: {query}")
         try:
-            wikipedia.set_lang("en") # Le domande GAIA sono in inglese
+            wikipedia.set_lang("en")
             results = wikipedia.search(query, results=MAX_WIKIPEDIA_RESULTS)
             if not results:
                 return "Nessun risultato trovato su Wikipedia."
@@ -103,17 +107,33 @@ class GaiaAgent:
         except Exception as e:
             return f"Errore durante la ricerca su Wikipedia: {str(e)}"
 
-    def _search_duckduckgo(self, query: str) -> str:
-        print(f"Ricerca DuckDuckGo per: {query}")
+    def _search_tavily(self, query: str) -> str:
+        print(f"Ricerca Tavily per: {query}")
+        if not self.tavily_client:
+            return "Errore: Tavily API key non configurata. Impossibile eseguire la ricerca."
         try:
-            with DDGS() as ddgs:
-                # Usare ddgs.text per risultati testuali, o ddgs.answers per risposte più dirette se disponibili
-                results = list(ddgs.text(query, max_results=MAX_DDG_RESULTS))
-            if not results:
-                return "Nessun risultato trovato su DuckDuckGo."
-            return "\n\n".join([f"Title: {r['title']}\nSnippet: {r['body'][:500]}...\nURL: {r['href']}" for r in results])
+            # Puoi personalizzare i parametri di ricerca di Tavily qui
+            # ad esempio: search_depth="advanced", include_answer=True, include_raw_content=False
+            response = self.tavily_client.search(
+                query=query,
+                search_depth="basic", # "basic" per velocità, "advanced" per risposte più approfondite
+                max_results=MAX_TAVILY_RESULTS,
+                include_answer=True # Chiede a Tavily di provare a fornire una risposta diretta
+            )
+            
+            results_str = ""
+            if response.get("answer"):
+                results_str += f"Risposta diretta da Tavily: {response['answer']}\n\n"
+
+            if response.get("results"):
+                results_str += "Risultati della ricerca:\n"
+                for r in response["results"]:
+                    results_str += f"Title: {r.get('title', 'N/A')}\nURL: {r.get('url', 'N/A')}\nContent Snippet: {r.get('content', 'N/A')[:500]}...\n\n"
+            
+            return results_str if results_str else "Nessun risultato significativo trovato da Tavily."
+
         except Exception as e:
-            return f"Errore durante la ricerca su DuckDuckGo: {str(e)}"
+            return f"Errore durante la ricerca su Tavily: {str(e)}"
 
     def _search_arxiv(self, query: str) -> str:
         print(f"Ricerca Arxiv per: {query}")
@@ -134,8 +154,11 @@ class GaiaAgent:
 
     def __call__(self, question: str) -> str:
         print(f"GaiaAgent ha ricevuto la domanda (primi 100 caratteri): {question[:100]}...")
-        if not self.client.api_key:
+        if not self.openai_client.api_key:
             return "Errore: OPENAI_API_KEY non configurata o non valida per l'agente."
+        if not self.tavily_client:
+             print("Avviso: Tavily client non inizializzato. La ricerca web non sarà disponibile.")
+
 
         tools = [
             {"type": "function", "function": {
@@ -143,27 +166,27 @@ class GaiaAgent:
                 "description": "Cerca informazioni su Wikipedia. Utile per conoscenza generale, fatti, definizioni, storia.",
                 "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "La query di ricerca per Wikipedia."}}, "required": ["query"]}}},
             {"type": "function", "function": {
-                "name": "search_duckduckgo",
-                "description": "Cerca sul web usando DuckDuckGo. Utile per eventi attuali, siti specifici, o quando Wikipedia non è sufficiente.",
-                "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "La query di ricerca per DuckDuckGo."}}, "required": ["query"]}}},
+                "name": "search_tavily", # Nome dello strumento aggiornato
+                "description": "Cerca sul web usando l'API di Tavily. Utile per eventi attuali, informazioni specifiche, siti web, o quando Wikipedia non è sufficiente. Può fornire risposte dirette e snippet di contenuto.",
+                "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "La query di ricerca per Tavily."}}, "required": ["query"]}}},
             {"type": "function", "function": {
                 "name": "search_arxiv",
                 "description": "Cerca su Arxiv articoli scientifici e preprint (fisica, matematica, informatica, ecc.).",
                 "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "La query di ricerca per Arxiv (es. autore, titolo, parole chiave)."}}, "required": ["query"]}}},
             {"type": "function", "function": {
                 "name": "execute_python_code",
-                "description": "Esegue una stringa di codice Python e restituisce il suo output. Usare per calcoli, manipolazione dati o qualsiasi task che richieda esecuzione di codice. Assicurarsi che il codice stampi il risultato su stdout. Il codice viene eseguito in un ambiente stateless. NON usare per installare pacchetti o interagire con file system.",
-                "parameters": {"type": "object", "properties": {"code_string": {"type": "string", "description": "Il codice Python da eseguire. Deve essere uno script Python valido. Esempio: 'print(sum([i for i in range(101)]))'"}}, "required": ["code_string"]}}}
+                "description": "Esegue una stringa di codice Python e restituisce il suo output. Usare per calcoli, manipolazione dati o qualsiasi task che richieda esecuzione di codice. Assicurarsi che il codice stampi il risultato su stdout. Il codice viene eseguito in un ambiente stateless.",
+                "parameters": {"type": "object", "properties": {"code_string": {"type": "string", "description": "Il codice Python da eseguire. Esempio: 'print(1+1)'"}}, "required": ["code_string"]}}}
         ]
 
         system_prompt = (
             "Sei GaiaAgent, un assistente AI progettato per rispondere a domande in modo accurato e completo, specialmente per task complessi come quelli di GAIA. "
-            "Hai accesso ai seguenti strumenti: ricerca Wikipedia, ricerca web DuckDuckGo, ricerca Arxiv e un interprete di codice Python. "
+            "Hai accesso ai seguenti strumenti: ricerca Wikipedia, ricerca web Tavily, ricerca Arxiv e un interprete di codice Python. " # Aggiornato DuckDuckGo a Tavily
             "Segui questi passaggi per rispondere alla domanda dell'utente:\n"
             "1. **Analizza la Domanda**: Comprendi a fondo cosa viene chiesto. Se la domanda è complessa, scomponila in sotto-problemi.\n"
             "2. **Pianifica l'Uso degli Strumenti**: Decidi quali strumenti sono più appropriati e in quale ordine. Puoi usare più strumenti in sequenza.\n"
             "   - `search_wikipedia`: per conoscenza generale consolidata.\n"
-            "   - `search_duckduckgo`: per informazioni recenti, argomenti di nicchia, o per confermare/trovare URL specifici.\n"
+            "   - `search_tavily`: per informazioni recenti, argomenti di nicchia, o per confermare/trovare URL specifici. Può fornire risposte dirette.\n" # Aggiornato
             "   - `search_arxiv`: per ricerca scientifica e tecnica.\n"
             "   - `execute_python_code`: per calcoli, elaborazione di dati testuali/numerici, o simulazioni. Il codice deve stampare esplicitamente i risultati.\n"
             "3. **Esegui e Itera**: Usa gli strumenti. Se uno strumento non fornisce l'informazione necessaria, valuta se riformulare la query, provare un altro strumento, o concludere che l'informazione non è reperibile con gli strumenti attuali.\n"
@@ -179,14 +202,14 @@ class GaiaAgent:
             
             api_response_or_error = self._call_openai_api(messages, tools=tools, tool_choice="auto")
 
-            if isinstance(api_response_or_error, str): # Errore gestito da _call_openai_api
-                return api_response_or_error # Restituisce il messaggio di errore
+            if isinstance(api_response_or_error, str):
+                return api_response_or_error
 
             response_message = api_response_or_error.choices[0].message
 
             if response_message.tool_calls:
                 print(f"OpenAI suggerisce chiamate a strumenti: {[tc.function.name for tc in response_message.tool_calls]}")
-                messages.append(response_message) # Aggiungi la risposta dell'assistente con le richieste di tool
+                messages.append(response_message)
                 
                 for tool_call in response_message.tool_calls:
                     function_name = tool_call.function.name
@@ -196,14 +219,17 @@ class GaiaAgent:
                         print(f"Errore nel decodificare gli argomenti JSON per {function_name}: {e}")
                         tool_output = f"Errore: argomenti JSON invalidi per {function_name}."
                         messages.append({"tool_call_id": tool_call.id, "role": "tool", "name": function_name, "content": tool_output})
-                        continue # Salta al prossimo tool_call o iterazione
+                        continue
 
                     print(f"Esecuzione strumento: {function_name} con argomenti: {function_args}")
                     tool_output = ""
                     if function_name == "search_wikipedia":
                         tool_output = self._search_wikipedia(query=function_args.get("query",""))
-                    elif function_name == "search_duckduckgo":
-                        tool_output = self._search_duckduckgo(query=function_args.get("query",""))
+                    elif function_name == "search_tavily": # Aggiornato per chiamare Tavily
+                        if not self.tavily_client:
+                            tool_output = "Errore: Tavily client non inizializzato. Impossibile eseguire la ricerca Tavily."
+                        else:
+                            tool_output = self._search_tavily(query=function_args.get("query",""))
                     elif function_name == "search_arxiv":
                         tool_output = self._search_arxiv(query=function_args.get("query",""))
                     elif function_name == "execute_python_code":
@@ -214,26 +240,24 @@ class GaiaAgent:
                     print(f"Output strumento {function_name} (primi 100 caratteri): {str(tool_output)[:100]}")
                     messages.append({"tool_call_id": tool_call.id, "role": "tool", "name": function_name, "content": str(tool_output)})
             
-            else: # Nessuna chiamata a strumento, l'LLM dovrebbe aver fornito una risposta finale
+            else:
                 final_answer = response_message.content
                 if final_answer:
                     print(f"Agente restituisce risposta finale (primi 200 caratteri): {final_answer[:200]}")
                     return final_answer
-                else: # Risposta vuota, prova a forzare una risposta basata sulla cronologia
+                else:
                     print("L'LLM non ha chiamato strumenti e non ha fornito contenuto. Tento di forzare una risposta.")
                     messages.append({"role": "user", "content": "Per favore, fornisci la migliore risposta possibile basata sulle informazioni raccolte finora, senza usare altri strumenti."})
-                    final_attempt_response = self._call_openai_api(messages) # No tools this time
-                    if isinstance(final_attempt_response, str): return final_attempt_response # Errore
+                    final_attempt_response = self._call_openai_api(messages)
+                    if isinstance(final_attempt_response, str): return final_attempt_response
                     if final_attempt_response and final_attempt_response.choices[0].message.content:
                         return final_attempt_response.choices[0].message.content
                     return "L'agente ha ricevuto una risposta finale vuota e non è riuscito a generarne una alternativa."
 
-
         print("L'agente ha raggiunto il numero massimo di iterazioni degli strumenti.")
-        # Tenta un'ultima chiamata per sintetizzare
         messages.append({"role": "user", "content": "Hai raggiunto il limite di utilizzo degli strumenti. Per favore, fornisci la migliore risposta possibile basata sulle informazioni raccolte finora."})
-        final_summary_response = self._call_openai_api(messages) # No tools
-        if isinstance(final_summary_response, str): return final_summary_response # Errore
+        final_summary_response = self._call_openai_api(messages)
+        if isinstance(final_summary_response, str): return final_summary_response
         if final_summary_response and final_summary_response.choices[0].message.content:
             return final_summary_response.choices[0].message.content
         return "L'agente ha raggiunto il numero massimo di iterazioni e non è riuscito a formulare una risposta finale."