Update agent.py

agent.py

@@ -1,42 +1,57 @@
-from smolagents import CodeAgent, HfApiModel, DuckDuckGoSearchTool, WikipediaSearchTool
-import datetime
+import time
+from langchain.memory import ConversationBufferMemory
+from langchain.agents import AgentExecutor, Tool
+from langchain.chat_models import ChatGoogleGenerativeAI
+import genai
+from gemini import GeminiAgent
+from smolagent_tools import WikipediaSearchTool, WebSearchTool, SmolagentToolWrapper
 
-class SmartDuckDuckGoAgent:
-    def __init__(self):
-        # Definir los tools de búsqueda
-        self.wikipedia_tool = WikipediaSearchTool()
-        self.duckduckgo_tool = DuckDuckGoSearchTool()
+# Función para configuración de llm
+def setup_llm(api_key: str, model_name: str = "gemini-2.0-flash"):
+    """Configuración del modelo de lenguaje con Gemini."""
+    genai.configure(api_key=api_key)
+    return ChatGoogleGenerativeAI(model_name=model_name)
 
-        # Modelo
-        self.model = HfApiModel()
-        
-        # Crear el agente con los tools y el modelo
-        self.agent = CodeAgent(
-            tools=[self.wikipedia_tool, self.duckduckgo_tool],
-            model=self.model,
-            additional_authorized_imports=['datetime']
+# Herramientas adicionales
+class EnhancedAgent:
+    def __init__(self, api_key: str, model_name: str = "gemini-2.0-flash"):
+        self.api_key = api_key
+        self.model_name = model_name
+        self.llm = setup_llm(api_key, model_name)
+        self.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+        self.tools = [
+            SmolagentToolWrapper(WikipediaSearchTool()),
+            Tool(name="web_search", func=self._web_search, description="Realizar búsqueda web avanzada")
+        ]
+
+        self.agent = GeminiAgent(
+            tools=self.tools,
+            llm=self.llm,
+            memory=self.memory,
         )
 
-    def __call__(self, question: str) -> str:
-        # Intentar buscar en Wikipedia primero
-        try:
-            wiki_response = self.wikipedia_tool.search(question)  # Usa 'search' en lugar de 'run'
-            if wiki_response:
-                return wiki_response
-        except Exception as e:
-            print(f"Error buscando en Wikipedia: {e}")
-        
-        # Si Wikipedia no tiene resultados, intentar con DuckDuckGo
+    def _web_search(self, query: str, domain: Optional[str] = None) -> str:
+        """Realiza una búsqueda en la web usando DuckDuckGo con limitación de tasa y reintentos."""
         try:
-            duck_response = self.duckduckgo_tool.run(question)
-            if duck_response:
-                return duck_response
+            search_tool = WebSearchTool()
+            results = search_tool.search(query, domain)
+            return results
         except Exception as e:
-            print(f"Error buscando en DuckDuckGo: {e}")
+            return f"Error al realizar la búsqueda: {str(e)}"
 
-        # Si ambos fallan, usar el modelo para generar una respuesta
-        fallback_prompt = f"""I couldn't find a direct answer to the following question:
-        {question}
-        
-        Based on your general knowledge, provide a reasonable and well-written answer."""
-        return self.model.run(fallback_prompt)
+    def run(self, query: str) -> str:
+        """Procesa las consultas del usuario con reintentos y manejo de errores."""
+        max_retries = 3
+        base_sleep = 1
+        for attempt in range(max_retries):
+            try:
+                response = self.agent.run(query)
+                return response
+            except Exception as e:
+                sleep_time = base_sleep * (attempt + 1)
+                if attempt < max_retries - 1:
+                    print(f"Intento {attempt + 1} fallido. Reintentando en {sleep_time} segundos...")
+                    time.sleep(sleep_time)
+                    continue
+                return f"Error procesando la consulta: {str(e)}"