Fix

agent.py

@@ -8,15 +8,12 @@ load_dotenv()
 os.environ["PROTOCOL_BUFFERS_PYTHON_IMPLEMENTATION"] = "python"
 
 # Load keys from environment
-groq_api_key = os.getenv("GROQ_API_KEY")
-serper_api_key = os.getenv("SERPER_API_KEY")
 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_google_genai import ChatGoogleGenerativeAI
-from langchain_groq import ChatGroq
 from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint, HuggingFaceEmbeddings
 from langchain_community.tools.tavily_search import TavilySearchResults
 from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
@@ -29,152 +26,334 @@ from langchain.vectorstores import Chroma
 from langchain.embeddings import HuggingFaceEmbeddings
 from langchain.schema import Document
 import json
+import requests
+from typing import List, Dict, Any
+import re
+import math
+from datetime import datetime
 
-# ---- Tools ----
+# ---- Enhanced Tools ----
 
 @tool
-def multiply(a: int, b: int) -> int:
+def multiply(a: float, b: float) -> float:
+    """Multiply two numbers"""
     return a * b
 
 @tool
-def add(a: int, b: int) -> int:
+def add(a: float, b: float) -> float:
+    """Add two numbers"""
     return a + b
 
 @tool
-def subtract(a: int, b: int) -> int:
+def subtract(a: float, b: float) -> float:
+    """Subtract two numbers"""
     return a - b
 
 @tool
-def divide(a: int, b: int) -> float:
+def divide(a: float, b: float) -> float:
+    """Divide two numbers"""
     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 wiki_search(query: str) -> str:
-    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>'
+    """Search Wikipedia for information"""
+    try:
+        search_docs = WikipediaLoader(query=query, load_max_docs=3).load()
+        if not search_docs:
+            return "No Wikipedia results found."
+        
+        formatted = "\n\n---\n\n".join([
+            f'<Document source="{doc.metadata.get("source", "Wikipedia")}" title="{doc.metadata.get("title", "Unknown")}"/>\n{doc.page_content[:2000]}\n</Document>'
             for doc in search_docs
-        ]
-    )
-    return {"wiki_results": formatted}
+        ])
+        return formatted
+    except Exception as e:
+        return f"Wikipedia search error: {str(e)}"
 
 @tool
 def web_search(query: str) -> str:
-    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>'
+    """Search the web using Tavily"""
+    try:
+        search_docs = TavilySearchResults(max_results=3).invoke(query=query)
+        if not search_docs:
+            return "No web search results found."
+        
+        formatted = "\n\n---\n\n".join([
+            f'<Document source="{doc.get("url", "Unknown")}" title="{doc.get("title", "Unknown")}"/>\n{doc.get("content", "")[:2000]}\n</Document>'
             for doc in search_docs
-        ]
-    )
-    return {"web_results": formatted}
+        ])
+        return formatted
+    except Exception as e:
+        return f"Web search error: {str(e)}"
 
 @tool
-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>'
+def arxiv_search(query: str) -> str:
+    """Search ArXiv for academic papers"""
+    try:
+        search_docs = ArxivLoader(query=query, load_max_docs=2).load()
+        if not search_docs:
+            return "No ArXiv results found."
+        
+        formatted = "\n\n---\n\n".join([
+            f'<Document source="{doc.metadata.get("source", "ArXiv")}" title="{doc.metadata.get("Title", "Unknown")}"/>\n{doc.page_content[:1500]}\n</Document>'
             for doc in search_docs
-        ]
-    )
-    return {"arvix_results": formatted}
+        ])
+        return formatted
+    except Exception as e:
+        return f"ArXiv search error: {str(e)}"
 
