dddd

my_tools.py

@@ -1,4 +1,4 @@
-# alfred_agent.py
+# my_tools.py
 
 import os
 import math
@@ -9,19 +9,17 @@ import pandas as pd
 from io import StringIO
 from duckduckgo_search import DDGS
 import wikipedia
-from llama_index import ServiceContext, LLMPredictor
 from llama_index.core.llms import ChatMessage, LLMMetadata, LLM, CompletionResponse
 from llama_index.core.tools import FunctionTool
 from llama_index.core.agent import ReActAgent
 from llama_index.indices.object_index import ObjectIndex
 from llama_index.indices.vector_store import VectorStoreIndex
-from llama_index.core.callbacks import CallbackManager
 from llama_index.core.callbacks.llama_debug import LlamaDebugHandler
 from pydantic import Field
 import google.generativeai as genai
 
 # -------------------------------------------------------------------
-# 1) GeminiLLM: tu implementación personalizada
+# 1) GeminiLLM personalizado
 # -------------------------------------------------------------------
 class GeminiLLM(LLM):
     model_name: str = Field(default="models/gemini-1.5-flash-latest")
@@ -117,13 +115,11 @@ class GeminiLLM(LLM):
 
 
 # -------------------------------------------------------------------
-# 2) Funciones de herramienta
+# 2) Herramientas
 # -------------------------------------------------------------------
-
 HEADERS = {'User-Agent':'Mozilla/5.0'}
 
 def buscar_web(query: str, max_attempts: int = 2) -> str:
-    """Búsqueda real en DuckDuckGo con reintentos."""
     for i in range(max_attempts):
         try:
             with DDGS(headers=HEADERS, timeout=25) as ddgs:
@@ -135,139 +131,94 @@ def buscar_web(query: str, max_attempts: int = 2) -> str:
             if i < max_attempts-1:
                 time.sleep(5*(i+1))
             else:
-                return f"Error al buscar_web tras {max_attempts} intentos: {e}"
+                return f"Error buscar_web tras {max_attempts} intentos: {e}"
 
 def reverse_text(text: str) -> str:
     return text[::-1]
 
 def analyze_table(table_md: str, question: str) -> str:
-    """
-    Parsea tabla Markdown y responde preguntas sencillas.
-    Ejemplo específico: acciones no conmutativas.
-    """
     try:
-        # Convertir Markdown a CSV-like
         lines = [l.strip() for l in table_md.strip().splitlines() if l.strip()]
-        # Quitar las líneas de separador '---'
         content = [l for l in lines if not set(l) <= set("|- ")]
-        # Extraer filas
         rows = [ [c.strip() for c in r.split("|")[1:-1]] for r in content ]
         df = pd.DataFrame(rows[1:], columns=rows[0])
-        # Si la pregunta menciona 'conmutativa', detectamos contrajemplos
         if "no conmut" in question.lower():
-            S = list(df.columns)
+            S = df.columns.tolist()
             counter = set()
             for x in S:
                 for y in S:
                     a = df.loc[df[rows[0][0]]==x, y].values[0]
                     b = df.loc[df[rows[0][0]]==y, x].values[0]
                     if a != b:
-                        counter.add(x); counter.add(y)
+                        counter.update([x,y])
             return ", ".join(sorted(counter)) or "No hay contraejemplos"
-        # Para otras preguntas, devolvemos la tabla en texto
         return df.to_csv(index=False)
     except Exception as e:
         return f"Error analyze_table: {e}"
 
 def execute_code(code: str) -> str:
-    """Ejecuta código Python en un subproceso seguro."""
     try:
-        # Prevenir imports faltantes
-        result = subprocess.run(["python","-c",code], capture_output=True, text=True, timeout=5)
-        if result.stderr:
-            return f"Error en código: {result.stderr.strip()}"
-        return result.stdout.strip() or "(sin salida)"
+        res = subprocess.run(["python","- << 'EOF'\n" + code + "\nEOF"], shell=True,
+                             capture_output=True, text=True, timeout=5)
+        if res.stderr:
+            return f"Error código: {res.stderr.strip()}"
+        return res.stdout.strip() or "(sin salida)"
     except Exception as e:
-        return f"Error ejecución código: {e}"
+        return f"Error ejecutar código: {e}"
 
 def no_tool_solution(query: str) -> str:
-    return "Procedo a responder con mi conocimiento interno."
+    return "Procedo con conocimiento interno."
 
 # -------------------------------------------------------------------
-# 3) Envolver como FunctionTool
+# 3) FunctionTools
 # -------------------------------------------------------------------
