Upload 11 files

README.md

@@ -1,12 +1,15 @@
----
-title: Final Gaia Agent
-emoji: ⚡
-colorFrom: gray
-colorTo: red
-sdk: gradio
-sdk_version: 5.48.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+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

agent.py

@@ -0,0 +1,801 @@
+import os
+from dotenv import load_dotenv
+from typing import List, Dict, Any, Optional
+import tempfile
+import re
+import json
+import requests
+from urllib.parse import urlparse
+import pytesseract
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageFilter
+import cmath
+import pandas as pd
+import uuid
+import numpy as np
+from code_interpreter import CodeInterpreter
+
+interpreter_instance = CodeInterpreter()
+
+from image_processing import *
+
+"""Langraph"""
+from langgraph.graph import START, StateGraph, MessagesState
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_community.document_loaders import ArxivLoader
+from langgraph.prebuilt import ToolNode, tools_condition
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_huggingface import (
+    ChatHuggingFace,
+    HuggingFaceEndpoint,
+    HuggingFaceEmbeddings,
+)
+from langchain_community.vectorstores import SupabaseVectorStore
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.tools import tool
+from langchain.tools.retriever import create_retriever_tool
+from supabase.client import Client, create_client
+
+load_dotenv()
+
+### =============== BROWSER TOOLS =============== ###
+
+
+@tool
+def wiki_search(query: str) -> str:
+    """Search Wikipedia for a query and return maximum 2 results.
+
+    Args:
+        query: The search query."""
+    search_docs = WikipediaLoader(query=query, load_max_docs=2).load()
+    formatted_search_docs = "\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_search_docs}
+
+
+@tool
+def web_search(query: str) -> str:
+    """Search Tavily for a query and return maximum 3 results.
+
+    Args:
+        query: The search query."""
+    search_docs = TavilySearchResults(max_results=3).invoke(query)
+    formatted_search_docs = "\n\n---\n\n".join(
+        [
+            f'<Document source="{doc.get("url", "")}" title="{doc.get("title", "")}"/>\n{doc.get("content", "")}\n</Document>'
+            for doc in search_docs
+        ]
+    )
+    return {"web_results": formatted_search_docs}
+
+
+@tool
+def arxiv_search(query: str) -> str:
+    """Search Arxiv for a query and return maximum 3 result.
+
+    Args:
+        query: The search query."""
+    search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+    formatted_search_docs = "\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
+        ]
+    )
+    return {"arxiv_results": formatted_search_docs}
+
+
+### =============== CODE INTERPRETER TOOLS =============== ###
+
+
+@tool
+def execute_code_multilang(code: str, language: str = "python") -> str:
+    """Execute code in multiple languages (Python, Bash, SQL, C, Java) and return results.
+
+    Args:
+        code (str): The source code to execute.
+        language (str): The language of the code. Supported: "python", "bash", "sql", "c", "java".
+
+    Returns:
+        A string summarizing the execution results (stdout, stderr, errors, plots, dataframes if any).
+    """
+    supported_languages = ["python", "bash", "sql", "c", "java"]
+    language = language.lower()
+
+    if language not in supported_languages:
+        return f"❌ Unsupported language: {language}. Supported languages are: {', '.join(supported_languages)}"
+
+    result = interpreter_instance.execute_code(code, language=language)
+
+    response = []
+
+    if result["status"] == "success":
+        response.append(f"✅ Code executed successfully in **{language.upper()}**")
+
+        if result.get("stdout"):
+            response.append(
+                "\n**Standard Output:**\n```\n" + result["stdout"].strip() + "\n```"
+            )
+
+        if result.get("stderr"):
+            response.append(
+                "\n**Standard Error (if any):**\n```\n"
+                + result["stderr"].strip()
+                + "\n```"
+            )
+
+        if result.get("result") is not None:
+            response.append(
+                "\n**Execution Result:**\n```\n"
+                + str(result["result"]).strip()
+                + "\n```"
+            )
+
+        if result.get("dataframes"):
+            for df_info in result["dataframes"]:
+                response.append(
+                    f"\n**DataFrame `{df_info['name']}` (Shape: {df_info['shape']})**"
+                )
+                df_preview = pd.DataFrame(df_info["head"])
+                response.append("First 5 rows:\n```\n" + str(df_preview) + "\n```")
+
+        if result.get("plots"):
+            response.append(
+                f"\n**Generated {len(result['plots'])} plot(s)** (Image data returned separately)"
+            )
+
+    else:
+        response.append(f"❌ Code execution failed in **{language.upper()}**")
+        if result.get("stderr"):
+            response.append(
+                "\n**Error Log:**\n```\n" + result["stderr"].strip() + "\n```"
+            )
+
+    return "\n".join(response)
+
+
+### =============== MATHEMATICAL TOOLS =============== ###
+
+
+@tool
+def multiply(a: float, b: float) -> float:
+    """
+    Multiplies two numbers.
+
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
+    return a * b
+
+
+@tool
+def add(a: float, b: float) -> float:
+    """
+    Adds two numbers.
+
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
+    return a + b
+
+
+@tool
+def subtract(a: float, b: float) -> int:
+    """
+    Subtracts two numbers.
+
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
+    return a - b
+
+
+@tool
+def divide(a: float, b: float) -> float:
+    """
+    Divides two numbers.
+
+    Args:
+        a (float): the first float number
+        b (float): the second float number
+    """
+    if b == 0:
+        raise ValueError("Cannot divided by zero.")
+    return a / b
+
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """
+    Get the modulus of two numbers.
+
+    Args:
+        a (int): the first number
+        b (int): the second number
+    """
+    return a % b
+
+
+@tool
+def power(a: float, b: float) -> float:
+    """
+    Get the power of two numbers.
+
+    Args:
+        a (float): the first number
+        b (float): the second number
+    """
+    return a**b
+
+
+@tool
+def square_root(a: float) -> float | complex:
+    """
+    Get the square root of a number.
+
+    Args:
+        a (float): the number to get the square root of
+    """
+    if a >= 0:
+        return a**0.5
+    return cmath.sqrt(a)
+
+
+### =============== DOCUMENT PROCESSING TOOLS =============== ###
+
+
+@tool
+def save_and_read_file(content: str, filename: Optional[str] = None) -> str:
+    """
+    Save content to a file and return the path.
+
+    Args:
+        content (str): the content to save to the file
+        filename (str, optional): the name of the file. If not provided, a random name file will be created.
+    """
+    temp_dir = tempfile.gettempdir()
+    if filename is None:
+        temp_file = tempfile.NamedTemporaryFile(delete=False, dir=temp_dir)
+        filepath = temp_file.name
+    else:
+        filepath = os.path.join(temp_dir, filename)
+
+    with open(filepath, "w") as f:
+        f.write(content)
+
+    return f"File saved to {filepath}. You can read this file to process its contents."
+
+
+@tool
+def download_file_from_url(url: str, filename: Optional[str] = None) -> str:
+    """
+    Download a file from a URL and save it to a temporary location.
+
+    Args:
+        url (str): the URL of the file to download.
+        filename (str, optional): the name of the file. If not provided, a random name file will be created.
+    """
+    try:
+        # Parse URL to get filename if not provided
+        if not filename:
+            path = urlparse(url).path
+            filename = os.path.basename(path)
+            if not filename:
+                filename = f"downloaded_{uuid.uuid4().hex[:8]}"
+
+        # Create temporary file
+        temp_dir = tempfile.gettempdir()
+        filepath = os.path.join(temp_dir, filename)
+
+        # Download the file
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+
+        # Save the file
+        with open(filepath, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+        return f"File downloaded to {filepath}. You can read this file to process its contents."
+    except Exception as e:
+        return f"Error downloading file: {str(e)}"
+
+
+@tool
+def extract_text_from_image(image_path: str) -> str:
+    """
+    Extract text from an image using OCR library pytesseract (if available).
+
+    Args:
+        image_path (str): the path to the image file.
+    """
+    try:
+        # Open the image
+        image = Image.open(image_path)
+
+        # Extract text from the image
+        text = pytesseract.image_to_string(image)
+
+        return f"Extracted text from image:\n\n{text}"
+    except Exception as e:
+        return f"Error extracting text from image: {str(e)}"
+
+
+@tool
+def analyze_csv_file(file_path: str, query: str) -> str:
+    """
+    Analyze a CSV file using pandas and answer a question about it.
+
+    Args:
+        file_path (str): the path to the CSV file.
+        query (str): Question about the data
+    """
+    try:
+        # Read the CSV file
+        df = pd.read_csv(file_path)
+
+        # Run various analyses based on the query
+        result = f"CSV file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+        result += f"Columns: {', '.join(df.columns)}\n\n"
+
+        # Add summary statistics
+        result += "Summary statistics:\n"
+        result += str(df.describe())
+
+        return result
+
+    except Exception as e:
+        return f"Error analyzing CSV file: {str(e)}"
+
+
+@tool
+def analyze_excel_file(file_path: str, query: str) -> str:
+    """
+    Analyze an Excel file using pandas and answer a question about it.
+
+    Args:
+        file_path (str): the path to the Excel file.
+        query (str): Question about the data
+    """
+    try:
+        # Read the Excel file
+        df = pd.read_excel(file_path)
+
+        # Run various analyses based on the query
+        result = (
+            f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+        )
+        result += f"Columns: {', '.join(df.columns)}\n\n"
+
+        # Add summary statistics
+        result += "Summary statistics:\n"
+        result += str(df.describe())
+
+        return result
+
+    except Exception as e:
+        return f"Error analyzing Excel file: {str(e)}"
+
+
+### ============== IMAGE PROCESSING AND GENERATION TOOLS =============== ###
+
+
+@tool
+def analyze_image(image_base64: str) -> Dict[str, Any]:
+    """
+    Analyze basic properties of an image (size, mode, color analysis, thumbnail preview).
+
+    Args:
+        image_base64 (str): Base64 encoded image string
+
+    Returns:
+        Dictionary with analysis result
+    """
+    try:
+        img = decode_image(image_base64)
+        width, height = img.size
+        mode = img.mode
+
+        if mode in ("RGB", "RGBA"):
+            arr = np.array(img)
+            avg_colors = arr.mean(axis=(0, 1))
+            dominant = ["Red", "Green", "Blue"][np.argmax(avg_colors[:3])]
+            brightness = avg_colors.mean()
+            color_analysis = {
+                "average_rgb": avg_colors.tolist(),
+                "brightness": brightness,
+                "dominant_color": dominant,
+            }
+        else:
+            color_analysis = {"note": f"No color analysis for mode {mode}"}
+
+        thumbnail = img.copy()
+        thumbnail.thumbnail((100, 100))
+        thumb_path = save_image(thumbnail, "thumbnails")
+        thumbnail_base64 = encode_image(thumb_path)
+
+        return {
+            "dimensions": (width, height),
+            "mode": mode,
+            "color_analysis": color_analysis,
+            "thumbnail": thumbnail_base64,
+        }
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def transform_image(
+    image_base64: str, operation: str, params: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Apply transformations: resize, rotate, crop, flip, brightness, contrast, blur, sharpen, grayscale.
+
+    Args:
+        image_base64 (str): Base64 encoded input image
+        operation (str): Transformation operation
+        params (Dict[str, Any], optional): Parameters for the operation
+
+    Returns:
+        Dictionary with transformed image (base64)
+    """
+    try:
+        img = decode_image(image_base64)
+        params = params or {}
+
+        if operation == "resize":
+            img = img.resize(
+                (
+                    params.get("width", img.width // 2),
+                    params.get("height", img.height // 2),
+                )
+            )
+        elif operation == "rotate":
+            img = img.rotate(params.get("angle", 90), expand=True)
+        elif operation == "crop":
+            img = img.crop(
+                (
+                    params.get("left", 0),
+                    params.get("top", 0),
+                    params.get("right", img.width),
+                    params.get("bottom", img.height),
+                )
+            )
+        elif operation == "flip":
+            if params.get("direction", "horizontal") == "horizontal":
+                img = img.transpose(Image.FLIP_LEFT_RIGHT)
+            else:
+                img = img.transpose(Image.FLIP_TOP_BOTTOM)
+        elif operation == "adjust_brightness":
+            img = ImageEnhance.Brightness(img).enhance(params.get("factor", 1.5))
+        elif operation == "adjust_contrast":
+            img = ImageEnhance.Contrast(img).enhance(params.get("factor", 1.5))
+        elif operation == "blur":
+            img = img.filter(ImageFilter.GaussianBlur(params.get("radius", 2)))
+        elif operation == "sharpen":
+            img = img.filter(ImageFilter.SHARPEN)
+        elif operation == "grayscale":
+            img = img.convert("L")
+        else:
+            return {"error": f"Unknown operation: {operation}"}
+
+        result_path = save_image(img)
+        result_base64 = encode_image(result_path)
+        return {"transformed_image": result_base64}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def draw_on_image(
+    image_base64: str, drawing_type: str, params: Dict[str, Any]
+) -> Dict[str, Any]:
+    """
+    Draw shapes (rectangle, circle, line) or text onto an image.
+
+    Args:
+        image_base64 (str): Base64 encoded input image
+        drawing_type (str): Drawing type
+        params (Dict[str, Any]): Drawing parameters
+
+    Returns:
+        Dictionary with result image (base64)
+    """
+    try:
+        img = decode_image(image_base64)
+        draw = ImageDraw.Draw(img)
+        color = params.get("color", "red")
+
+        if drawing_type == "rectangle":
+            draw.rectangle(
+                [params["left"], params["top"], params["right"], params["bottom"]],
+                outline=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "circle":
+            x, y, r = params["x"], params["y"], params["radius"]
+            draw.ellipse(
+                (x - r, y - r, x + r, y + r),
+                outline=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "line":
+            draw.line(
+                (
+                    params["start_x"],
+                    params["start_y"],
+                    params["end_x"],
+                    params["end_y"],
+                ),
+                fill=color,
+                width=params.get("width", 2),
+            )
+        elif drawing_type == "text":
+            font_size = params.get("font_size", 20)
+            try:
+                font = ImageFont.truetype("arial.ttf", font_size)
+            except IOError:
+                font = ImageFont.load_default()
+            draw.text(
+                (params["x"], params["y"]),
+                params.get("text", "Text"),
+                fill=color,
+                font=font,
+            )
+        else:
+            return {"error": f"Unknown drawing type: {drawing_type}"}
+
+        result_path = save_image(img)
+        result_base64 = encode_image(result_path)
+        return {"result_image": result_base64}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def generate_simple_image(
+    image_type: str,
+    width: int = 500,
+    height: int = 500,
+    params: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """
+    Generate a simple image (gradient, noise, pattern, chart).
+
+    Args:
+        image_type (str): Type of image
+        width (int), height (int)
+        params (Dict[str, Any], optional): Specific parameters
+
+    Returns:
+        Dictionary with generated image (base64)
+    """
+    try:
+        params = params or {}
+
+        if image_type == "gradient":
+            direction = params.get("direction", "horizontal")
+            start_color = params.get("start_color", (255, 0, 0))
+            end_color = params.get("end_color", (0, 0, 255))
+
+            img = Image.new("RGB", (width, height))
+            draw = ImageDraw.Draw(img)
+
+            if direction == "horizontal":
+                for x in range(width):
+                    r = int(
+                        start_color[0] + (end_color[0] - start_color[0]) * x / width
+                    )
+                    g = int(
+                        start_color[1] + (end_color[1] - start_color[1]) * x / width
+                    )
+                    b = int(
+                        start_color[2] + (end_color[2] - start_color[2]) * x / width
+                    )
+                    draw.line([(x, 0), (x, height)], fill=(r, g, b))
+            else:
+                for y in range(height):
+                    r = int(
+                        start_color[0] + (end_color[0] - start_color[0]) * y / height
+                    )
+                    g = int(
+                        start_color[1] + (end_color[1] - start_color[1]) * y / height
+                    )
+                    b = int(
+                        start_color[2] + (end_color[2] - start_color[2]) * y / height
+                    )
+                    draw.line([(0, y), (width, y)], fill=(r, g, b))
+
+        elif image_type == "noise":
+            noise_array = np.random.randint(0, 256, (height, width, 3), dtype=np.uint8)
+            img = Image.fromarray(noise_array, "RGB")
+
+        else:
+            return {"error": f"Unsupported image_type {image_type}"}
+
+        result_path = save_image(img)
+        result_base64 = encode_image(result_path)
+        return {"generated_image": result_base64}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+@tool
+def combine_images(
+    images_base64: List[str], operation: str, params: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    """
+    Combine multiple images (collage, stack, blend).
+
+    Args:
+        images_base64 (List[str]): List of base64 images
+        operation (str): Combination type
+        params (Dict[str, Any], optional)
+
+    Returns:
+        Dictionary with combined image (base64)
+    """
+    try:
+        images = [decode_image(b64) for b64 in images_base64]
+        params = params or {}
+
+        if operation == "stack":
+            direction = params.get("direction", "horizontal")
+            if direction == "horizontal":
+                total_width = sum(img.width for img in images)
+                max_height = max(img.height for img in images)
+                new_img = Image.new("RGB", (total_width, max_height))
+                x = 0
+                for img in images:
+                    new_img.paste(img, (x, 0))
+                    x += img.width
+            else:
+                max_width = max(img.width for img in images)
+                total_height = sum(img.height for img in images)
+                new_img = Image.new("RGB", (max_width, total_height))
+                y = 0
+                for img in images:
+                    new_img.paste(img, (0, y))
+                    y += img.height
+        else:
+            return {"error": f"Unsupported combination operation {operation}"}
+
+        result_path = save_image(new_img)
+        result_base64 = encode_image(result_path)
+        return {"combined_image": result_base64}
+
+    except Exception as e:
+        return {"error": str(e)}
+
+
+# load the system prompt from the file
+with open("system_prompt.txt", "r", encoding="utf-8") as f:
+    system_prompt = f.read()
+print(system_prompt)
+
+# System message
+sys_msg = SystemMessage(content=system_prompt)
+
+# build a retriever
+embeddings = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-mpnet-base-v2"
+)  #  dim=768
+supabase: Client = create_client(
+    os.environ.get("SUPABASE_URL"), os.environ.get("SUPABASE_SERVICE_ROLE_KEY")
+)
+vector_store = SupabaseVectorStore(
+    client=supabase,
+    embedding=embeddings,
+    table_name="documents2",
+    query_name="match_documents_2",
+)
+create_retriever_tool = create_retriever_tool(
+    retriever=vector_store.as_retriever(),
+    name="Question Search",
+    description="A tool to retrieve similar questions from a vector store.",
+)
+
+
+tools = [
+    web_search,
+    wiki_search,
+    arxiv_search,
+    multiply,
+    add,
+    subtract,
+    divide,
+    modulus,
+    power,
+    square_root,
+    save_and_read_file,
+    download_file_from_url,
+    extract_text_from_image,
+    analyze_csv_file,
+    analyze_excel_file,
+    execute_code_multilang,
+    analyze_image,
+    transform_image,
+    draw_on_image,
+    generate_simple_image,
+    combine_images,
+]
+
+
+# Build graph function
+def build_graph(provider: str = "groq"):
+    """Build the graph"""
+    # Load environment variables from .env file
+    if provider == "groq":
+        # Groq https://console.groq.com/docs/models
+        llm = ChatGroq(model="qwen/qwen3-32b", temperature=0)
+    elif provider == "huggingface":
+        # TODO: Add huggingface endpoint
+        llm = ChatHuggingFace(
+            llm=HuggingFaceEndpoint(
+                repo_id="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+                task="text-generation",  # for chat‐style use “text-generation”
+                max_new_tokens=1024,
+                do_sample=False,
+                repetition_penalty=1.03,
+                temperature=0,
+            ),
+            verbose=True,
+        )
+    else:
+        raise ValueError("Invalid provider. Choose 'groq' or 'huggingface'.")
+    # Bind tools to LLM
+    llm_with_tools = llm.bind_tools(tools)
+
+    # Node
+    def assistant(state: MessagesState):
+        """Assistant node"""
+        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+    def retriever(state: MessagesState):
+        """Retriever node"""
+        similar_question = vector_store.similarity_search(state["messages"][0].content)
+
+        if similar_question:  # Check if the list is not empty
+            example_msg = HumanMessage(
+                content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
+            )
+            return {"messages": [sys_msg] + state["messages"] + [example_msg]}
+        else:
+            # Handle the case when no similar questions are found
+            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))
+    builder.add_edge(START, "retriever")
+    builder.add_edge("retriever", "assistant")
+    builder.add_conditional_edges(
+        "assistant",
+        tools_condition,
+    )
+    builder.add_edge("tools", "assistant")
+
+    # Compile graph
+    return builder.compile()
+
+
+# test
+if __name__ == "__main__":
+    question = "When was a picture of St. Thomas Aquinas first added to the Wikipedia page on the Principle of double effect?"
+    graph = build_graph(provider="groq")
+    messages = [HumanMessage(content=question)]
+    messages = graph.invoke({"messages": messages})
+    for m in messages["messages"]:
+        m.pretty_print()

app.py

@@ -0,0 +1,945 @@
+import gradio as gr
+import time
+import os
+import base64
+from typing import List, Tuple, Optional
+from langchain_core.messages import HumanMessage
+from agent import build_graph
+
+class QnAChatbot:
+    """A Q&A chatbot interface for the agent."""
+    
+    def __init__(self):
+        print("🤖 QnAChatbot initializing...")
+        print("🔧 Building agent graph...")
+        self.graph = build_graph()
+        self.conversation_history = []
+        print("✅ QnAChatbot initialized successfully")
+    
+    def process_question(self, question: str, history: List[Tuple[str, str]], uploaded_files: Optional[List] = None) -> Tuple[str, List[Tuple[str, str]]]:
+        """Process a question and return the response with updated history."""
+        if not question.strip() and not uploaded_files:
+            print("⚠️  No question or files provided")
+            return "", history
+        
+        try:
+            print(f"\n{'='*60}")
+            print(f"🤖 Processing new question...")
+            print(f"📝 Question: {question[:100]}{'...' if len(question) > 100 else ''}")
+            print(f"📁 Files uploaded: {len(uploaded_files) if uploaded_files else 0}")
+            
+            # Handle uploaded files
+            file_context = ""
+            if uploaded_files:
+                print(f"📂 Processing {len(uploaded_files)} uploaded file(s)...")
+                file_context = self._process_uploaded_files(uploaded_files)
+                if file_context:
+                    original_question = question
+                    question = f"{question}\n\n{file_context}" if question.strip() else file_context
+                    print(f"📋 File context added to question (length: {len(file_context)} chars)")
+            
+            # Wrap the question in a HumanMessage
+            messages = [HumanMessage(content=question)]
+            print(f"🔄 Invoking agent graph...")
+            
+            # Get response from the agent
+            result = self.graph.invoke({"messages": messages})
+            print(f"📨 Received {len(result['messages'])} message(s) from agent")
+            
+            # Print all messages for debugging
+            for i, msg in enumerate(result['messages']):
+                print(f"📧 Message {i+1}: {type(msg).__name__}")
+                if hasattr(msg, 'content'):
+                    content_preview = msg.content[:200] + "..." if len(msg.content) > 200 else msg.content
+                    print(f"   Content preview: {content_preview}")
+            
+            answer = result['messages'][-1].content
+            
+            # Clean up the answer if it starts with "Assistant: "
+            if answer.startswith("Assistant: "):
+                answer = answer[11:]
+                print("🧹 Cleaned 'Assistant: ' prefix from response")
+            
+            # Update conversation history
+            history.append((question, answer))
+            print(f"✅ Question processed successfully")
+            print(f"📊 Response length: {len(answer)} characters")
+            print(f"💬 Total conversation history: {len(history)} exchanges")
+            print(f"{'='*60}\n")
+            
+            return "", history
+            
+        except Exception as e:
+            error_msg = f"Error processing question: {str(e)}"
+            print(f"❌ {error_msg}")
+            print(f"🔍 Exception details: {type(e).__name__}: {str(e)}")
+            import traceback
+            print(f"📋 Traceback:\n{traceback.format_exc()}")
+            history.append((question, error_msg))
+            print(f"{'='*60}\n")
+            return "", history
+    
+    def _process_uploaded_files(self, uploaded_files: List) -> str:
+        """Process uploaded files and return context for the question."""
+        file_contexts = []
+        
+        for file_path in uploaded_files:
+            if not file_path or not os.path.exists(file_path):
+                print(f"⚠️  Skipping invalid file path: {file_path}")
+                continue
+                
+            try:
+                file_name = os.path.basename(file_path)
+                file_ext = os.path.splitext(file_name)[1].lower()
+                file_size = os.path.getsize(file_path)
+                
+                print(f"📄 Processing file: {file_name} ({file_size} bytes, {file_ext})")
+                
+                # Handle different file types
+                if file_ext in ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.webp']:
+                    # Image file - convert to base64
+                    with open(file_path, 'rb') as f:
+                        image_data = base64.b64encode(f.read()).decode('utf-8')
+                    file_contexts.append(f"[UPLOADED IMAGE: {file_name}] - Base64 data: {image_data}")
+                    print(f"🖼️  Image converted to base64 ({len(image_data)} chars)")
+                    
+                elif file_ext in ['.txt', '.md', '.py', '.js', '.html', '.css', '.json', '.xml']:
+                    # Text file - read content
+                    with open(file_path, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                    file_contexts.append(f"[UPLOADED TEXT FILE: {file_name}]\nContent:\n{content}")
+                    print(f"📝 Text file content read ({len(content)} chars)")
+                    
+                elif file_ext in ['.csv']:
+                    # CSV file - provide file path for analysis
+                    file_contexts.append(f"[UPLOADED CSV FILE: {file_name}] - File path: {file_path}")
+                    print(f"📊 CSV file prepared for analysis")
+                    
+                elif file_ext in ['.xlsx', '.xls']:
+                    # Excel file - provide file path for analysis
+                    file_contexts.append(f"[UPLOADED EXCEL FILE: {file_name}] - File path: {file_path}")
+                    print(f"📈 Excel file prepared for analysis")
+                    
+                elif file_ext in ['.pdf']:
+                    # PDF file - mention it's available
+                    file_contexts.append(f"[UPLOADED PDF FILE: {file_name}] - File path: {file_path}")
+                    print(f"📄 PDF file prepared for processing")
+                    
+                else:
+                    # Other file types - just mention the file
+                    file_contexts.append(f"[UPLOADED FILE: {file_name}] - File path: {file_path}")
+                    print(f"📁 Generic file prepared for processing")
+                    
+            except Exception as e:
+                error_msg = f"Error processing file {file_path}: {e}"
+                print(f"❌ {error_msg}")
+                print(f"🔍 File processing error details: {type(e).__name__}: {str(e)}")
+                file_contexts.append(f"[ERROR PROCESSING FILE: {os.path.basename(file_path)}] - {str(e)}")
+        
+        total_context = "\n\n".join(file_contexts) if file_contexts else ""
+        if total_context:
+            print(f"📋 Total file context generated: {len(total_context)} characters")
+        
+        return total_context
+    
+    def clear_history(self):
+        """Clear the conversation history."""
+        print("🧹 Clearing conversation history...")
+        self.conversation_history = []
+        print("✅ Conversation history cleared")
+        return []
+
+def create_qna_interface():
+    """Create the Q&A chatbot interface."""
+    
+    print("🚀 Creating Q&A interface...")
+    # Initialize the chatbot
+    chatbot = QnAChatbot()
+    print("🎨 Setting up UI components...")
+    
+    # Enhanced Custom CSS for modern, professional styling
+    custom_css = """
+    /* Import Google Fonts */
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&family=JetBrains+Mono:wght@400;500&display=swap');
+    
+    /* CSS Variables for Theme Support */
+    :root {
+        --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        --secondary-gradient: linear-gradient(135deg, #f093fb 0%, #f5576c 100%);
+        --success-gradient: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%);
+        --warning-gradient: linear-gradient(135deg, #43e97b 0%, #38f9d7 100%);
+        --glass-bg: rgba(255, 255, 255, 0.95);
+        --glass-border: rgba(255, 255, 255, 0.2);
+        --text-primary: #2d3748;
+        --text-secondary: #4a5568;
+        --text-light: #718096;
+        --bg-light: #f7fafc;
+        --bg-card: #ffffff;
+        --shadow-sm: 0 2px 10px rgba(0, 0, 0, 0.05);
+        --shadow-md: 0 10px 30px rgba(0, 0, 0, 0.1);
+        --shadow-lg: 0 20px 40px rgba(0, 0, 0, 0.15);
+        --border-radius: 12px;
+        --border-radius-lg: 20px;
+        --transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+    }
+    
+    /* Global Styles */
+    * {
+        font-family: 'Inter', sans-serif !important;
+        box-sizing: border-box !important;
+    }
+    
+    /* Main Container with Enhanced Background */
+    .gradio-container {
+        max-width: 1400px !important;
+        margin: 0 auto !important;
+        background: 
+            radial-gradient(circle at 20% 50%, rgba(120, 119, 198, 0.3), transparent 50%),
+            radial-gradient(circle at 80% 20%, rgba(255, 119, 198, 0.3), transparent 50%),
+            radial-gradient(circle at 40% 80%, rgba(120, 219, 255, 0.3), transparent 50%),
+            var(--primary-gradient) !important;
+        min-height: 100vh !important;
+        padding: 20px !important;
+        position: relative !important;
+        overflow-x: hidden !important;
+    }
+    
+    /* Animated Background Particles */
+    .gradio-container::before {
+        content: '' !important;
+        position: fixed !important;
+        top: 0 !important;
+        left: 0 !important;
+        width: 100% !important;
+        height: 100% !important;
+        background: url("data:image/svg+xml,%3Csvg width='60' height='60' viewBox='0 0 60 60' xmlns='http://www.w3.org/2000/svg'%3E%3Cg fill='none' fill-rule='evenodd'%3E%3Cg fill='%23ffffff' fill-opacity='0.05'%3E%3Ccircle cx='7' cy='7' r='1'/%3E%3Ccircle cx='53' cy='7' r='1'/%3E%3Ccircle cx='7' cy='53' r='1'/%3E%3Ccircle cx='53' cy='53' r='1'/%3E%3C/g%3E%3C/g%3E%3C/svg%3E") !important;
+        animation: float 20s ease-in-out infinite !important;
+        pointer-events: none !important;
+        z-index: 0 !important;
+    }
+    
+    /* Main Content Area with Glass Effect */
+    .main-content {
+        background: var(--glass-bg) !important;
+        backdrop-filter: blur(20px) !important;
+        -webkit-backdrop-filter: blur(20px) !important;
+        border-radius: var(--border-radius-lg) !important;
+        box-shadow: 
+            var(--shadow-lg),
+            inset 0 1px 0 var(--glass-border) !important;
+        padding: 40px !important;
+        margin: 20px 0 !important;
+        position: relative !important;
+        z-index: 1 !important;
+        border: 1px solid var(--glass-border) !important;
+        transition: var(--transition) !important;
+    }
+    
+    .main-content:hover {
+        transform: translateY(-2px) !important;
+        box-shadow: 
+            0 25px 50px rgba(0, 0, 0, 0.15),
+            inset 0 1px 0 var(--glass-border) !important;
+    }
+    
+    /* Enhanced Header with Animations */
+    .markdown h1 {
+        background: var(--primary-gradient) !important;
+        -webkit-background-clip: text !important;
+        -webkit-text-fill-color: transparent !important;
+        background-clip: text !important;
+        font-size: 3rem !important;
+        font-weight: 800 !important;
+        text-align: center !important;
+        margin-bottom: 1.5rem !important;
+        position: relative !important;
+        animation: titleGlow 3s ease-in-out infinite alternate !important;
+    }
+    
+    .markdown h1::after {
+        content: '' !important;
+        position: absolute !important;
+        bottom: -10px !important;
+        left: 50% !important;
+        transform: translateX(-50%) !important;
+        width: 100px !important;
+        height: 4px !important;
+        background: var(--primary-gradient) !important;
+        border-radius: 2px !important;
+        animation: pulse 2s ease-in-out infinite !important;
+    }
+    
+    /* Enhanced Chat Interface */
+    .chatbot {
+        border: none !important;
+        border-radius: var(--border-radius) !important;
+        box-shadow: var(--shadow-md) !important;
+        background: var(--bg-card) !important;
+        overflow: hidden !important;
+        position: relative !important;
+    }
+    
+    /* Chat Messages with Better Styling */
+    .chatbot .message-wrap {
+        padding: 20px !important;
+        margin: 15px !important;
+        border-radius: 18px !important;
+        max-width: 85% !important;
+        animation: messageSlideIn 0.5s cubic-bezier(0.4, 0, 0.2, 1) !important;
+        position: relative !important;
+        word-wrap: break-word !important;
+    }
+    
+    .chatbot .message.user {
+        background: var(--primary-gradient) !important;
+        color: white !important;
+        margin-left: auto !important;
+        margin-right: 15px !important;
+        box-shadow: 0 8px 25px rgba(102, 126, 234, 0.4) !important;
+        border-bottom-right-radius: 5px !important;
+    }
+    
+    .chatbot .message.user::before {
+        content: '🧑‍💻' !important;
+        position: absolute !important;
+        top: -25px !important;
+        right: 10px !important;
+        font-size: 16px !important;
+        background: var(--bg-card) !important;
+        padding: 5px 8px !important;
+        border-radius: 20px !important;
+        box-shadow: var(--shadow-sm) !important;
+    }
+    
+    .chatbot .message.bot {
+        background: linear-gradient(135deg, #f8f9ff 0%, #e8eeff 100%) !important;
+        color: var(--text-primary) !important;
+        margin-right: auto !important;
+        margin-left: 15px !important;
+        border: 1px solid #e2e8f0 !important;
+        box-shadow: var(--shadow-sm) !important;
+        border-bottom-left-radius: 5px !important;
+    }
+    
+    .chatbot .message.bot::before {
+        content: '🤖' !important;
+        position: absolute !important;
+        top: -25px !important;
+        left: 10px !important;
+        font-size: 16px !important;
+        background: var(--bg-card) !important;
+        padding: 5px 8px !important;
+        border-radius: 20px !important;
+        box-shadow: var(--shadow-sm) !important;
+    }
+    
+    /* Typing Indicator */
+    .typing-indicator {
+        display: flex !important;
+        align-items: center !important;
+        padding: 15px 20px !important;
+        margin: 15px !important;
+        background: linear-gradient(135deg, #f8f9ff 0%, #e8eeff 100%) !important;
+        border-radius: 18px !important;
+        max-width: 85% !important;
+        margin-right: auto !important;
+        margin-left: 15px !important;
+        border: 1px solid #e2e8f0 !important;
+        animation: messageSlideIn 0.5s cubic-bezier(0.4, 0, 0.2, 1) !important;
+    }
+    
+    .typing-dots {
+        display: flex !important;
+        align-items: center !important;
+        gap: 4px !important;
+    }
+    
+    .typing-dots span {
+        width: 8px !important;
+        height: 8px !important;
+        border-radius: 50% !important;
+        background: var(--text-light) !important;
+        animation: typingDots 1.4s ease-in-out infinite both !important;
+    }
+    
+    .typing-dots span:nth-child(1) { animation-delay: -0.32s !important; }
+    .typing-dots span:nth-child(2) { animation-delay: -0.16s !important; }
+    .typing-dots span:nth-child(3) { animation-delay: 0s !important; }
+    
+    /* Enhanced Input Areas */
+    .textbox input, .textbox textarea {
+        border: 2px solid #e2e8f0 !important;
+        border-radius: var(--border-radius) !important;
+        padding: 18px 24px !important;
+        font-size: 16px !important;
+        line-height: 1.5 !important;
+        transition: var(--transition) !important;
+        background: var(--bg-card) !important;
+        box-shadow: var(--shadow-sm) !important;
+        font-family: 'Inter', sans-serif !important;
+    }
+    
+    .textbox input:focus, .textbox textarea:focus {
+        border-color: #667eea !important;
+        box-shadow: 
+            0 0 0 4px rgba(102, 126, 234, 0.1),
+            var(--shadow-md) !important;
+        outline: none !important;
+        transform: translateY(-1px) !important;
+        background: #ffffff !important;
+    }
+    
+    /* Enhanced Buttons with Micro-interactions */
+    .btn {
+        border-radius: var(--border-radius) !important;
+        font-weight: 600 !important;
+        text-transform: none !important;
+        letter-spacing: 0.3px !important;
+        transition: var(--transition) !important;
+        border: none !important;
+        box-shadow: var(--shadow-sm) !important;
+        padding: 14px 28px !important;
+        font-size: 16px !important;
+        position: relative !important;
+        overflow: hidden !important;
+        cursor: pointer !important;
+    }
+    
+    .btn::before {
+        content: '' !important;
+        position: absolute !important;
+        top: 0 !important;
+        left: -100% !important;
+        width: 100% !important;
+        height: 100% !important;
+        background: linear-gradient(90deg, transparent, rgba(255,255,255,0.3), transparent) !important;
+        transition: left 0.5s !important;
+    }
+    
+    .btn:hover::before {
+        left: 100% !important;
+    }
+    
+    .btn-primary {
+        background: var(--primary-gradient) !important;
+        color: white !important;
+        box-shadow: 0 8px 25px rgba(102, 126, 234, 0.3) !important;
+    }
+    
+    .btn-primary:hover {
+        transform: translateY(-3px) scale(1.02) !important;
+        box-shadow: 0 12px 35px rgba(102, 126, 234, 0.4) !important;
+    }
+    
+    .btn-primary:active {
+        transform: translateY(-1px) scale(0.98) !important;
+    }
+    
+    .btn-secondary {
+        background: linear-gradient(135deg, #f7fafc 0%, #edf2f7 100%) !important;
+        color: var(--text-secondary) !important;
+        border: 1px solid #e2e8f0 !important;
+    }
+    
+    .btn-secondary:hover {
+        transform: translateY(-2px) !important;
+        background: linear-gradient(135deg, #edf2f7 0%, #e2e8f0 100%) !important;
+        box-shadow: var(--shadow-md) !important;
+    }
+    
+    /* Enhanced File Upload with Drag & Drop Animation */
+    .file-upload {
+        border: 3px dashed #cbd5e0 !important;
+        border-radius: var(--border-radius) !important;
+        background: linear-gradient(135deg, #f7fafc 0%, #edf2f7 100%) !important;
+        padding: 40px !important;
+        text-align: center !important;
+        transition: var(--transition) !important;
+        position: relative !important;
+        overflow: hidden !important;
+        cursor: pointer !important;
+    }
+    
+    .file-upload:hover {
+        border-color: #667eea !important;
+        background: linear-gradient(135deg, #edf2f7 0%, #e2e8f0 100%) !important;
+        transform: translateY(-2px) scale(1.01) !important;
+        box-shadow: var(--shadow-md) !important;
+    }
+    
+    .file-upload::before {
+        content: '📁' !important;
+        font-size: 4rem !important;
+        display: block !important;
+        margin-bottom: 15px !important;
+        animation: fileFloat 3s ease-in-out infinite !important;
+    }
+    
+    .file-upload::after {
+        content: 'Drag files here or click to browse' !important;
+        position: absolute !important;
+        bottom: 15px !important;
+        left: 50% !important;
+        transform: translateX(-50%) !important;
+        font-size: 14px !important;
+        color: var(--text-light) !important;
+        font-weight: 500 !important;
+    }
+    
+    /* Enhanced Examples Section */
+    .examples {
+        background: linear-gradient(135deg, #f8f9ff 0%, #e8eeff 100%) !important;
+        border-radius: var(--border-radius) !important;
+        padding: 30px !important;
+        margin: 25px 0 !important;
+        border: 1px solid #e2e8f0 !important;
+        box-shadow: var(--shadow-sm) !important;
+        position: relative !important;
+    }
+    
+    .examples::before {
+        content: '💡' !important;
+        position: absolute !important;
+        top: -15px !important;
+        left: 30px !important;
+        background: var(--bg-card) !important;
+        padding: 10px !important;
+        border-radius: 50% !important;
+        font-size: 20px !important;
+        box-shadow: var(--shadow-sm) !important;
+    }
+    
+    .examples h3 {
+        color: #667eea !important;
+        font-weight: 700 !important;
+        margin-bottom: 20px !important;
+        font-size: 1.3rem !important;
+        margin-left: 20px !important;
+    }
+    
+    /* Feature Cards with Hover Effects */
+    .feature-card {
+        background: var(--bg-card) !important;
+        border-radius: var(--border-radius) !important;
+        padding: 25px !important;
+        margin: 15px 0 !important;
+        box-shadow: var(--shadow-sm) !important;
+        border-left: 4px solid transparent !important;
+        transition: var(--transition) !important;
+        cursor: pointer !important;
+    }
+    
+    .feature-card:hover {
+        transform: translateY(-5px) translateX(5px) !important;
+        box-shadow: var(--shadow-md) !important;
+    }
+    
+    .feature-card.research {
+        border-left-color: #667eea !important;
+    }
+    
+    .feature-card.code {
+        border-left-color: #48bb78 !important;
+    }
+    
+    .feature-card.data {
+        border-left-color: #ed8936 !important;
+    }
+    
+    .feature-card.image {
+        border-left-color: #dd6b20 !important;
+    }
+    
+    /* Status Indicator with Pulse Animation */
+    .status-indicator {
+        display: inline-block !important;
+        width: 12px !important;
+        height: 12px !important;
+        border-radius: 50% !important;
+        background: radial-gradient(circle, #48bb78, #38a169) !important;
+        margin-right: 12px !important;
+        animation: statusPulse 2s ease-in-out infinite !important;
+        box-shadow: 0 0 0 0 rgba(72, 187, 120, 0.7) !important;
+    }
+    
+    /* Enhanced Footer */
+    .footer {
+        background: var(--glass-bg) !important;
+        backdrop-filter: blur(10px) !important;
+        border-radius: var(--border-radius) !important;
+        padding: 30px !important;
+        margin-top: 40px !important;
+        text-align: center !important;
+        border: 1px solid var(--glass-border) !important;
+        box-shadow: var(--shadow-sm) !important;
+    }
+    
+    /* Advanced Animations */
+    @keyframes titleGlow {
+        0%, 100% { text-shadow: 0 0 20px rgba(102, 126, 234, 0.5); }
+        50% { text-shadow: 0 0 30px rgba(102, 126, 234, 0.8), 0 0 40px rgba(118, 75, 162, 0.6); }
+    }
+    
+    @keyframes messageSlideIn {
+        from {
+            opacity: 0;
+            transform: translateY(30px) scale(0.95);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0) scale(1);
+        }
+    }
+    
+    @keyframes typingDots {
+        0%, 80%, 100% { transform: scale(0.8); opacity: 0.5; }
+        40% { transform: scale(1.2); opacity: 1; }
+    }
+    
+    @keyframes fileFloat {
+        0%, 100% { transform: translateY(0px); }
+        50% { transform: translateY(-10px); }
+    }
+    
+    @keyframes statusPulse {
+        0% {
+            transform: scale(0.95);
+            box-shadow: 0 0 0 0 rgba(72, 187, 120, 0.7);
+        }
+        70% {
+            transform: scale(1);
+            box-shadow: 0 0 0 10px rgba(72, 187, 120, 0);
+        }
+        100% {
+            transform: scale(0.95);
+            box-shadow: 0 0 0 0 rgba(72, 187, 120, 0);
+        }
+    }
+    
+    @keyframes float {
+        0%, 100% { transform: translateY(0px) rotate(0deg); }
+        33% { transform: translateY(-10px) rotate(1deg); }
+        66% { transform: translateY(-5px) rotate(-1deg); }
+    }
+    
+    @keyframes pulse {
+        0%, 100% { transform: scale(1) scaleX(1); }
+        50% { transform: scale(1.05) scaleX(1.1); }
+    }
+    
+    /* Responsive Design Enhancements */
+    @media (max-width: 1024px) {
+        .gradio-container { padding: 15px !important; }
+        .main-content { padding: 25px !important; margin: 15px 0 !important; }
+        .markdown h1 { font-size: 2.5rem !important; }
+    }
+    
+    @media (max-width: 768px) {
+        .gradio-container { padding: 10px !important; }
+        .main-content { padding: 20px !important; margin: 10px 0 !important; }
+        .chatbot .message-wrap { max-width: 90% !important; margin: 10px !important; padding: 15px !important; }
+        .markdown h1 { font-size: 2rem !important; }
+        .btn { padding: 12px 20px !important; font-size: 14px !important; }
+        .file-upload { padding: 30px 20px !important; }
+    }
+    
+    @media (max-width: 480px) {
+        .markdown h1 { font-size: 1.8rem !important; }
+        .chatbot .message-wrap { margin: 8px !important; padding: 12px !important; }
+        .main-content { padding: 15px !important; }
+    }
+    
+    /* Custom Scrollbar Enhancement */
+    ::-webkit-scrollbar { width: 12px; }
+    ::-webkit-scrollbar-track { 
+        background: rgba(241, 241, 241, 0.5); 
+        border-radius: 6px; 
+    }
+    ::-webkit-scrollbar-thumb { 
+        background: var(--primary-gradient); 
+        border-radius: 6px; 
+        border: 2px solid rgba(255, 255, 255, 0.2);
+    }
+    ::-webkit-scrollbar-thumb:hover { 
+        background: linear-gradient(135deg, #5a6fd8 0%, #6a4190 100%); 
+    }
+    
+    /* Loading States */
+    .loading { animation: pulse 2s infinite !important; }
+    .processing { 
+        position: relative !important;
+        overflow: hidden !important;
+    }
+    .processing::after {
+        content: '' !important;
+        position: absolute !important;
+        top: 0 !important;
+        left: -100% !important;
+        width: 100% !important;
+        height: 100% !important;
+        background: linear-gradient(90deg, transparent, rgba(255,255,255,0.4), transparent) !important;
+        animation: shimmer 2s infinite !important;
+    }
+    
+    @keyframes shimmer {
+        0% { left: -100%; }
+        100% { left: 100%; }
+    }
+    
+    /* Dark mode support (future enhancement) */
+    @media (prefers-color-scheme: dark) {
+        :root {
+            --glass-bg: rgba(26, 32, 44, 0.95);
+            --text-primary: #e2e8f0;
+            --text-secondary: #cbd5e0;
+            --text-light: #a0aec0;
+            --bg-card: #2d3748;
+            --bg-light: #1a202c;
+        }
+    }
+    """
+    
+    with gr.Blocks(css=custom_css, title="GAIA Agent - Q&A Chatbot", theme=gr.themes.Soft()) as demo:
+        # Header with enhanced styling
+        with gr.Row(elem_classes="main-content"):
+            gr.Markdown(
+                """
+                <h1 align="center">🤖 GAIA Agent - Advanced Q&A Chatbot</h1>
+                
+                Welcome to the **GAIA Agent Q&A interface**! Ask me anything and I'll help you find the answer using my various tools and capabilities.
+                
+                ### 🌟 **What I can do:**
+                
+                <div style="display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; margin: 20px 0;">
+                    <div class="feature-card research" style="background: linear-gradient(135deg, #f8f9ff 0%, #e8eeff 100%); padding: 25px; border-radius: 12px; border-left: 4px solid #667eea; cursor: pointer; transition: all 0.3s ease;">
+                        <div style="display: flex; align-items: center; margin-bottom: 10px;">
+                            <span style="font-size: 2rem; margin-right: 15px;">🔍</span>
+                            <strong style="font-size: 1.1rem; color: #667eea;">Research & Search</strong>
+                        </div>
+                        <p style="margin: 0; color: #718096; font-size: 14px; line-height: 1.5;">Web search, Wikipedia, academic papers, arXiv research</p>
+                    </div>
+                    <div class="feature-card code" style="background: linear-gradient(135deg, #f0fff4 0%, #c6f6d5 100%); padding: 25px; border-radius: 12px; border-left: 4px solid #48bb78; cursor: pointer; transition: all 0.3s ease;">
+                        <div style="display: flex; align-items: center; margin-bottom: 10px;">
+                            <span style="font-size: 2rem; margin-right: 15px;">💻</span>
+                            <strong style="font-size: 1.1rem; color: #48bb78;">Code Execution</strong>
+                        </div>
+                        <p style="margin: 0; color: #718096; font-size: 14px; line-height: 1.5;">Python, Bash, SQL, C, Java with real-time results</p>
+                    </div>
+                    <div class="feature-card data" style="background: linear-gradient(135deg, #fffaf0 0%, #fbd38d 100%); padding: 25px; border-radius: 12px; border-left: 4px solid #ed8936; cursor: pointer; transition: all 0.3s ease;">
+                        <div style="display: flex; align-items: center; margin-bottom: 10px;">
+                            <span style="font-size: 2rem; margin-right: 15px;">📊</span>
+                            <strong style="font-size: 1.1rem; color: #ed8936;">Data Analysis</strong>
+                        </div>
+                        <p style="margin: 0; color: #718096; font-size: 14px; line-height: 1.5;">CSV, Excel, visualizations, statistical analysis</p>
+                    </div>
+                    <div class="feature-card image" style="background: linear-gradient(135deg, #fef5e7 0%, #f6ad55 100%); padding: 25px; border-radius: 12px; border-left: 4px solid #dd6b20; cursor: pointer; transition: all 0.3s ease;">
+                        <div style="display: flex; align-items: center; margin-bottom: 10px;">
+                            <span style="font-size: 2rem; margin-right: 15px;">🖼️</span>
+                            <strong style="font-size: 1.1rem; color: #dd6b20;">Image Processing</strong>
+                        </div>
+                        <p style="margin: 0; color: #718096; font-size: 14px; line-height: 1.5;">Analysis, OCR, transformations, generation</p>
+                    </div>
+                </div>
+                
+                ---
+                """
+            )
+        
+        # Chat interface with enhanced styling
+        with gr.Row(elem_classes="main-content"):
+            with gr.Column(scale=1):
+                chatbot_interface = gr.Chatbot(
+                    label="💬 Conversation",
+                    height=600,
+                    show_label=True,
+                    container=True,
+                    bubble_full_width=False,
+                    elem_classes="chatbot"
+                )
+        
+        # File upload section with enhanced styling
+        with gr.Row(elem_classes="main-content"):
+            with gr.Column():
+                file_upload = gr.File(
+                    label="📁 Upload Files - Drag & drop or click to upload images, documents, CSV, Excel files, etc.",
+                    file_count="multiple",
+                    file_types=[
+                        ".jpg", ".jpeg", ".png", ".gif", ".bmp", ".webp",  # Images
+                        ".txt", ".md", ".py", ".js", ".html", ".css", ".json", ".xml",  # Text files
+                        ".csv", ".xlsx", ".xls",  # Data files
+                        ".pdf", ".doc", ".docx"  # Documents
+                    ],
+                    height=120,
+                    elem_classes="file-upload"
+                )
+        
+        # Input and buttons with enhanced styling
+        with gr.Row(elem_classes="main-content"):
+            with gr.Column(scale=8):
+                question_input = gr.Textbox(
+                    label="💭 Ask a question",
+                    placeholder="Type your question here or upload files above... (e.g., 'What is the capital of France?', 'Analyze this image', 'Summarize this document')",
+                    lines=3,
+                    max_lines=5,
+                    elem_classes="textbox"
+                )
+            with gr.Column(scale=2, min_width=120):
+                submit_btn = gr.Button("🚀 Send", variant="primary", size="lg", elem_classes="btn btn-primary")
+        
+        with gr.Row(elem_classes="main-content"):
+            with gr.Column(scale=1):
+                clear_btn = gr.Button("🧹 Clear History", variant="secondary", elem_classes="btn btn-secondary")
+            with gr.Column(scale=1):
+                clear_files_btn = gr.Button("🗑️ Clear Files", variant="secondary", elem_classes="btn btn-secondary")
+            with gr.Column(scale=1):
+                export_btn = gr.Button("💾 Export Chat", variant="secondary", elem_classes="btn btn-secondary")
+                
+        # Hidden download component for chat export
+        download_file = gr.File(visible=False)
+            
+        with gr.Row(elem_classes="main-content"):
+            with gr.Column():
+                gr.Examples(
+                    examples=[
+                        "What is the current population of Tokyo?",
+                        "Calculate the square root of 144",
+                        "Write a Python function to sort a list",
+                        "What are the latest developments in AI?",
+                        "Explain quantum computing in simple terms",
+                    ],
+                    inputs=question_input,
+                    label="🌐 General Questions"
+                )
+            with gr.Column():
+                gr.Examples(
+                    examples=[
+                        "Search for recent papers on machine learning",
+                        "What is the weather like today?",
+                        "Create a simple bar chart using Python",
+                        "Convert 100 USD to EUR",
+                        "What are the benefits of renewable energy?",
+                    ],
+                    inputs=question_input,
+                    label="🔬 Research & Analysis"
+                )
+            with gr.Column():
+                gr.Examples(
+                    examples=[
+                        "Analyze this image and describe what you see",
+                        "Extract text from this image using OCR",
+                        "Summarize the content of this document",
+                        "Analyze the data in this CSV file",
+                        "What insights can you find in this Excel file?",
+                    ],
+                    inputs=question_input,
+                    label="📁 File Analysis"
+                )
+        
+        # Event handlers
+        def submit_question(question, history, files):
+            print(f"🎯 UI: Submit button clicked")
+            print(f"📝 UI: Question length: {len(question) if question else 0}")
+            print(f"📁 UI: Files count: {len(files) if files else 0}")
+            result_question, result_history = chatbot.process_question(question, history, files)
+            print(f"🔄 UI: Returning results and clearing files")
+            return result_question, result_history, None  # Clear files after processing
+        
+        def clear_conversation():
+            print("🧹 UI: Clear conversation button clicked")
+            return chatbot.clear_history()
+        
+        def clear_files():
+            print("🗑️  UI: Clear files button clicked")
+            return None
+            
+        def export_conversation(history):
+            """Export conversation history to a text file"""
+            print("💾 UI: Export conversation button clicked")
+            if not history:
+                print("⚠️  No conversation to export")
+                return None
+                
+            try:
+                import tempfile
+                import datetime
+                
+                # Create export content
+                timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+                export_content = f"# GAIA Agent Conversation Export\n"
+                export_content += f"Export Date: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+                export_content += f"Total Messages: {len(history)}\n\n"
+                export_content += "=" * 50 + "\n\n"
+                
+                for i, (user_msg, bot_msg) in enumerate(history, 1):
+                    export_content += f"## Message {i}\n\n"
+                    export_content += f"**User:** {user_msg}\n\n"
+                    export_content += f"**Assistant:** {bot_msg}\n\n"
+                    export_content += "-" * 30 + "\n\n"
+                
+                # Save to temporary file
+                temp_file = tempfile.NamedTemporaryFile(
+                    mode='w', 
+                    suffix=f'_gaia_chat_export_{timestamp}.md',
+                    delete=False,
+                    encoding='utf-8'
+                )
+                temp_file.write(export_content)
+                temp_file.close()
+                
+                print(f"📄 Conversation exported to: {temp_file.name}")
+                return temp_file.name
+                
+            except Exception as e:
+                print(f"❌ Error exporting conversation: {e}")
+                return None
+        
+        # Connect the events
+        submit_btn.click(
+            fn=submit_question,
+            inputs=[question_input, chatbot_interface, file_upload],
+            outputs=[question_input, chatbot_interface, file_upload],
+            show_progress=True
+        )
+        
+        question_input.submit(
+            fn=submit_question,
+            inputs=[question_input, chatbot_interface, file_upload],
+            outputs=[question_input, chatbot_interface, file_upload],
+            show_progress=True
+        )
+        
+        clear_btn.click(
+            fn=clear_conversation,
+            outputs=[chatbot_interface],
+            show_progress=False
+        )
+        
+        clear_files_btn.click(
+            fn=clear_files,
+            outputs=[file_upload],
+            show_progress=False
+        )
+        
+        export_btn.click(
+            fn=export_conversation,
+            inputs=[chatbot_interface],
+            outputs=[download_file],
+            show_progress=True
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    print("\n" + "-"*50)
+    print("🚀 Starting GAIA Agent Q&A Chatbot...")
+    print("-"*50 + "\n")
+    
+    # Create and launch the interface
+    demo = create_qna_interface()
+    demo.launch(
+        debug=True,
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True
+    ) 

code_interpreter.py

@@ -0,0 +1,281 @@
+import os
+import io
+import sys
+import uuid
+import base64
+import traceback
+import contextlib
+import tempfile
+import subprocess
+import sqlite3
+from typing import Dict, List, Any, Optional, Union
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from PIL import Image
+
+class CodeInterpreter:
+    def __init__(self, allowed_modules=None, max_execution_time=30, working_directory=None):
+        """Initialize the code interpreter with safety measures."""
+        self.allowed_modules = allowed_modules or [
+            "numpy", "pandas", "matplotlib", "scipy", "sklearn", 
+            "math", "random", "statistics", "datetime", "collections",
+            "itertools", "functools", "operator", "re", "json",
+            "sympy", "networkx", "nltk", "PIL", "pytesseract", 
+            "cmath", "uuid", "tempfile", "requests", "urllib"
+        ]
+        self.max_execution_time = max_execution_time
+        self.working_directory = working_directory or os.path.join(os.getcwd()) 
+        if not os.path.exists(self.working_directory):
+            os.makedirs(self.working_directory)
+        
+        self.globals = {
+            "__builtins__": __builtins__,
+            "np": np,
+            "pd": pd,
+            "plt": plt,
+            "Image": Image,
+        }
+        self.temp_sqlite_db = os.path.join(tempfile.gettempdir(), "code_exec.db")
+
+    def execute_code(self, code: str, language: str = "python") -> Dict[str, Any]:
+        """Execute the provided code in the selected programming language."""
+        language = language.lower()
+        execution_id = str(uuid.uuid4())
+        
+        result = {
+            "execution_id": execution_id,
+            "status": "error",
+            "stdout": "",
+            "stderr": "",
+            "result": None,
+            "plots": [],
+            "dataframes": []
+        }
+        
+        try:
+            if language == "python":
+                return self._execute_python(code, execution_id)
+            elif language == "bash":
+                return self._execute_bash(code, execution_id)
+            elif language == "sql":
+                return self._execute_sql(code, execution_id)
+            elif language == "c":
+                return self._execute_c(code, execution_id)
+            elif language == "java":
+                return self._execute_java(code, execution_id)
+            else:
+                result["stderr"] = f"Unsupported language: {language}"
+        except Exception as e:
+            result["stderr"] = str(e)
+        
+        return result
+
+    def _execute_python(self, code: str, execution_id: str) -> dict:
+        output_buffer = io.StringIO()
+        error_buffer = io.StringIO()
+        result = {
+            "execution_id": execution_id,
+            "status": "error",
+            "stdout": "",
+            "stderr": "",
+            "result": None,
+            "plots": [],
+            "dataframes": []
+        }
+        
+        try:
+            exec_dir = os.path.join(self.working_directory, execution_id)
+            os.makedirs(exec_dir, exist_ok=True)
+            plt.switch_backend('Agg')
+            
+            with contextlib.redirect_stdout(output_buffer), contextlib.redirect_stderr(error_buffer):
+                exec_result = exec(code, self.globals)
+
+                if plt.get_fignums():
+                    for i, fig_num in enumerate(plt.get_fignums()):
+                        fig = plt.figure(fig_num)
+                        img_path = os.path.join(exec_dir, f"plot_{i}.png")
+                        fig.savefig(img_path)
+                        with open(img_path, "rb") as img_file:
+                            img_data = base64.b64encode(img_file.read()).decode('utf-8')
+                            result["plots"].append({
+                                "figure_number": fig_num,
+                                "data": img_data
+                            })
+
+                for var_name, var_value in self.globals.items():
+                    if isinstance(var_value, pd.DataFrame) and len(var_value) > 0:
+                        result["dataframes"].append({
+                            "name": var_name,
+                            "head": var_value.head().to_dict(),
+                            "shape": var_value.shape,
+                            "dtypes": str(var_value.dtypes)
+                        })
+                
+            result["status"] = "success"
+            result["stdout"] = output_buffer.getvalue()
+            result["result"] = exec_result
+            
+        except Exception as e:
+            result["status"] = "error"
+            result["stderr"] = f"{error_buffer.getvalue()}\n{traceback.format_exc()}"
+        
+        return result
+
+    def _execute_bash(self, code: str, execution_id: str) -> dict:
+        try:
+            completed = subprocess.run(
+                code, shell=True, capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            return {
+                "execution_id": execution_id,
+                "status": "success" if completed.returncode == 0 else "error",
+                "stdout": completed.stdout,
+                "stderr": completed.stderr,
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+        except subprocess.TimeoutExpired:
+            return {
+                "execution_id": execution_id,
+                "status": "error",
+                "stdout": "",
+                "stderr": "Execution timed out.",
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+
+    def _execute_sql(self, code: str, execution_id: str) -> dict:
+        result = {
+            "execution_id": execution_id,
+            "status": "error",
+            "stdout": "",
+            "stderr": "",
+            "result": None,
+            "plots": [],
+            "dataframes": []
+        }
+        try:
+            conn = sqlite3.connect(self.temp_sqlite_db)
+            cur = conn.cursor()
+            cur.execute(code)
+            if code.strip().lower().startswith("select"):
+                columns = [description[0] for description in cur.description]
+                rows = cur.fetchall()
+                df = pd.DataFrame(rows, columns=columns)
+                result["dataframes"].append({
+                    "name": "query_result",
+                    "head": df.head().to_dict(),
+                    "shape": df.shape,
+                    "dtypes": str(df.dtypes)
+                })
+            else:
+                conn.commit()
+
+            result["status"] = "success"
+            result["stdout"] = "Query executed successfully."
+
+        except Exception as e:
+            result["stderr"] = str(e)
+        finally:
+            conn.close()
+
+        return result
+
+    def _execute_c(self, code: str, execution_id: str) -> dict:
+        temp_dir = tempfile.mkdtemp()
+        source_path = os.path.join(temp_dir, "program.c")
+        binary_path = os.path.join(temp_dir, "program")
+
+        try:
+            with open(source_path, "w") as f:
+                f.write(code)
+
+            compile_proc = subprocess.run(
+                ["gcc", source_path, "-o", binary_path],
+                capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            if compile_proc.returncode != 0:
+                return {
+                    "execution_id": execution_id,
+                    "status": "error",
+                    "stdout": compile_proc.stdout,
+                    "stderr": compile_proc.stderr,
+                    "result": None,
+                    "plots": [],
+                    "dataframes": []
+                }
+
+            run_proc = subprocess.run(
+                [binary_path],
+                capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            return {
+                "execution_id": execution_id,
+                "status": "success" if run_proc.returncode == 0 else "error",
+                "stdout": run_proc.stdout,
+                "stderr": run_proc.stderr,
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+        except Exception as e:
+            return {
+                "execution_id": execution_id,
+                "status": "error",
+                "stdout": "",
+                "stderr": str(e),
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+
+    def _execute_java(self, code: str, execution_id: str) -> dict:
+        temp_dir = tempfile.mkdtemp()
+        source_path = os.path.join(temp_dir, "Main.java")
+
+        try:
+            with open(source_path, "w") as f:
+                f.write(code)
+
+            compile_proc = subprocess.run(
+                ["javac", source_path],
+                capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            if compile_proc.returncode != 0:
+                return {
+                    "execution_id": execution_id,
+                    "status": "error",
+                    "stdout": compile_proc.stdout,
+                    "stderr": compile_proc.stderr,
+                    "result": None,
+                    "plots": [],
+                    "dataframes": []
+                }
+
+            run_proc = subprocess.run(
+                ["java", "-cp", temp_dir, "Main"],
+                capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            return {
+                "execution_id": execution_id,
+                "status": "success" if run_proc.returncode == 0 else "error",
+                "stdout": run_proc.stdout,
+                "stderr": run_proc.stderr,
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }
+        except Exception as e:
+            return {
+                "execution_id": execution_id,
+                "status": "error",
+                "stdout": "",
+                "stderr": str(e),
+                "result": None,
+                "plots": [],
+                "dataframes": []
+            }

evaluation_app.py

@@ -0,0 +1,211 @@
+""" Basic Agent Evaluation Runner"""
+import os
+import inspect
+import gradio as gr
+import requests
+import pandas as pd
+import time
+from langchain_core.messages import HumanMessage
+from agent import build_graph
+
+
+
+# (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:
+    """A langgraph agent."""
+    def __init__(self):
+        print("BasicAgent initialized.")
+        self.graph = build_graph()
+
+    def __call__(self, question: str) -> str:
+        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):
+    """
+    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
+
+    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:
+        agent = BasicAgent()
+    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)
+    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 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:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred 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
+        
+        time.sleep(30)
+        
+        try:
+            submitted_answer = agent(question_text)
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+        except Exception as e:
+             print(f"Error running agent on task {task_id}: {e}")
+             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+
+    if not answers_payload:
+        print("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 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:
+        status_message = f"An unexpected error occurred during submission: {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("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+        ---
+        **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")
+
+    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]
+    )
+
+if __name__ == "__main__":
+    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") # 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")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    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?). Repo URL cannot be determined.")
+
+    print("-"*(60 + len(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)

explore_metadata.ipynb

@@ -0,0 +1,332 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a600d7fc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json \n",
+    "with open('metadata.jsonl', 'r') as f: \n",
+    "    json_list = list(f)\n",
+    "\n",
+    "json_QA = []\n",
+    "for json_str in json_list: \n",
+    "    json_data = json.loads(json_str)\n",
+    "    json_QA.append(json_data)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fa5d8eb8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "==================================================\n",
+      "Task ID: d1af70ea-a9a4-421a-b9cc-94b5e02f1788\n",
+      "Question: As of the 2020 census, what was the population difference between the largest county seat and smallest county seat, by land area of the county seat, in Washington state? For population figures, please use the official data from data.census.gov. Please report the integer difference.\n",
+      "Level: 2\n",
+      "Final Answer: 736455\n",
+      "Annotator Metadata: \n",
+      "  ├── Steps: \n",
+      "  │      ├── Step 1: Using a web browser, access a search engine and conduct a search, \"Washington cities by area\"\n",
+      "  │      ├── Step 2: Navigate to the second search result, https://en.wikipedia.org/wiki/List_of_municipalities_in_Washington\n",
+      "  │      ├── Step 3: Evaluate the page contents, finding the largest and smallest county seats by land area, Seattle and Cathlamet\n",
+      "  │      ├── Step 4: Using a web browser, navigate to https://data.census.gov/\n",
+      "  │      ├── Step 5: Using the website's search area, conduct a search, Seattle, Washington\n",
+      "  │      ├── Step 6: Record the reported 2020 Decennial Census population of Seattle, Washington, 737,015\n",
+      "  │      ├── Step 7: Using the website's search area, conduct a search, Cathlamet, Washington\n",
+      "  │      ├── Step 8: Record the reported 2020 Decennial Census population of Cathlamet, Washington, 560\n",
+      "  │      ├── Step 9: Using a calculator, find the difference in populations,\n",
+      "  │      ├── \n",
+      "  │      ├── 737,015 - 560\n",
+      "  │      ├── 736,455\n",
+      "  │      ├── Step 10: Report the correct answer to my user in the requested format, \"736,455\"\n",
+      "  ├── Number of steps: 10\n",
+      "  ├── How long did this take?: 5 minutes\n",
+      "  ├── Tools:\n",
+      "  │      ├── 1. A web browser\n",
+      "  │      ├── 2. A search engine\n",
+      "  │      ├── 3. A calculator\n",
+      "  └── Number of tools: 3\n",
+      "==================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "import random\n",
+    "random_samples = random.sample(json_QA, 1)\n",
+    "for sample in random_samples:\n",
+    "    print(\"=\" * 50)\n",
+    "    print(f\"Task ID: {sample['task_id']}\")\n",
+    "    print(f\"Question: {sample['Question']}\")\n",
+    "    print(f\"Level: {sample['Level']}\")\n",
+    "    print(f\"Final Answer: {sample['Final answer']}\")\n",
+    "    print(f\"Annotator Metadata: \")\n",
+    "    print(f\"  ├── Steps: \")\n",
+    "    for step in sample['Annotator Metadata']['Steps'].split('\\n'):\n",
+    "        print(f\"  │      ├── {step}\")\n",
+    "    print(f\"  ├── Number of steps: {sample['Annotator Metadata']['Number of steps']}\")\n",
+    "    print(f\"  ├── How long did this take?: {sample['Annotator Metadata']['How long did this take?']}\")\n",
+    "    print(f\"  ├── Tools:\")\n",
+    "    for tool in sample['Annotator Metadata']['Tools'].split('\\n'):\n",
+    "        print(f\"  │      ├── {tool}\")\n",
+    "    print(f\"  └── Number of tools: {sample['Annotator Metadata']['Number of tools']}\")\n",
+    "print(\"=\" * 50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05076516",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from dotenv import load_dotenv\n",
+    "from langchain_huggingface import HuggingFaceEmbeddings\n",
+    "from langchain_community.vectorstores import SupabaseVectorStore\n",
+    "from supabase.client import Client, create_client\n",
+    "\n",
+    "\n",
+    "load_dotenv()\n",
+    "embeddings = HuggingFaceEmbeddings(model_name=\"sentence-transformers/all-mpnet-base-v2\") #  dim=768\n",
+    "\n",
+    "supabase_url = os.environ.get(\"SUPABASE_URL\")\n",
+    "supabase_key = os.environ.get(\"SUPABASE_SERVICE_ROLE_KEY\")\n",
+    "supabase: Client = create_client(supabase_url, supabase_key)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "aa1402e3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from langchain.schema import Document\n",
+    "docs = []\n",
+    "cnt = 0 \n",
+    "for sample in json_QA:\n",
+    "    content = f\"Question : {sample['Question']}\\n\\nFinal answer : {sample['Final answer']}\"\n",
+    "    doc = {\n",
+    "        \"id\" : cnt,\n",
+    "        \"content\" : content,\n",
+    "        \"metadata\" : {\n",
+    "            \"source\" : sample['task_id']\n",
+    "        },\n",
+    "        \"embedding\" : embeddings.embed_query(content),\n",
+    "    }\n",
+    "    docs.append(doc)\n",
+    "    cnt += 1\n",
+    "\n",
+    "# upload the documents to the vector database\n",
+    "try:\n",
+    "    response = (\n",
+    "        supabase.table(\"documents2\")\n",
+    "        .insert(docs)\n",
+    "        .execute()\n",
+    "    )\n",
+    "except Exception as exception:\n",
+    "    print(\"Error inserting data into Supabase:\", exception)\n",
+    "\n",
+    "# # Save the documents (a list of dict) into a csv file, and manually upload it to Supabase\n",
+    "# import pandas as pd\n",
+    "# df = pd.DataFrame(docs)\n",
+    "# df.to_csv('supabase_docs.csv',index=False)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "9aa7eb5e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# add items to vector database\n",
+    "vector_store = SupabaseVectorStore(\n",
+    "    client=supabase,\n",
+    "    embedding= embeddings,\n",
+    "    table_name=\"documents2\",\n",
+    "    query_name=\"match_documents_2\",\n",
+    ")\n",
+    "retriever = vector_store.as_retriever()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "id": "9eecafd1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "query = \"On June 6, 2023, an article by Carolyn Collins Petersen was published in Universe Today. This article mentions a team that produced a paper about their observations, linked at the bottom of the article. Find this paper. Under what NASA award number was the work performed by R. G. Arendt supported by?\"\n",
+    "# matched_docs = vector_store.similarity_search(query, k=2)\n",
+    "docs = retriever.invoke(query)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "id": "ff917840",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Document(metadata={'source': '840bfca7-4f7b-481a-8794-c560c340185d'}, page_content='Question : On June 6, 2023, an article by Carolyn Collins Petersen was published in Universe Today. This article mentions a team that produced a paper about their observations, linked at the bottom of the article. Find this paper. Under what NASA award number was the work performed by R. G. Arendt supported by?\\n\\nFinal answer : 80GSFC21M0002')"
+      ]
+     },
+     "execution_count": 43,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "docs[0]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "id": "01c8f337",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "List of tools used in all samples:\n",
+      "Total number of tools used: 83\n",
+      "  ├── web browser: 107\n",
+      "  ├── image recognition tools (to identify and parse a figure with three axes): 1\n",
+      "  ├── search engine: 101\n",
+      "  ├── calculator: 34\n",
+      "  ├── unlambda compiler (optional): 1\n",
+      "  ├── a web browser.: 2\n",
+      "  ├── a search engine.: 2\n",
+      "  ├── a calculator.: 1\n",
+      "  ├── microsoft excel: 5\n",
+      "  ├── google search: 1\n",
+      "  ├── ne: 9\n",
+      "  ├── pdf access: 7\n",
+      "  ├── file handling: 2\n",
+      "  ├── python: 3\n",
+      "  ├── image recognition tools: 12\n",
+      "  ├── jsonld file access: 1\n",
+      "  ├── video parsing: 1\n",
+      "  ├── python compiler: 1\n",
+      "  ├── video recognition tools: 3\n",
+      "  ├── pdf viewer: 7\n",
+      "  ├── microsoft excel / google sheets: 3\n",
+      "  ├── word document access: 1\n",
+      "  ├── tool to extract text from images: 1\n",
+      "  ├── a word reversal tool / script: 1\n",
+      "  ├── counter: 1\n",
+      "  ├── excel: 3\n",
+      "  ├── image recognition: 5\n",
+      "  ├── color recognition: 3\n",
+      "  ├── excel file access: 3\n",
+      "  ├── xml file access: 1\n",
+      "  ├── access to the internet archive, web.archive.org: 1\n",
+      "  ├── text processing/diff tool: 1\n",
+      "  ├── gif parsing tools: 1\n",
+      "  ├── a web browser: 7\n",
+      "  ├── a search engine: 7\n",
+      "  ├── a speech-to-text tool: 2\n",
+      "  ├── code/data analysis tools: 1\n",
+      "  ├── audio capability: 2\n",
+      "  ├── pdf reader: 1\n",
+      "  ├── markdown: 1\n",
+      "  ├── a calculator: 5\n",
+      "  ├── access to wikipedia: 3\n",
+      "  ├── image recognition/ocr: 3\n",
+      "  ├── google translate access: 1\n",
+      "  ├── ocr: 4\n",
+      "  ├── bass note data: 1\n",
+      "  ├── text editor: 1\n",
+      "  ├── xlsx file access: 1\n",
+      "  ├── powerpoint viewer: 1\n",
+      "  ├── csv file access: 1\n",
+      "  ├── calculator (or use excel): 1\n",
+      "  ├── computer algebra system: 1\n",
+      "  ├── video processing software: 1\n",
+      "  ├── audio processing software: 1\n",
+      "  ├── computer vision: 1\n",
+      "  ├── google maps: 1\n",
+      "  ├── access to excel files: 1\n",
+      "  ├── calculator (or ability to count): 1\n",
+      "  ├── a file interface: 3\n",
+      "  ├── a python ide: 1\n",
+      "  ├── spreadsheet editor: 1\n",
+      "  ├── tools required: 1\n",
+      "  ├── b browser: 1\n",
+      "  ├── image recognition and processing tools: 1\n",
+      "  ├── computer vision or ocr: 1\n",
+      "  ├── c++ compiler: 1\n",
+      "  ├── access to google maps: 1\n",
+      "  ├── youtube player: 1\n",
+      "  ├── natural language processor: 1\n",
+      "  ├── graph interaction tools: 1\n",
+      "  ├── bablyonian cuniform -> arabic legend: 1\n",
+      "  ├── access to youtube: 1\n",
+      "  ├── image search tools: 1\n",
+      "  ├── calculator or counting function: 1\n",
+      "  ├── a speech-to-text audio processing tool: 1\n",
+      "  ├── access to academic journal websites: 1\n",
+      "  ├── pdf reader/extracter: 1\n",
+      "  ├── rubik's cube model: 1\n",
+      "  ├── wikipedia: 1\n",
+      "  ├── video capability: 1\n",
+      "  ├── image processing tools: 1\n",
+      "  ├── age recognition software: 1\n",
+      "  ├── youtube: 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# list of the tools used in all the samples\n",
+    "from collections import Counter, OrderedDict\n",
+    "\n",
+    "tools = []\n",
+    "for sample in json_QA:\n",
+    "    for tool in sample['Annotator Metadata']['Tools'].split('\\n'):\n",
+    "        tool = tool[2:].strip().lower()\n",
+    "        if tool.startswith(\"(\"):\n",
+    "            tool = tool[11:].strip()\n",
+    "        tools.append(tool)\n",
+    "tools_counter = OrderedDict(Counter(tools))\n",
+    "print(\"List of tools used in all samples:\")\n",
+    "print(\"Total number of tools used:\", len(tools_counter))\n",
+    "for tool, count in tools_counter.items():\n",
+    "    print(f\"  ├── {tool}: {count}\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "env",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

image_processing.py

@@ -0,0 +1,26 @@
+import os
+import io
+import base64
+import uuid
+from PIL import Image
+
+# Helper functions for image processing
+def encode_image(image_path: str) -> str:
+    """Convert an image file to base64 string."""
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode("utf-8")
+
+
+def decode_image(base64_string: str) -> Image.Image:
+    """Convert a base64 string to a PIL Image."""
+    image_data = base64.b64decode(base64_string)
+    return Image.open(io.BytesIO(image_data))
+
+
+def save_image(image: Image.Image, directory: str = "image_outputs") -> str:
+    """Save a PIL Image to disk and return the path."""
+    os.makedirs(directory, exist_ok=True)
+    image_id = str(uuid.uuid4())
+    image_path = os.path.join(directory, f"{image_id}.png")
+    image.save(image_path)
+    return image_path

requirements.txt

@@ -0,0 +1,21 @@
+gradio
+requests
+langchain
+langchain-community
+langchain-core
+langchain-google-genai
+langchain-huggingface
+langchain-groq
+langchain-tavily
+langchain-chroma
+langgraph
+huggingface_hub
+supabase
+arxiv
+pymupdf
+wikipedia
+pgvector
+python-dotenv
+pytesseract
+matplotlib
+sentence_transformers

system_prompt.txt

@@ -0,0 +1,5 @@
+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. 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 rules above for each element (number or string), ensure there is exactly one space after each comma.
+Your answer should only start with "FINAL ANSWER: ", then follows with the answer.