one more try

app.py

@@ -2,169 +2,89 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
-from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
-from transformers import AutoProcessor, AutoModelForVision2Seq
-from dotenv import load_dotenv
-from typing import Optional, Dict, Any
-from PIL import Image
-import yt_dlp
 import torch
-import re
-from io import BytesIO
+from llama_index.llms.huggingface import HuggingFaceLLM
+from llama_index.core import ChatPromptTemplate
+from llama_index.core.llms import ChatMessage
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
+# --- LlamaIndex Agent Definition ---
+# ----- THIS IS THE MODIFIED AGENT USING LLAMA-INDEX ------
+class LlamaIndexAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
-        load_dotenv()
-
-        # Initialize model and tokenizer using Qwen
-        model_name = "Qwen/Qwen-7B-Chat"  # Changed to Qwen
+        print("Initializing LlamaIndexAgent...")
+
+        # Define the system prompt as requested by the user
+        system_prompt = """
+        You are a helpful assistant tasked with answering questions. 
+        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.
+        Your answer should only start with "FINAL ANSWER: ", then follows with the answer.
+        """
 
-        # Configure quantization
-        quantization_config = BitsAndBytesConfig(
-            load_in_8bit=True, bnb_4bit_compute_dtype=torch.float16
+        # Using a fixed user and assistant message for the prompt template
+        self.chat_prompt_template = ChatPromptTemplate(
+            message_templates=[
+                ChatMessage(
+                    role="system",
+                    content=system_prompt,
+                ),
+                ChatMessage(role="user", content="{question}"),
+            ]
         )
 
-        self.tokenizer = AutoTokenizer.from_pretrained(
-            model_name, trust_remote_code=True  # Required for Qwen
-        )
-        self.model = AutoModelForCausalLM.from_pretrained(
-            model_name,
+        # Load the model. Using a smaller, free model that can run on CPU
+        # Using quantization to reduce memory footprint
+        self.llm = HuggingFaceLLM(
+            model_name="HuggingFaceH4/zephyr-7b-beta",
+            tokenizer_name="HuggingFaceH4/zephyr-7b-beta",
+            query_wrapper_prompt=self.chat_prompt_template,
             device_map="auto",
-            quantization_config=quantization_config,
-            trust_remote_code=True,
-        )
-
-        # Initialize vision model
-        vision_model_name = "microsoft/kosmos-2-patch14-224"
-        self.vision_processor = AutoProcessor.from_pretrained(vision_model_name)
-        self.vision_model = AutoModelForVision2Seq.from_pretrained(
-            vision_model_name, device_map="auto", trust_remote_code=True
+            model_kwargs={"torch_dtype": torch.float16, "load_in_8bit": True},
         )
-
-        print("Agent initialized with multimodal capabilities.")
-
-    def generate_text(self, prompt: str) -> str:
-        inputs = self.tokenizer(prompt, return_tensors="pt").to(self.model.device)
-        outputs = self.model.generate(
-            **inputs, max_new_tokens=512, temperature=0.1, do_sample=True
-        )
-        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-    def analyze_image(self, image_url: str) -> str:
-        try:
-            response = requests.get(image_url)
-            image = Image.open(BytesIO(response.content))
-            inputs = self.vision_processor(images=image, return_tensors="pt")
-            outputs = self.vision_model.generate(
-                pixel_values=inputs["pixel_values"], max_length=128, num_beams=5
-            )
-            return self.vision_processor.batch_decode(
-                outputs, skip_special_tokens=True
-            )[0]
-        except Exception as e:
-            print(f"Error analyzing image: {e}")
-            return "Error analyzing image"
-
-    def analyze_video(self, video_url: str) -> str:
-        try:
-            # Extract video info using yt-dlp
-            ydl_opts = {
-                "format": "worst",  # Lowest quality to save bandwidth
-                "extract_flat": True,
-                "quiet": True,
-            }
-            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
-                info = ydl.extract_info(video_url, download=False)
-
-            # Extract relevant information
-            title = info.get("title", "")
-            description = info.get("description", "")
-            duration = info.get("duration", 0)
-
-            # Create prompt for the LLM
-            video_context = f"""
-            Video Title: {title}
-            Duration: {duration} seconds
-            Description: {description}
-            """
-
-            return self.generate_response(video_context)
-        except Exception as e:
-            print(f"Error analyzing video: {e}")
-            return "Error analyzing video"
-
-    def analyze_data(self, df: pd.DataFrame, question: str) -> str:
-        try:
-            prompt = f"""Analyze this DataFrame:
-            Columns: {', '.join(df.columns)}
-            Sample: {df.head().to_string()}
-            Question: {question}
-            Provide only the numerical answer or specific value."""
-
-            return self.generate_response(prompt)
-        except Exception as e:
-            print(f"Error analyzing data: {e}")
-            return "Error analyzing data"
-
-    def generate_response(self, prompt: str) -> str:
-        try:
-            response = self.llm.complete(prompt)
-            return response.text.strip()
-        except Exception as e:
-            print(f"Error generating response: {e}")
-            return "Error generating response"
+        print("LlamaIndexAgent initialized successfully.")
 
     def __call__(self, question: str) -> str:
-        print(f"Agent received question: {question[:50]}...")
+        print(f"Agent received question (first 80 chars): {question[:80]}...")
 
-        try:
-            # Check for data analysis task
-            if "```python" in question:
-                data_start = question.find("```python")
-                data_end = question.find("```", data_start + 8)
-                data_code = question[data_start + 8 : data_end].strip()
-                local_vars = {}
-                exec(data_code, {"pd": pd}, local_vars)
-                df = local_vars.get("df")
-                actual_question = question[data_end + 3 :].strip()
-                return self.analyze_data(df, actual_question)
+        # Format the messages
+        messages = self.chat_prompt_template.format_messages(question=question)
 
-            # Check for video analysis task
-            video_pattern = r"https?://(?:www\.)?youtube\.com/\S+"
-            video_match = re.search(video_pattern, question)
-            if video_match:
-                return self.analyze_video(video_match.group(0))
+        # Get the response from the LLM
+        response = self.llm.chat(messages)
 
-            # Check for image analysis task
-            image_pattern = r"https?://\S+\.(?:jpg|jpeg|png|gif)"
-            image_match = re.search(image_pattern, question)
-            if image_match:
-                return self.analyze_image(image_match.group(0))
+        # Extract the answer from the response
+        answer = response.message.content.strip()
 
-            # General question
-            return self.generate_text(question)
+        # Ensure the answer starts with "FINAL ANSWER: "
+        if "FINAL ANSWER:" in answer:
+            final_answer = answer.split("FINAL ANSWER:")[-1].strip()
+        else:
+            # If the model fails to follow the template, we return its raw output
+            # as the answer, prefixed with the required string.
+            print(
+                f"Warning: Model did not use the 'FINAL ANSWER:' template. Raw output: {answer}"
+            )
+            final_answer = answer
 
-        except Exception as e:
-            print(f"Error processing question: {e}")
-            return "Error occurred while processing the question"
+        print(f"Agent returning answer: {final_answer}")
+        return f"FINAL ANSWER: {final_answer}"
 
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    Fetches all questions, runs the LlamaIndexAgent 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}")
@@ -176,13 +96,14 @@ 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:
-        agent = BasicAgent()
+        agent = LlamaIndexAgent()
     except Exception as 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 ( usefull for others so please keep it public)
+
+    # 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(agent_code)
 
@@ -217,16 +138,21 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+
         try:
             submitted_answer = agent(question_text)
+            # The agent now returns the full "FINAL ANSWER: ..." string, so we extract the answer part for submission.
+            answer_for_submission = submitted_answer.replace(
+                "FINAL ANSWER:", ""
+            ).strip()
             answers_payload.append(
-                {"task_id": task_id, "submitted_answer": submitted_answer}
+                {"task_id": task_id, "submitted_answer": answer_for_submission}
             )
             results_log.append(
                 {
                     "Task ID": task_id,
                     "Question": question_text,
-                    "Submitted Answer": submitted_answer,
+                    "Submitted Answer": answer_for_submission,
                 }
             )
         except Exception as e:
@@ -298,30 +224,24 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown("# LlamaIndex Agent Evaluation Runner for GAIA")
     gr.Markdown(
         """
         **Instructions:**
-
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        1.  This space is configured with a `LlamaIndexAgent` to answer the GAIA subset questions.
         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.
-
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run the agent, submit answers, and see the score.
         ---
         **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.
+        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. 
+        Model loading can also take a few minutes on the first run.
         """
     )
-
     gr.LoginButton()
-
     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(fn=run_and_submit_all, outputs=[status_output, results_table])
@@ -331,7 +251,6 @@ if __name__ == "__main__":
     # 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")  # Get SPACE_ID at startup
-
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
         print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
@@ -350,6 +269,5 @@ if __name__ == "__main__":
         )
 
     print("-" * (60 + len(" App Starting ")) + "\n")
-
-    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    print("Launching Gradio Interface for LlamaIndex Agent Evaluation...")
     demo.launch(debug=True, share=False)

requirements.txt

@@ -1,16 +1,8 @@
-gradio~=4.44.0
-numpy<2.0.0
-requests==2.31.0
+gradio
+requests
+pandas
+llama-index
+torch
 transformers
-python-dotenv==1.0.0
-torch==2.2.0
-sentence-transformers==2.3.1
-nltk==3.8.1
-accelerate==0.27.2
-bitsandbytes==0.41.0
-yt-dlp
-Pillow==10.2.0
-pandas==2.1.4
-gradio[oauth]
-transformers_stream_generator
-einops
+accelerate
+bitsandbytes