Fix

agent.py

@@ -1,474 +1,172 @@
 import os
+import json
 from dotenv import load_dotenv
 
-# Load environment variables
+# ---- Environment & Setup ----
 load_dotenv()
-
-# Set protobuf implementation to avoid C++ extension issues
 os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
 
-# Load keys from environment
 hf_token = os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
-serper_api_key = os.getenv("SERPER_API_KEY")
 
 # ---- Imports ----
 from langgraph.graph import START, StateGraph, MessagesState
 from langgraph.prebuilt import tools_condition, ToolNode
-from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFaceEmbeddings
+from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_community.tools.tavily_search import TavilySearchResults
 from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
-try:
-    from langchain_community.vectorstores import Chroma
-except ImportError:
-    from langchain.vectorstores import Chroma
-from langchain_core.documents import Document
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+from langchain_community.vectorstores import Chroma
+from langchain_core.messages import SystemMessage, HumanMessage
 from langchain_core.tools import tool
-from langchain_core.language_models.base import BaseLanguageModel
-from langchain.tools.retriever import create_retriever_tool
-try:
-    from langchain.embeddings import HuggingFaceEmbeddings as LegacyHFEmbeddings
-except ImportError:
-    LegacyHFEmbeddings = HuggingFaceEmbeddings
-from langchain.schema import Document as LegacyDocument
-import json
-import requests
-from typing import List, Dict, Any
-import re
-import math
-from datetime import datetime
+from langchain.schema import Document
 
-# Custom HuggingFace LLM wrapper with better error handling
-class SimpleHuggingFaceLLM(BaseLanguageModel):
-    def __init__(self, repo_id: str, hf_token: str):
-        super().__init__()
-        self.repo_id = repo_id
-        self.hf_token = hf_token
-        self.api_url = f"https://api-inference.huggingface.co/models/{repo_id}"
-        self.headers = {"Authorization": f"Bearer {hf_token}"}
-        
-        # Test the connection
-        self._test_connection()
-    
-    def _test_connection(self):
-        """Test if the model is accessible"""
-        payload = {
-            "inputs": "Hello",
-            "parameters": {
-                "max_new_tokens": 10,
-                "temperature": 0.1,
-                "return_full_text": False
-            }
-        }
-        
-        try:
-            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=30)
-            if response.status_code != 200:
-                print(f"Model {self.repo_id} test failed with status {response.status_code}: {response.text}")
-                raise Exception(f"Model not accessible: {response.status_code}")
-            print(f"Model {self.repo_id} test successful")
-        except Exception as e:
-            print(f"Model {self.repo_id} connection test failed: {e}")
-            raise e
-    
-    def _generate(self, messages, stop=None, run_manager=None, **kwargs):
-        # Convert messages to a single prompt
-        if isinstance(messages, list):
-            prompt = messages[-1].content if messages else ""
-        else:
-            prompt = str(messages)
-        
-        payload = {
-            "inputs": prompt,
-            "parameters": {
-                "max_new_tokens": 512,
-                "temperature": 0.1,
-                "return_full_text": False,
-                "do_sample": False
-            }
-        }
-        
-        try:
-            response = requests.post(self.api_url, headers=self.headers, json=payload, timeout=60)
-            if response.status_code == 200:
-                result = response.json()
-                if isinstance(result, list) and len(result) > 0:
-                    generated_text = result[0].get('generated_text', '')
-                elif isinstance(result, dict):
-                    generated_text = result.get('generated_text', str(result))
-                else:
-                    generated_text = str(result)
-                
-                from langchain_core.outputs import LLMResult, Generation
-                return LLMResult(generations=[[Generation(text=generated_text)]])
-            else:
-                error_msg = f"API Error {response.status_code}: {response.text[:200]}"
-                print(error_msg)
-                from langchain_core.outputs import LLMResult, Generation
-                return LLMResult(generations=[[Generation(text=f"Error: {error_msg}")]])
-        except Exception as e:
-            error_msg = f"Request failed: {str(e)}"
-            print(error_msg)
-            from langchain_core.outputs import LLMResult, Generation
-            return LLMResult(generations=[[Generation(text=error_msg)]])
-    
-    def invoke(self, input, config=None, **kwargs):
-        if isinstance(input, list):
-            prompt = input[-1].content if input else ""
-        else:
-            prompt = str(input)
-        
-        result = self._generate(prompt)
-        generated_text = result.generations[0][0].text
-        return AIMessage(content=generated_text)
-    
-    @property
-    def _llm_type(self):
-        return "huggingface_custom"
-    
-    def _call(self, prompt: str, stop=None, run_manager=None, **kwargs):
-        """Legacy method for compatibility"""
-        result = self._generate(prompt)
-        return result.generations[0][0].text
-
-# ---- Enhanced Tools ----
+# ---- Tools ----
 
 @tool
