dddd

my_tools.py

@@ -1,88 +1,117 @@
 import os
 import math
-import pandas as pd
+import pandas as pd # No se usa directamente aquí pero podría ser útil para el DataFrame en app.py
 from duckduckgo_search import DDGS
 import wikipedia
 import llama_index
 from llama_index.core.tools import FunctionTool
 from llama_index.core.agent import ReActAgent
-from llama_index.core.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse # <--- AÑADIR CompletionResponse
+from llama_index.core.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse
 from llama_index.core.callbacks import CallbackManager
 from llama_index.core.callbacks.llama_debug import LlamaDebugHandler
 import google.generativeai as genai
-import asyncio # <--- AÑADIR para asyncio.to_thread
+import asyncio
+from pydantic import Field # Para declarar campos si fuera necesario, aunque no para _generation_config
 
-# ... (código para obtener la versión de LlamaIndex) ...
-# print(f"LlamaIndex version detectada: {llama_index_version}")
+# --- Intento mejorado para obtener la versión de LlamaIndex ---
+try:
+    from importlib import metadata
+    try:
+        llama_index_version = metadata.version('llama-index')
+    except metadata.PackageNotFoundError:
+        try:
+            llama_index_version = metadata.version('llama-index-core')
+        except metadata.PackageNotFoundError:
+            llama_index_version = "No se pudo determinar (con importlib.metadata)"
+except ImportError:
+    try:
+        from llama_index.core import __version__ as llama_index_core_version
+        llama_index_version = llama_index_core_version
+    except ImportError:
+        llama_index_version = "No se pudo determinar (fallback a __version__ falló)"
+
+print(f"LlamaIndex version detectada: {llama_index_version}")
 
 
 # --- Gemini LLM personalizado ---
 class GeminiLLM(LLM):
-    def __init__(self, model_name="models/gemini-1.5-flash-latest", temperature: float = 0.7): # Añadido temperature
-        super().__init__()
+    model_name: str = Field(default="models/gemini-1.5-flash-latest", description="The Gemini model to use.")
+    temperature: float = Field(default=0.7, description="The temperature to use for generation.")
+    
+    # Atributos privados que no queremos que Pydantic valide como campos del modelo directamente
+    # pero que necesitamos para la lógica interna. Los inicializaremos en __init__.
+    _model_instance: genai.GenerativeModel = None
+    _generation_config_instance: genai.types.GenerationConfig = None
+
+    # Para Pydantic v1, si la clase base lo es, permitir atributos extra
+    # Para Pydantic v2, esto sería model_config = {"extra": "allow"}
+    class Config:
+        extra = "allow" # Permite atributos que no están definidos explícitamente como campos
+
+    def __init__(self, model_name: str = "models/gemini-1.5-flash-latest", temperature: float = 0.7, **kwargs):
+        # Llamar a super().__init__() con los campos definidos y **kwargs
+        # Esto es importante para que Pydantic inicialice correctamente
+        super().__init__(model_name=model_name, temperature=temperature, **kwargs) # Pasar kwargs a 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)
         
