Update app.py

app.py

@@ -3,440 +3,166 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-import google.generativeai as genai
-from langchain_core.prompts import ChatPromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.messages import HumanMessage, SystemMessage
-from typing import Dict, List, Any, Tuple, Optional
-import json
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langgraph.graph import END, StateGraph
-from langgraph.prebuilt import ToolExecutor, ToolInvocation
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")  # Asegúrate de configurar esta variable de entorno
 
-# Configuración de Gemini
-if GEMINI_API_KEY:
-    genai.configure(api_key=GEMINI_API_KEY)
-else:
-    print("WARNING: GEMINI_API_KEY not set. The agent will not function properly.")
-
-# --- Definición de herramientas ---
-def search_web(query: str) -> str:
-    """Simula una búsqueda web para obtener información relevante."""
-    # En un entorno real, aquí se conectaría a un servicio de búsqueda
-    return f"Resultados simulados de búsqueda para: {query}"
-
-def calculate(expression: str) -> str:
-    """Realiza cálculos matemáticos básicos."""
-    try:
-        result = eval(expression)
-        return f"El resultado de {expression} es {result}"
-    except Exception as e:
-        return f"Error al calcular: {str(e)}"
-
-# Definición de herramientas disponibles
-tools = [
-    {
-        "name": "search_web",
-        "description": "Busca información en la web sobre un tema específico",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "query": {
-                    "type": "string",
-                    "description": "La consulta de búsqueda"
-                }
-            },
-            "required": ["query"]
-        },
-        "function": search_web
-    },
-    {
-        "name": "calculate",
-        "description": "Realiza cálculos matemáticos",
-        "parameters": {
-            "type": "object",
-            "properties": {
-                "expression": {
-                    "type": "string",
-                    "description": "La expresión matemática a calcular"
-                }
-            },
-            "required": ["expression"]
-        },
-        "function": calculate
-    }
-]
-
-# Crear el ejecutor de herramientas
-tool_executor = ToolExecutor(tools)
-
-# --- Componentes del Sistema Multiagente ---
-class AgentState(Dict):
-    """Estado del agente que se pasa entre nodos del grafo."""
-    question: str
-    thoughts: List[str]
-    tool_calls: List[Dict]
-    tool_results: List[Dict]
-    answer: Optional[str] = None
-
-# Componente para analizar la pregunta
-def analyze_question(state: AgentState) -> AgentState:
-    """Analiza la pregunta para determinar cómo abordarla."""
-    llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0)
-    
-    prompt = ChatPromptTemplate.from_messages([
-        SystemMessage(content="""Eres un agente analítico que examina preguntas para determinar su naturaleza y cómo abordarlas. 
-        Analiza la pregunta proporcionada y describe brevemente:
-        1. Tipo de pregunta (factual, opinión, cálculo, etc.)
-        2. Conocimiento necesario para responder
-        3. Si se necesita alguna herramienta específica
-        Proporciona tu análisis en formato conciso."""),
-        HumanMessage(content=f"Analiza esta pregunta: {state['question']}")
-    ])
-    
-    chain = prompt | llm | StrOutputParser()
-    analysis = chain.invoke({})
-    
-    state["thoughts"] = state.get("thoughts", []) + [f"Análisis: {analysis}"]
-    return state
-
-# Componente para decidir si usar herramientas
-def decide_tool_use(state: AgentState) -> str:
-    """Decide si usar herramientas o responder directamente."""
-    llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0)
-    
-    tools_descriptions = "\n".join([f"- {tool['name']}: {tool['description']}" for tool in tools])
-    
-    prompt = ChatPromptTemplate.from_messages([
-        SystemMessage(content=f"""Eres un agente que decide si necesita usar herramientas para responder preguntas.
-        Las herramientas disponibles son:
-        {tools_descriptions}
-        
-        Si la pregunta requiere usar una herramienta, responde con "use_tool" e indica qué herramienta usar.
-        Si puedes responder directamente sin herramientas, responde con "direct_answer"."""),
-        HumanMessage(content=f"""
-        Pregunta: {state['question']}
-        Pensamientos previos: {state['thoughts']}
-        
-        ¿Debo usar una herramienta o responder directamente?""")
-    ])
-    
-    chain = prompt | llm | StrOutputParser()
-    decision = chain.invoke({})
-    
-    state["thoughts"] = state.get("thoughts", []) + [f"Decisión: {decision}"]
-    
-    if "use_tool" in decision.lower():
-        return "use_tool"
-    else:
-        return "direct_answer"
-
-# Componente para seleccionar y usar herramientas
-def select_and_use_tool(state: AgentState) -> AgentState:
-    """Selecciona una herramienta apropiada y la utiliza."""
-    llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0)
-    
-    tools_descriptions = json.dumps(tools, indent=2)
-    
-    prompt = ChatPromptTemplate.from_messages([
-        SystemMessage(content=f"""Eres un agente que selecciona y usa herramientas.
-        Las herramientas disponibles son:
-        {tools_descriptions}
-        
-        Selecciona la herramienta más apropiada para la pregunta y proporciona los parámetros necesarios.
-        Responde con un JSON exactamente en este formato:
-        {{
-            "tool_name": "nombre_de_la_herramienta",
-            "parameters": {{
-                "param1": "valor1",
-                ...
-            }}
-        }}"""),
-        HumanMessage(content=f"""
-        Pregunta: {state['question']}
-        Pensamientos previos: {state['thoughts']}
-        
-        ¿Qué herramienta debo usar y con qué parámetros?""")
-    ])
-    
-    chain = prompt | llm | StrOutputParser()
-    tool_selection = chain.invoke({})
-    
-    # Procesar la selección de herramienta
-    try:
-        tool_data = json.loads(tool_selection)
-        tool_name = tool_data.get("tool_name")
-        parameters = tool_data.get("parameters", {})
-        
-        # Verificar que la herramienta existe
-        tool_exists = any(tool["name"] == tool_name for tool in tools)
-        if not tool_exists:
-            state["thoughts"] = state.get("thoughts", []) + [f"Error: La herramienta '{tool_name}' no existe."]
-            return state
-        
-        # Preparar la invocación de la herramienta
-        tool_invocation = ToolInvocation(
-            name=tool_name,
-            parameters=parameters
-        )
-        
-        # Ejecutar la herramienta
-        result = tool_executor.invoke(tool_invocation)
-        
-        # Almacenar el resultado
-        state["tool_calls"] = state.get("tool_calls", []) + [{"tool": tool_name, "parameters": parameters}]
-        state["tool_results"] = state.get("tool_results", []) + [{"tool": tool_name, "result": result}]
-        state["thoughts"] = state.get("thoughts", []) + [f"Resultado de {tool_name}: {result}"]
-        
-    except Exception as e:
-        state["thoughts"] = state.get("thoughts", []) + [f"Error al usar herramienta: {str(e)}"]
-    
-    return state
-
-# Componente para formular la respuesta final
-def formulate_answer(state: AgentState) -> AgentState:
-    """Formula la respuesta final basada en toda la información recopilada."""
-    llm = ChatGoogleGenerativeAI(model="gemini-1.5-flash", temperature=0)
-    
-    # Preparar el contexto para la respuesta
-    tool_results = "\n".join([
-        f"- {result['tool']}: {result['result']}" 
-        for result in state.get("tool_results", [])
-    ])
-    
-    prompt = ChatPromptTemplate.from_messages([
-        SystemMessage(content="""Eres un agente experto que formula respuestas precisas y útiles.
-        Usa toda la información disponible para proporcionar la mejor respuesta posible.
-        Sé conciso pero completo. No menciones tu proceso de pensamiento en la respuesta final."""),
-        HumanMessage(content=f"""
-        Pregunta original: {state['question']}
-        
-        Pensamientos previos: {state['thoughts']}
-        
-        Resultados de herramientas:
-        {tool_results if tool_results else "No se usaron herramientas"}
-        
-        Por favor, formula una respuesta final a la pregunta original.""")
-    ])
-    
-    chain = prompt | llm | StrOutputParser()
-    final_answer = chain.invoke({})
-    
-    state["answer"] = final_answer
-    return state
-
-# --- Definición del Grafo del Sistema Multiagente ---
-def build_agent_graph():
-    """Construye el grafo de flujo del sistema multiagente."""
-    # Crear el grafo
-    graph = StateGraph(AgentState)
-    
-    # Añadir nodos
-    graph.add_node("analyze_question", analyze_question)
-    graph.add_node("decide_tool_use", decide_tool_use)
-    graph.add_node("select_and_use_tool", select_and_use_tool)
-    graph.add_node("formulate_answer", formulate_answer)
-    
-    # Definir el flujo
-    graph.add_edge("analyze_question", "decide_tool_use")
-    graph.add_conditional_edges(
-        "decide_tool_use",
-        {
-            "use_tool": "select_and_use_tool",
-            "direct_answer": "formulate_answer"
-        }
-    )
-    graph.add_edge("select_and_use_tool", "formulate_answer")
-    graph.add_edge("formulate_answer", END)
-    
-    # Compilar el grafo
-    return graph.compile()
-
-# --- Implementación del Agente Principal ---
-class MultiAgentSystem:
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+class BasicAgent:
     def __init__(self):
