lll

my_tools.py

@@ -1,5 +1,3 @@
-# my_tools.py
-
 import os
 import math
 import time
@@ -7,7 +5,7 @@ import asyncio
 import subprocess
 import requests
 import pandas as pd
-from io import BytesIO
+from io import BytesIO, StringIO
 from bs4 import BeautifulSoup
 from duckduckgo_search import DDGS
 import wikipedia
@@ -40,20 +38,19 @@ class GeminiLLM(LLM):
 
     def __init__(self, **kwargs):
         super().__init__(**kwargs)
-        # Resolver FieldInfo si es necesario
         actual_model_name = self.model_name
         if not isinstance(actual_model_name, str):
-            model_field_definition = self.__fields__.get("model_name")
-            if model_field_definition and hasattr(model_field_definition, 'default'):
-                actual_model_name = model_field_definition.default
+            field_def = self.__fields__.get("model_name")
+            if field_def and hasattr(field_def, 'default'):
+                actual_model_name = field_def.default
             if not isinstance(actual_model_name, str):
                 actual_model_name = "models/gemini-1.5-flash-latest"
 
         actual_temperature = self.temperature
         if not isinstance(actual_temperature, (float, int)):
-            temp_field_definition = self.__fields__.get("temperature")
-            if temp_field_definition and hasattr(temp_field_definition, 'default'):
-                actual_temperature = temp_field_definition.default
+            temp_field_def = self.__fields__.get("temperature")
+            if temp_field_def and hasattr(temp_field_def, 'default'):
+                actual_temperature = temp_field_def.default
             if not isinstance(actual_temperature, (float, int)):
                 actual_temperature = 0.0
 
@@ -78,9 +75,9 @@ class GeminiLLM(LLM):
     def metadata(self):
         actual_model_name_meta = self.model_name
         if not isinstance(actual_model_name_meta, str):