-def multiply(a: float, b: float) -> float:
-    """Multiply two numbers"""
+def multiply(a: int, b: int) -> int:
     return a * b
 
 @tool
-def add(a: float, b: float) -> float:
-    """Add two numbers"""
+def add(a: int, b: int) -> int:
     return a + b
 
 @tool
-def subtract(a: float, b: float) -> float:
-    """Subtract two numbers"""
+def subtract(a: int, b: int) -> int:
     return a - b
 
 @tool
-def divide(a: float, b: float) -> float:
-    """Divide two numbers"""
+def divide(a: int, b: int) -> float:
     if b == 0:
         raise ValueError("Cannot divide by zero.")
     return a / b
 
 @tool
 def modulus(a: int, b: int) -> int:
-    """Calculate modulus of two integers"""
     return a % b
 
-@tool
-def power(a: float, b: float) -> float:
-    """Calculate a raised to the power of b"""
-    return a ** b
-
-@tool
-def square_root(a: float) -> float:
-    """Calculate square root of a number"""
-    return math.sqrt(a)
-
-@tool
-def factorial(n: int) -> int:
-    """Calculate factorial of a number"""
-    if n < 0:
-        raise ValueError("Factorial is not defined for negative numbers")
-    if n == 0 or n == 1:
-        return 1
-    result = 1
-    for i in range(2, n + 1):
-        result *= i
-    return result
-
-@tool
-def gcd(a: int, b: int) -> int:
-    """Calculate greatest common divisor"""
-    while b:
-        a, b = b, a % b
-    return a
-
-@tool
-def lcm(a: int, b: int) -> int:
-    """Calculate least common multiple"""
-    return abs(a * b) // gcd(a, b)
-
-@tool
-def percentage(part: float, whole: float) -> float:
-    """Calculate percentage"""
-    return (part / whole) * 100
-
-@tool
-def compound_interest(principal: float, rate: float, time: float, n: int = 1) -> float:
-    """Calculate compound interest"""
-    return principal * (1 + rate/n) ** (n * time)
-
-@tool
-def calculate_average(numbers: str) -> float:
-    """Calculate average of comma-separated numbers"""
-    try:
-        nums = [float(x.strip()) for x in numbers.split(',')]
-        return sum(nums) / len(nums)
-    except:
-        return 0.0
-
 @tool
 def wiki_search(query: str) -> str:
-    """Search Wikipedia for information"""
-    try:
-        search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
-        if not search_docs:
-            return "No Wikipedia results found."
-        
-        formatted = "\n\n---\n\n".join([
-            f'Wikipedia: {doc.metadata.get("title", "Unknown")}\n{doc.page_content[:1500]}'
+    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+    formatted = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
             for doc in search_docs
-        ])
-        return formatted
-    except Exception as e:
-        return f"Wikipedia search error: {str(e)}"
+        ]
+    )
+    return {"wiki_results": formatted}
 
 @tool
 def web_search(query: str) -> str:
-    """Search the web using Tavily"""
-    try:
-        search_docs = TavilySearchResults(max_results=2).invoke(query=query)
-        if not search_docs:
-            return "No web search results found."
-        
-        formatted = "\n\n---\n\n".join([
-            f'Web: {doc.get("title", "Unknown")}\n{doc.get("content", "")[:1500]}'
+    search_docs = TavilySearchResults(max_results=3).invoke(query=query)
+    formatted = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
             for doc in search_docs
-        ])
-        return formatted
-    except Exception as e:
-        return f"Web search error: {str(e)}"
+        ]
+    )
+    return {"web_results": formatted}
 
 @tool
-def simple_calculation(expression: str) -> str:
-    """Safely evaluate simple mathematical expressions"""
-    try:
-        # Remove any non-mathematical characters for safety
-        safe_chars = set('0123456789+-*/.() ')
-        if not all(c in safe_chars for c in expression):
-            return "Invalid characters in expression"
-        
-        # Evaluate the expression
-        result = eval(expression)
-        return str(result)
-    except Exception as e:
-        return f"Calculation error: {str(e)}"
-
-# ---- Embedding & Vector Store Setup with better error handling ----
-def setup_vector_store():
-    try:
-        # Try different embedding models
-        embedding_models = [
-            "sentence-transformers/all-MiniLM-L6-v2",
-            "sentence-transformers/all-mpnet-base-v2"
+def arvix_search(query: str) -> str:
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+    formatted = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+            for doc in search_docs
         ]
-        
-        embeddings = None
-        for model_name in embedding_models:
-            try:
-                embeddings = HuggingFaceEmbeddings(model_name=model_name)
-                print(f"Successfully loaded embeddings: {model_name}")
-                break
-            except Exception as e:
-                print(f"Failed to load embeddings {model_name}: {e}")
-                continue
-        
-        if embeddings is None:
-            print("Could not load any embedding model, skipping vector store setup")
-            return None
-        
-        # Check if metadata.jsonl exists and load it
-        if os.path.exists('metadata.jsonl'):
-            json_QA = []
-            with open('metadata.jsonl', 'r') as jsonl_file:
-                for line in jsonl_file:
-                    if line.strip():
-                        try:
-                            json_QA.append(json.loads(line))
-                        except:
-                            continue
-            
-            if json_QA:
-                documents = []
-                for sample in json_QA:
-                    if sample.get('Question') and sample.get('Final answer'):
-                        doc = Document(
-                            page_content=f"Question: {sample['Question']}\n\nAnswer: {sample['Final answer']}",
-                            metadata={"source": sample.get("task_id", "unknown")}
-                        )
-                        documents.append(doc)
-                
-                if documents:
-                    try:
-                        vector_store = Chroma.from_documents(
-                            documents=documents,
-                            embedding=embeddings,
-                            persist_directory="./chroma_db",
-                            collection_name="my_collection"
-                        )
-                        vector_store.persist()
-                        print(f"Vector store created with {len(documents)} documents")
-                        return vector_store
-                    except Exception as e:
-                        print(f"Error creating vector store with documents: {e}")
-        
-        # Create empty vector store if no data
-        try:
-            vector_store = Chroma(
-                embedding_function=embeddings,
-                persist_directory="./chroma_db",
-                collection_name="my_collection"
-            )
-            print("Empty vector store created")
-            return vector_store
-        except Exception as e:
-            print(f"Error creating empty vector store: {e}")
-            return None
-        
-    except Exception as e:
-        print(f"Vector store setup error: {e}")
-        return None
+    )
+    return {"arvix_results": formatted}
 
-# Try to setup vector store, but don't fail if it doesn't work
-vector_store = setup_vector_store()
+# ---- Embedding & Vector Store ----
 