-        print("Inicializando Sistema Multiagente con LangGraph y Gemini 2.5 Flash...")
-        if not GEMINI_API_KEY:
-            print("ADVERTENCIA: GEMINI_API_KEY no está configurado. El sistema no funcionará correctamente.")
-        self.agent_graph = build_agent_graph()
-    
+        print("BasicAgent initialized.")
     def __call__(self, question: str) -> str:
-        print(f"Recibiendo pregunta: {question[:50]}...")
-        
-        if not GEMINI_API_KEY:
-            return "Error: GEMINI_API_KEY no está configurado. No se puede procesar la pregunta."
-        
-        try:
-            # Inicializar el estado
-            initial_state = AgentState(
-                question=question,
-                thoughts=[],
-                tool_calls=[],
-                tool_results=[]
-            )
-            
-            # Ejecutar el grafo de agentes
-            print("Procesando con el sistema multiagente...")
-            final_state = self.agent_graph.invoke(initial_state)
-            
-            # Obtener y devolver la respuesta
-            answer = final_state.get("answer", "No se pudo generar una respuesta.")
-            print(f"Respuesta generada: {answer[:50]}...")
-            return answer
-            
-        except Exception as e:
-            error_msg = f"Error al procesar la pregunta: {str(e)}"
-            print(error_msg)
-            return error_msg
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        fixed_answer = "This is a default answer."
+        print(f"Agent returning fixed answer: {fixed_answer}")
+        return fixed_answer
 