-# ---- Embedding & Vector Store Setup ----
-
-embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
-
-json_QA = []
-with open('metadata.jsonl', 'r') as jsonl_file:
-    for line in jsonl_file:
-        json_QA.append(json.loads(line))
+@tool
+def serper_search(query: str) -> str:
+    """Enhanced web search using Serper API"""
+    if not serper_api_key:
+        return "Serper API key not available"
+    
+    try:
+        url = "https://google.serper.dev/search"
+        payload = json.dumps({
+            "q": query,
+            "num": 5
+        })
+        headers = {
+            'X-API-KEY': serper_api_key,
+            'Content-Type': 'application/json'
+        }
+        
+        response = requests.request("POST", url, headers=headers, data=payload)
+        results = response.json()
+        
+        if 'organic' not in results:
+            return "No search results found"
+        
+        formatted = "\n\n---\n\n".join([
+            f'<Document source="{result.get("link", "Unknown")}" title="{result.get("title", "Unknown")}"/>\n{result.get("snippet", "")}\n</Document>'
+            for result in results['organic'][:3]
+        ])
+        return formatted
+    except Exception as e:
+        return f"Serper search error: {str(e)}"
 
-documents = [
-    Document(
-        page_content=f"Question : {sample['Question']}\n\nFinal answer : {sample['Final answer']}",
-        metadata={"source": sample["task_id"]}
-    )
-    for sample in json_QA
-]
+# ---- Embedding & Vector Store Setup ----
+def setup_vector_store():
+    try:
+        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
+        
+        # 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():  # Skip empty lines
+                        json_QA.append(json.loads(line))
+            
+            if json_QA:
+                documents = [
+                    Document(
+                        page_content=f"Question: {sample.get('Question', '')}\n\nFinal answer: {sample.get('Final answer', '')}",
+                        metadata={"source": sample.get("task_id", "unknown")}
+                    )
+                    for sample in json_QA if sample.get('Question') and sample.get('Final answer')
+                ]
+                
+                if documents:
+                    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
+        
+        # Create empty vector store if no data
+        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"Vector store setup error: {e}")
+        # Return a dummy vector store function
+        return None
 
-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())
+vector_store = setup_vector_store()
 
 @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>'
+    """Search for similar questions in the knowledge base"""
+    if not vector_store:
+        return "Vector store not available"
+    
+    try:
+        matched_docs = vector_store.similarity_search(query, 3)
+        if not matched_docs:
+            return "No similar questions found"
+        
+        formatted = "\n\n---\n\n".join([
+            f'<Document source="{doc.metadata.get("source", "Unknown")}" />\n{doc.page_content[:1000]}\n</Document>'
             for doc in matched_docs
-        ]
-    )
-    return {"similar_questions": formatted}
-
-# ---- System Prompt ----
+        ])
+        return formatted
+    except Exception as e:
+        return f"Similar question search error: {str(e)}"
 
+# ---- Enhanced System Prompt ----
 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...