-@tool
-def similar_question_search(query: str) -> str:
-    """Search for similar questions in the knowledge base"""
-    if not vector_store:
-        return "No similar questions available"
-    
-    try:
-        matched_docs = vector_store.similarity_search(query, k=2)
-        if not matched_docs:
-            return "No similar questions found"
-        
-        formatted = "\n\n".join([
-            f'Similar Q&A:\n{doc.page_content[:800]}'
-            for doc in matched_docs
-        ])
-        return formatted
-    except Exception as e:
-        return f"Similar question search error: {str(e)}"
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
 
-# ---- Enhanced System Prompt ----
-system_prompt = """
-You are an expert assistant that can solve various types of questions using available tools.
+json_QA = []
+with open('metadata.jsonl', 'r') as jsonl_file:
+    for line in jsonl_file:
+        json_QA.append(json.loads(line))
 
-Available tools:
-- Math: add, subtract, multiply, divide, modulus, power, square_root, factorial, gcd, lcm, percentage, compound_interest, calculate_average, simple_calculation
-- Search: wiki_search, web_search, similar_question_search
+documents = [
+    Document(
+        page_content=f"Question : {sample['Question']}\n\nFinal answer : {sample['Final answer']}",
+        metadata={"source": sample["task_id"]}
+    )
+    for sample in json_QA
+]
 
-Instructions:
-1. Read the question carefully
-2. Break down complex problems into steps
-3. Use appropriate tools to gather information or perform calculations
-4. Think step by step and show your reasoning
-5. Provide accurate, concise answers
+vector_store = Chroma.from_documents(
+    documents=documents,
+    embedding=embeddings,
+    persist_directory="./chroma_db",
+    collection_name="my_collection"
+)
+vector_store.persist()
+print("Documents inserted:", vector_store._collection.count())
 
-IMPORTANT: Always end your response with:
-FINAL ANSWER: [your answer here]
+@tool
+def similar_question_search(query: str) -> str:
+    matched_docs = vector_store.similarity_search(query, 3)
+    formatted = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+            for doc in matched_docs
+        ]
+    )
+    return {"similar_questions": formatted}
 
-For the final answer:
-- Numbers: Use plain digits (no commas, units, or symbols unless requested)
-- Text: Use exact names without articles
-- Lists: Comma-separated values
+# ---- System Prompt ----
 
-Think carefully and use tools when needed.
+system_prompt = """
+You are a helpful assistant tasked with answering questions using a set of tools. 
+Now, I will ask you a question. Report your thoughts, and finish your answer with the following template: 
+FINAL ANSWER: [YOUR FINAL ANSWER]. 
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings...
 """
 
 sys_msg = SystemMessage(content=system_prompt)
 
 # ---- Tool List ----
+
 tools = [
-    # Math tools
-    multiply, add, subtract, divide, modulus, power, square_root, 
-    factorial, gcd, lcm, percentage, compound_interest, calculate_average, simple_calculation,
-    # Search tools
-    wiki_search, web_search, similar_question_search
+    multiply, add, subtract, divide, modulus,
+    wiki_search, web_search, arvix_search, similar_question_search
 ]
 
-# ---- Graph Definition with better error handling ----
+# ---- Graph Construction ----
+
 def build_graph(provider: str = "huggingface"):
-    """Build the agent graph with custom HuggingFace integration"""
-    
     if provider == "huggingface":
-        if not hf_token:
-            raise ValueError("HUGGINGFACE_INFERENCE_TOKEN is required but not found in environment variables")
-        
-        # Use custom HuggingFace LLM with better model selection
-        models_to_try = [
-            "microsoft/DialoGPT-medium",
-            "google/flan-t5-base",
-            "facebook/blenderbot-400M-distill",
-            "microsoft/DialoGPT-small"
-        ]
-        
-        llm = None
-        for model_id in models_to_try:
-            try:
-                print(f"Trying to initialize model: {model_id}")
-                llm = SimpleHuggingFaceLLM(repo_id=model_id, hf_token=hf_token)
-                print(f"Successfully initialized model: {model_id}")
-                break
-            except Exception as e:
-                print(f"Failed to initialize {model_id}: {e}")
-                continue
-        
-        if llm is None:
-            raise ValueError("Failed to initialize any HuggingFace model. Please check your HUGGINGFACE_INFERENCE_TOKEN and internet connection.")
+        llm = ChatHuggingFace(
+            llm=HuggingFaceEndpoint(
+                repo_id="mosaicml/mpt-30b",
+                temperature=0,
+                huggingfacehub_api_token=hf_token
+            )
+        )
+    elif provider == "google":
+        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
     else:
-        raise ValueError("Only 'huggingface' provider is supported")
+        raise ValueError("Invalid provider: choose 'huggingface' or 'google'.")
 
-    # Simple tool binding simulation
-    def llm_with_tools(messages):
-        return llm.invoke(messages)
+    llm_with_tools = llm.bind_tools(tools)
 
     def assistant(state: MessagesState):
-        """Assistant node with enhanced error handling"""
-        try:
-            messages = state["messages"]
-            response = llm_with_tools(messages)
-            return {"messages": [response]}
-        except Exception as e:
-            print(f"Assistant error: {e}")
-            fallback_response = AIMessage(content="I encountered an error processing your request. Let me try a simpler approach.")
-            return {"messages": [fallback_response]}
+        return {"messages": [llm_with_tools.invoke(state["messages"])]}
 
     def retriever(state: MessagesState):
-        """Enhanced retriever with context injection"""
-        messages = state["messages"]
-        user_query = messages[-1].content if messages else ""
-        
-        context_messages = [sys_msg]
-        
-        # Add similar question context if available
-        if vector_store:
-            try:
-                similar = vector_store.similarity_search(user_query, k=1)
-                if similar:
-                    context_msg = HumanMessage(
-                        content=f"Here's a similar example:\n{similar[0].page_content[:500]}"
-                    )
-                    context_messages.append(context_msg)
-            except Exception as e:
-                print(f"Retriever error: {e}")
-        
-        return {"messages": context_messages + messages}
+        similar = vector_store.similarity_search(state["messages"][0].content)
+        if similar:
+            example_msg = HumanMessage(content=f"Here is a similar question:\n\n{similar[0].page_content}")
+            return {"messages": [sys_msg] + state["messages"] + [example_msg]}
+        return {"messages": [sys_msg] + state["messages"]}
 
-    # Build simplified graph
     builder = StateGraph(MessagesState)
     builder.add_node("retriever", retriever)
     builder.add_node("assistant", assistant)
-    
-    # Simple linear flow
+    builder.add_node("tools", ToolNode(tools))
     builder.add_edge(START, "retriever")
     builder.add_edge("retriever", "assistant")
+    builder.add_conditional_edges("assistant", tools_condition)
+    builder.add_edge("tools", "assistant")
 
-    return builder.compile()
+    return builder.compile()

app.py

@@ -1,97 +1,31 @@
-
 import os
 import gradio as gr
 import requests
 import inspect
 import pandas as pd
 from agent import build_graph
-from langchain_core.messages import HumanMessage
-import time
 
+# (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Improved Agent Definition ---
+# --- Basic Agent Definition ---
+# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
-        print("Initializing BasicAgent...")
-        try:
-            # Add more verbose logging
-            print("Building graph...")
-            self.graph = build_graph()
-            print("Graph built successfully.")
-        except Exception as e:
-            print(f"Error building graph: {e}")
-            print(f"Error type: {type(e).__name__}")
-            import traceback
-            traceback.print_exc()
-            raise e
+        print("BasicAgent initialized.")
+        self.graph = build_graph()
         
     def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 100 chars): {question[:100]}...")
-        
-        try:
-            # Clean the question
-            question = question.strip()
-            if not question:
-                return "Empty question received"
-            
-            # Wrap the question in a HumanMessage
-            messages = [HumanMessage(content=question)]
-            
-            # Invoke the graph with retry mechanism
-            max_retries = 3
-            for attempt in range(max_retries):
-                try:
-                    print(f"Attempt {attempt + 1} to process question...")
-                    result = self.graph.invoke({"messages": messages})
-                    
-                    if 'messages' in result and result['messages']:
-                        answer = result['messages'][-1].content
-                        
-                        # Clean up the answer
-                        if isinstance(answer, str):
-                            # Remove the "FINAL ANSWER: " prefix if it exists
-                            if "FINAL ANSWER:" in answer:
-                                answer = answer.split("FINAL ANSWER:")[-1].strip()
-                            
-                            # Additional cleanup
-                            answer = answer.replace("Assistant: ", "").strip()
-                            
-                            # Handle empty or error responses
-                            if not answer or "Error:" in answer or "error" in answer.lower():
-                                if attempt < max_retries - 1:
-                                    print(f"Got error response, retrying: {answer[:100]}")
-                                    time.sleep(2)
-                                    continue
-                                else:
-                                    return "Unable to generate answer"
-                            
-                            print(f"Agent answer (first 100 chars): {answer[:100]}...")
-                            return answer
-                        else:
-                            return str(answer)
-                    else:
-                        print("No messages in result")
-                        if attempt < max_retries - 1:
-                            time.sleep(2)
-                            continue
-                        return "No response generated"
-                        
-                except Exception as e:
-                    print(f"Attempt {attempt + 1} failed: {e}")
-                    if attempt == max_retries - 1:
-                        return f"Error processing question: {str(e)}"
-                    time.sleep(2)  # Brief pause before retry
-            
-        except Exception as e:
-            print(f"Error in agent call: {e}")
-            import traceback
-            traceback.print_exc()
-            return f"Agent error: {str(e)}"
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        # Wrap the question in a HumanMessage from langchain_core
+        messages = [HumanMessage(content=question)]
+        messages = self.graph.invoke({"messages": messages})
+        answer = messages['messages'][-1].content
+        return answer[14:]
 
 
-def run_and_submit_all(profile: gr.OAuthProfile | None):
+def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
@@ -100,7 +34,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username = f"{profile.username}"
+        username= f"{profile.username}"
         print(f"User logged in: {username}")
     else:
         print("User not logged in.")
@@ -110,25 +44,20 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Agent (modify this part to create your agent)
+    # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        print("Initializing agent...")
         agent = BasicAgent()
-        print("Agent initialized successfully.")
     except Exception as e:
         print(f"Error instantiating agent: {e}")
-        import traceback
-        traceback.print_exc()
         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
+    # 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(f"Agent code URL: {agent_code}")
+    print(agent_code)
 
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
     try:
-        response = requests.get(questions_url, timeout=30)
+        response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
@@ -146,95 +75,49 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
 
-    # 3. Run your Agent with better error handling
+    # 3. Run your Agent
     results_log = []
     answers_payload = []
     print(f"Running agent on {len(questions_data)} questions...")
-    
-    for i, item in enumerate(questions_data):
+    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"Skipping item with missing task_id or question: {item}")
             continue
-            
-        print(f"Processing question {i+1}/{len(questions_data)}: {task_id}")
-        
         try:
-            # Add timeout and better error handling for individual questions
-            start_time = time.time()
             submitted_answer = agent(question_text)
-            end_time = time.time()
-            
-            print(f"Question {i+1} completed in {end_time - start_time:.2f} seconds")
-            
-            # Validate the answer
-            if not submitted_answer or submitted_answer.strip() == "":
-                submitted_answer = "No answer generated"
-            
-            # Clean up the answer further
-            submitted_answer = str(submitted_answer).strip()
-            if submitted_answer.startswith("Error:") or submitted_answer.startswith("Agent error:"):
-                submitted_answer = "Unable to process question"
-            
-            answers_payload.append({
-                "task_id": task_id, 
-                "submitted_answer": submitted_answer
-            })
-            
-            results_log.append({
-                "Task ID": task_id, 
-                "Question": question_text[:200] + "..." if len(question_text) > 200 else question_text, 
-                "Submitted Answer": submitted_answer
-            })
-            
+            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 running agent on task {task_id}: {e}")
-             error_answer = "Processing error occurred"
-             answers_payload.append({
-                 "task_id": task_id, 
-                 "submitted_answer": error_answer
-             })
-             results_log.append({
-                 "Task ID": task_id, 
-                 "Question": question_text[:200] + "..." if len(question_text) > 200 else question_text, 
-                 "Submitted Answer": error_answer
-             })
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
 
     if not answers_payload:
         print("Agent did not produce any answers to submit.")
         return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
 
     # 4. Prepare Submission 
-    submission_data = {
-        "username": username.strip(), 
-        "agent_code": agent_code, 
-        "answers": answers_payload
-    }
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
-    # 5. Submit with better error handling
+    # 5. Submit
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=120)
+        response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
-        
         final_status = (
             f"Submission Successful!\n"
-            f"User: {result_data.get('username', 'Unknown')}\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("Submission successful.")
-        print(f"Score: {result_data.get('score', 'N/A')}%")
-        
         results_df = pd.DataFrame(results_log)
         return final_status, results_df
-        
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
         try:
@@ -246,19 +129,16 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         print(status_message)
         results_df = pd.DataFrame(results_log)
         return status_message, results_df
-        
     except requests.exceptions.Timeout:
         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"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"An unexpected error occurred during submission: {e}"
         print(status_message)
@@ -268,31 +148,26 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Enhanced Agent Evaluation Runner")
+    gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
         """
         **Instructions:**