-# --- Función para ejecutar la evaluación y enviar respuestas ---
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
-    Obtiene todas las preguntas, ejecuta el Sistema Multiagente en ellas, envía todas las respuestas,
-    y muestra los resultados.
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
     """
-    # --- Determinar URL de ejecución de HF Space y URL del repositorio ---
-    space_id = os.getenv("SPACE_ID")  # Obtener SPACE_ID para enviar enlace al código
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username = f"{profile.username}"
-        print(f"Usuario conectado: {username}")
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
     else:
-        print("Usuario no conectado.")
-        return "Por favor, inicia sesión en Hugging Face con el botón.", None
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instanciar el Sistema Multiagente
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = MultiAgentSystem()
+        agent = BasicAgent()
     except Exception as e:
-        print(f"Error al instanciar el sistema multiagente: {e}")
-        return f"Error al inicializar el sistema multiagente: {e}", None
-    
-    # En caso de una aplicación ejecutándose como espacio de Hugging Face, este enlace apunta a tu código base
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
     print(agent_code)
 
-    # 2. Obtener preguntas
-    print(f"Obteniendo preguntas de: {questions_url}")
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-            print("La lista de preguntas obtenida está vacía.")
-            return "La lista de preguntas obtenida está vacía o tiene un formato no válido.", None
-        print(f"Obtenidas {len(questions_data)} preguntas.")
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
     except requests.exceptions.RequestException as e:
-        print(f"Error al obtener preguntas: {e}")
-        return f"Error al obtener preguntas: {e}", None
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
     except requests.exceptions.JSONDecodeError as e:
-        print(f"Error al decodificar la respuesta JSON del endpoint de preguntas: {e}")
-        print(f"Texto de respuesta: {response.text[:500]}")
-        return f"Error al decodificar la respuesta del servidor para preguntas: {e}", None
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
     except Exception as e:
-        print(f"Ocurrió un error inesperado al obtener preguntas: {e}")
-        return f"Ocurrió un error inesperado al obtener preguntas: {e}", None
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
 
-    # 3. Ejecutar el Sistema Multiagente
+    # 3. Run your Agent
     results_log = []
     answers_payload = []
-    print(f"Ejecutando el sistema multiagente en {len(questions_data)} preguntas...")
+    print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
-            print(f"Omitiendo elemento con task_id o pregunta faltante: {item}")
+            print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
             submitted_answer = agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
         except Exception as e:
-            print(f"Error al ejecutar el sistema multiagente en la tarea {task_id}: {e}")
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"ERROR DE AGENTE: {e}"})
+             print(f"Error running agent on task {task_id}: {e}")
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
-        print("El sistema multiagente no produjo ninguna respuesta para enviar.")
-        return "El sistema multiagente no produjo ninguna respuesta para enviar.", pd.DataFrame(results_log)
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
-    # 4. Preparar envío
+    # 4. Prepare Submission 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Sistema multiagente finalizado. Enviando {len(answers_payload)} respuestas para el usuario '{username}'..."
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
-    # 5. Enviar
-    print(f"Enviando {len(answers_payload)} respuestas a: {submit_url}")
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
         final_status = (
-            f"¡Envío exitoso!\n"
-            f"Usuario: {result_data.get('username')}\n"
-            f"Puntuación general: {result_data.get('score', 'N/A')}% "
-            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correctas)\n"
-            f"Mensaje: {result_data.get('message', 'No se recibió mensaje.')}"
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
         )
-        print("Envío exitoso.")
+        print("Submission successful.")
         results_df = pd.DataFrame(results_log)
         return final_status, results_df
     except requests.exceptions.HTTPError as e:
-        error_detail = f"El servidor respondió con estado {e.response.status_code}."
+        error_detail = f"Server responded with status {e.response.status_code}."
         try:
             error_json = e.response.json()
-            error_detail += f" Detalle: {error_json.get('detail', e.response.text)}"
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
         except requests.exceptions.JSONDecodeError:
-            error_detail += f" Respuesta: {e.response.text[:500]}"
-        status_message = f"Envío fallido: {error_detail}"
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
     except requests.exceptions.Timeout:
-        status_message = "Envío fallido: La solicitud se agotó."
+        status_message = "Submission Failed: The request timed out."
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
     except requests.exceptions.RequestException as e:
-        status_message = f"Envío fallido: Error de red - {e}"
+        status_message = f"Submission Failed: Network error - {e}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
     except Exception as e:
-        status_message = f"Ocurrió un error inesperado durante el envío: {e}"
+        status_message = f"An unexpected error occurred during submission: {e}"
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
 
-# --- Construir interfaz Gradio usando Blocks ---
+
+# --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Sistema Multiagente para GAIA Level 1")
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
         """