+You are an expert assistant capable of solving complex questions using available tools. You have access to:
+
+1. Mathematical tools: add, subtract, multiply, divide, modulus, power, square_root, factorial, gcd, lcm, percentage, compound_interest
+2. Search tools: wiki_search, web_search, arxiv_search, serper_search, similar_question_search
+
+IMPORTANT INSTRUCTIONS:
+1. Break down complex questions into smaller steps
+2. Use tools systematically to gather information and perform calculations
+3. For mathematical problems, show your work step by step
+4. For factual questions, search for current and accurate information
+5. Cross-reference information from multiple sources when possible
+6. Be precise with numbers - avoid rounding unless necessary
+
+When providing your final answer, use this exact format:
+FINAL ANSWER: [YOUR ANSWER]
+
+Rules for the final answer:
+- Numbers: Use plain digits without commas, units, or symbols (unless specifically requested)
+- Strings: Use exact names without articles or abbreviations
+- Lists: Comma-separated values following the above rules
+- Be concise and accurate
+
+Think step by step and use the available tools to ensure accuracy.
 """
 
 sys_msg = SystemMessage(content=system_prompt)
 
-# ---- Tool List ----
-
+# ---- Enhanced Tool List ----
 tools = [
-    multiply, add, subtract, divide, modulus,
-    wiki_search, web_search, arvix_search, similar_question_search
+    # Math tools
+    multiply, add, subtract, divide, modulus, power, square_root, 
+    factorial, gcd, lcm, percentage, compound_interest,
+    # Search tools
+    wiki_search, web_search, arxiv_search, serper_search, similar_question_search
 ]
 
 # ---- Graph Definition ----
-
-def build_graph(provider: str = "groq"):
-    if provider == "groq":
-        llm = ChatGroq(model="qwen-qwq-32b", temperature=0, api_key=groq_api_key)
-    elif provider == "google":
-        llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash", temperature=0)
-    elif provider == "huggingface":
-        llm = ChatHuggingFace(
-            llm=HuggingFaceEndpoint(repo_id="mosaicml/mpt-30b", temperature=0)
+def build_graph(provider: str = "huggingface"):
+    """Build the agent graph with improved HuggingFace model"""
+    
+    if provider == "huggingface":
+        # Use a more capable model from HuggingFace
+        endpoint = HuggingFaceEndpoint(
+            repo_id="microsoft/DialoGPT-large",  # You can also try "google/flan-t5-xl" or "bigscience/bloom-7b1"
+            temperature=0.1,
+            huggingfacehub_api_token=hf_token,
+            model_kwargs={
+                "max_length": 1024,
+                "return_full_text": False
+            }
         )
+        llm = ChatHuggingFace(llm=endpoint)
     else:
-        raise ValueError("Invalid provider: choose 'groq', 'google', or 'huggingface'.")
+        raise ValueError("Only 'huggingface' provider is supported in this version.")
 
     llm_with_tools = llm.bind_tools(tools)
 
     def assistant(state: MessagesState):
-        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+        """Enhanced assistant node with better error handling"""
+        try:
+            messages = state["messages"]
+            response = llm_with_tools.invoke(messages)
+            return {"messages": [response]}
+        except Exception as e:
+            print(f"Assistant error: {e}")
+            # Fallback response
+            fallback_msg = HumanMessage(content=f"I encountered an error: {str(e)}. Let me try a simpler approach.")
+            return {"messages": [fallback_msg]}
 
     def retriever(state: MessagesState):
-        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"]}
+        """Enhanced retriever with better context injection"""
+        messages = state["messages"]
+        user_query = messages[-1].content if messages else ""
+        
+        # Try to find similar questions
+        context_messages = [sys_msg]
+        
+        if vector_store:
+            try:
+                similar = vector_store.similarity_search(user_query, k=2)
+                if similar:
+                    context_msg = HumanMessage(
+                        content=f"Here are similar questions for context:\n\n{similar[0].page_content}"
+                    )
+                    context_messages.append(context_msg)
+            except Exception as e:
+                print(f"Retriever error: {e}")
+        
+        return {"messages": context_messages + messages}
 
+    # Build the graph
     builder = StateGraph(MessagesState)
     builder.add_node("retriever", retriever)
     builder.add_node("assistant", assistant)
     builder.add_node("tools", ToolNode(tools))
+    
+    # Define edges
     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,235 +1,302 @@
 import os
-from dotenv import load_dotenv
-
-# Load environment variables
-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")
-
-# ---- Updated Imports ----
-from langgraph.graph import START, StateGraph, MessagesState
-from langgraph.prebuilt import tools_condition, ToolNode
-from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
-from langchain_community.embeddings import HuggingFaceEmbeddings  # Updated import
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
-from langchain_community.vectorstores import Chroma
-from langchain_core.documents import Document
-from langchain_core.messages import SystemMessage, HumanMessage
-from langchain_core.tools import tool
-from langchain.tools.retriever import create_retriever_tool
-import json
-
-# ---- Tools ----
-
-@tool
-def multiply(a: int, b: int) -> int:
-    """Multiply two numbers together."""
-    return a * b
-
-@tool
-def add(a: int, b: int) -> int:
-    """Add two numbers together."""
-    return a + b
-
-@tool
-def subtract(a: int, b: int) -> int:
-    """Subtract the second number from the first."""
-    return a - b
-
-@tool
-def divide(a: int, b: int) -> float:
-    """Divide the first number by the second. Returns float or error if dividing by zero."""
-    if b == 0:
-        raise ValueError("Cannot divide by zero.")
-    return a / b
-
-@tool
-def modulus(a: int, b: int) -> int:
-    """Returns the remainder after division of the first number by the second."""
-    return a % b
-
-@tool
-def wiki_search(query: str) -> str:
-    """Search Wikipedia for information. Useful for factual questions about people, places, events, etc."""
-    try:
-        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 {"wiki_results": formatted}
-    except Exception as e:
-        return f"Wikipedia search failed: {str(e)}"
+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 ---
+class BasicAgent:
+    def __init__(self):
+        print("BasicAgent initialized.")
+        try:
+            self.graph = build_graph()
+            print("Graph built successfully.")
+        except Exception as e:
+            print(f"Error building graph: {e}")
+            raise e
+        
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 100 chars): {question[:100]}...")
+        
+        try:
+            # Clean the question
+            question = question.strip()
+            
+            # 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:
+                    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()
+                            
+                            print(f"Agent answer (first 100 chars): {answer[:100]}...")
+                            return answer
+                        else:
+                            return str(answer)
+                    else:
+                        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(1)  # Brief pause before retry
+            
+        except Exception as e:
+            print(f"Error in agent call: {e}")
+            return f"Agent error: {str(e)}"
+
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+    """
+    # --- 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"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
 
