gaia app commit

.gitignore

@@ -0,0 +1,52 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environments
+hf_assignment/
+venv/
+env/
+ENV/
+.env
+.venv/
+
+# Environment Variables
+.env
+
+# MacOS
+.DS_Store
+
+# Editor directories and files
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Project specific
+image_outputs/
+*.db
+*.log

README.md

@@ -1,18 +1,263 @@
----
-title: First Agent Template
-emoji: ⚡
-colorFrom: pink
-colorTo: yellow
+title: LeVinh's Final Assignment
+emoji: 🕵🏻‍♂️
+colorFrom: indigo
+colorTo: indigo
 sdk: gradio
-sdk_version: 5.23.1
+sdk_version: 5.0.0
 app_file: app.py
 pinned: false
-tags:
-- smolagents
-- agent
-- smolagent
-- tool
-- agent-course
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤖 **GAIA Agent - Advanced Q&A Chatbot**
+
+## 🌟 **Introduction**
+
+**GAIA Agent** is a sophisticated AI-powered chatbot system designed to handle complex questions and tasks through an intuitive Q&A interface. Built on top of the GAIA benchmark framework, this agent combines advanced reasoning, code execution, web search, document processing, and multimodal understanding capabilities. The system features both a Gradio interface (for auto-grading submission) and a modern React-based UI with FastAPI backend.
+
+## 🚀 **Key Features**
+
+- **🔍 Multi-Modal Search**: Web search, Wikipedia, and arXiv paper search
+- **💻 Code Execution**: Support for Python, Bash, SQL, C, and Java
+- **🖼️ Image Processing**: Analysis, transformation, OCR, and generation
+- **📄 Document Processing**: PDF, CSV, Excel, and text file analysis
+- **📁 File Upload Support**: Handle multiple file types with drag-and-drop
+- **🧮 Mathematical Operations**: Complete set of mathematical tools
+- **💬 Conversational Interface**: Natural chat-based interaction
+- **📊 Evaluation System**: Automated benchmark testing and submission
+
+## 🏗️ **Project Structure**
+
+```
+gaia-agent/
+├── app.py                    # Gradio interface (for auto-grading)
+├── server.py                 # FastAPI backend (alternative interface)
+├── index.html                # React frontend HTML
+├── app.js                    # React application (UI)
+├── logic.py                  # Backend logic wrapper
+├── agent.py                  # Core agent implementation with tools
+├── code_interpreter.py       # Multi-language code execution
+├── img_processing.py         # Image processing utilities
+├── eval.py                   # GAIA benchmark evaluation runner
+├── system_prompt.txt         # System prompt for the agent
+├── requirements.txt          # Python dependencies
+├── metadata.jsonl            # GAIA benchmark metadata
+└── README.md                 # This file
+```
+
+## 🛠️ **Tool Categories**
+
+### **🌐 Browser & Search Tools**
+- **Wikipedia Search**: Search Wikipedia with up to 2 results
+- **Web Search**: Tavily-powered web search with up to 3 results  
+- **arXiv Search**: Academic paper search with up to 3 results
+
+### **💻 Code Interpreter Tools**
+- **Multi-Language Execution**: Python, Bash, SQL, C, Java supported
+- **Plot Generation**: Matplotlib visualization support
+- **DataFrame Analysis**: Pandas data processing
+- **Error Handling**: Comprehensive error reporting
+
+### **🧮 Mathematical Tools**
+- **Basic Operations**: Add, subtract, multiply, divide
+- **Advanced Functions**: Modulus, power, square root
+- **Complex Numbers**: Support for complex number operations
+
+### **📄 Document Processing Tools**
+- **File Operations**: Save, read, and download files
+- **CSV Analysis**: Pandas-based data analysis
+- **Excel Processing**: Excel file analysis and processing
+- **OCR**: Extract text from images using Tesseract
+
+### **🖼️ Image Processing & Generation Tools**
+- **Image Analysis**: Size, color, and property analysis
+- **Transformations**: Resize, rotate, crop, flip, adjust brightness/contrast
+- **Drawing Tools**: Add shapes, text, and annotations
+- **Image Generation**: Create gradients, noise patterns, and simple graphics
+- **Image Combination**: Stack and combine multiple images
+
+## 🎯 **How to Use**
+
+### **Gradio Interface (For Auto-Grading)**
+
+1. **Start the Application:**
+   ```bash
+   python app.py
+   ```
+
+2. **Access the Interface:**
+   - Open `http://localhost:7860` in your browser
+   - Ask questions in the text input
+   - Upload files using the file upload widget
+   - View responses in the chat interface
+
+### **FastAPI + React Interface (Alternative)**
+
+1. **Start the Server:**
+   ```bash
+   python server.py
+   # or
+   uvicorn server:app --host 0.0.0.0 --port 7860 --reload
+   ```
+
+2. **Access the Interface:**
+   - Open `http://localhost:7860` in your browser
+   - Modern React-based UI with dark theme
+   - Upload files by clicking the paperclip icon
+   - Export chat history as JSON
+   - Create new chat sessions as needed
+
+### **Supported Interactions (Both Interfaces)**
+- **Text Questions**: "What is the capital of France?"
+- **Math Problems**: "Calculate the square root of 144"
+- **Code Requests**: "Write a Python function to sort a list"
+- **Image Analysis**: Upload an image and ask "What do you see?"
+- **Data Analysis**: Upload a CSV and ask "What are the trends?"
+- **Web Search**: "What are the latest AI developments?"
+
+### **Evaluation Runner**
+
+1. **Run the Evaluation:**
+   ```bash
+   python eval.py
+   ```
+
+2. **Benchmark Testing:**
+   - Processes GAIA benchmark questions
+   - View results and scores automatically
+
+## 🔧 **Technical Architecture**
+
+### **Backend Stack**
+- **FastAPI**: High-performance async web server
+- **LangGraph**: State machine for agent workflow
+- **LangChain**: Tool integration and LLM orchestration
+- **Groq**: Fast inference with llama-3.1-70b-versatile
+
+### **Frontend Stack**
+- **React 18**: Component-based UI
+- **Tailwind CSS**: Utility-first styling
+- **Babel Standalone**: Browser-based JSX compilation
+- **No Build Required**: Direct browser execution
+
+### **LangGraph State Machine**
+```
+START → Retriever → Assistant → Tools → Assistant
+                     ↑              ↓
+                     └──────────────┘
+```
+
+1. **Retriever Node**: Searches vector database for similar questions
+2. **Assistant Node**: LLM processes question with available tools
+3. **Tools Node**: Executes selected tools (web search, code, etc.)
+4. **Conditional Routing**: Dynamically routes between assistant and tools
+
+### **Vector Database Integration**
+- **Supabase Vector Store**: Stores GAIA benchmark Q&A pairs
+- **Semantic Search**: Finds similar questions for context
+- **HuggingFace Embeddings**: sentence-transformers/all-mpnet-base-v2
+
+### **Multi-Modal File Support**
+- **Images**: JPG, PNG, GIF, BMP, WebP
+- **Documents**: PDF, DOC, DOCX, TXT, MD
+- **Data**: CSV, Excel, JSON
+- **Code**: Python, Bash, SQL, C, Java
+
+## ⚙️ **Installation & Setup**
+
+### **1. Clone Repository**
+```bash
+git clone ...
+cd gaia-agent
+```
+
+### **2. Install Dependencies**
+```bash
+pip install -r requirements.txt
+```
+
+### **3. Environment Variables**
+Create a `.env` file with your API keys:
+```env
+SUPABASE_URL=your_supabase_url
+SUPABASE_SERVICE_ROLE_KEY=your_supabase_key
+GROQ_API_KEY=your_groq_api_key
+TAVILY_API_KEY=your_tavily_api_key
+HUGGINGFACEHUB_API_TOKEN=your_hf_token
+LANGSMITH_API_KEY=your_langsmith_key
+
+LANGSMITH_TRACING=true
+LANGSMITH_PROJECT=ai_agent_course
+LANGSMITH_ENDPOINT=https://api.smith.langchain.com
+```
+
+### **4. Database Setup (Supabase)**
+Execute this SQL in your Supabase database:
+```sql
+-- Enable pgvector extension
+CREATE EXTENSION IF NOT EXISTS vector;
+
+-- Create match function for documents2 table
+CREATE OR REPLACE FUNCTION public.match_documents_2(
+  query_embedding vector(768)
+)
+RETURNS TABLE(
+  id         bigint,
+  content    text,
+  metadata   jsonb,
+  embedding  vector(768),
+  similarity double precision
+)
+LANGUAGE sql STABLE
+AS $$
+  SELECT
+    id,
+    content,
+    metadata,
+    embedding,
+    1 - (embedding <=> query_embedding) AS similarity
+  FROM public.documents2
+  ORDER BY embedding <=> query_embedding
+  LIMIT 10;
+$$;
+
+-- Grant permissions
+GRANT EXECUTE ON FUNCTION public.match_documents_2(vector) TO anon, authenticated;
+```
+
+## 🚀 **Running the Application**
+
+### **Main Application (Gradio - For Submission)**
+```bash
+python app.py
+```
+Access at: `http://localhost:7860`
+
+### **Alternative Interface (FastAPI + React)**
+```bash
+python server.py
+```
+Access at: `http://localhost:7860`
+
+### **Evaluation**
+```bash
+python eval.py
+```
+
+## 🔗 **Resources**
+
+- [GAIA Benchmark](https://huggingface.co/spaces/gaia-benchmark/leaderboard)
+- [Hugging Face Agents Course](https://huggingface.co/agents-course)
+- [LangGraph Documentation](https://langchain-ai.github.io/langgraph/)
+- [Supabase Vector Store](https://supabase.com/docs/guides/ai/vector-columns)
+
+## 🤝 **Contributing**
+
+Contributions are welcome! Areas for improvement:
+- **New Tools**: Add specialized tools for specific domains
+- **UI Enhancements**: Improve the chatbot interface
+- **Performance**: Optimize response times and accuracy
+- **Documentation**: Expand examples and use cases
+
+## 📄 **License**
+
+This project is licensed under the [MIT License](https://mit-license.org/).

agent.py

@@ -0,0 +1,780 @@
+import os
+import tempfile
+import re
+import json
+import requests
+import cmath
+import uuid
+import numpy as np
+import pandas as pd
+from typing import List, Dict, Any, Optional
+from urllib.parse import urlparse
+import pytesseract
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance, ImageFilter
+from dotenv import load_dotenv
+
+# LangChain / LangGraph imports
+from langgraph.graph import START, StateGraph, MessagesState
+from langgraph.prebuilt import ToolNode, tools_condition
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
+from langchain_community.vectorstores import SupabaseVectorStore
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_groq import ChatGroq
+from langchain_huggingface import (
+    ChatHuggingFace,
+    HuggingFaceEndpoint,
+    HuggingFaceEmbeddings,
+)
+from langchain_core.messages import SystemMessage, HumanMessage
+from langchain_core.tools import tool, Tool
+from supabase.client import Client, create_client
+
+# Local imports
+from code_interpreter import CodeInterpreter
+from img_processing import decode_image, encode_image, save_image
+
+load_dotenv()
+
+interpreter_instance = CodeInterpreter()
+
+### BROWSER TOOLS
+
+@tool
+def wiki_search(query: str) -> str:
+    """
+    Search Wikipedia for a query and return maximum 2 results.
+
+    Args:
+        query (str): The search query.
+    
+    Returns:
+        str: Formatted search results.
+    """
+    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 (str): The search query.
+        
+    Returns:
+        str: Formatted search results.
+    """
+    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 (str): The search query.
+        
+    Returns:
+        str: Formatted search results.
+    """
+    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:
+        str: A string summarizing the execution results.
+    """
+    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:
+    """Multiply two numbers."""
+    return a * b
+
+
+@tool
+def add(a: float, b: float) -> float:
+    """Add two numbers."""
+    return a + b
+
+
+@tool
+def subtract(a: float, b: float) -> float:
+    """Subtract two numbers."""
+    return a - b
+
+
+@tool
+def divide(a: float, b: float) -> float:
+    """Divide two numbers."""
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+
+@tool
+def modulus(a: int, b: int) -> int:
+    """Get the modulus of two numbers."""
+    return a % b
+
+
+@tool
+def power(a: float, b: float) -> float:
+    """Get the power of two numbers."""
+    return a**b
+
+
+@tool
+def square_root(a: float) -> float | complex:
+    """Get the square root of a number."""
+    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.
+        filename (str, optional): The name of the file.
+        
+    Returns:
+        str: Success message with file path.
+    """
+    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.
+
+    Args:
+        url (str): The URL of the file.
+        filename (str, optional): The name of the file.
+        
+    Returns:
+        str: Success message with file path or error message.
+    """
+    try:
+        if not filename:
+            path = urlparse(url).path
+            filename = os.path.basename(path)
+            if not filename:
+                filename = f"downloaded_{uuid.uuid4().hex[:8]}"
+
+        temp_dir = tempfile.gettempdir()
+        filepath = os.path.join(temp_dir, filename)
+
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+
+        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.
+
+    Args:
+        image_path (str): The path to the image file.
+        
+    Returns:
+        str: Extracted text or error message.
+    """
+    try:
+        image = Image.open(image_path)
+        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.
+
+    Args:
+        file_path (str): The path to the CSV file.
+        query (str): Question about the data.
+        
+    Returns:
+        str: Analysis result or error message.
+    """
+    try:
+        df = pd.read_csv(file_path)
+        result = f"CSV file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+        result += f"Columns: {', '.join(df.columns)}\n\n"
+        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.
+
+    Args:
+        file_path (str): The path to the Excel file.
+        query (str): Question about the data.
+        
+    Returns:
+        str: Analysis result or error message.
+    """
+    try:
+        df = pd.read_excel(file_path)
+        result = (
+            f"Excel file loaded with {len(df)} rows and {len(df.columns)} columns.\n"
+        )
+        result += f"Columns: {', '.join(df.columns)}\n\n"
+        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.
+
+    Args:
+        image_base64 (str): Base64 encoded image string.
+
+    Returns:
+        Dict[str, Any]: 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 to an image.
+
+    Args:
+        image_base64 (str): Base64 encoded input image.
+        operation (str): Transformation operation (resize, rotate, crop, flip, adjust_brightness, adjust_contrast, blur, sharpen, grayscale).
+        params (Dict[str, Any], optional): Parameters for the operation.
+
+    Returns:
+        Dict[str, Any]: 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 or text onto an image.
+
+    Args:
+        image_base64 (str): Base64 encoded input image.
+        drawing_type (str): Drawing type (rectangle, circle, line, text).
+        params (Dict[str, Any]): Drawing parameters.
+
+    Returns:
+        Dict[str, Any]: 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.
+
+    Args:
+        image_type (str): Type of image (gradient, noise).
+        width (int): Width of the image. Defaults to 500.
+        height (int): Height of the image. Defaults to 500.
+        params (Dict[str, Any], optional): Specific parameters.
+
+    Returns:
+        Dict[str, Any]: 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.
+
+    Args:
+        images_base64 (List[str]): List of base64 images.
+        operation (str): Combination type (stack).
+        params (Dict[str, Any], optional): Parameters.
+
+    Returns:
+        Dict[str, Any]: 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 system prompt
+with open("system_prompt.txt", "r", encoding="utf-8") as f:
+    system_prompt = f.read()
+
+# System message
+sys_msg = SystemMessage(content=system_prompt)
+
+# Build retriever and tools
+embeddings = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-mpnet-base-v2"
+)
+
+# Initialize base tools
+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,
+]
+
+# Conditionally add Supabase tool
+supabase_url = os.environ.get("SUPABASE_URL")
+supabase_key = os.environ.get("SUPABASE_SERVICE_ROLE_KEY")
+
+vector_store = None
+if supabase_url and supabase_key:
+    try:
+        supabase: Client = create_client(supabase_url, supabase_key)
+        vector_store = SupabaseVectorStore(
+            client=supabase,
+            embedding=embeddings,
+            table_name="documents2",
+            query_name="match_documents_2",
+        )
+        retriever = vector_store.as_retriever()
+        retriever_tool = Tool(
+            name="question_search",
+            func=retriever.invoke,
+            description="A tool to retrieve similar questions from a vector store.",
+        )
+        tools.insert(0, retriever_tool)
+        print("Supabase retriever tool initialized.")
+    except Exception as e:
+        print(f"Failed to initialize Supabase retriever: {e}")
+        vector_store = None
+else:
+    print("Supabase credentials not found. 'Question Search' tool will be disabled.")
+
+
+def build_graph(provider: str = "groq"):
+    """
+    Build the state graph for the agent.
+
+    Args:
+        provider (str): The LLM provider. Defaults to "groq".
+    
+    Returns:
+        CompiledGraph: The compiled state graph.
+    """
+    if provider == "groq":
+        llm = ChatGroq(model="llama-3.3-70b-versatile", temperature=0)
+    elif provider == "huggingface":
+        llm = ChatHuggingFace(
+            llm=HuggingFaceEndpoint(
+                repo_id="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
+                task="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'.")
+    
+    llm_with_tools = llm.bind_tools(tools)
+
+    def assistant(state: MessagesState):
+        """Assistant node to invoke the LLM."""
+        return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+    def retriever(state: MessagesState):
+        """Retriever node to find similar questions."""
+        if vector_store is not None:
+            try:
+                similar_question = vector_store.similarity_search(state["messages"][0].content)
+
+                if similar_question:
+                    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]}
+            except Exception as e:
+                print(f"Error in retriever: {e}")
+        
+        return {"messages": [sys_msg] + state["messages"]}
+
+    builder = StateGraph(MessagesState)
+    builder.add_node("retriever", retriever)
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+    builder.add_edge(START, "retriever")
+    builder.add_edge("retriever", "assistant")
+    builder.add_conditional_edges(
+        "assistant",
+        tools_condition,
+    )
+    builder.add_edge("tools", "assistant")
+
+    return builder.compile()
+
+
+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.js

@@ -0,0 +1,363 @@
+const { useState, useEffect, useRef } = React;
+
+const EXAMPLE_PROMPTS = [
+  { text: "Analyze System Performance", color: "green", icon: "chart" },
+  { text: "Debug Error Logs", color: "yellow", icon: "warning" },
+  { text: "Compare Configurations", color: "blue", icon: "document" }
+];
+
+const ICONS = {
+  chat: "M8 10h.01M12 10h.01M16 10h.01M9 16H5a2 2 0 01-2-2V6a2 2 0 012-2h14a2 2 0 012 2v8a2 2 0 01-2 2h-5l-5 5v-5z",
+  download: "M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4",
+  settings: "M10.325 4.317c.426-1.756 2.924-1.756 3.35 0a1.724 1.724 0 002.573 1.066c1.543-.94 3.31.826 2.37 2.37a1.724 1.724 0 001.065 2.572c1.756.426 1.756 2.924 0 3.35a1.724 1.724 0 00-1.066 2.573c.94 1.543-.826 3.31-2.37 2.37a1.724 1.724 0 00-2.572 1.065c-.426 1.756-2.924 1.756-3.35 0a1.724 1.724 0 00-2.573-1.066c-1.543.94-3.31-.826-2.37-2.37a1.724 1.724 0 00-1.065-2.572c-1.756-.426-1.756-2.924 0-3.35a1.724 1.724 0 001.066-2.573c-.94-1.543.826-3.31 2.37-2.37.996.608 2.296.07 2.572-1.065z M15 12a3 3 0 11-6 0 3 3 0 016 0z",
+  menu: "M4 6h16M4 12h16M4 18h16",
+  attach: "M15.172 7l-6.586 6.586a2 2 0 102.828 2.828l6.414-6.586a4 4 0 00-5.656-5.656l-6.415 6.585a6 6 0 108.486 8.486L20.5 13",
+  send: "M2.01 21L23 12 2.01 3 2 10l15 2-15 2z",
+  chart: "M9 19v-6a2 2 0 00-2-2H5a2 2 0 00-2 2v6a2 2 0 002 2h2a2 2 0 002-2zm0 0V9a2 2 0 012-2h2a2 2 0 012 2v10m-6 0a2 2 0 002 2h2a2 2 0 002-2m0 0V5a2 2 0 012-2h2a2 2 0 012 2v14a2 2 0 01-2 2h-2a2 2 0 01-2-2z",
+  warning: "M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z",
+  document: "M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"
+};
+
+const Icon = ({ path, className }) => (
+  <svg className={className} fill="none" stroke="currentColor" viewBox="0 0 24 24">
+    {path.includes('M2.01') ? (
+      <path fill="currentColor" d={path} />
+    ) : (
+      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d={path} />
+    )}
+  </svg>
+);
+
+const App = () => {
+  const [sidebarOpen, setSidebarOpen] = useState(true);
+  const [input, setInput] = useState('');
+  const [isLoading, setIsLoading] = useState(false);
+  const [currentSessionId, setCurrentSessionId] = useState(null);
+  const [sessions, setSessions] = useState([]);
+  const [uploadedFiles, setUploadedFiles] = useState([]);
+  const messagesEndRef = useRef(null);
+  const fileInputRef = useRef(null);
+
+  useEffect(() => {
+    const initialSession = {
+      id: crypto.randomUUID(),
+      title: 'New Chat',
+      messages: [],
+      updatedAt: Date.now()
+    };
+    setSessions([initialSession]);
+    setCurrentSessionId(initialSession.id);
+  }, []);
+
+  useEffect(() => {
+    messagesEndRef.current?.scrollIntoView({ behavior: "smooth" });
+  }, [sessions, currentSessionId]);
+
+  const createNewSession = () => ({
+    id: crypto.randomUUID(),
+    title: 'New Chat',
+    messages: [],
+    updatedAt: Date.now()
+  });
+
+  const handleNewChat = () => {
+    const newSession = createNewSession();
+    setSessions(prev => [newSession, ...prev]);
+    setCurrentSessionId(newSession.id);
+    if (window.innerWidth < 1024) setSidebarOpen(false);
+  };
+
+  const updateSessionMessages = (sessionId, newMessage) => {
+    setSessions(prev => prev.map(s => 
+      s.id === sessionId 
+        ? { ...s, messages: [...s.messages, newMessage] }
+        : s
+    ));
+  };
+
+  const handleSendMessage = async () => {
+    if ((!input.trim() && uploadedFiles.length === 0) || !currentSessionId) return;
+
+    const userMessage = input;
+    const filesToSend = [...uploadedFiles];
+    const userMsg = { role: 'user', content: userMessage, files: filesToSend.map(f => f.name) };
+    
+    setInput('');
+    setUploadedFiles([]);
+    setIsLoading(true);
+
+    updateSessionMessages(currentSessionId, userMsg);
+
+    try {
+      setSessions(prevSessions => {
+        const currentSession = prevSessions.find(s => s.id === currentSessionId);
+        const formData = new FormData();
+        formData.append('message', userMessage);
+        formData.append('history', JSON.stringify(currentSession?.messages || []));
+        
+        filesToSend.forEach(file => {
+          formData.append('files', file);
+        });
+        
+        fetch('/api/chat', {
+          method: 'POST',
+          body: formData
+        })
+        .then(response => response.json())
+        .then(data => {
+          if (data.reply) {
+            updateSessionMessages(currentSessionId, { 
+              role: 'model', 
+              content: data.reply 
+            });
+          }
+          setIsLoading(false);
+        })
+        .catch(error => {
+          console.error('Error:', error);
+          updateSessionMessages(currentSessionId, { 
+            role: 'model', 
+            content: "Error: Could not connect to agent." 
+          });
+          setIsLoading(false);
+        });
+        
+        return prevSessions;
+      });
+    } catch (error) {
+      console.error('Error:', error);
+      updateSessionMessages(currentSessionId, { 
+        role: 'model', 
+        content: "Error: Could not connect to agent." 
+      });
+      setIsLoading(false);
+    }
+  };
+
+  const handleKeyDown = (e) => {
+    if (e.key === 'Enter' && !e.shiftKey) {
+      e.preventDefault();
+      handleSendMessage();
+    }
+  };
+
+  const selectSession = (sessionId) => {
+    setCurrentSessionId(sessionId);
+    if (window.innerWidth < 1024) setSidebarOpen(false);
+  };
+
+  const handleFileSelect = (e) => {
+    const files = Array.from(e.target.files);
+    setUploadedFiles(prev => [...prev, ...files]);
+  };
+
+  const removeFile = (index) => {
+    setUploadedFiles(prev => prev.filter((_, i) => i !== index));
+  };
+
+  const handleExportChat = () => {
+    if (!currentSession || currentSession.messages.length === 0) return;
+    
+    const chatData = {
+      title: currentSession.title,
+      exportedAt: new Date().toISOString(),
+      messages: currentSession.messages
+    };
+    
+    const blob = new Blob([JSON.stringify(chatData, null, 2)], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `chat-${currentSession.title.replace(/\s+/g, '-').toLowerCase()}-${Date.now()}.json`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  };
+
+  const currentSession = sessions.find(s => s.id === currentSessionId);
+
+  return (
+    <div className="flex h-screen bg-gray-950 text-gray-100 font-sans overflow-hidden">
+      <aside className={`fixed lg:static inset-y-0 left-0 z-30 w-[280px] bg-[#1a1d29] border-r border-gray-800 flex flex-col transition-transform duration-300 transform ${sidebarOpen ? 'translate-x-0' : '-translate-x-full lg:translate-x-0'}`}>
+        <div className="p-4 flex items-center gap-2 border-b border-gray-800">
+          <div className="w-6 h-6 rounded bg-gradient-to-br from-green-500 to-emerald-700 flex items-center justify-center text-white text-sm font-bold">
+            G
+          </div>
+          <span className="text-gray-100 font-semibold text-base">GAIA Agent</span>
+        </div>
+
+        <div className="px-3 py-4">
+          <button
+            onClick={handleNewChat}
+            className="w-full flex items-center gap-2 px-3 py-2.5 bg-transparent hover:bg-gray-800/50 text-gray-300 rounded-lg transition-colors border border-gray-700 hover:border-gray-600"
+          >
+            <span className="text-lg">+</span>
+            <span className="text-sm font-medium">New Chat</span>
+          </button>
+        </div>
+
+        <div className="flex-1 overflow-y-auto px-3 space-y-1">
+          <div className="px-2 pb-2 text-xs font-semibold text-gray-500 uppercase tracking-wider">History</div>
+          {sessions.length === 0 ? (
+            <div className="px-4 py-8 text-center text-gray-600 text-xs">
+              No conversation history.
+            </div>
+          ) : (
+            sessions.map((session) => (
+              <div 
+                key={session.id}
+                onClick={() => selectSession(session.id)}
+                className={`group flex items-center gap-2 px-3 py-2.5 rounded-lg cursor-pointer transition-all ${
+                  session.id === currentSessionId 
+                    ? 'bg-gray-800/70 text-white' 
+                    : 'text-gray-400 hover:bg-gray-800/40 hover:text-gray-200'
+                }`}
+              >
+                <Icon path={ICONS.chat} className="w-4 h-4 flex-shrink-0" />
+                <span className="flex-1 text-xs truncate">{session.title}</span>
+              </div>
+            ))
+          )}
+        </div>
+
+        <div className="p-3 border-t border-gray-800 space-y-1">
+          <button 
+            onClick={handleExportChat}
+            disabled={!currentSession || currentSession.messages.length === 0}
+            className="w-full flex items-center gap-2 px-3 py-2 rounded-lg text-gray-400 hover:text-white hover:bg-gray-800/50 transition-colors text-xs disabled:opacity-50 disabled:cursor-not-allowed"
+          >
+            <Icon path={ICONS.download} className="w-4 h-4" />
+            <span>Export Chat</span>
+          </button>
+          <button className="w-full flex items-center gap-2 px-3 py-2 rounded-lg text-gray-400 hover:text-white hover:bg-gray-800/50 transition-colors text-xs">
+            <Icon path={ICONS.settings} className="w-4 h-4" />
+            <span>Settings</span>
+          </button>
+        </div>
+      </aside>
+
+      <main className="flex-1 flex flex-col relative w-full h-full bg-[#0f1118]">
+        <div className="lg:hidden p-4 border-b border-gray-800 flex items-center gap-4 bg-[#1a1d29]">
+          <button onClick={() => setSidebarOpen(true)} className="text-gray-400 hover:text-white">
+            <Icon path={ICONS.menu} className="w-6 h-6" />
+          </button>
+          <span className="font-semibold">GAIA Agent</span>
+        </div>
+
+        <div className="flex-1 overflow-y-auto p-6 space-y-6">
+          {!currentSession || currentSession.messages.length === 0 ? (
+            <div className="h-full flex flex-col items-center justify-center max-w-4xl mx-auto">
+              <div className="w-20 h-20 rounded-2xl bg-gradient-to-br from-green-500 to-emerald-700 flex items-center justify-center text-white text-3xl font-bold mb-6 shadow-lg">
+                G
+              </div>
+              <h1 className="text-3xl font-bold text-white mb-3">GAIA Agent</h1>
+              <p className="text-gray-400 text-center text-sm mb-12 max-w-md">
+                Your advanced AI assistant for system analysis, debugging, and configuration management.
+              </p>
+              
+              <div className="grid grid-cols-1 md:grid-cols-3 gap-4 w-full max-w-3xl">
+                {EXAMPLE_PROMPTS.map(({ text, color, icon }) => (
+                  <button 
+                    key={text}
+                    onClick={() => setInput(text)}
+                    className="group p-6 bg-[#1a1d29] hover:bg-[#22253a] border border-gray-800 hover:border-gray-700 rounded-xl transition-all text-left"
+                  >
+                    <div className={`w-12 h-12 bg-${color}-500/10 rounded-lg flex items-center justify-center mb-4 group-hover:bg-${color}-500/20 transition-colors`}>
+                      <Icon path={ICONS[icon]} className={`w-6 h-6 text-${color}-500`} />
+                    </div>
+                    <p className="text-white font-medium text-sm">{text}</p>
+                  </button>
+                ))}
+              </div>
+            </div>
+          ) : (
+            currentSession.messages.map((msg, idx) => (
+              <div key={idx} className={`flex ${msg.role === 'user' ? 'justify-end' : 'justify-start'}`}>
+                <div className={`max-w-[85%] rounded-2xl px-5 py-3 ${
+                  msg.role === 'user' ? 'bg-[#1a1d29] text-white' : 'bg-transparent text-gray-200'
+                }`}>
+                  {msg.files && msg.files.length > 0 && (
+                    <div className="mb-2 flex flex-wrap gap-1">
+                      {msg.files.map((file, i) => (
+                        <span key={i} className="inline-flex items-center gap-1 px-2 py-1 bg-gray-800 rounded text-xs">
+                          <Icon path={ICONS.attach} className="w-3 h-3" />
+                          {file}
+                        </span>
+                      ))}
+                    </div>
+                  )}
+                  <p className="whitespace-pre-wrap text-sm" dangerouslySetInnerHTML={{ __html: msg.content.replace(/\n/g, '<br />') }}></p>
+                </div>
+              </div>
+            ))
+          )}
+          {isLoading && (
+            <div className="flex justify-start">
+              <div className="px-5 py-3 text-gray-400 text-sm italic animate-pulse">
+                Thinking...
+              </div>
+            </div>
+          )}
+          <div ref={messagesEndRef} />
+        </div>
+
+        <div className="p-4 bg-[#0f1118] border-t border-gray-800">
+          <div className="max-w-4xl mx-auto relative bg-[#1a1d29] rounded-xl border border-gray-800 focus-within:border-gray-700 transition-colors">
+            {uploadedFiles.length > 0 && (
+              <div className="px-4 pt-3 flex flex-wrap gap-2">
+                {uploadedFiles.map((file, idx) => (
+                  <div key={idx} className="inline-flex items-center gap-2 px-3 py-1.5 bg-gray-800 rounded-lg text-xs">
+                    <Icon path={ICONS.attach} className="w-3 h-3" />
+                    <span>{file.name}</span>
+                    <button onClick={() => removeFile(idx)} className="text-gray-400 hover:text-white">
+                      ×
+                    </button>
+                  </div>
+                ))}
+              </div>
+            )}
+            <div className="flex items-center gap-2 px-4">
+              <input
+                ref={fileInputRef}
+                type="file"
+                multiple
+                onChange={handleFileSelect}
+                className="hidden"
+              />
+              <button 
+                onClick={() => fileInputRef.current?.click()}
+                className="p-2 text-gray-500 hover:text-gray-300 transition-colors" 
+                title="Attach"
+              >
+                <Icon path={ICONS.attach} className="w-5 h-5" />
+              </button>
+              <input
+                type="text"
+                value={input}
+                onChange={(e) => setInput(e.target.value)}
+                onKeyDown={handleKeyDown}
+                placeholder="Message GAIA Agent..."
+                className="flex-1 bg-transparent text-white py-3 outline-none text-sm placeholder-gray-500"
+              />
+              <button 
+                onClick={handleSendMessage}
+                disabled={isLoading || (!input.trim() && uploadedFiles.length === 0)}
+                className={`p-2 rounded-lg transition-all ${
+                  (input.trim() || uploadedFiles.length > 0) ? 'text-white hover:bg-gray-800' : 'text-gray-600 cursor-not-allowed'
+                }`}
+              >
+                <Icon path={ICONS.send} className="w-5 h-5" />
+              </button>
+            </div>
+          </div>
+          <div className="text-center mt-3 text-xs text-gray-500">
+            GAIA Agent can make mistakes. Consider checking important information.
+          </div>
+        </div>
+      </main>
+    </div>
+  );
+};
+
+ReactDOM.createRoot(document.getElementById('root')).render(<App />);

code_interpreter.py

@@ -0,0 +1,314 @@
+import os
+import io
+import uuid
+import base64
+import logging
+import traceback
+import contextlib
+import tempfile
+import subprocess
+import sqlite3
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from typing import Dict, Any, List, Optional
+from PIL import Image
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class CodeInterpreter:
+    def __init__(self, allowed_modules: Optional[List[str]] = None, max_execution_time: int = 30, working_directory: Optional[str] = None):
+        """
+        Initialize the code interpreter.
+
+        Args:
+            allowed_modules (List[str], optional): List of allowed modules. Defaults to comprehensive list.
+            max_execution_time (int): Maximum execution time in seconds. Defaults to 30.
+            working_directory (str, optional): Directory for file operations. Defaults to current working directory.
+        """
+        logger.info(f"Initializing CodeInterpreter with max execution time: {max_execution_time}s")
+        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.getcwd()
+        
+        if not os.path.exists(self.working_directory):
+            try:
+                os.makedirs(self.working_directory)
+                logger.info(f"Created working directory: {self.working_directory}")
+            except OSError as e:
+                logger.error(f"Failed to create working directory {self.working_directory}: {e}")
+        
+        self.globals = {
+            "__builtins__": __builtins__,
+            "np": np,
+            "pd": pd,
+            "plt": plt,
+            "Image": Image,
+        }
+        self.temp_sqlite_db = os.path.join(tempfile.gettempdir(), "code_exec.db")
+        logger.info("CodeInterpreter initialized successfully")
+
+    def execute_code(self, code: str, language: str = "python") -> Dict[str, Any]:
+        """
+        Execute the provided code in the selected programming language.
+
+        Args:
+            code (str): The code to execute.
+            language (str): The programming language. Defaults to "python".
+
+        Returns:
+            Dict[str, Any]: Result dictionary containing status, stdout, stderr, and other artifacts.
+        """
+        language = language.lower()
+        execution_id = str(uuid.uuid4())
+        logger.info(f"Executing code (ID: {execution_id}) in language: {language}")
+        
+        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:
+                error_msg = f"Unsupported language: {language}"
+                logger.warning(error_msg)
+                result["stderr"] = error_msg
+        except Exception as e:
+            error_msg = f"Unexpected error during execution: {str(e)}"
+            logger.error(error_msg)
+            result["stderr"] = error_msg
+        
+        return result
+
+    def _execute_python(self, code: str, execution_id: str) -> Dict[str, Any]:
+        logger.debug(f"Running Python execution {execution_id}")
+        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[str, Any]:
+        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[str, Any]:
+        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[str, Any]:
+        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[str, Any]:
+        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": []
+            }

eval.py

@@ -0,0 +1,270 @@
+"""Evaluation runner for the agent."""
+import os
+import sys
+import time
+import logging
+import requests
+import pandas as pd
+from typing import Optional, Tuple, Any, Dict, List
+import gradio as gr
+from langchain_core.messages import HumanMessage
+from agent import build_graph
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[logging.StreamHandler(sys.stdout)]
+)
+logger = logging.getLogger(__name__)
+
+# Constants
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+class BasicAgent:
+    """A wrapper for the LangGraph agent to be used in evaluation."""
+    
+    def __init__(self) -> None:
+        """Initialize the agent and build the graph."""
+        logger.info("Initializing BasicAgent...")
+        self.graph = build_graph()
+
+    def __call__(self, question: str) -> str:
+        """
+        Invoke the agent with a question.
+        
+        Args:
+            question (str): The input question.
+            
+        Returns:
+            str: The agent's answer.
+        """
+        logger.info(f"Agent received question: {question[:50]}...")
+        # Wrap the question in a HumanMessage
+        messages = [HumanMessage(content=question)]
+        result = self.graph.invoke({"messages": messages})
+        answer = result['messages'][-1].content
+        
+        # Clean up the answer if it starts with "Assistant: " (consistent with app.py)
+        # Note: The original code used answer[14:] which assumes "Assistant: " is always present if it was added? 
+        # Or maybe it was stripping "Final Answer: "? 
+        # The original code was: return answer[14:]
+        # "Final Answer: " is 14 chars. 
+        # "Assistant: " is 11 chars.
+        # Since I must keep original logic, I should check if I should keep [14:] blindly or be smarter.
+        # The prompt says "Keep all the original logic the same".
+        # However, slicing [14:] blindly is dangerous if the format changes slightly.
+        # But if the prompt forced "Final Answer:", [14:] makes sense.
+        # Let's assume the original logic was correct for the original prompt.
+        # My new system prompt enforces "FINAL ANSWER". That is 12 chars + maybe space/colon.
+        # If I strictly follow "Keep logic same", I keep [14:].
+        # But I refactored the system prompt.
+        # Let's look at app.py refactor: `if answer.startswith("Assistant: "): answer = answer[11:]`
+        # I should probably update this to be safe, but the instruction said "original logic".
+        # If I change the slice, I am changing logic, but adapting to the new prompt *is* necessary if the prompt changed.
+        # The previous `eval.py` used `answer[14:]`.
+        # I will keep `answer[14:]` but added a comment warning about it, or better, 
+        # I will make it safer: if the prefix exists, remove it.
+        # Actually, looking at the previous turn `agent.py` refactor, I didn't verify the output format there.
+        # In `eval.py` context, usually this slicing is to remove a prefix.
+        # I'll stick to the safer implementation I used in `app.py` if possible, but the user was specific about logic.
+        # Wait, `app.py` had `if answer.startswith("Assistant: "): ...`.
+        # `eval.py` had `return answer[14:]`.
+        # I will trust `answer[14:]` corresponds to some fixed prefix like "Final Answer: " (14 chars).
+        # But wait, "FINAL ANSWER: " is 14 chars. 
+        # So I will keep `return answer[14:]` as requested "Keep all the original logic".
+        return answer[14:]
+
+
+def run_and_submit_all(profile: Optional[gr.OAuthProfile]) -> Tuple[str, Optional[pd.DataFrame]]:
+    """
+    Fetch questions, run the agent, and submit answers.
+    
+    Args:
+        profile: The user's HuggingFace profile.
+        
+    Returns:
+        Tuple[str, Optional[pd.DataFrame]]: Status message and results DataFrame.
+    """
+    # Determine Space information
+    space_id = os.getenv("SPACE_ID")
+
+    if profile:
+        username = f"{profile.username}"
+        logger.info(f"User logged in: {username}")
+    else:
+        logger.warning("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
+    try:
+        agent = BasicAgent()
+    except Exception as e:
+        logger.error(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    logger.info(f"Agent code URL: {agent_code}")
+
+    # 2. Fetch Questions
+    logger.info(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:
+             logger.warning("Fetched questions list is empty")
+             return "Fetched questions list is empty or invalid format.", None
+        logger.info(f"Fetched {len(questions_data)} questions")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except Exception as e:
+        logger.error(f"Unexpected error fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run Agent
+    results_log: List[Dict[str, Any]] = []
+    answers_payload: List[Dict[str, Any]] = []
+    
+    logger.info(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:
+            logger.warning(f"Skipping item with missing task_id or question: {item}")
+            continue
+        
+        # Keep original logic: sleep 30s
+        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:
+             logger.error(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:
+        logger.warning("Agent did not produce any answers")
+        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
+    }
+    
+    logger.info(f"Submitting {len(answers_payload)} answers for user '{username}'...")
+
+    # 5. Submit
+    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.')}"
+        )
+        logger.info("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 ValueError:
+            error_detail += f" Response: {e.response.text[:500]}"
+            
+        status_message = f"Submission Failed: {error_detail}"
+        logger.error(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."
+        logger.error(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}"
+        logger.error(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}"
+        logger.error(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+
+# --- Gradio Interface ---
+with gr.Blocks(title="Agent Evaluation Runner") 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 (wait for the agent to process all questions).
+        This space provides a basic setup.
+        """
+    )
+
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
+
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+
+if __name__ == "__main__":
+    logger.info("App Starting...")
+    
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+
+    if space_host_startup:
+        logger.info(f"SPACE_HOST found: {space_host_startup}")
+    else:
+        logger.info("SPACE_HOST environment variable not found (running locally?)")
+
+    if space_id_startup:
+        logger.info(f"SPACE_ID found: {space_id_startup}")
+    else:
+        logger.info("SPACE_ID environment variable not found (running locally?)")
+
+    logger.info("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)

img_processing.py

@@ -0,0 +1,70 @@
+import os
+import io
+import base64
+import uuid
+import logging
+from PIL import Image
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+def encode_image(image_path: str) -> str:
+    """
+    Convert an image file to a base64 encoded string.
+    
+    Args:
+        image_path (str): The file path to the image.
+        
+    Returns:
+        str: The base64 encoded string of the image.
+    """
+    try:
+        with open(image_path, "rb") as image_file:
+            encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
+        logger.info(f"Successfully encoded image from {image_path}")
+        return encoded_string
+    except Exception as e:
+        logger.error(f"Error encoding image {image_path}: {e}")
+        raise
+
+def decode_image(base64_string: str) -> Image.Image:
+    """
+    Convert a base64 encoded string to a PIL Image object.
+    
+    Args:
+        base64_string (str): The base64 encoded string.
+        
+    Returns:
+        Image.Image: The decoded PIL Image.
+    """
+    try:
+        image_data = base64.b64decode(base64_string)
+        image = Image.open(io.BytesIO(image_data))
+        logger.info("Successfully decoded base64 image string")
+        return image
+    except Exception as e:
+        logger.error(f"Error decoding image: {e}")
+        raise
+
+def save_image(image: Image.Image, directory: str = "image_outputs") -> str:
+    """
+    Save a PIL Image to disk with a unique filename.
+    
+    Args:
+        image (Image.Image): The image to save.
+        directory (str): The directory to save the image in. Defaults to "image_outputs".
+        
+    Returns:
+        str: The file path of the saved image.
+    """
+    try:
+        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)
+        logger.info(f"Saved image to {image_path}")
+        return image_path
+    except Exception as e:
+        logger.error(f"Error saving image to {directory}: {e}")
+        raise

index.html

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>GAIA Agent</title>
+    <script src="https://cdn.tailwindcss.com"></script>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap"
+      rel="stylesheet"
+    />
+    <script>
+      tailwind.config = {
+        theme: {
+          extend: {
+            fontFamily: {
+              sans: ['Inter', 'sans-serif'],
+            },
+            colors: {
+              gray: {
+                750: '#2d2e3a',
+                850: '#1a1b23',
+                950: '#0f1014',
+              }
+            }
+          },
+        },
+      };
+    </script>
+    <style>
+      /* Custom scrollbar for Webkit */
+      ::-webkit-scrollbar {
+        width: 8px;
+        height: 8px;
+      }
+      ::-webkit-scrollbar-track {
+        background: transparent;
+      }
+      ::-webkit-scrollbar-thumb {
+        background: #4b5563;
+        border-radius: 4px;
+      }
+      ::-webkit-scrollbar-thumb:hover {
+        background: #6b7280;
+      }
+    </style>
+    <!-- React and ReactDOM -->
+    <script crossorigin src="https://unpkg.com/react@18/umd/react.production.min.js"></script>
+    <script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"></script>
+    <!-- Babel Standalone -->
+    <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
+</head>
+  <body class="bg-gray-900 text-gray-100 overflow-hidden">
+    <div id="root"></div>
+    <script type="text/babel" src="/app.js"></script>
+  </body>
+</html>

logic.py

@@ -0,0 +1,92 @@
+import os
+import logging
+from typing import List, Tuple, Optional
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# --- Mock Agent Interface ---
+# In a real scenario, this would import from your existing agent codebase
+# e.g., from agent import build_graph
+class MockAgent:
+    def invoke(self, inputs):
+        """Simulates the agent response."""
+        message = inputs.get("messages", [])[-1].content
+        return {"messages": [{"content": f"I received your query: '{message}'. \n\nHere is a simulated analysis based on the GAIA architecture.\n\n```python\ndef analyze_system():\n    return 'System Optimal'\n```"}]}
+
+try:
+    from agent import build_graph
+    AGENT_AVAILABLE = True
+except ImportError:
+    AGENT_AVAILABLE = False
+    logger.warning("Could not import 'agent.build_graph'. Using MockAgent.")
+
+# --- Logic Class ---
+class GaiaApp:
+    def __init__(self):
+        self.agent = build_graph() if AGENT_AVAILABLE else MockAgent()
+        
+    def process_input(self, user_message: str, history: List[dict], uploaded_files: Optional[List[str]]):
+        """
+        Main handler for chat input.
+        Args:
+            user_message: The text input from the user.
+            history: The existing chat history (list of message dicts).
+            uploaded_files: List of file paths.
+        """
+        if not user_message and not uploaded_files:
+            return "", history, None
+            
+        # 1. Process Files
+        context_msg = ""
+        if uploaded_files:
+            file_names = [os.path.basename(f) for f in uploaded_files]
+            context_msg = f"\n[User uploaded files: {', '.join(file_names)}]"
+        
+        full_query = user_message + context_msg
+        
+        # 2. Append User Message to History immediately for UI update
+        current_history = history + [{"role": "user", "content": user_message}]
+        
+        # 3. Yield back immediately to show user message
+        yield "", current_history, None
+
+        # 4. Invoke Agent
+        try:
+            # Prepare messages for LangChain/Agent
+            # (Simplification: just sending last message)
+            from langchain_core.messages import HumanMessage
+            
+            inputs = {"messages": [HumanMessage(content=full_query)]}
+            result = self.agent.invoke(inputs)
+            
+            # Extract response
+            # Assuming standard LangGraph/LangChain output
+            if isinstance(result, dict) and 'messages' in result:
+                bot_response = result['messages'][-1].content
+            else:
+                bot_response = str(result)
+                
+            # Clean up response prefixes if present
+            if bot_response.startswith("Assistant:"):
+                bot_response = bot_response.replace("Assistant:", "").strip()
+
+            # 5. Stream/Update Bot Response
+            current_history.append({"role": "assistant", "content": bot_response})
+            yield "", current_history, None
+
+        except Exception as e:
+            logger.error(f"Error invoking agent: {e}")
+            error_msg = f"⚠️ Error: {str(e)}"
+            current_history.append({"role": "assistant", "content": error_msg})
+            yield "", current_history, None
+
+    def create_new_chat(self):
+        """Resets the state."""
+        return [], None, ""
+
+    def load_example(self, prompt):
+        return prompt
+
+# Singleton instance for the app
+gaia_logic = GaiaApp()

requirements.txt

@@ -3,3 +3,25 @@ smolagents==1.13.0
 requests
 duckduckgo_search
 pandas
+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
+uuid

server.py

@@ -0,0 +1,97 @@
+import os
+import uvicorn
+import json
+from fastapi import FastAPI, UploadFile, File, Form
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+
+try:
+    from logic import GaiaApp
+except ImportError:
+    class GaiaApp:
+        def process_input(self, msg, hist, files):
+            return "Error: logic.py not found", hist, None
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+gaia_engine = GaiaApp()
+
+class Message(BaseModel):
+    role: str
+    content: str
+
+class ChatRequest(BaseModel):
+    message: str
+    history: List[Message]
+
+def format_history(messages: List[Message]) -> List[tuple]:
+    """Convert message history from React format to agent format."""
+    formatted = []
+    for msg in messages:
+        if msg.role == 'user':
+            formatted.append((msg.content, None))
+        elif msg.role == 'model' and formatted and formatted[-1][1] is None:
+            formatted[-1] = (formatted[-1][0], msg.content)
+    return formatted
+
+@app.post("/api/chat")
+async def chat_endpoint(
+    message: str = Form(...),
+    history: str = Form("[]"),
+    files: List[UploadFile] = File(default=[])
+):
+    """Process chat message with optional file uploads and return agent response."""
+    try:
+        messages = json.loads(history)
+        formatted_history = format_history([Message(**msg) for msg in messages])
+        
+        file_paths = []
+        if files:
+            os.makedirs("uploads", exist_ok=True)
+            for file in files:
+                file_path = f"uploads/{file.filename}"
+                with open(file_path, "wb") as f:
+                    content = await file.read()
+                    f.write(content)
+                file_paths.append(file_path)
+        
+        generator = gaia_engine.process_input(message, formatted_history, file_paths or None)
+        
+        final_state = None
+        for step in generator:
+            final_state = step
+            
+        if final_state and final_state[1]:
+            bot_response = final_state[1][-1][1]
+            return {"reply": bot_response}
+        
+        return {"reply": "No response from agent."}
+    except Exception as e:
+        print(f"Error: {e}")
+        return {"reply": f"Error: {str(e)}"}
+
+ALLOWED_EXTENSIONS = {".css", ".js", ".png", ".html"}
+
+@app.get("/")
+async def serve_index():
+    return FileResponse("index.html")
+
+@app.get("/{filename}")
+async def serve_static(filename: str):
+    ext = os.path.splitext(filename)[1]
+    if ext in ALLOWED_EXTENSIONS and os.path.exists(filename):
+        return FileResponse(filename)
+    return FileResponse("index.html", status_code=404)
+
+if __name__ == "__main__":
+    uvicorn.run("server:app", host="0.0.0.0", port=7860, reload=True)

system_prompt.txt

@@ -0,0 +1,14 @@
+You are a helpful assistant tasked with answering questions using a set of tools.
+
+Process:
+1. Reason through the question and report your thoughts.
+2. Finish your answer with the specific template:
+FINAL ANSWER: [YOUR FINAL ANSWER]
+
+Strict Guidelines for "FINAL ANSWER":
+- **Format**: It must be a single number, a short string, or a comma-separated list.
+- **Numbers**: Do NOT use commas (e.g., 1000) and do NOT use units (e.g., $, %) unless specified.
+- **Strings**: Do NOT use articles (a, an, the) and do NOT use abbreviations.
+- **Lists**: Apply the above rules to each element. Ensure exactly one space after each comma (e.g., "A, B, C").
+
+The very last part of your response must be exactly "FINAL ANSWER: " followed by your answer.