dddddddddd

my_tools.py

@@ -3,92 +3,172 @@ import math
 import pandas as pd
 from duckduckgo_search import DDGS
 import wikipedia
+import llama_index # <--- AÑADIR ESTA LÍNEA
 from llama_index.core.tools import FunctionTool
 from llama_index.core.agent import ReActAgent
-from llama_index.core.llms.types import ChatMessage, LLMMetadata, LLM
-from llama_index.core.callbacks import CallbackManager, LlamaDebugHandler
+# --- CORREGIR ESTA IMPORTACIÓN ---
+# from llama_index.core.llms.types import ChatMessage, LLMMetadata, LLM
+from llama_index.core.llms import ChatMessage, LLMMetadata, LLM # <--- NUEVA IMPORTACIÓN
+from llama_index.core.callbacks import CallbackManager # LlamaDebugHandler no se usa directamente aquí, pero sí en el property
+from llama_index.core.callbacks.llama_debug import LlamaDebugHandler # Importación completa si se usa directamente
 import google.generativeai as genai
 
-print("LlamaIndex version:", llama_index.__version__)
+print("LlamaIndex version:", llama_index.__version__) # Ahora esto debería funcionar
 
 # --- Gemini LLM personalizado ---
 class GeminiLLM(LLM):
     def __init__(self, model="models/gemini-1.5-flash-latest"):
-        genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
+        super().__init__() # <--- Buena práctica llamar al __init__ de la clase base
+        gemini_api_key = os.getenv("GEMINI_API_KEY")
+        if not gemini_api_key:
+            raise ValueError("GEMINI_API_KEY environment variable not set.")
+        genai.configure(api_key=gemini_api_key)
         self.model = genai.GenerativeModel(model)
+        # El callback_manager se puede inicializar aquí si siempre será el mismo
+        self._callback_manager = CallbackManager([LlamaDebugHandler()])
+
 
     def chat(self, messages: list[ChatMessage], **kwargs):
-        prompt = "\n".join([
-            ("User: " if m.role == "user" else "Assistant: ") + m.content
-            for m in messages
-        ]) + "\nAssistant:"
-        resp = self.model.generate_content(prompt)
+        # Construir el prompt compatible con Gemini
+        # Gemini espera una lista de mensajes con roles 'user' y 'model' (para historial)
+        # El último mensaje de 'user' es el prompt actual.
+        gemini_messages = []
+        system_prompt = "" # LlamaIndex podría pasar un system_prompt vía kwargs o primer mensaje
+        
+        prompt_parts = []
+        for m in messages:
+            # Adaptar roles si es necesario, Gemini usa 'user' y 'model'
+            role = "user" if m.role == "user" else "model" # Asumimos que 'assistant' mapea a 'model'
+            prompt_parts.append(f"{role}: {m.content}")
+        
+        # El prompt final para generate_content usualmente es solo el último mensaje del usuario,
+        # con el historial implícito si el modelo es conversacional.
+        # Para el modelo genai.GenerativeModel, el historial se maneja a través de start_chat.
+        # Si solo hacemos una llamada, el prompt concatenado está bien, pero es mejor usar la API de chat.
+        
+        # Usando start_chat para mantener el contexto si es una conversación más larga
+        # Esto es más robusto si el agente hace múltiples llamadas al LLM con historial
+        chat_session = self.model.start_chat(
+            history=[{'role': msg.role if msg.role in ['user', 'model'] else ('user' if msg.role == 'assistant' else 'user'), 'parts': [msg.content]} for msg in messages[:-1]]
+        )
+        resp = chat_session.send_message(messages[-1].content)
+        
+        # Alternativa simple si solo es un turno (como en el prompt original construido)
+        # prompt_str = "\n".join(prompt_parts) + "\nAssistant:" # O model:
+        # resp = self.model.generate_content(prompt_str)
+
         return ChatMessage(role="assistant", content=resp.text)
 
     @property
     def metadata(self) -> LLMMetadata:
         return LLMMetadata(
-            context_window=8192,
-            num_output=1024,
+            context_window=8192, # Consultar la documentación de gemini-1.5-flash para el valor exacto
+            num_output=1024,     # Consultar la documentación de gemini-1.5-flash para el valor exacto
             is_chat_model=True,
-            is_function_calling_model=False,
+            is_function_calling_model=False, # Gemini tiene su propio sistema de tools/function calling
             model_name="gemini-1.5-flash-latest"
         )
 
     @property