-@tool
-def web_search(query: str) -> str:
-    """Search the web for current information. Useful when you need recent or non-Wikipedia information."""
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Agent (modify this part to create your agent)
     try:
-        search = TavilySearchResults(max_results=3)
-        search_docs = search.invoke(query)
-        formatted = "\n\n---\n\n".join(
-            [
-                f'<Document source="{doc["url"]}"/>\n{doc["content"]}\n</Document>'
-                for doc in search_docs
-            ]
-        )
-        return {"web_results": formatted}
+        print("Initializing agent...")
+        agent = BasicAgent()
+        print("Agent initialized successfully.")
     except Exception as e:
-        return f"Web search failed: {str(e)}"
+        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
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(f"Agent code URL: {agent_code}")
 
-@tool
-def arxiv_search(query: str) -> str:
-    """Search academic papers on ArXiv. Useful for technical or scientific questions."""
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
     try:
-        search_docs = ArxivLoader(query=query, load_max_docs=2).load()
-        formatted = "\n\n---\n\n".join(
-            [
-                f'<Document source="{doc.metadata["source"]}"/>\n{doc.page_content[:1000]}\n</Document>'
-                for doc in search_docs
-            ]
-        )
-        return {"arxiv_results": formatted}
+        response = requests.get(questions_url, timeout=30)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+             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 fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         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:
-        return f"ArXiv search failed: {str(e)}"
-
-# ---- Updated Embedding & Vector Store Setup ----
-try:
-    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-mpnet-base-v2")
-except Exception as e:
-    print(f"Error loading embeddings: {e}")
-    raise
-
-# Load QA pairs
-json_QA = []
-try:
-    with open('metadata.jsonl', 'r') as jsonl_file:
-        for line in jsonl_file:
-            json_QA.append(json.loads(line))
-except Exception as e:
-    print(f"Error loading metadata.jsonl: {e}")
-    json_QA = []
-
-documents = [
-    Document(
-        page_content=f"Question: {sample['Question']}\n\nAnswer: {sample['Final answer']}",
-        metadata={"source": sample["task_id"], "question": sample["Question"], "answer": sample["Final answer"]}
-    )
-    for sample in json_QA
-]
-
-try:
-    vector_store = Chroma.from_documents(
-        documents=documents,
-        embedding=embeddings,
-        persist_directory="./chroma_db",
-        collection_name="qa_collection"
-    )
-    vector_store.persist()
-    print(f"Documents inserted: {len(documents)}")
-except Exception as e:
-    print(f"Error creating vector store: {e}")
-    raise
-
-@tool
-def similar_question_search(query: str) -> str:
-    """Search for similar questions that have been answered before. Always check here first before using other tools."""
+        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
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    
+    for i, item in enumerate(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"
+            
+            answers_payload.append({
+                "task_id": task_id, 
+                "submitted_answer": str(submitted_answer).strip()
+            })
+            
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text[:200] + "..." if len(question_text) > 200 else question_text, 
+                "Submitted Answer": str(submitted_answer).strip()
+            })
+            
+        except Exception as e:
+             print(f"Error running agent on task {task_id}: {e}")
+             error_answer = f"AGENT ERROR: {str(e)}"
+             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
+             })
+
+    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
+    }
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 5. Submit with better error handling
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
-        matched_docs = vector_store.similarity_search(query, k=3)
-        formatted = "\n\n---\n\n".join(
-            [
-                f'<Question: {doc.metadata["question"]}>\n<Answer: {doc.metadata["answer"]}>\n</Document>'
-                for doc in matched_docs
-            ]
+        response = requests.post(submit_url, json=submission_data, timeout=120)
+        response.raise_for_status()
+        result_data = response.json()
+        
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username', 'Unknown')}\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.')}"
         )