-            model_field_def_meta = self.__fields__.get("model_name")
-            if model_field_def_meta and hasattr(model_field_def_meta, 'default'):
-                actual_model_name_meta = model_field_def_meta.default
+            field_meta = self.__fields__.get("model_name")
+            if field_meta and hasattr(field_meta, 'default'):
+                actual_model_name_meta = field_meta.default
             if not isinstance(actual_model_name_meta, str):
                 actual_model_name_meta = "models/gemini-1.5-flash-latest"
         return LLMMetadata(
@@ -201,7 +198,6 @@ def analyze_table(table_md: str, question: str) -> str:
     verifica la conmutatividad de la matriz; en otro caso, devuelve el CSV equivalente.
     """
     try:
-        # Quitar líneas de separación y vacías
         lines = [l for l in table_md.splitlines() if l.strip() and '---' not in l]
         rows = [[c.strip() for c in l.strip().strip('|').split('|')] for l in lines]
         if len(rows) < 2:
@@ -265,16 +261,26 @@ def classify_botanical(items_list_str: str) -> str:
     """
     Clasifica botánicamente una lista de alimentos (en inglés o español) en Verduras, Frutas u Otros.
     """
-    # Mapeo inglés → español
     mapping = {
         "tomato": "tomate", "pepper": "pimiento", "bell pepper": "pimiento",
-        "cucumber": "pepino", "eggplant": "berenjena", "zucchini": "calabacín",
-        "avocado": "aguacate", "squash": "calabaza", "pea": "guisante", "corn": "maíz",
-        "bean": "judía", "beans": "judía", "green beans": "judía verde", "sweet potato": "batata",
-        "whole bean coffee": "café", "rice": "arroz", "oregano": "orégano"
+        "green beans": "judía verde", "beans": "judía verde",
+        "zucchini": "calabacín", "eggplant": "berenjena", "cucumber": "pepino",
+        "broccoli": "brócoli", "celery": "apio", "lettuce": "lechuga",
+        "corn": "maíz", "peas": "guisante", "pea": "guisante",
+        "spinach": "espinaca", "kale": "col rizada",
+        "sweet potatoes": "batata", "sweet potato": "batata", "potato": "patata",
+        "onion": "cebolla", "garlic": "ajo", "carrot": "zanahoria",
+        "okra": "okra", "cabbage": "col", "cauliflower": "coliflor"
+    }
+    vegetables_es = {
+        "zanahoria","patata","batata","cebolla","ajo","puerro","apio",
+        "lechuga","espinaca","brócoli","calabacín","berenjena","pepino",
+        "judía verde","maíz","okra","col rizada","col","coliflor"
+    }
+    fruits_es = {
+        "tomate","pepino","calabacín","berenjena","pimiento","aguacate",
+        "calabaza","guisante","judía verde","maíz"
     }
-    fruits = {"tomate", "pepino", "calabacín", "berenjena", "pimiento", "aguacate", "calabaza", "guisante", "judía verde", "maíz"}
-    vegetables = {"zanahoria", "patata", "batata", "cebolla", "ajo", "puerro", "apio", "lechuga", "espinaca", "brócoli", "pepino", "pepino"}
 
     items = []
     for raw in items_list_str.split(','):
@@ -282,13 +288,18 @@ def classify_botanical(items_list_str: str) -> str:
         itm_es = mapping.get(itm, itm)
         items.append(itm_es)
 
-    vegs = [i for i in items if i in vegetables]
-    fruits_found = [i for i in items if i in fruits]
-    others = [i for i in items if i not in fruits and i not in vegetables]
+    vegs = [i for i in items if i in vegetables_es and i not in fruits_es]
+    fruits_found = [i for i in items if i in fruits_es]
+    others = [i for i in items if i not in vegetables_es and i not in fruits_es]
+
+    vegs_sorted = sorted(set(vegs))
+    fruits_sorted = sorted(set(fruits_found))
+    others_sorted = sorted(set(others))
+
     return (
-        f"Verduras: {', '.join(sorted(set(vegs)))}\n"
-        f"Frutas: {', '.join(sorted(set(fruits_found)))}\n"
-        f"Otros: {', '.join(sorted(set(others)))}"
+        f"Verduras: {', '.join(vegs_sorted)}\n"
+        f"Frutas: {', '.join(fruits_sorted)}\n"
+        f"Otros: {', '.join(others_sorted)}"
     )
 
 def scrape_wikipedia_table(page_title: str, section: str, table_index: int = 0) -> str:
@@ -380,11 +391,11 @@ all_tools = [
 tool_descriptions = "\n".join([
     f"{t.metadata.name}: {t.metadata.description} "
     + {
-        "classify_botanical_foods": "(Ej: classify_botanical_foods('zanahoria, pepino, tomate'))",
+        "classify_botanical_foods": "(Ej: classify_botanical_foods('milk, eggs, broccoli, celery, lettuce'))",
         "read_excel_data": "(Ej: read_excel_data('ventas.xlsx', sheet_name=0))",
         "analyze_markdown_table": "(Ej: analyze_markdown_table('| A | B |\\n|---|---|\\n|1|2|', '¿Es conmut?'))",
-        "web_search": "(Ej: web_search('¿Quién ganó la Champions 2025?'))",
-        "scrape_wiki_table": "(Ej: scrape_wiki_table('Lionel Messi', 'Carrera', 0))",
+        "web_search": "(Ej: web_search('Hokkaido Nippon-Ham Fighters roster'))",
+        "scrape_wiki_table": "(Ej: scrape_wiki_table('Malko Competition', 'Winners', 0))",
         "reverse_text": "(Ej: reverse_text('Hola'))",
         "execute_code": "(Ej: execute_code('5*7'))",
     }.get(t.metadata.name, "")
@@ -392,30 +403,50 @@ tool_descriptions = "\n".join([
 ])
 
 # -------------------------------------------------------------------
-# 6) PROMPT DE SISTEMA MEJORADO
+# 6) PROMPT DE SISTEMA MEJORADO with few-shot examples
 # -------------------------------------------------------------------
 system_prompt = f"""
 Eres Alfred, un agente ReAct eficiente y preciso. Tu objetivo es responder correctamente usando las herramientas disponibles.
-Sigue este flujo en cada pregunta:
-1. LEE la pregunta y analiza palabras clave:
-   - Si menciona “lista” de “alimentos” o “categorizar” botánicamente, llama:
-        classify_botanical_foods(<lista_coma_sep>).
-   - Si menciona “archivo Excel” o “Excel adjunto”, llama:
-        read_excel_data(<ruta_o_URL>).
-   - Si ves una “tabla Markdown”, llama:
-        analyze_markdown_table(<tabla_md>, <pregunta>).
-   - Si necesitas información general de la web, llama:
-        web_search(<consulta>).
-   - Si necesitas raspar tablas de Wikipedia, llama:
-        scrape_wiki_table(<título>, <sección>, <índice_tabla>).
-   - Si hay que invertir texto, llama:
-        reverse_text(<texto>).
-   - Si hay que ejecutar código Python, llama:
-        execute_code(<código>).
-2. GENERA el “TOOL CALL” con la entrada correcta.
-3. EJECUTA la herramienta y observa el resultado.
-4. VERIFICA que el resultado responda bien la pregunta. Si no, intenta otro paso.
-5. RESPONDE de forma clara y concisa usando la salida obtenida.
+A continuación tienes ejemplos de cómo usar cada herramienta:
+
+### EJEMPLO 1: Clasificación botánica
+Usuario: "I have a grocery list: milk, eggs, broccoli, celery, lettuce. Please give me only the vegetables, alphabetized, comma-separated."
+Agente (pensando): "La pregunta menciona 'grocery list' y 'vegetables' -> usar classify_botanical_foods"
+Agente (acción):
+    {{"tool": "classify_botanical_foods", "input": "milk, eggs, broccoli, celery, lettuce"}}
+Observación: "Verduras: broccoli, celery, lettuce\nFrutas: \nOtros: eggs, milk"
+Agente (respuesta final): "Verduras: broccoli, celery, lettuce"
+
+### EJEMPLO 2: Excel ventas de comida
+Usuario: "Attached is an Excel file with sales data. What were the total sales from food only?"
+Agente (pensando): "Menciona 'Excel' y 'food' -> usar read_excel_data"
+Agente (acción):
+    {{"tool": "read_excel_data", "input": "data/attached.xlsx"}}
+Observación (CSV): "item,type,sales\nBurger,food,1000\nSoda,drink,200\nPizza,food,1500"
+Agente (respuesta final): "Total food sales: $2500.00"
+
+### EJEMPLO 3: Roster de jugadores
+Usuario: "Who are the pitchers with the numbers before and after Taishō Tamai as of July 2023? Use last names only, Roman characters."
+Agente (pensando): "La pregunta menciona 'Taishō Tamai' y 'pitchers' -> usar scrape_wiki_table o web_search"
+Agente (acción):
+    {{"tool": "scrape_wiki_table", "input": ["Hokkaido Nippon-Ham Fighters roster", "Players", 0]}}
+Observación (CSV): "Number,Name,Position\n... ,Tamai Taishō,Pitcher\n45,Uehara,Pitcher\n47,Kakui,Pitcher, ..."
+Agente (procesar): "Tamai tiene número 46. El pitcher 45 es Uehara, el 47 es Kakui."
+Agente (respuesta final): "Uehara, Kakui"
+
+### FLUJO GENERAL:
+1. LEE la pregunta y detecta palabras clave:
+   - "grocery list", "vegetables" -> classify_botanical_foods
+   - "attached Excel", "sales" -> read_excel_data
+   - "roster", "pitchers", "number" -> scrape_wiki_table o web_search
+   - "Malko Competition" -> scrape_wiki_table
+   - "tabla Markdown" -> analyze_markdown_table
+   - "invertir texto" -> reverse_text
+   - "ejecutar código" -> execute_code
+2. PRODUCE el "TOOL CALL" en formato JSON con el nombre exacto de la herramienta.
+3. EJECUTA la herramienta y recibe la salida.
+4. PROCESA la salida (filter, sumar, ordenar) en Python si es necesario.
+5. RESPONDE con el formato exacto que SAIA espera (solo la parte solicitada, sin texto extra).
 
 Herramientas disponibles (USAR EXÁCTAMENTE estos nombres):
 {tool_descriptions}
@@ -430,31 +461,23 @@ alfred_agent = ReActAgent.from_tools(
     llm=llm,
     system_prompt=system_prompt,
     verbose=True,
-    max_iterations=25,            # Más iteraciones para razonamiento multi-paso
+    max_iterations=25,
     callback_manager=llm.callback_manager,
-    handle_parsing_errors=True     # Para que reintente si la llamada a herramienta sale malformada
+    handle_parsing_errors=True
 )
 
 def basic_agent_response(question: str) -> str:
     """
-    Si detecta “Excel adjunto”, asume que SAIA inyecta el path y fuerza read_excel_data.
-    De lo contrario, usa ReActAgent.query().
+    Detecta "Excel adjunto" o usa ReActAgent.query para el resto.
     """
     try:
-        # Forzar uso de read_excel_data si aparece Excel en la pregunta
         if "attached excel" in question.lower() or "archivo excel" in question.lower():
-            # En el entorno SAIA normalmente inyectan la ruta real; aquí usamos un placeholder.
             return read_excel_data("data/attached.xlsx")
         resp = alfred_agent.query(question)
         if hasattr(resp, 'response') and resp.response is not None:
             return str(resp.response)
         elif resp is not None:
             return str(resp)
-        else:
-            return "No se generó una respuesta válida."
+        return "No se generó una respuesta válida."
     except Exception as e:
         return f"Error crítico del agente: {e}"
-
-# --- FIN DE my_tools.py ---
-
-