-        # Configuración para la generación, incluida la temperatura
-        self._generation_config = genai.types.GenerationConfig(
-            # candidate_count=1, # Ya es 1 por defecto
-            # stop_sequences=stop_sequences, # Podríamos añadir esto si es necesario
-            # max_output_tokens=max_output_tokens, # Controlado por LlamaIndex via num_output
-            temperature=temperature
+        # Usar self.temperature y self.model_name que Pydantic ya ha asignado
+        self._generation_config_instance = genai.types.GenerationConfig(
+            temperature=self.temperature 
         )
-        self.model = genai.GenerativeModel(
-            model_name=model_name,
-            generation_config=self._generation_config
-            # safety_settings=... # Podríamos añadir configuraciones de seguridad aquí
+        self._model_instance = genai.GenerativeModel(
+            model_name=self.model_name,
+            generation_config=self._generation_config_instance
         )
-        self._callback_manager = CallbackManager([LlamaDebugHandler(print_trace=True)]) # print_trace para más detalle
+        # El callback_manager se hereda de la clase base LLM, podemos configurarlo si es necesario.
+        # self.callback_manager = kwargs.get('callback_manager', CallbackManager([LlamaDebugHandler(print_trace=True)]))
+        # Si la clase base LLM ya inicializa callback_manager, no necesitamos reasignarlo a menos que queramos uno específico.
+        # Por defecto, llama_index.core.llms.LLM inicializa self.callback_manager = callback_manager or CallbackManager([])
+        # Si queremos el LlamaDebugHandler, podemos pasarlo o reconfigurarlo
+        if not self.callback_manager.handlers: # Si no hay manejadores, añadir el nuestro
+             self.callback_manager.add_handler(LlamaDebugHandler(print_trace=True))
+
 
     @property
     def metadata(self) -> LLMMetadata:
-        # Estos valores deben ser precisos para el modelo específico
-        # gemini-1.5-flash tiene hasta 1M de tokens de contexto.
-        # num_output puede ser configurado o es inherentemente grande.
         return LLMMetadata(
-            context_window=1048576, # Para gemini-1.5-flash
-            num_output=8192,        # Max output tokens para gemini-1.5-flash
+            context_window=1048576, 
+            num_output=8192,        
             is_chat_model=True,
-            is_function_calling_model=True, # Gemini sí soporta function calling (declarar herramientas)
-            model_name=self.model.model_name # Usar el nombre del modelo configurado
+            is_function_calling_model=True, 
+            model_name=self.model_name 
         )
 
-    @property
-    def callback_manager(self):
-        return self._callback_manager
+    # callback_manager ya es una propiedad en la clase base LLM.
+    # No necesitamos redefinirla a menos que la lógica de acceso sea diferente.
+    # @property
+    # def callback_manager(self):
+    #     return self._callback_manager
 
     # --- Implementación de Chat ---
     def chat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
         gemini_history = []
-        for msg in messages[:-1]: # Todos excepto el último
+        for msg in messages[:-1]: 
             role = "user" if msg.role == "user" else "model"
             gemini_history.append({'role': role, 'parts': [{'text': msg.content}]})
         
         last_user_message = messages[-1].content
         
-        chat_session = self.model.start_chat(history=gemini_history)
+        chat_session = self._model_instance.start_chat(history=gemini_history)
         try:
             response = chat_session.send_message(last_user_message)
             return ChatMessage(role="assistant", content=response.text)
         except Exception as e:
-            # Podríamos manejar errores específicos de Gemini aquí, como bloqueos de contenido
             print(f"Error en Gemini chat: {e}")
-            # Devolver un mensaje de error coherente o re-lanzar
             return ChatMessage(role="assistant", content=f"Error al generar respuesta: {e}")
 
-
     async def achat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
-        # Para SDK síncrona, usar asyncio.to_thread
         return await asyncio.to_thread(self.chat, messages, **kwargs)
 
     def stream_chat(self, messages: list[ChatMessage], **kwargs):
-        # El SDK de Gemini v1 para Python con genai.GenerativeModel().generate_content(..., stream=True)
-        # o chat_session.send_message(..., stream=True) soporta streaming.
         gemini_history = []
         for msg in messages[:-1]:
             role = "user" if msg.role == "user" else "model"
@@ -90,33 +119,26 @@ class GeminiLLM(LLM):
         
         last_user_message = messages[-1].content
         
-        chat_session = self.model.start_chat(history=gemini_history)
+        chat_session = self._model_instance.start_chat(history=gemini_history)
         response_stream = chat_session.send_message(last_user_message, stream=True)
 
         def gen():
             accumulated_text = ""
             for chunk in response_stream:
-                delta = chunk.text # Asumiendo que el chunk tiene .text con el delta
-                accumulated_text += delta
-                yield ChatMessage(role="assistant", content=accumulated_text, additional_kwargs={"delta": delta})
+                delta = ""
+                if hasattr(chunk, 'text') and chunk.text:
+                    delta = chunk.text
+                # Podríamos necesitar revisar la estructura exacta del chunk para obtener el delta correcto.
+                # A veces es chunk.parts[0].text
+                elif chunk.parts and hasattr(chunk.parts[0], 'text'):
+                    delta = chunk.parts[0].text
+
+                if delta:
+                    accumulated_text += delta
+                    yield ChatMessage(role="assistant", content=accumulated_text, additional_kwargs={"delta": delta})
         return gen()
 
     async def astream_chat(self, messages: list[ChatMessage], **kwargs):
-        # Similar a stream_chat pero con manejo async si la SDK lo permite,
-        # o envolviendo la lógica de streaming síncrona.
-        # Por simplicidad, si la SDK no tiene un `asend_message` o similar,
-        # podemos hacer esto bloqueante o intentar adaptarlo.
-        # Dado que send_message(stream=True) devuelve un iterador,
-        # necesitamos una forma de iterar asíncronamente o usar to_thread.
-
-        # Este es un placeholder más complejo de implementar correctamente de forma no bloqueante
-        # sin una API async nativa en la SDK para streaming.
-        # Por ahora, una simulación básica como la anterior:
-        
-        # De manera simple, podemos hacer que devuelva el resultado completo en un solo chunk.
-        # O, si queremos que funcione con `async for`, tenemos que adaptar el generador.
-        
-        # Este es un enfoque un poco más avanzado para iterar sobre el stream en un hilo separado:
         loop = asyncio.get_event_loop()
         
         gemini_history = []
@@ -125,94 +147,188 @@ class GeminiLLM(LLM):
             gemini_history.append({'role': role, 'parts': [{'text': msg.content}]})
         last_user_message = messages[-1].content
 
-        # La función que se ejecutará en el hilo
         def get_stream_iterator():
-            chat_session = self.model.start_chat(history=gemini_history)
+            chat_session = self._model_instance.start_chat(history=gemini_history)
             return chat_session.send_message(last_user_message, stream=True)
 
         response_stream = await loop.run_in_executor(None, get_stream_iterator)
         
         async def gen():
             accumulated_text = ""
-            # Necesitamos iterar sobre el stream de forma que no bloquee el bucle de eventos
-            # Esto puede ser complejo si el iterador es bloqueante.
-            # Una forma es obtener todos los chunks en el hilo y luego producirlos.
             all_chunks_text = []
-            for chunk in response_stream: # Esto podría seguir siendo bloqueante si response_stream es un iterador síncrono
-                all_chunks_text.append(chunk.text)
+            for chunk in response_stream: 
+                delta = ""
+                if hasattr(chunk, 'text') and chunk.text:
+                    delta = chunk.text
+                elif chunk.parts and hasattr(chunk.parts[0], 'text'):
+                    delta = chunk.parts[0].text
+                if delta:
+                    all_chunks_text.append(delta)
             
             for text_delta in all_chunks_text:
                 accumulated_text += text_delta
                 yield ChatMessage(role="assistant", content=accumulated_text, additional_kwargs={"delta": text_delta})
-                await asyncio.sleep(0) # Ceder control brevemente
-
+                await asyncio.sleep(0) 
         return gen()
 
-    # --- Implementación de Complete (requerido por la clase base LLM) ---
+    # --- Implementación de Complete ---
     def complete(self, prompt: str, formatted: bool = False, **kwargs) -> CompletionResponse:
-        # `formatted` es una pista de LlamaIndex, podemos ignorarla si no aplica.
-        # Usar generate_content para una sola finalización
         try:
-            response = self.model.generate_content(prompt)
+            response = self._model_instance.generate_content(prompt)
             return CompletionResponse(text=response.text)
         except Exception as e:
             print(f"Error en Gemini complete: {e}")
             return CompletionResponse(text=f"Error al generar completion: {e}")
 
-
     async def acomplete(self, prompt: str, formatted: bool = False, **kwargs) -> CompletionResponse:
         return await asyncio.to_thread(self.complete, prompt, formatted=formatted, **kwargs)
 
     def stream_complete(self, prompt: str, formatted: bool = False, **kwargs):
-        # Usar generate_content con stream=True
-        response_stream = self.model.generate_content(prompt, stream=True)
+        response_stream = self._model_instance.generate_content(prompt, stream=True)
         
         def gen():
             accumulated_text = ""
             for chunk in response_stream:
-                # Asegurarse de que el chunk tiene 'text' y no es un error de prompt feedback, etc.
-                if hasattr(chunk, 'text'):
+                delta = ""
+                if hasattr(chunk, 'text') and chunk.text:
                     delta = chunk.text
+                elif chunk.parts and hasattr(chunk.parts[0], 'text'):
+                    delta = chunk.parts[0].text
+                
+                if delta:
                     accumulated_text += delta
                     yield CompletionResponse(text=accumulated_text, delta=delta)
                 elif hasattr(chunk, 'prompt_feedback'):
-                    # Manejar el caso donde el prompt es bloqueado, etc.
                     print(f"Feedback del prompt en stream_complete: {chunk.prompt_feedback}")
-                    # Podríamos lanzar una excepción o devolver un mensaje de error especial.
-                    # Por ahora, solo lo imprimimos y el stream podría detenerse o continuar vacío.
-                    pass # O `break` si queremos detener el stream ante un feedback negativo
-
         return gen()
 
-
     async def astream_complete(self, prompt: str, formatted: bool = False, **kwargs):
-        # Similar a astream_chat, la implementación async de un stream síncrono es un poco más compleja.
         loop = asyncio.get_event_loop()
 
         def get_stream_iterator():
-            return self.model.generate_content(prompt, stream=True)
+            return self._model_instance.generate_content(prompt, stream=True)
 
         response_stream = await loop.run_in_executor(None, get_stream_iterator)
         
         async def gen():
             accumulated_text = ""
-            all_chunks_data = [] # Para recolectar en el hilo y luego generar
-            for chunk in response_stream: # Esto es bloqueante en el hilo executor
-                 if hasattr(chunk, 'text'):
-                    all_chunks_data.append({'delta': chunk.text})
-                 elif hasattr(chunk, 'prompt_feedback'):
-                    all_chunks_data.append({'feedback': chunk.prompt_feedback})
+            all_chunks_data = [] 
+            for chunk in response_stream: 
+                delta = ""
+                feedback = None
+                if hasattr(chunk, 'text') and chunk.text:
+                    delta = chunk.text
+                elif chunk.parts and hasattr(chunk.parts[0], 'text'):
+                    delta = chunk.parts[0].text
+                
+                if hasattr(chunk, 'prompt_feedback'):
+                    feedback = chunk.prompt_feedback
+                
+                if delta:
+                    all_chunks_data.append({'delta': delta})
+                if feedback:
+                     all_chunks_data.append({'feedback': feedback})
+
 
             for data in all_chunks_data:
                 if 'delta' in data:
-                    delta = data['delta']
-                    accumulated_text += delta
-                    yield CompletionResponse(text=accumulated_text, delta=delta)
+                    delta_val = data['delta']
+                    accumulated_text += delta_val
+                    yield CompletionResponse(text=accumulated_text, delta=delta_val)
                 elif 'feedback' in data:
                     print(f"Feedback del prompt en astream_complete: {data['feedback']}")
-                await asyncio.sleep(0) # Ceder control
+                await asyncio.sleep(0) 
         return gen()
 
-llm = GeminiLLM() # Esto ya no debería dar error
+llm = GeminiLLM()
+
+# --- HERRAMIENTAS RESTAURADAS ---
+def buscar_web(query: str) -> str:
+    """Busca en la web utilizando DuckDuckGo y devuelve los 3 primeros resultados."""
+    try:
+        with DDGS() as ddgs:
+            # Nota: ddgs.text devuelve un generador. Convertir a lista para obtener resultados.
+            results = list(ddgs.text(query, region='es-es', safesearch='moderate', timelimit='y', max_results=3))
+            if results:
+                return "\n".join([f"Título: {r['title']}, Cuerpo: {r['body']}" for r in results])
+        return "No se encontraron resultados en la web."
+    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="Útil para buscar información actual o general en internet. Proporciona un resumen de los resultados de búsqueda."
+)
+
+def get_wikipedia_summary(query: str) -> str:
+    """Busca un resumen breve de un tema en Wikipedia (primeras 3 frases)."""
+    try:
+        wikipedia.set_lang("es") # Asegurar el idioma
+        return wikipedia.summary(query, sentences=3, auto_suggest=False)
+    except wikipedia.exceptions.PageError:
+        return f"La página '{query}' no existe en Wikipedia en español."
+    except wikipedia.exceptions.DisambiguationError as e:
+        # Devolver algunas opciones para que el LLM pueda refinar la búsqueda si es necesario
+        options_str = ", ".join(e.options[:3])
+        return f"La búsqueda '{query}' es ambigua. Posibles opciones: {options_str}. Por favor, sé más específico."
+    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 conciso de un tema específico en Wikipedia. Ideal para definiciones, hechos históricos, biografías, etc."
+)
+
+def calcular_expresion(expr: str) -> str:
+    """
+    Evalúa expresiones matemáticas de forma segura.
+    Ejemplos: '2+2', 'math.sqrt(16)', 'pow(2,3)', '37 * 19'.
+    Funciones math disponibles: sqrt, pow, sin, cos, tan, log, log10, pi, e, etc.
+    """
+    try:
+        # Entorno seguro para eval()
+        allowed_names = {k: v for k, v in math.__dict__.items() if not k.startswith("__")}
+        # Permitir acceso directo a funciones de math sin el prefijo 'math.'
+        # y también con el prefijo 'math.' para consistencia con la descripción.
+        safe_env = allowed_names.copy()
+        safe_env["math"] = math 
+        
+        result = eval(expr, {"__builtins__": {}}, safe_env)
+        return str(result)
+    except NameError as e:
+        return f"Error de cálculo: '{e}'. Asegúrate de usar funciones matemáticas válidas (ej: sqrt, pow, log) y constantes (ej: pi, e)."
+    except SyntaxError as e:
+        return f"Error de sintaxis en la expresión matemática: '{expr}'. Verifica la expresión."
+    except Exception as e:
+        return f"Error de cálculo al evaluar '{expr}': {type(e).__name__} {e}"
+
+calculator_tool = FunctionTool.from_defaults(
+    fn=calcular_expresion,
+    name="calculadora",
+    description="Calculadora para expresiones matemáticas. Puede usar funciones como sqrt(), pow(), log(), sin(), cos(), tan() y constantes como pi, e. Ejemplo: 'sqrt(25) + pow(2,3)' o '37*19'."
+)
+
+# --- AGENTE RESTAURADO ---
+alfred_agent = ReActAgent.from_tools(
+    tools=[search_tool, wikipedia_tool, calculator_tool],
+    llm=llm,
+    verbose=True # Mantener verbose=True para depuración
+)
 
-# ... (resto del código de my_tools.py: herramientas, agente, basic_agent_response) ...
+# --- FUNCIÓN DE RESPUESTA DEL AGENTE RESTAURADA ---
+def basic_agent_response(question: str) -> str:
+    print(f"🤖 Alfred (ReAct Agent) recibió la pregunta: {question}")
+    try:
+        response = alfred_agent.query(question)
+        # response es un objeto AgentChatResponse, necesitamos su .response
+        response_text = str(response.response) if hasattr(response, 'response') else str(response)
+        print(f"📝 Respuesta final de Alfred: {response_text}")
+        return response_text
+    except Exception as e:
+        # Capturar errores específicos de la ejecución del agente si es posible
+        print(f"💥 Error crítico en Alfred al procesar la pregunta '{question}': {e}")
+        import traceback
+        traceback.print_exc() # Imprimir el traceback completo para más detalles
+        return f"Error del agente al procesar la pregunta: {type(e).__name__} - {e}"