-
-search_tool = FunctionTool.from_defaults(fn=buscar_web, name="web_search",
-    description="Busca información en la web usando DuckDuckGo (3 resultados).")
-reverse_tool = FunctionTool.from_defaults(fn=reverse_text, name="reverse_text",
-    description="Invierte el texto dado. Útil para decodificar cadenas al revés.")
-table_tool = FunctionTool.from_defaults(fn=analyze_table, name="analyze_table",
-    description="Parsea tabla Markdown y responde preguntas sobre conmutatividad u otras sencillas.")
-code_tool = FunctionTool.from_defaults(fn=execute_code, name="execute_code",
-    description="Ejecuta fragmentos de código Python para cálculos o procesamiento.")
-fallback_tool = FunctionTool.from_defaults(fn=no_tool_solution, name="no_tool_solution",
-    description="Fallback: responde usando únicamente conocimiento interno si otras herramientas fallan.")
+search_tool   = FunctionTool.from_defaults(fn=buscar_web, name="web_search", description="Búsqueda DDG (3 resultados).")
+reverse_tool  = FunctionTool.from_defaults(fn=reverse_text, name="reverse_text", description="Invierte texto.")
+table_tool    = FunctionTool.from_defaults(fn=analyze_table, name="analyze_table", description="Parses Markdown tables y responde conmutatividad.")
+code_tool     = FunctionTool.from_defaults(fn=execute_code, name="execute_code", description="Ejecuta Python para cálculos.")
+fallback_tool = FunctionTool.from_defaults(fn=no_tool_solution, name="no_tool_solution", description="Fallback: conocimiento interno.")
 
 # -------------------------------------------------------------------
-# 4) Índice de herramientas + ToolRetriever
+# 4) ObjectIndex + Retriever
 # -------------------------------------------------------------------
-
-all_tools = [search_tool, reverse_tool, table_tool, code_tool, fallback_tool]
-obj_index = ObjectIndex.from_objects(all_tools, index_cls=VectorStoreIndex)
+all_tools      = [search_tool, reverse_tool, table_tool, code_tool, fallback_tool]
+obj_index      = ObjectIndex.from_objects(all_tools, index_cls=VectorStoreIndex)
 tool_retriever = obj_index.as_retriever(similarity_top_k=3)
 
 # -------------------------------------------------------------------
 # 5) Prompt de sistema
 # -------------------------------------------------------------------
-
 system_prompt = (
-    "Eres Alfred, un agente ReAct que usa pasos de pensamiento claros y herramientas especializadas.\n"
-    "Sigue este flujo:\n"
+    "Eres Alfred, un agente ReAct paso a paso.\n"
     "1) Analiza la pregunta.\n"
-    "2) Piensa paso a paso (internamente), luego decide qué acción tomar.\n"
-    "3) Si necesitas datos externos, usa web_search.\n"
-    "4) Si hay texto invertido, usa reverse_text.\n"
-    "5) Si hay tablas Markdown, usa analyze_table.\n"
-    "6) Para cálculos complejos, usa execute_code.\n"
-    "7) Si nada ayuda, llama no_tool_solution y responde con tu conocimiento.\n"
-    "8) Si la pregunta involucra audio, video o imágenes no procesables, informa que no puedes acceder.\n"
-    "9) Proporciona siempre una respuesta final clara al usuario.\n"
-    "\nHerramientas disponibles:\n{tool_descriptions}\n"
-    "No muestres tus pensamientos al usuario; solo la respuesta final."
+    "2) Decide la herramienta adecuada.\n"
+    "3) Usa web_search, reverse_text, analyze_table, execute_code o no_tool_solution.\n"
+    "4) Si no puedes procesar audio/video, indícalo.\n"
+    "5) Responde claramente.\n"
+    "Herramientas: {tool_descriptions}"
 )
 
 # -------------------------------------------------------------------
-# 6) Inicializar Agent con GeminiLLM
+# 6) Inicializar agente
 # -------------------------------------------------------------------
+llm = GeminiLLM(model_name="models/gemini-1.5-flash-latest", temperature=0.0)
 
-# Contexto de LLM
-service_ctx = ServiceContext.from_defaults(
-    llm=GeminiLLM(model_name="models/gemini-1.5-flash-latest", temperature=0.0)
-)
-
-# Crear el agente ReAct
 alfred_agent = ReActAgent.from_tools(
     tool_retriever=tool_retriever,
-    service_context=service_ctx,
+    llm=llm,
     system_prompt=system_prompt,
-    verbose=True,         # mostrar pasos para depuración
-    max_iterations=20     # permitir suficiente iteraciones
+    verbose=True,
+    max_iterations=20
 )
 
 # -------------------------------------------------------------------
-# 7) Función de invocación
+# 7) Función pública
 # -------------------------------------------------------------------
-
 def basic_agent_response(question: str) -> str:
-    print(f"🤖 Alfred recibió: {question}")
     try:
-        resp_obj = alfred_agent.query(question)
-        return resp_obj.response or "No se generó respuesta."
+        resp = alfred_agent.query(question)
+        return resp.response or "No se generó respuesta."
     except Exception as e:
-        return f"Error crítico en el agente: {e}"
+        return f"Error crítico del agente: {e}"
 
-# -------------------------------------------------------------------
-# 8) Prueba rápida (descomentar para test local)
-# -------------------------------------------------------------------
-if __name__ == "__main__":
-    tests = [
-        "¿Cuánto es 37 por 19?",
-        ".tfel",
-        "|*|a|b|\n|---|---|---|\n|a|b|c|\n|b|c|a|\nprovide the subset involved in non-commutative",
-        "I'm making a grocery list para mi mamá..., incluye milk, eggs, bell pepper, zucchini. Solo vegetales."
-    ]
-    for q in tests:
-        print("Q:", q)
-        print("A:", basic_agent_response(q))
-        print("-"*40)