xxxxxxxxxxx

my_tools.py

@@ -3,172 +3,216 @@ import math
 import pandas as pd
 from duckduckgo_search import DDGS
 import wikipedia
-import llama_index # <--- AÑADIR ESTA LÍNEA
+import llama_index
 from llama_index.core.tools import FunctionTool
 from llama_index.core.agent import ReActAgent
-# --- 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
+from llama_index.core.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse # <--- AÑADIR 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
 
+# ... (código para obtener la versión de LlamaIndex) ...
+# print(f"LlamaIndex version detectada: {llama_index_version}")
 
 
 # --- Gemini LLM personalizado ---
 class GeminiLLM(LLM):
-    def __init__(self, model="models/gemini-1.5-flash-latest"):
-        super().__init__() # <--- Buena práctica llamar al __init__ de la clase base
+    def __init__(self, model_name="models/gemini-1.5-flash-latest", temperature: float = 0.7): # Añadido temperature
+        super().__init__()
         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):
-        # 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]]
+        # 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
         )
-        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)
+        self.model = genai.GenerativeModel(
+            model_name=model_name,
+            generation_config=self._generation_config
+            # safety_settings=... # Podríamos añadir configuraciones de seguridad aquí
+        )
+        self._callback_manager = CallbackManager([LlamaDebugHandler(print_trace=True)]) # print_trace para más detalle
 
     @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=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
+            context_window=1048576, # Para gemini-1.5-flash
+            num_output=8192,        # Max output tokens para gemini-1.5-flash
             is_chat_model=True,
-            is_function_calling_model=False, # Gemini tiene su propio sistema de tools/function calling
-            model_name="gemini-1.5-flash-latest"
+            is_function_calling_model=True, # Gemini sí soporta function calling (declarar herramientas)
+            model_name=self.model.model_name # Usar el nombre del modelo configurado
         )
 
     @property
-    def callback_manager(self): # Propiedad para acceder al callback_manager
+    def callback_manager(self):
         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)
+
+    # --- Implementación de Chat ---
+    def chat(self, messages: list[ChatMessage], **kwargs) -> ChatMessage:
+        gemini_history = []
+        for msg in messages[:-1]: # Todos excepto el último
+            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)
+        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"
+            gemini_history.append({'role': role, 'parts': [{'text': msg.content}]})
+        
+        last_user_message = messages[-1].content
+        
+        chat_session = self.model.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})
+        return gen()
 
     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)
+        # 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 = []
+        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
+
+        # La función que se ejecutará en el hilo
+        def get_stream_iterator():
+            chat_session = self.model.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():
-            yield response
+            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 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
+
         return gen()
 
-    def stream_chat(self, messages: list[ChatMessage], **kwargs):
-        # Placeholder para streaming síncrono
-        response = self.chat(messages, **kwargs)
+    # --- Implementación de Complete (requerido por la clase base LLM) ---
+    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)
+            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)
+        
         def gen():
-            yield response
+            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 = chunk.text
+                    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()
 
 
-llm = GeminiLLM()
-
-# --- Herramientas ---
-def buscar_web(query: str) -> str:
-    """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 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 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:
-        # 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.
+    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)
+
+        response_stream = await loop.run_in_executor(None, get_stream_iterator)
         
-        result = eval(expr, {"__builtins__": {}}, allowed_names)
-        return str(result)
-    except Exception as 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. 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=True # <--- Poner a True para debugging inicial es muy útil
-)
-
-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}"
+        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})
+
+            for data in all_chunks_data:
+                if 'delta' in data:
+                    delta = data['delta']
+                    accumulated_text += delta
+                    yield CompletionResponse(text=accumulated_text, delta=delta)
+                elif 'feedback' in data:
+                    print(f"Feedback del prompt en astream_complete: {data['feedback']}")
+                await asyncio.sleep(0) # Ceder control
+        return gen()
+
+llm = GeminiLLM() # Esto ya no debería dar error
+
+# ... (resto del código de my_tools.py: herramientas, agente, basic_agent_response) ...