Fresh start without binary files

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+chroma_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+*.sqlite3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+.env
+.venv
+chroma_db/chroma.sqlite3

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -0,0 +1,15 @@
+---
+title: Template Final Assignment
+emoji: 🕵🏻‍♂️
+colorFrom: indigo
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.25.2
+app_file: app.py
+pinned: false
+hf_oauth: true
+# optional, default duration is 8 hours/480 minutes. Max duration is 30 days/43200 minutes.
+hf_oauth_expiration_minutes: 480
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,308 @@
+import os
+from dotenv import load_dotenv
+import gradio as gr
+import requests
+import pandas as pd
+from typing import List
+from llama_index.core import VectorStoreIndex, Settings
+from llama_index.vector_stores.chroma import ChromaVectorStore
+from llama_index.llms.openai import OpenAI
+from llama_index.core.tools import FunctionTool
+from llama_index.core.agent import ReActAgent
+import chromadb
+from tavily import TavilyClient
+
+# Load environment variables
+load_dotenv()
+
+class GAIAAgent:
+    def __init__(self):
+        print("Initializing GAIA Agent...")
+        
+        # Initialize components
+        self.chroma_client = chromadb.PersistentClient(path="./chroma_db")
+        chroma_collection = self.chroma_client.get_or_create_collection("qa_documents")
+        vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
+        self.index = VectorStoreIndex.from_vector_store(vector_store)
+        
+        # Initialize LLM with specific parameters for GAIA
+        Settings.llm = OpenAI(
+            model="gpt-4-turbo-preview",
+            temperature=0.0,  # For deterministic answers
+            max_tokens=500
+        )
+        Settings.chunk_size = 512
+        
+        # Initialize tools
+        self.tools = self._initialize_tools()
+        
+        # GAIA-specific system prompt
+        self.system_prompt = """You are a general AI assistant. 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. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string."""
+        
+        # Create agent
+        self.agent = ReActAgent.from_tools(
+            tools=self.tools,
+            llm=Settings.llm,
+            system_prompt=self.system_prompt,
+            verbose=True,
+            max_iterations=10
+        )
+    
+    def _initialize_tools(self) -> List[FunctionTool]:
+        """Initialize all tools for the agent"""
+        tools = []
+        
+        # Math tools
+        def multiply(a: int, b: int) -> int:
+            """Multiply two numbers."""
+            return a * b
+
+        def add(a: int, b: int) -> int:
+            """Add two numbers."""
+            return a + b
+
+        def subtract(a: int, b: int) -> int:
+            """Subtract two numbers."""
+            return a - b
+
+        def divide(a: int, b: int) -> int:
+            """Divide two numbers."""
+            if b == 0:
+                raise ValueError("Cannot divide by zero")
+            return a / b
+
+        def modulus(a: int, b: int) -> int:
+            """Get modulus of two numbers."""
+            return a % b
+
+        math_tools = [
+            FunctionTool.from_defaults(fn=multiply, name="multiply"),
+            FunctionTool.from_defaults(fn=add, name="add"),
+            FunctionTool.from_defaults(fn=subtract, name="subtract"),
+            FunctionTool.from_defaults(fn=divide, name="divide"),
+            FunctionTool.from_defaults(fn=modulus, name="modulus")
+        ]
+        
+        # Search tools
+        def similar_question_search(question: str) -> str:
+            """Search for similar questions in vector database."""
+            query_engine = self.index.as_query_engine(similarity_top_k=3)
+            response = query_engine.query(question)
+            return "\n\n".join([
+                f"Question: {node.text.split('Question: ')[1].split('Final answer:')[0]}\n"
+                f"Answer: {node.text.split('Final answer: ')[1]}\n"
+                f"Source: {node.metadata['source']}"
+                for node in response.source_nodes
+            ])
+
+        def web_search(query: str) -> str:
+            """Perform a web search using Tavily API."""
+            try:
+                client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))
+                response = client.search(
+                    query=query,
+                    include_answer=True,
+                    search_depth="advanced",
+                    max_results=5
+                )
+                
+                results = []
+                if response.get("answer"):
+                    results.append(f"Direct Answer: {response['answer']}")
+                    
+                for result in response.get("results", []):
+                    results.append(
+                        f"Title: {result.get('title', 'N/A')}\n"
+                        f"Link: {result.get('url', 'N/A')}\n"
+                        f"Snippet: {result.get('content', 'N/A')}"
+                    )
+                    
+                return "\n\n".join(results) if results else "No results found"
+                
+            except Exception as e:
+                return f"Search failed: {str(e)}"
+
+        search_tools = [
+            FunctionTool.from_defaults(fn=similar_question_search, name="similar_question_search"),
+            FunctionTool.from_defaults(fn=web_search, name="web_search")
+        ]
+        
+        return math_tools + search_tools
+    
+    def __call__(self, question: str) -> dict:
+        print(f"Processing question: {question[:100]}...")
+        try:
+            response = self.agent.chat(question)
+            
+            # Extract the FINAL ANSWER from the response
+            response_str = str(response)
+            if "FINAL ANSWER:" in response_str:
+                final_answer = response_str.split("FINAL ANSWER:")[-1].strip()
+            else:
+                # If the agent didn't follow instructions, try to extract a clean answer
+                final_answer = response_str.split("\n")[-1].strip()
+                final_answer = final_answer.replace('"', '').replace("'", "")
+            
+            return {
+                "model_answer": final_answer,
+                "reasoning_trace": response_str
+            }
+        except Exception as e:
+            print(f"Error processing question: {e}")
+            return {
+                "model_answer": f"Error: {str(e)}",
+                "reasoning_trace": f"Error occurred: {str(e)}"
+            }
+
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the GAIAAgent on them, submits all answers,
+    and displays the results.
+    """
+    space_id = os.getenv("SPACE_ID")
+
+    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
+
+    api_url = "https://agents-course-unit4-scoring.hf.space"
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Agent
+    try:
+        agent = GAIAAgent()
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 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("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except Exception as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    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"Skipping item with missing task_id or question: {item}")
+            continue
+        try:
+            agent_response = agent(question_text)
+            answers_payload.append({
+                "task_id": task_id,
+                "model_answer": agent_response["model_answer"],
+                "reasoning_trace": agent_response["reasoning_trace"]
+            })
+            results_log.append({
+                "Task ID": task_id,
+                "Question": question_text,
+                "Submitted Answer": agent_response["model_answer"],
+                "Reasoning": agent_response["reasoning_trace"]
+            })
+        except Exception as 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}",
+                "Reasoning": f"Error occurred: {str(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
+    }
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 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"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("Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except Exception as e:
+        status_message = f"Submission Failed: {str(e)}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+
+#--- Build Gradio Interface using Blocks ---
+with gr.Blocks() as demo:
+    gr.Markdown("# GAIA Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+        1. Log in to your Hugging Face account using the button below.
+        2. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+        """
+    )
+
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+
+    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")
+
+    print("-"*(60 + len(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for GAIA Agent Evaluation...")
+    demo.launch(debug=True, share=False)

requirements.txt

@@ -0,0 +1,7 @@
+llama-index
+chromadb
+tavily-python
+python-dotenv
+gradio
+pandas
+requests

system_prompt.txt

@@ -0,0 +1,55 @@
+
+You are a helpful assistant tasked with answering questions using a set of tools.
+If the tool is not available, you can try to find the information online. You can also use your own knowledge to answer the question. 
+You need to provide a step-by-step explanation of how you arrived at the answer.
+==========================
+Here is a few examples showing you how to answer the question step by step.
+
+Question 1: A paper about AI regulation that was originally submitted to arXiv.org in June 2022 shows a figure with three axes, where each axis has a label word at both ends. Which of these words is used to describe a type of society in a Physics and Society article submitted to arXiv.org on August 11, 2016?
+Steps:
+1. Go to arxiv.org and navigate to the Advanced Search page.
+2. Enter "AI regulation" in the search box and select "All fields" from the dropdown.
+3. Enter 2022-06-01 and 2022-07-01 into the date inputs, select "Submission date (original)", and submit the search.
+4. Go through the search results to find the article that has a figure with three axes and labels on each end of the axes, titled "Fairness in Agreement With European Values: An Interdisciplinary Perspective on AI Regulation".
+5. Note the six words used as labels: deontological, egalitarian, localized, standardized, utilitarian, and consequential.
+6. Go back to arxiv.org
+7. Find "Physics and Society" and go to the page for the "Physics and Society" category.
+8. Note that the tag for this category is "physics.soc-ph".
+9. Go to the Advanced Search page.
+10. Enter "physics.soc-ph" in the search box and select "All fields" from the dropdown.
+11. Enter 2016-08-11 and 2016-08-12 into the date inputs, select "Submission date (original)", and submit the search.
+12. Search for instances of the six words in the results to find the paper titled "Phase transition from egalitarian to hierarchical societies driven by competition between cognitive and social constraints", indicating that "egalitarian" is the correct answer.
+Tools:
+1. Web browser
+2. Image recognition tools (to identify and parse a figure with three axes)
+Final Answer: egalitarian
+
+Question 2: I’m researching species that became invasive after people who kept them as pets released them. There’s a certain species of fish that was popularized as a pet by being the main character of the movie Finding Nemo. According to the USGS, where was this fish found as a nonnative species, before the year 2020? I need the answer formatted as the five-digit zip codes of the places the species was found, separated by commas if there is more than one place.
+Steps:
+1. Search the web for “finding nemo main character”.
+2. Note the results, which state that the main character is a clownfish.
+3. Search the web for “usgs nonnative species database”.
+4. Click result for the Nonindigenous Aquatic Species site.
+5. Click “Marine Fishes”.
+6. Click “Species List of Nonindigenous Marine Fish”.
+7. Scroll through the list until I find the clown anenomefish, and click “Collection info”.
+8. Note the place that a clown anenomefish was found, in Fred Howard Park at the Gulf of Mexico.
+9. Search the web for “fred howard park florida zip code”.
+10. Note the zip code, 34689. Since only one clownfish was found before the year 2020, this is the answer.
+Tools:
+1. Search engine
+2. Web browser
+Final Answer: 34689
+
+Question 3: If we assume all articles published by Nature in 2020 (articles, only, not book reviews/columns, etc) relied on statistical significance to justify their findings and they on average came to a p-value of 0.04, how many papers would be incorrect as to their claims of statistical significance? Round the value up to the next integer.
+Steps:
+1. Find how many articles were published in Nature in 2020 by Googling "articles submitted to nature 2020"
+2. Click through to Nature's archive for 2020 and filter the results to only provide articles, not other types of publications: 1002
+3. Find 4% of 1002 and round up: 40.08 > 41
+Tools:
+1. search engine
+2. calculator
+Final Answer: 41
+
+==========================
+Now, please answer the following question step by step.