-        1. Please clone this space, then modify the code to define your agent's logic, tools, and necessary packages.
-        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.
-        
-        **Improvements in this version:**
-        - Enhanced mathematical tools (factorial, gcd, lcm, compound interest, etc.)
-        - Better search tools with error handling
-        - Improved HuggingFace model integration
-        - Better answer processing and cleanup
-        - Enhanced error handling and retry mechanisms
-        
+        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.
         ---
-        **Note:** The evaluation process may take some time as the agent processes all questions systematically.
+        **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("Run Evaluation & Submit All Answers", variant="primary")
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
 
     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(
@@ -301,12 +176,10 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " Enhanced App Starting " + "-"*30)
-    
-    # Check for environment variables
+    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")
-    hf_token = os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -314,19 +187,15 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup:
+    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("ℹ️  SPACE_ID environment variable not found (running locally?).")
-        
-    if hf_token:
-        print("✅ HUGGINGFACE_INFERENCE_TOKEN found")
-    else:
-        print("⚠️  HUGGINGFACE_INFERENCE_TOKEN not found - this may cause issues")
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
 
-    print("-"*(60 + len(" Enhanced App Starting ")) + "\n")
+    print("-"*(60 + len(" App Starting ")) + "\n")
 
-    print("Launching Enhanced Gradio Interface for Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)
+    

requirements.txt

@@ -3,27 +3,18 @@ requests
 langchain
 langchain-community
 langchain-core
+langchain-google-genai
 langchain-huggingface
-langchain-chroma
+langchain-groq
 langchain-tavily
+langchain-chroma
 langgraph
 sentence-transformers
 huggingface_hub
-transformers
-torch
 supabase
 arxiv
 pymupdf
 wikipedia
 pgvector
 python-dotenv
-protobuf==3.20.3
-chromadb
-tiktoken
-numpy
-pandas
-scipy
-sympy
-python-dateutil
-beautifulsoup4
-lxml
+protobuf==3.20.3