-    def callback_manager(self):
-        return CallbackManager([LlamaDebugHandler()])
+    def callback_manager(self): # Propiedad para acceder al callback_manager
+        return self._callback_manager
+    
+    # Necesario para LLM. LlamaIndex espera estos métodos async aunque no los usemos activamente para todo.
+    async def achat(self, messages: list[ChatMessage], **kwargs):
+        # Implementación asíncrona simple (puede ser igual a la síncrona si la SDK no es async nativa fácil)
+        # o usar asyncio.to_thread si la SDK de Gemini es bloqueante
+        return self.chat(messages, **kwargs)
+
+    async def astream_chat(self, messages: list[ChatMessage], **kwargs):
+        # Placeholder para streaming asíncrono
+        # Por ahora, podemos hacer que devuelva un generador que produce la respuesta completa de una vez.
+        response = self.chat(messages, **kwargs)
+        async def gen():
+            yield response
+        return gen()
+
+    def stream_chat(self, messages: list[ChatMessage], **kwargs):
+        # Placeholder para streaming síncrono
+        response = self.chat(messages, **kwargs)
+        def gen():
+            yield response
+        return gen()
+
 
 llm = GeminiLLM()
 
 # --- Herramientas ---
 def buscar_web(query: str) -> str:
-    with DDGS() as ddgs:
-        results = list(ddgs.text(query, region='es-es', safesearch='moderate', timelimit='y', max_results=3))
-        if results:
-            return "\n".join([f"{r['title']}: {r['body']}" for r in results])
-    return "No se encontraron resultados."
+    """Busca en la web utilizando DuckDuckGo y devuelve los 3 primeros resultados."""
+    try:
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, region='es-es', safesearch='moderate', timelimit='y', max_results=3))
+            if results:
+                return "\n".join([f"{r['title']}: {r['body']}" for r in results])
+        return "No se encontraron resultados."
+    except Exception as e:
+        return f"Error al buscar en la web: {e}"
+
 
 search_tool = FunctionTool.from_defaults(
     fn=buscar_web,
     name="web_search",
-    description="Busca en la web utilizando DuckDuckGo."
+    description="Busca en la web utilizando DuckDuckGo para obtener información actualizada o temas generales."
 )
 
 def get_wikipedia_summary(query: str) -> str:
+    """Busca un resumen breve de un tema en Wikipedia (primeras 3 frases)."""
     try:
+        wikipedia.set_lang("es")
         return wikipedia.summary(query, sentences=3, auto_suggest=False)
+    except wikipedia.exceptions.PageError:
+        return f"La página '{query}' no existe en Wikipedia."
+    except wikipedia.exceptions.DisambiguationError as e:
+        return f"La búsqueda '{query}' es ambigua. Opciones posibles: {e.options[:5]}"
     except Exception as e:
         return f"Error al buscar en Wikipedia: {e}"
 
 wikipedia_tool = FunctionTool.from_defaults(
     fn=get_wikipedia_summary,
     name="wikipedia_lookup",
-    description="Busca un resumen breve de un tema en Wikipedia."
+    description="Busca un resumen breve de un tema específico en Wikipedia."
 )
 
 def calcular_expresion(expr: str) -> str:
+    """
+    Evalúa expresiones matemáticas.
+    Ejemplos: '2+2', 'math.sqrt(16)', 'pow(2,3)', '37 * 19'.
+    Funciones math disponibles: sqrt, pow, sin, cos, tan, log, log10, etc.
+    """
     try:
-        result = eval(expr, {"__builtins__": {}}, math.__dict__)
+        # Un entorno seguro para eval(), permitiendo solo funciones de math
+        allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith("__")}
+        allowed_names["math"] = math # Para poder usar math.sqrt() etc.
+        
+        result = eval(expr, {"__builtins__": {}}, allowed_names)
         return str(result)
     except Exception as e:
-        return f"Error de cálculo: {e}"
+        return f"Error de cálculo al evaluar '{expr}': {e}"
 
 calculator_tool = FunctionTool.from_defaults(
     fn=calcular_expresion,
     name="calculadora",
-    description="Resuelve expresiones matemáticas, incluyendo funciones trigonométricas, logaritmos, potencias, etc."
+    description="Resuelve expresiones matemáticas. Utiliza 'math.funcion()' para funciones como sqrt, pow, sin, etc. Ej: 'math.sqrt(16)', '37*19'."
 )
 
 # --- Agente ---
 alfred_agent = ReActAgent.from_tools(
     tools=[search_tool, wikipedia_tool, calculator_tool],
     llm=llm,
-    verbose=False
+    verbose=True # <--- Poner a True para debugging inicial es muy útil
 )
 
-def basic_agent_response(question):
-    response = alfred_agent.query(question)
-    return str(response)
-
-
+def basic_agent_response(question: str) -> str:
+    print(f"🤖 Alfred recibió la pregunta: {question}")
+    try:
+        response = alfred_agent.query(question)
+        print(f"📝 Respuesta de Alfred: {response}")
+        return str(response) # <--- CORREGIDO: Eliminado el punto extra
+    except Exception as e:
+        print(f"💥 Error en Alfred al procesar la pregunta '{question}': {e}")
+        return f"Error del agente al procesar la pregunta: {e}"