-        **Instrucciones:**
-        1. Asegúrate de configurar la variable de entorno GEMINI_API_KEY con tu clave de API de Google AI.
-        2. Inicia sesión en tu cuenta de Hugging Face utilizando el botón de abajo.
-        3. Haz clic en 'Ejecutar evaluación y enviar todas las respuestas' para obtener preguntas, ejecutar el sistema multiagente y ver los resultados.
+        **Instructions:**
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
         ---
-        **Notas:**
-        - Este sistema utiliza LangGraph como framework de agentes y Gemini 2.5 Flash como LLM.
-        - El proceso puede tardar varios minutos dependiendo de la complejidad de las preguntas.
+        **Disclaimers:**
+        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
         """
     )
 
     gr.LoginButton()
 
-    run_button = gr.Button("Ejecutar evaluación y enviar todas las respuestas")
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
 
-    status_output = gr.Textbox(label="Estado de ejecución / Resultado del envío", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Preguntas y respuestas del agente", wrap=True)
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    # Removed max_rows=10 from DataFrame constructor
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
     run_button.click(
         fn=run_and_submit_all,
@@ -444,25 +170,25 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " Iniciando aplicación " + "-"*30)
-    # Comprobar SPACE_HOST y SPACE_ID al inicio para información
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID")  # Obtener SPACE_ID al inicio
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
 
     if space_host_startup:
-        print(f"✅ SPACE_HOST encontrado: {space_host_startup}")
-        print(f"   La URL de ejecución debería ser: https://{space_host_startup}.hf.space")
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
     else:
-        print("ℹ️  Variable de entorno SPACE_HOST no encontrada (¿ejecutando localmente?).")
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup:  # Imprimir URLs del repositorio si se encuentra SPACE_ID
-        print(f"✅ SPACE_ID encontrado: {space_id_startup}")
-        print(f"   URL del repositorio: https://huggingface.co/spaces/{space_id_startup}")
-        print(f"   URL del árbol del repositorio: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
     else:
-        print("ℹ️  Variable de entorno SPACE_ID no encontrada (¿ejecutando localmente?). No se puede determinar la URL del repositorio.")
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
 
-    print("-"*(60 + len(" Iniciando aplicación ")) + "\n")
+    print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Lanzando interfaz Gradio para el Sistema Multiagente...")
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
     demo.launch(debug=True, share=False)