-        return {"similar_questions": formatted}
+        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:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            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 = "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:
-        return f"Similar question search failed: {str(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
 
-# ---- System Prompt ----
 
-system_prompt = """
-You are an expert question-answering assistant. Follow these steps for each question:
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks() as demo:
+    gr.Markdown("# Enhanced 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
+        
+        ---
+        **Note:** The evaluation process may take some time as the agent processes all questions systematically.
+        """
+    )
 
-1. FIRST check for similar questions using the similar_question_search tool
-2. If a similar question exists with a clear answer, use that answer
-3. If not, determine which tools might help answer the question
-4. Use the tools systematically to gather information
-5. Combine information from multiple sources if needed
-6. Format your final answer precisely as:
-FINAL ANSWER: [your answer here]
+    gr.LoginButton()
 
-Rules for answers:
-- Numbers: plain digits only (no commas, units, or symbols)
-- Strings: minimal words, no articles, full names
-- Lists: comma-separated with no extra formatting
-- Be concise but accurate
-"""
+    run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
 
-sys_msg = SystemMessage(content=system_prompt)
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
-# ---- Tool List ----
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
 
-tools = [
-    similar_question_search,  # Check this first
-    multiply, add, subtract, divide, modulus,  # Math tools
-    wiki_search, web_search, arxiv_search  # Information tools
-]
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " Enhanced App Starting " + "-"*30)
+    
+    # Check for environment variables
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+    hf_token = os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
 
-# ---- Graph Definition ----
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-def build_graph():
-    try:
-        # Using a powerful HuggingFace model
-        llm = ChatHuggingFace(
-            llm=HuggingFaceEndpoint(
-                repo_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
-                temperature=0,
-                max_new_tokens=512,
-                huggingfacehub_api_token=hf_token
-            )
-        )
-        
-        llm_with_tools = llm.bind_tools(tools)
-
-        def assistant(state: MessagesState):
-            return {"messages": [llm_with_tools.invoke(state["messages"])]}
-
-        def retriever(state: MessagesState):
-            try:
-                # First try to find similar questions
-                similar = vector_store.similarity_search(state["messages"][-1].content, k=2)
-                if similar:
-                    example_msg = HumanMessage(
-                        content=f"Here are similar questions and their answers:\n\n" +
-                        "\n\n".join([f"Q: {doc.metadata['question']}\nA: {doc.metadata['answer']}" 
-                                   for doc in similar])
-                    )
-                    return {"messages": [sys_msg] + state["messages"] + [example_msg]}
-                return {"messages": [sys_msg] + state["messages"]}
-            except Exception as e:
-                print(f"Retriever error: {e}")
-                return {"messages": [sys_msg] + state["messages"]}
-
-        builder = StateGraph(MessagesState)
-        builder.add_node("retriever", retriever)
-        builder.add_node("assistant", assistant)
-        builder.add_node("tools", ToolNode(tools))
+    if space_id_startup:
+        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?).")
         
-        builder.add_edge(START, "retriever")
-        builder.add_edge("retriever", "assistant")
-        builder.add_conditional_edges("assistant", tools_condition)
-        builder.add_edge("tools", "assistant")
+    if hf_token:
+        print("✅ HUGGINGFACE_INFERENCE_TOKEN found")
+    else:
+        print("⚠️  HUGGINGFACE_INFERENCE_TOKEN not found - this may cause issues")
 
-        return builder.compile()
-    
-    except Exception as e:
-        print(f"Error building graph: {e}")
-        raise
+    print("-"*(60 + len(" Enhanced App Starting ")) + "\n")
+
+    print("Launching Enhanced Gradio Interface for Agent Evaluation...")
+    demo.launch(debug=True, share=False)

requirements.txt

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