GAIA agent project.

- Better project structure.
- Support multiple LLM providers: ollama, gemini, openai, huggingface
- Unit test.
- Tool collection.
- Vector databases with chroma and supabase.

.gitignore

@@ -0,0 +1,3 @@
+__pycache__
+.env
+.venv

.pre-commit-config.yaml

@@ -0,0 +1,45 @@
+repos:
+# -   repo: https://github.com/astral-sh/ruff-pre-commit
+#     rev: v0.11.7
+#     hooks:
+#     -   id: ruff
+#         args: [--fix]
+#         ignore: ["E501"]
+#         line-length: 120
+#     -   id: ruff-format
+
+-   repo: https://github.com/psf/black
+    rev: 25.1.0
+    hooks:
+    -   id: black
+
+# -   repo: https://github.com/pre-commit/mirrors-mypy
+#     rev: v1.15.0
+#     hooks:
+#     -   id: mypy
+#         args: ["--allow-untyped-globals"]
+#         additional_dependencies: [
+#             "types-requests",
+#             "types-PyYAML",
+#             "types-setuptools",
+#             "types-urllib3",
+#             "types-python-dateutil",
+#             "types-six"
+#         ]
+
+-   repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+    -   id: trailing-whitespace
+    -   id: end-of-file-fixer
+    -   id: check-yaml
+    -   id: check-added-large-files
+        args: ['--maxkb=20480']
+    -   id: check-ast
+    -   id: check-json
+    -   id: check-merge-conflict
+    -   id: debug-statements
+    -   id: detect-private-key
+    # -   id: name-tests-test
+    #     args: ['--pytest-test-first']
+    -   id: requirements-txt-fixer

.vscode/settings.json

@@ -0,0 +1,7 @@
+{
+    "python.testing.pytestArgs": [
+        "tests"
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
+}

README.md

@@ -1,14 +1,299 @@
 ---
-title: Final Assignment
+title: GAgent
 emoji: 🔥
 colorFrom: green
 colorTo: blue
 sdk: gradio
-sdk_version: 5.26.0
+sdk_version: 5.27.0
 app_file: app.py
 pinned: false
 hf_oauth: true
 hf_oauth_expiration_minutes: 480
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Agentic AI
+
+This project implements multiple agentic systems including:
+1. LangGraph-based agents with various tools
+2. Gemini-powered agents with multimedia analysis capabilities
+3. GAIA agents built with smolagents for flexible deployment
+
+## Project Structure
+
+```text
+.
+├── gagent/           # Main package
+│   ├── __init__.py     # Package initialization
+│   ├── agents/         # Agent implementations
+│   │   ├── base_agent.py      # Base agent implementation
+│   │   ├── gemini_agent.py    # Gemini-based agent
+│   │   ├── huggingface_agent.py # HuggingFace-based agent
+│   │   ├── ollama_agent.py    # Ollama-based agent
+│   │   ├── openai_agent.py    # OpenAI-based agent
+│   │   ├── registry.py        # Agent registry
+│   │   └── __init__.py        # Package initialization
+│   ├── config/         # Configuration settings
+│   │   ├── settings.py        # Application settings
+│   │   └── __init__.py        # Package initialization
+│   ├── rag/            # Retrieval Augmented Generation
+│   │   ├── chroma_vector_store.py   # Chroma vectorstore implementation
+│   │   ├── supabase_vector_store.py # Supabase vectorstore implementation
+│   │   ├── vector_store.py          # Base vectorstore implementation
+│   │   └── __init__.py              # Package initialization
+│   ├── tools/          # Tool implementations
+│   │   ├── code_interpreter.py  # Code execution tools
+│   │   ├── data.py             # Data processing tools
+│   │   ├── file.py             # File handling tools
+│   │   ├── image.py            # Image processing tools
+│   │   ├── math.py             # Mathematical tools
+│   │   ├── media.py            # Media handling tools
+│   │   ├── search.py           # Search tools
+│   │   ├── utilities.py        # Utility tools
+│   │   ├── wrappers.py         # Tool wrappers
+│   │   └── __init__.py         # Package initialization
+├── tests/              # Test files
+│   ├── __init__.py
+│   └── agents/         # Agent tests
+│       ├── fixtures.py      # Test fixtures
+│       ├── test_agents.py   # Agent tests
+│       └── __init__.py      # Package initialization
+├── exp/                # Experimental code and notebooks
+├── app.py             # Gradio application
+├── system_prompt.txt  # System prompt for the agent
+├── pyproject.toml     # Project configuration
+├── requirements.txt   # Dependencies
+├── install.sh         # Installation script
+├── env.example        # Example environment variables
+├── .pre-commit-config.yaml # Pre-commit hooks configuration
+└── README.md          # This file
+```
+
+## Installation
+
+### Quick Start
+```shell
+# Clone the repository
+git clone https://github.com/uoc/gagent.git
+cd gagent
+
+# Run the installation script
+./install.sh
+```
+
+### Manual Installation
+1. Create and activate a virtual environment:
+```shell
+python -m venv .venv
+source .venv/bin/activate  # On Windows: venv\Scripts\activate
+```
+
+2. Install dependencies:
+```shell
+pip install -r requirements.txt
+```
+
+3. Set up environment variables:
+```shell
+cp .env.example .env
+# Edit .env with your API keys and configuration
+```
+
+## Development Setup
+
+### Prerequisites
+- Python 3.8 or higher
+- Git
+- Virtual environment (recommended)
+
+### Development Tools
+The project uses several development tools:
+- **Ruff**: For linting and code formatting
+- **Black**: For code formatting
+- **MyPy**: For type checking
+- **Pytest**: For testing
+
+### Running Development Tools
+```shell
+# Format code
+black .
+
+# Lint code
+ruff check .
+
+# Type check
+mypy .
+
+# Run tests
+pytest
+```
+
+### Pre-commit Hooks
+Pre-commit hooks are set up to run checks before each commit:
+```shell
+pre-commit install
+```
+
+## Configuration
+
+Create a `.env` file with the following variables:
+```python
+# API Keys
+OPENAI_API_KEY=your_openai_api_key
+GOOGLE_API_KEY=your_google_api_key
+HUGGINGFACE_API_KEY=your_huggingface_api_key
+
+# Database Configuration
+SUPABASE_URL=your_supabase_url
+SUPABASE_KEY=your_supabase_key
+
+# Other Configuration
+PYTHONPATH=$(pwd)
+```
+
+## Usage
+
+### Running the Application
+```shell
+python gagent/main.py
+```
+
+### Using Agents Programmatically
+
+#### LangGraph Agent
+```python
+from main import process_question
+
+# Process a question using Google's Gemini
+result = process_question("Your question here", provider="google")
+
+# Or use Groq
+result = process_question("Your question here", provider="groq")
+
+# Or use HuggingFace
+result = process_question("Your question here", provider="huggingface")
+```
+
+#### Gemini Agent
+```python
+from main import create_gemini_agent
+
+# Create the agent
+agent = create_gemini_agent(api_key="your_google_api_key")
+
+# Run a query
+response = agent.run("What are the main effects of climate change?")
+```
+
+#### GAIA Agent
+```python
+from main import create_gaia_agent
+
+# Create with HuggingFace models
+agent = create_gaia_agent(
+    model_type="HfApiModel",
+    model_id="meta-llama/Llama-3-70B-Instruct",
+    verbose=True
+)
+
+# Or create with OpenAI
+agent = create_gaia_agent(
+    model_type="OpenAIServerModel",
+    model_id="gpt-4o",
+    verbose=True
+)
+
+# Answer a question
+response = agent.answer_question("What is the square root of 144?")
+```
+
+## Testing
+
+### Running Tests
+```shell
+# Run all tests
+pytest
+
+# Run tests with coverage
+pytest --cov=gagent
+
+# Run specific test file
+pytest tests/test_agents.py
+```
+
+### Writing Tests
+1. Create test files in the `tests` directory
+2. Use fixtures from `conftest.py`
+3. Follow pytest best practices
+
+## Available Agent Types
+
+1. LangGraph Agent:
+   - Graph-based approach for complex reasoning
+   - Vectorstore-backed retrieval
+   - Multiple LLM provider support
+
+2. Gemini Agent:
+   - Media analysis capabilities (images, videos, tables)
+   - Multi-tool framework with web search and Wikipedia
+   - Conversation memory
+
+3. GAIA Agent:
+   - Built with smolagents
+   - Code execution capability
+   - Multiple model backends
+   - File handling and data analysis
+
+## Available Tools
+
+1. Mathematical Operations:
+   - Addition, Subtraction, Multiplication, Division, Modulus
+
+2. Search Tools:
+   - Wikipedia Search
+   - Web Search (via Tavily or DuckDuckGo)
+   - ArXiv Search
+
+3. File & Media Tools:
+   - Image analysis
+   - Excel/CSV analysis
+   - File download and processing
+
+## Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Set up development environment
+4. Make your changes
+5. Run tests and checks
+6. Commit your changes
+7. Push to the branch
+8. Create a Pull Request
+
+### Development Workflow
+1. Create a new branch:
+```shell
+git checkout -b feature/your-feature-name
+```
+
+2. Make your changes and run checks:
+```shell
+black .
+ruff check .
+mypy .
+pytest
+```
+
+3. Commit your changes:
+```shell
+git add .
+git commit -m "Description of your changes"
+```
+
+4. Push and create a PR:
+```shell
+git push origin feature/your-feature-name
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

app.py

@@ -1,8 +1,15 @@
+"""Basic Agent Evaluation Runner"""
+
+import inspect
 import os
+from typing import Any
+
 import gradio as gr
-import requests
-import inspect
 import pandas as pd
+import requests
+
+from gagent.agents import registry
+from gagent.config import settings
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -10,37 +17,115 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+
+
 class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
-
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+    """A langgraph agent."""
+
+    def __init__(self, agent_type: str, **kwargs):
+        print(f"BasicAgent initialized with type: {agent_type}")
+        self.agent = registry.get_agent(agent_type=agent_type, **kwargs)
+
+    def __call__(self, question: str, question_number: int | None, total_questions: int | None) -> str:
+        print(
+            f"\n{':' * 20}Agent received question ({question_number}/{total_questions}){':' * 20}\n{question}\n{'-' * 100}"
+        )
+        answer = self.agent.run(question, question_number=question_number, total_questions=total_questions)
+        return answer
+
+
+def get_agent_parameters(agent_type: str) -> dict[str, Any]:
+    """Get the parameters for a specific agent type."""
+    if agent_type not in registry._agent_classes:
+        return {}
+
+    agent_class = registry._agent_classes[agent_type]
+    init_signature = inspect.signature(agent_class.__init__)
+
+    parameters = {}
+    for name, param in init_signature.parameters.items():
+        if name == "self":
+            continue
+
+        # Get default value if available
+        default = param.default if param.default != inspect.Parameter.empty else None
+
+        # Get parameter type
+        param_type = param.annotation if param.annotation != inspect.Parameter.empty else str
+
+        # Get parameter description from docstring if available
+        description = ""
+        if agent_class.__doc__:
+            doc_lines = agent_class.__doc__.split("\n")
+            for line in doc_lines:
+                if f"{name}:" in line:
+                    description = line.split(":")[1].strip()
+                    break
+
+        parameters[name] = {
+            "type": param_type,
+            "default": default,
+            "description": description,
+        }
+
+    return parameters
+
+
+def get_settings_value(param_name: str) -> str:
+    """Get the value of a parameter from settings if available."""
+    return getattr(settings, param_name.upper(), "")
+
+
+def run_and_submit_all(request: gr.Request, profile: gr.OAuthProfile | None, *args):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
-    and displays the results.
+    and displays the results. Optionally skips submission.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
 
     if profile:
-        username= f"{profile.username}"
+        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
 
+    # Get available agents from registry
+    available_agents = registry.list_available_agents()
+    if not available_agents:
+        return "No agents available in registry.", None
+
+    agent_type = agent_type_dropdown.value
+
+    # Validate agent type
+    if not agent_type or agent_type not in available_agents:
+        print(f"Invalid agent type: {agent_type}, using first available agent")
+        agent_type = available_agents[0]
+
+    print(f"Running agent with type: {agent_type}")  # Debug log
+
     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)
+    # Get parameters from args
+    parameters = {}
+    agent_params = get_agent_parameters(agent_type)
+    print(f"Agent {agent_type} parameters: {agent_params}")  # Debug log
+
+    # Map input values to their corresponding parameters
+    for i, (param_name, param_info) in enumerate(agent_params.items()):
+        if i < len(parameter_inputs):
+            parameters[param_name] = parameter_inputs[param_name].value
+            print(f"Setting parameter {param_name} = {parameter_inputs[param_name].value}")  # Debug log
+
+    print(f"Agent parameters: {parameters}")  # Debug log
+
+    # 1. Instantiate Agent
     try:
-        agent = BasicAgent()
+        print(f"Initializing agent with type: {agent_type}")
+        agent = BasicAgent(agent_type=agent_type, **parameters)
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -55,48 +140,85 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         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("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
+        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
 
+    # # TODO: Remove this
+    # questions_data = questions_data[:3]
+
     # 3. Run your Agent
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
-    for item in questions_data:
+    total_questions = len(questions_data)
+    print(f"Running agent on {total_questions} questions...")
+
+    # Create a progress bar
+    progress = gr.Progress()
+
+    for i, item in enumerate(questions_data, 1):
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            # Update progress
+            progress((i - 1) / total_questions)
+
+            # Run agent with progress info
+            submitted_answer = agent(question_text, question_number=i, total_questions=total_questions)
             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})
+            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}"})
+            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}",
+                }
+            )
+
+    # Complete progress bar
+    progress(1.0)
 
     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}'..."
+    # 4. Prepare Submission
+    submission_data = {
+        "username": username.strip(),
+        "agent_code": agent_code,
+        "answers": answers_payload,
+    }
+    status_update = f"Agent finished. Preparing {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
-    # 5. Submit
+    # 5. Submit (or Skip)
+    results_df = pd.DataFrame(results_log)
+    if skip_submission:
+        final_status = "Submission skipped as requested."
+        print(final_status)
+        return final_status, results_df
+
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
@@ -110,7 +232,6 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             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}."
@@ -121,25 +242,29 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             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
 
 
+# Dictionary to store parameter inputs for each agent type
+all_parameter_inputs = {}
+
+# Initialize parameter inputs dictionary
+parameter_inputs = {}
+
+skip_submission = True
+
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
@@ -149,7 +274,8 @@ with gr.Blocks() as demo:
 
         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.
+        3.  Select your agent type and configure its parameters.
+        4.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
 
         ---
         **Disclaimers:**
@@ -160,22 +286,145 @@ with gr.Blocks() as demo:
 
     gr.LoginButton()
 
+    with gr.Row():
+        with gr.Column():
+            # Get available agents from registry
+            available_agents = registry.list_available_agents()
+            if not available_agents:
+                raise ValueError("No agents found in registry. Please check your agent implementations.")
+
+            # Get default agent from settings
+            default_agent = settings.DEFAULT_AGENT
+            if default_agent not in available_agents:
+                default_agent = available_agents[0]  # Fallback to first available agent
+                print(f"Default agent '{settings.DEFAULT_AGENT}' not available, using '{default_agent}' instead")
+
+            # Create agent type dropdown with change handler
+            def on_agent_type_change(agent_type: str):
+                """Handle agent type change."""
+                print(f"Agent type changed to: {agent_type}")
+                if not agent_type:
+                    return gr.Column(visible=False)
+
+                param_col = create_parameter_inputs(agent_type)
+                return param_col
+
+            agent_type_dropdown = gr.Dropdown(
+                choices=available_agents,
+                label="Agent Type",
+                value=default_agent,  # Use default agent from settings
+            )
+
+            # Create a container for parameter inputs
+            parameter_container = gr.Column()
+
+            def create_parameter_inputs(agent_type: str):
+                """Create parameter inputs for the selected agent type."""
+                global parameter_inputs
+
+                if not agent_type:
+                    return gr.Column(visible=False)
+
+                print(f"Creating parameter inputs for agent type: {agent_type}")
+
+                parameters = get_agent_parameters(agent_type)
+
+                # Check if we already have inputs for this agent type
+                if agent_type in all_parameter_inputs:
+                    parameter_inputs = all_parameter_inputs[agent_type]
+                else:
+                    # Create new parameter inputs
+                    parameter_inputs = {}
+
+                    # Create a new column for parameters
+                    with gr.Column(visible=True) as param_col:
+                        for param_name, param_info in parameters.items():
+                            # Determine input type based on parameter type
+                            if param_info["type"] == bool:
+                                input_component = gr.Checkbox(
+                                    label=param_name,
+                                    value=param_info["default"] or False,
+                                    info=param_info["description"],
+                                )
+                            elif param_info["type"] == int:
+                                input_component = gr.Number(
+                                    label=param_name,
+                                    value=param_info["default"] or 0,
+                                    info=param_info["description"],
+                                )
+                            elif param_info["type"] == float:
+                                input_component = gr.Number(
+                                    label=param_name,
+                                    value=param_info["default"] or 0.0,
+                                    info=param_info["description"],
+                                )
+                            else:  # Default to text input
+                                # Check if this is likely an API key
+                                is_api_key = any(key in param_name.lower() for key in ["api", "key", "token"])
+                                input_component = gr.Textbox(
+                                    label=param_name,
+                                    value=get_settings_value(param_name) or param_info["default"] or "",
+                                    type="password" if is_api_key else "text",
+                                    info=param_info["description"],
+                                )
+
+                            input_component.placeholder = "Leave blank for default from environment variable"
+                            parameter_inputs[param_name] = input_component
+
+                    # Store in our dictionary
+                    all_parameter_inputs[agent_type] = parameter_inputs
+
+                return param_col
+
+            # Create initial parameter inputs for default agent
+            initial_params = create_parameter_inputs(default_agent)
+            parameter_container = initial_params
+
+            # Update parameter inputs when agent type changes
+            def update_parameter_inputs(agent_type):
+                global parameter_inputs
+                # Update the parameter_inputs reference
+                if agent_type in all_parameter_inputs:
+                    parameter_inputs = all_parameter_inputs[agent_type]
+                return on_agent_type_change(agent_type)
+
+            agent_type_dropdown.change(
+                fn=update_parameter_inputs,
+                inputs=[agent_type_dropdown],
+                outputs=[parameter_container],
+            )
+
     run_button = gr.Button("Run Evaluation & Submit All Answers")
+    skip_submission_checkbox = gr.Checkbox(
+        label="Skip Submission",
+        value=skip_submission,
+        info="Check this box to run the agent without submitting answers to the scoring API.",
+    )
+
+    def update_skip_submission(val: bool):
+        global skip_submission
+        skip_submission = val
+
+    skip_submission_checkbox.change(
+        fn=update_skip_submission,
+        inputs=[skip_submission_checkbox],
+        outputs=[],
+    )
 
     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]
+        inputs=[gr.State(), gr.State()],
+        outputs=[status_output, results_table],
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    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
+    space_id_startup = os.getenv("SPACE_ID")  # Get SPACE_ID at startup
 
     if space_host_startup:
         print(f"✅ SPACE_HOST found: {space_host_startup}")
@@ -183,14 +432,14 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
 
-    if space_id_startup: # Print repo URLs if SPACE_ID is found
+    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("-" * (60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)

env.example

@@ -0,0 +1,23 @@
+PYTHONPATH=gagent
+HUGGINGFACE_API_KEY=
+HUGGINGFACE_REPO_ID=
+
+VECTOR_STORE_TYPE=chroma
+VECTOR_STORE_DOCUMENT_TABLE=documents
+CHROMA_DB_PATH=vector_store.db
+CHROMA_EMBEDDING_MODEL=sentence-transformers/all-mpnet-base-v2
+
+GOOGLE_API_KEY=
+# GEMINI_MODEL=gemini-2.5-pro
+# GEMINI_MODEL=gemini-2.5-pro-exp-03-25
+GEMINI_MODEL=gemini-2.5-flash-preview-04-17
+
+OPENAI_BASE_URL=https://openrouter.ai/api/v1
+OPENAI_API_KEY=
+# OPENAI_MODEL=meta-llama/llama-3.1-405b:free
+OPENAI_MODEL=mistralai/mistral-nemo:free
+
+OLLAMA_BASE_URL=http://localhost:11434
+# OLLAMA_MODEL=mistral-small3.1
+# OLLAMA_MODEL=deepseek-r1:7b
+OLLAMA_MODEL=qwen3

gagent.code-workspace

@@ -0,0 +1,18 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {
+		"sqltools.connections": [
+			{
+				"previewLimit": 50,
+				"driver": "SQLite",
+				"name": "vector store",
+				"database": "${workspaceFolder:uoc-gagent}/vector_store.db"
+			}
+		],
+		"sqltools.useNodeRuntime": true
+	}
+}

gagent/__init__.py

@@ -0,0 +1,7 @@
+"""NBU Agent package."""
+
+from .config import settings  # noqa
+from .rag.vector_store import VectorStore  # noqa
+
+from .agents import *  # noqa
+from .tools import *  # noqa

gagent/agents/__init__.py

@@ -0,0 +1,17 @@
+"""Agent package initialization."""
+
+from gagent.agents.base_agent import BaseAgent
+from gagent.agents.gemini_agent import GeminiAgent
+from gagent.agents.huggingface_agent import HuggingFaceAgent
+from gagent.agents.ollama_agent import OllamaAgent
+from gagent.agents.openai_agent import OpenAIAgent
+from gagent.agents.registry import registry
+
+__all__ = [
+    "BaseAgent",
+    "GeminiAgent",
+    "HuggingFaceAgent",
+    "OllamaAgent",
+    "OpenAIAgent",
+    "registry",
+]

gagent/agents/base_agent.py

@@ -0,0 +1,224 @@
+"""Base agent implementation."""
+
+import json
+import time
+from urllib.parse import urlparse
+
+import yt_dlp
+from langchain.memory import ConversationBufferMemory
+from langchain.tools import Tool
+from langchain.tools.retriever import create_retriever_tool
+from langchain_community.utilities import DuckDuckGoSearchAPIWrapper
+from langchain_core.documents import Document
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from langgraph.graph import START, MessagesState, StateGraph
+from langgraph.prebuilt import ToolNode, tools_condition
+
+from gagent.config.settings import (
+    VECTOR_STORE_DOCUMENT_TABLE,
+    CHROMA_EMBEDDING_MODEL,
+    CHROMA_DB_PATH,
+)
+from gagent.tools import TOOLS
+from gagent.rag.vector_store import VectorStore
+
+
+class BaseAgent:
+    """Base class for all agents."""
+
+    name = "__BASE__"
+
+    SYSTEM_PROMPT = "You are a helpful assistant."
+
+    TEMPERATURE = 0.0
+    MAX_ITERATIONS = 5
+    MAX_RETRIES = 3
+    BASE_SLEEP = 0.5
+    MAX_SLEEP = 2
+
+    def __init__(self, model_name: str | None, api_key: str | None, base_url: str | None):
+        # Suppress warnings
+        import warnings
+
+        warnings.filterwarnings("ignore", category=UserWarning)
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
+        warnings.filterwarnings("ignore", message=".*will be deprecated.*")
+        warnings.filterwarnings("ignore", "LangChain.*")
+
+        # Load system prompt from file
+        with open("system_prompt.txt", "r") as file:
+            self.SYSTEM_PROMPT = file.read()
+
+        self.model_name = model_name
+        self.api_key = api_key
+        self.base_url = base_url
+
+        self.llm = self.create_llm(self.model_name, self.api_key, self.base_url)
+
+        masked_api_key = "********" if self.api_key else "Not Provided"
+        print(
+            f"Agent {self.name} initialized with model: {self.model_name}, base_url: {self.base_url}, api_key: {masked_api_key}"
+        )
+
+        # Setup tools
+        self.tools = [Tool(name=tool.name, func=tool.func, description=tool.description) for tool in TOOLS]
+
+        # Setup memory
+        self.memory = ConversationBufferMemory(memory_key="chat_history", return_messages=True)
+
+        # Create system message
+        self.sys_msg = SystemMessage(content=self.SYSTEM_PROMPT)
+
+        # Initialize vector store
+        self.vector_store = self._init_vector_store()
+
+        self.question_retrieve_tool = create_retriever_tool(
+            self.vector_store.store.as_retriever(),
+            "Question Retriever",
+            "Find similar questions in the vector database for the given question.",
+        )
+
+        # Build the graph
+        self.graph = self._build_graph()
+
+    def create_llm(self, model_name: str, api_key: str, base_url: str) -> BaseChatModel:
+        """Create the LLM based on the model name, API key, and base URL."""
+        raise NotImplementedError("Subclasses must implement this method.")
+
+    def _init_vector_store(self) -> VectorStore:
+        """Initialize the SQLite vector store."""
+        vs = VectorStore.create(
+            store_type="chroma",
+            db_path=CHROMA_DB_PATH,
+            document_table=VECTOR_STORE_DOCUMENT_TABLE,
+            embedding_model=CHROMA_EMBEDDING_MODEL,
+        )
+        # Initialize the vector store
+        # Load the metadata.jsonl file
+        # with open(GAIA_DATASET_METADATA_PATH) as jsonl_file:
+        #     json_list = list(jsonl_file)
+
+        # json_QA = []
+        # for json_str in json_list:
+        #     json_data = json.loads(json_str)
+        #     json_QA.append(json_data)
+
+        # docs = []
+        # for sample in json_QA:
+        #     doc = Document(
+        #         page_content=f"Question : {sample['Question']}\n\nFinal answer : {sample['Final answer']}",
+        #         metadata={  # Meatadata format must have source key.
+        #             "source": sample["task_id"]
+        #         },
+        #     )
+        #     docs.append(doc)
+
+        # vs.store.add_documents(documents=docs, ids=[str(i) for i in range(len(docs))])
+
+        return vs
+
+    def _build_graph(self):
+        """Build the StateGraph for the agent."""
+        # Bind tools to LLM
+        llm_with_tools = self.llm.bind_tools(self.tools)
+
+        # Node functions
+        def assistant(state: MessagesState):
+            """Assistant node"""
+            return {"messages": [llm_with_tools.invoke(state["messages"])]}
+
+        def retriever(state: MessagesState):
+            """Retriever node"""
+            similar_question = self.vector_store.similarity_search(state["messages"][0].content)
+            if len(similar_question) > 0:
+                example_msg = HumanMessage(
+                    content=f"Here I provide a similar question and answer for reference: \n\n{similar_question[0].page_content}",
+                )
+                return {"messages": [self.sys_msg] + state["messages"] + [example_msg]}
+            else:
+                return {"messages": [self.sys_msg] + state["messages"]}
+
+        # Build graph
+        builder = StateGraph(MessagesState)
+        builder.add_node("retriever", retriever)
+        builder.add_node("assistant", assistant)
+        builder.add_node("tools", ToolNode(TOOLS))
+        # builder.add_node("tools", ToolNode(TOOLS + [self.question_retrieve_tool]))
+
+        # builder.add_edge(START, "assistant")
+        builder.add_edge(START, "retriever")
+        builder.add_edge("retriever", "assistant")
+        builder.add_conditional_edges(
+            "assistant",
+            # If the latest message (result) from assistant is a tool call -> tools_condition routes to tools
+            # If the latest message (result) from assistant is a not a tool call -> tools_condition routes to END
+            tools_condition,
+        )
+        builder.add_edge("tools", "assistant")
+
+        # Compile graph
+        return builder.compile()
+
+    def run(self, query: str, question_number: int | None, total_questions: int | None) -> str:
+        """Run the agent on a query"""
+        progress_info = ""
+        if question_number is not None and total_questions is not None:
+            progress_info = f"[Question {question_number}/{total_questions}] "
+
+        print(f"{progress_info}Running graph...")
+
+        return self.run_graph(query, progress_info)
+
+    def run_graph(self, query: str, progress_info: str) -> str:
+        """Run the graph."""
+        messages = [self.sys_msg] + [HumanMessage(content=query)]
+        messages = self.graph.invoke({"messages": messages})
+
+        for m in messages["messages"]:
+            m.pretty_print()
+
+        return messages["messages"][-1].content
+
+    def run_rag(self, query: str, progress_info: str) -> str:
+        for attempt in range(self.MAX_RETRIES):
+            try:
+                # Create initial messages
+                messages = [HumanMessage(content=query)]
+
+                # Run the graph
+                result = self.graph.invoke({"messages": messages})
+
+                # Get the final message
+                final_message = result["messages"][-1]
+
+                # Log the LLM response with progress info
+                print(f"{progress_info}LLM Response: {final_message.content}")
+
+                # Save to memory
+                self.memory.save_context({"input": query}, {"output": final_message.content})
+
+                return final_message.content
+
+            except Exception as e:
+                # Calculate exponential backoff with jitter
+                sleep_time = min(self.BASE_SLEEP * (2**attempt), self.MAX_SLEEP)
+                if attempt < self.MAX_RETRIES - 1:
+                    print(f"{progress_info}Attempt {attempt + 1} failed. Retrying in {sleep_time} seconds...")
+                    time.sleep(sleep_time)
+                    continue
+                print(f"{progress_info}Error processing query after {self.MAX_RETRIES} attempts: {e!s}")
+                return f"Error processing query after {self.MAX_RETRIES} attempts: {e!s}"
+
+    def run_interactive(self):
+        """Run the agent in interactive mode."""
+        print("AI Assistant Ready! (Type 'exit' to quit)")
+
+        while True:
+            query = input("You: ").strip()
+            if query.lower() == "exit":
+                print("Goodbye!")
+                break
+
+            print("Assistant:", self.run_rag(query))

gagent/agents/gemini_agent.py

@@ -0,0 +1,45 @@
+"""Gemini agent implementation."""
+
+import google.generativeai as genai
+from google.generativeai.types import HarmBlockThreshold, HarmCategory
+from langchain_core.messages import SystemMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+from ..config.settings import GEMINI_MODEL, GOOGLE_API_KEY
+from .base_agent import BaseAgent
+
+
+class GeminiAgent(BaseAgent):
+    name = "gemini"
+
+    def create_llm(self, model_name: str, api_key: str, base_url: str):
+        api_key = api_key if api_key else self.api_key or GOOGLE_API_KEY
+        model_name = model_name if model_name else self.model_name or GEMINI_MODEL
+
+        # Configure Gemini
+        genai.configure(api_key=api_key)
+
+        # Set up model with video capabilities
+        generation_config = {
+            "temperature": self.TEMPERATURE,
+            "max_output_tokens": 2000,
+            "candidate_count": 1,
+        }
+
+        # Set up the language model.
+        safety_settings = {
+            HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+            HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+            HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+            HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
+        }
+
+        self.llm = ChatGoogleGenerativeAI(
+            model=model_name,
+            google_api_key=api_key,
+            generation_config=generation_config,
+            safety_settings=safety_settings,
+            system_message=SystemMessage(content=self.SYSTEM_PROMPT),
+        )
+
+        return self.llm

gagent/agents/huggingface_agent.py

@@ -0,0 +1,36 @@
+"""HuggingFace Space API agent implementation."""
+
+from huggingface_hub import login
+from langchain_huggingface import ChatHuggingFace
+
+from ..config.settings import HUGGINGFACE_API_KEY, HUGGINGFACE_REPO_ID
+from .base_agent import BaseAgent
+
+
+class HuggingFaceAgent(BaseAgent):
+    """Agent for interacting with Hugging Face Space API."""
+
+    name = "huggingface"
+
+    def create_llm(self, model_name: str, api_token: str | None):
+        """Create the LLM based on the model name and API token.
+
+        Args:
+            model_name: The Hugging Face repository ID in format "username/repo_name".
+            api_token: The Hugging Face API token.
+        """
+        api_token = api_token if api_token else self.api_token or HUGGINGFACE_API_KEY
+        model_name = model_name if model_name else self.model_name or HUGGINGFACE_REPO_ID
+
+        if api_token is None:
+            api_token = HUGGINGFACE_API_KEY
+
+        login(token=api_token)
+
+        self.llm = ChatHuggingFace(
+            repo_id=model_name,
+            task="text-generation",
+            temperature=self.TEMPERATURE,
+        )
+
+        return self.llm

gagent/agents/ollama_agent.py

@@ -0,0 +1,24 @@
+"""Ollama agent implementation."""
+
+from langchain_ollama import ChatOllama
+
+from ..config.settings import OLLAMA_API_KEY, OLLAMA_BASE_URL, OLLAMA_MODEL
+from .base_agent import BaseAgent
+
+
+class OllamaAgent(BaseAgent):
+    name = "ollama"
+
+    def create_llm(self, model_name: str, api_key: str, base_url: str):
+        model_name = model_name if model_name else self.model_name or OLLAMA_MODEL
+        api_key = api_key if api_key else self.api_key or OLLAMA_API_KEY
+        base_url = base_url if base_url else self.base_url or OLLAMA_BASE_URL
+
+        self.llm = ChatOllama(
+            model=model_name,
+            base_url=base_url,
+            api_key=api_key,
+            temperature=self.TEMPERATURE,
+        )
+
+        return self.llm

gagent/agents/openai_agent.py

@@ -0,0 +1,36 @@
+"""OpenAI API agent implementation using LangChain."""
+
+from langchain_openai import ChatOpenAI
+
+from ..config.settings import OPENAI_API_KEY, OPENAI_BASE_URL, OPENAI_MODEL
+from .base_agent import BaseAgent
+
+
+class OpenAIAgent(BaseAgent):
+    """Agent for interacting with OpenAI API using LangChain."""
+
+    name = "openai"
+
+    def create_llm(self, model_name: str, api_key: str, base_url: str):
+        model_name = model_name if model_name else self.model_name or OPENAI_MODEL
+        api_key = api_key if api_key else self.api_key or OPENAI_API_KEY
+        base_url = base_url if base_url else self.base_url or OPENAI_BASE_URL
+
+        self.llm = ChatOpenAI(
+            model_name=model_name,
+            openai_api_key=api_key,
+            openai_api_base=base_url,
+            temperature=self.TEMPERATURE,
+            model_kwargs=(
+                {
+                    "headers": {
+                        "HTTP-Referer": "https://huggingface.co/spaces/uoc/Agentic_Final_Assignment/tree/main",
+                        "X-Title": "NBU Agent",
+                    }
+                }
+                if "openai" in base_url
+                else {}
+            ),
+        )
+
+        return self.llm

gagent/agents/registry.py

@@ -0,0 +1,85 @@
+"""Agent registry implementation."""
+
+import importlib
+import inspect
+import pkgutil
+from functools import lru_cache
+
+from .base_agent import BaseAgent
+
+
+class AgentRegistry:
+    """Registry for managing different agent types."""
+
+    def __init__(self):
+        self._agent_classes: dict[str, type[BaseAgent]] = {}
+        self._instances: dict[str, BaseAgent] = {}
+        self._scan_agent_classes()
+        print(f"Agent registry initialized with {len(self._agent_classes)} agents as {self.list_available_agents()}")
+
+    def _scan_agent_classes(self):
+        """Scan the agents module for agent classes and register them."""
+        # Import the agents package
+        agents_package = importlib.import_module("gagent.agents")
+
+        # Iterate through all modules in the agents package
+        for _, module_name, _ in pkgutil.iter_modules(agents_package.__path__):
+            try:
+                # Import the module
+                module = importlib.import_module(f"gagent.agents.{module_name}")
+
+                # Find all classes in the module that are BaseAgent subclasses
+                for name, obj in inspect.getmembers(module):
+                    if (
+                        inspect.isclass(obj)
+                        and issubclass(obj, BaseAgent)
+                        and obj != BaseAgent
+                        and hasattr(obj, "name")
+                    ):
+                        # Register the agent class using its name attribute
+                        self.register_agent(obj.name, obj)
+
+            except ImportError:
+                # Skip modules that can't be imported
+                continue
+
+    def register_agent(self, agent_type: str, agent_class: type[BaseAgent]):
+        """Register a new agent class."""
+        if agent_type in self._agent_classes:
+            raise ValueError(f"Agent type '{agent_type}' is already registered")
+        self._agent_classes[agent_type] = agent_class
+
+    @lru_cache(maxsize=32)
+    def get_agent(self, agent_type: str, **kwargs) -> BaseAgent:
+        """
+        Get an agent instance. Creates a new instance if one doesn't exist.
+
+        Args:
+            agent_type: Type of agent to get (e.g., "gemini", "ollama")
+            **kwargs: Configuration parameters for the agent
+
+        Returns:
+            An instance of the requested agent type
+
+        Raises:
+            ValueError: If the agent type is not registered
+        """
+        if agent_type not in self._agent_classes:
+            raise ValueError(f"Unknown agent type: {agent_type}")
+
+        # Create a unique key for this configuration
+        config_key = f"{agent_type}:{sorted(kwargs.items())!s}"
+
+        if config_key not in self._instances:
+            agent_class = self._agent_classes[agent_type]
+            self._instances[config_key] = agent_class(**kwargs)
+
+        return self._instances[config_key]
+
+    def list_available_agents(self) -> list[str]:
+        """List all available agent types."""
+        return list(self._agent_classes.keys())
+
+
+# Create a global registry instance
+registry = AgentRegistry()

gagent/config/settings.py

@@ -0,0 +1,46 @@
+"""Configuration settings for the application."""
+
+import os
+
+from dotenv import load_dotenv
+
+
+# Load environment variables
+load_dotenv()
+
+HUGGINGFACE_API_KEY = os.environ.get("HUGGINGFACE_API_KEY")
+HUGGINGFACE_REPO_ID = os.environ.get("HUGGINGFACE_REPO_ID")
+
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY")
+OPENAI_MODEL = os.environ.get("OPENAI_MODEL", "openai/gpt-4o")
+OPENAI_BASE_URL = os.environ.get("OPENAI_BASE_URL", "https://openai.com/api/v1")
+
+OLLAMA_API_KEY = os.environ.get("OLLAMA_API_KEY")
+OLLAMA_MODEL = os.environ.get("OLLAMA_MODEL", "llama3.1:8b")
+OLLAMA_BASE_URL = os.environ.get("OLLAMA_BASE_URL", "http://localhost:11434")
+
+# Model configurations
+GROQ_MODEL = os.environ.get("GROQ_MODEL", "qwen-qwq-32b")
+GEMINI_MODEL = os.environ.get("GEMINI_MODEL", "gemini-2.5-pro")
+HF_MODEL_URL = os.environ.get(
+    "HF_MODEL_URL",
+    "https://api-inference.huggingface.co/models/Meta-DeepLearning/llama-2-7b-chat-hf",
+)
+
+# Default agent configuration
+DEFAULT_AGENT = os.environ.get("DEFAULT_AGENT", "ollama")
+
+# Vector store settings
+VECTOR_STORE_TYPE = os.environ.get("VECTOR_STORE_TYPE", "chroma")
+VECTOR_STORE_DOCUMENT_TABLE = os.environ.get("VECTOR_STORE_DOCUMENT_TABLE", "documents")
+
+# Chroma settings
+CHROMA_EMBEDDING_MODEL = os.environ.get("CHROMA_EMBEDDING_MODEL", "sentence-transformers/all-mpnet-base-v2")
+CHROMA_DB_PATH = os.environ.get("CHROMA_DB_PATH", "vector_store.db")
+
+# Supabase settings
+SUPABASE_URL = os.environ.get("SUPABASE_URL")
+SUPABASE_KEY = os.environ.get("SUPABASE_KEY")
+SUPABASE_TABLE_NAME = VECTOR_STORE_DOCUMENT_TABLE

gagent/rag/__init__.py

@@ -0,0 +1,11 @@
+from gagent.rag.vector_store import VectorStore  # noqa
+from gagent.rag.chroma_vector_store import ChromaVectorStore  # noqa
+from gagent.rag.supabase_vector_store import SupabaseVectorStore  # noqa
+
+
+def create_vector_store(store_type=None, **kwargs):
+    """Factory function to create a vector store instance."""
+    return VectorStore.create(store_type, **kwargs)
+
+
+__all__ = ["VectorStore", "ChromaVectorStore", "SupabaseVectorStore", "create_vector_store"]

gagent/rag/chroma_vector_store.py

@@ -0,0 +1,46 @@
+from typing import Any, Dict, List, Optional, Tuple
+
+from langchain_chroma import Chroma
+
+from gagent.rag.vector_store import VectorStore
+from gagent.config.settings import CHROMA_DB_PATH, VECTOR_STORE_DOCUMENT_TABLE
+
+
+@VectorStore.register("chroma")
+class ChromaVectorStore(VectorStore):
+    """Chroma vector store implementation."""
+
+    def __init__(self, db_path=None, document_table=None, embedding_model=None, **kwargs):
+        """Initialize the Chroma vector store."""
+        super().__init__(embedding_model=embedding_model, **kwargs)
+
+        self.db_path = db_path or CHROMA_DB_PATH
+        self.document_table = document_table or VECTOR_STORE_DOCUMENT_TABLE
+
+        if not all([self.db_path, self.document_table]):
+            raise ValueError("db_path and document_table must be provided.")
+
+        self.store = Chroma(
+            collection_name=self.document_table,
+            embedding_function=self.embedding,
+            persist_directory=self.db_path,
+            create_collection_if_not_exists=True,
+        )
+
+    def add_texts(
+        self, texts: List[str], metadatas: Optional[List[Dict]] = None, ids: Optional[List[str]] = None, **kwargs
+    ) -> List[str]:
+        """Add texts to the vector store."""
+        return self.store.add_texts(texts, metadatas, ids, **kwargs)
+
+    def similarity_search(self, query: str, k: int = 4, **kwargs) -> List[Any]:
+        """Search for documents similar to the query."""
+        return self.store.similarity_search(query, k, **kwargs)
+
+    def similarity_search_with_score(self, query: str, k: int = 4, **kwargs) -> List[Tuple[Any, float]]:
+        """Search for documents similar to the query and return with scores."""
+        return self.store.similarity_search_with_score(query, k, **kwargs)
+
+    def delete(self, ids: List[str], **kwargs) -> Optional[bool]:
+        """Delete documents from the vector store."""
+        return self.store.delete(ids, **kwargs)

gagent/rag/supabase_vector_store.py

@@ -0,0 +1,55 @@
+from langchain_community.vectorstores import SupabaseVectorStore as LangchainSupabaseVectorStore
+from supabase.client import create_client
+from typing import Dict, List, Optional, Tuple, Any
+
+from gagent.rag.vector_store import VectorStore
+from gagent.config.settings import (
+    SUPABASE_URL,
+    SUPABASE_KEY,
+    SUPABASE_TABLE_NAME,
+)
+
+
+@VectorStore.register("supabase")
+class SupabaseVectorStore(VectorStore):
+    """Supabase vector store implementation."""
+
+    def __init__(self, supabase_url=None, supabase_key=None, table_name=None, embedding_model=None, **kwargs):
+        """Initialize the Supabase vector store."""
+        super().__init__(embedding_model=embedding_model, **kwargs)
+
+        self.supabase_url = supabase_url or SUPABASE_URL
+        self.supabase_key = supabase_key or SUPABASE_KEY
+        self.table_name = table_name or SUPABASE_TABLE_NAME
+
+        if not all([self.supabase_url, self.supabase_key, self.table_name]):
+            raise ValueError("supabase_url, supabase_key, and table_name must be provided.")
+
+        # Create Supabase client
+        self.supabase_client = create_client(self.supabase_url, self.supabase_key)
+
+        # Initialize Supabase vector store
+        self.store = LangchainSupabaseVectorStore(
+            client=self.supabase_client,
+            embedding=self.embedding,
+            table_name=self.table_name,
+            query_name="match_documents",
+        )
+
+    def add_texts(
+        self, texts: List[str], metadatas: Optional[List[Dict]] = None, ids: Optional[List[str]] = None, **kwargs
+    ) -> List[str]:
+        """Add texts to the vector store."""
+        return self.store.add_texts(texts, metadatas, ids, **kwargs)
+
+    def similarity_search(self, query: str, k: int = 4, **kwargs) -> List[Any]:
+        """Search for documents similar to the query."""
+        return self.store.similarity_search(query, k, **kwargs)
+
+    def similarity_search_with_score(self, query: str, k: int = 4, **kwargs) -> List[Tuple[Any, float]]:
+        """Search for documents similar to the query and return with scores."""
+        return self.store.similarity_search_with_score(query, k, **kwargs)
+
+    def delete(self, ids: List[str], **kwargs) -> Optional[bool]:
+        """Delete documents from the vector store."""
+        return self.store.delete(ids, **kwargs)

gagent/rag/vector_store.py

@@ -0,0 +1,61 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Tuple, Any, Type
+from langchain_huggingface import HuggingFaceEmbeddings
+
+from gagent.config.settings import VECTOR_STORE_TYPE, CHROMA_EMBEDDING_MODEL
+
+
+class VectorStore(ABC):
+    """Abstract base class for vector store implementations."""
+
+    _registry: Dict[str, Type["VectorStore"]] = {}
+    embedding = None
+
+    @classmethod
+    def register(cls, name: str):
+        """Register a vector store implementation."""
+
+        def decorator(subclass):
+            cls._registry[name] = subclass
+            return subclass
+
+        return decorator
+
+    @classmethod
+    def create(cls, store_type: str = None, **kwargs):
+        """Create a vector store instance of the specified type."""
+        store_type = store_type or VECTOR_STORE_TYPE
+        if store_type not in cls._registry:
+            raise ValueError(f"Vector store type '{store_type}' not found in registry.")
+        return cls._registry[store_type](**kwargs)
+
+    def __init__(self, embedding_model=None, **kwargs):
+        """Initialize the vector store with embeddings."""
+        embedding_model = embedding_model or CHROMA_EMBEDDING_MODEL
+        self.embedding = (
+            embedding_model
+            if isinstance(embedding_model, HuggingFaceEmbeddings)
+            else HuggingFaceEmbeddings(model_name=embedding_model)
+        )
+
+    @abstractmethod
+    def add_texts(
+        self, texts: List[str], metadatas: Optional[List[Dict]] = None, ids: Optional[List[str]] = None, **kwargs
+    ) -> List[str]:
+        """Add texts to the vector store."""
+        pass
+
+    @abstractmethod
+    def similarity_search(self, query: str, k: int = 4, **kwargs) -> List[Any]:
+        """Search for documents similar to the query."""
+        pass
+
+    @abstractmethod
+    def similarity_search_with_score(self, query: str, k: int = 4, **kwargs) -> List[Tuple[Any, float]]:
+        """Search for documents similar to the query and return with scores."""
+        pass
+
+    @abstractmethod
+    def delete(self, ids: List[str], **kwargs) -> Optional[bool]:
+        """Delete documents from the vector store."""
+        pass

gagent/tools/__init__.py

@@ -0,0 +1,76 @@
+"""Tool implementations package."""
+
+from gagent.tools.code_interpreter import execute_code_multilang
+from gagent.tools.data import analyze_csv_file, analyze_excel_file, analyze_list, analyze_table
+from gagent.tools.file import download_file_from_url, extract_text_from_image, save_and_read_file
+from gagent.tools.image import (
+    analyze_image,
+    combine_images,
+    draw_on_image,
+    generate_simple_image,
+    transform_image,
+)
+from gagent.tools.math import add, divide, modulus, multiply, power, square_root, subtract
+from gagent.tools.media import analyze_video
+from gagent.tools.search import arxiv_search, web_search, wiki_search
+from gagent.tools.wrappers import SmolagentToolWrapper, duckduckgo_search_tool, wikipedia_search_tool
+
+__all__ = [
+    "add",
+    "analyze_csv_file",
+    "analyze_excel_file",
+    "analyze_image",
+    "analyze_list",
+    "analyze_table",
+    "analyze_video",
+    "arxiv_search",
+    "combine_images",
+    "divide",
+    "download_file_from_url",
+    "draw_on_image",
+    "execute_code_multilang",
+    "extract_text_from_image",
+    "generate_simple_image",
+    "modulus",
+    "multiply",
+    "power",
+    "save_and_read_file",
+    "SmolagentToolWrapper",
+    "square_root",
+    "subtract",
+    "transform_image",
+    "web_search",
+    "wiki_search",
+    "duckduckgo_search_tool",
+    "wikipedia_search_tool",
+]
+
+# All TOOLS
+TOOLS = [
+    add,
+    analyze_csv_file,
+    analyze_excel_file,
+    analyze_image,
+    analyze_list,
+    analyze_table,
+    analyze_video,
+    arxiv_search,
+    combine_images,
+    divide,
+    download_file_from_url,
+    draw_on_image,
+    execute_code_multilang,
+    extract_text_from_image,
+    generate_simple_image,
+    modulus,
+    multiply,
+    power,
+    save_and_read_file,
+    square_root,
+    subtract,
+    transform_image,
+    web_search,
+    wiki_search,
+    # duckduckgo_search_tool,
+    # wikipedia_search_tool,
+]

gagent/tools/code_interpreter.py

@@ -0,0 +1,333 @@
+import base64
+import contextlib
+import io
+import os
+import shutil
+import sqlite3
+import subprocess
+import tempfile
+import traceback
+import uuid
+from typing import Any, Dict
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from PIL import Image
+
+from langchain_core.tools import tool
+
+
+class CodeInterpreter:
+    # Singleton instance
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(CodeInterpreter, cls).__new__(cls)
+            cls._instance._initialized = False
+        return cls._instance
+
+    @classmethod
+    def get_instance(cls, *args, **kwargs):
+        """Get or create the singleton instance of CodeInterpreter."""
+        if cls._instance is None:
+            return cls(*args, **kwargs)
+        return cls._instance
+
+    def __init__(self, allowed_modules=None, max_execution_time=30, working_directory=None):
+        """Initialize the code interpreter with safety measures."""
+        # Only initialize once
+        if getattr(self, "_initialized", False):
+            return
+
+        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):
+            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")
+        self._initialized = True
+
+    def _create_default_result(self, execution_id: str) -> Dict[str, Any]:
+        """Create a default result dictionary."""
+        return {
+            "execution_id": execution_id,
+            "status": "error",
+            "stdout": "",
+            "stderr": "",
+            "result": None,
+            "plots": [],
+            "dataframes": [],
+        }
+
+    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())
+
+        execution_handlers = {
+            "python": self._execute_python,
+            "bash": self._execute_bash,
+            "sql": self._execute_sql,
+            "c": self._execute_c,
+            "java": self._execute_java,
+        }
+
+        try:
+            if language in execution_handlers:
+                return execution_handlers[language](code, execution_id)
+            else:
+                result = self._create_default_result(execution_id)
+                result["stderr"] = f"Unsupported language: {language}"
+                return result
+        except Exception as e:
+            result = self._create_default_result(execution_id)
+            result["stderr"] = str(e)
+            return result
+
+    def _execute_python(self, code: str, execution_id: str) -> dict:
+        result = self._create_default_result(execution_id)
+        output_buffer = io.StringIO()
+        error_buffer = io.StringIO()
+
+        exec_dir = os.path.join(self.working_directory, execution_id)
+        try:
+            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)
+
+                # Handle matplotlib plots
+                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})
+
+                # Extract dataframes from globals
+                for var_name, var_value in self.globals.items():
+                    if isinstance(var_value, pd.DataFrame) and not var_value.empty:
+                        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["stderr"] = f"{error_buffer.getvalue()}\n{traceback.format_exc()}"
+        finally:
+            plt.close("all")  # Clean up all matplotlib figures
+
+        return result
+
+    def _execute_bash(self, code: str, execution_id: str) -> dict:
+        result = self._create_default_result(execution_id)
+
+        try:
+            completed = subprocess.run(
+                code, shell=True, capture_output=True, text=True, timeout=self.max_execution_time
+            )
+            result["status"] = "success" if completed.returncode == 0 else "error"
+            result["stdout"] = completed.stdout
+            result["stderr"] = completed.stderr
+        except subprocess.TimeoutExpired:
+            result["stderr"] = "Execution timed out."
+        except Exception as e:
+            result["stderr"] = str(e)
+
+        return result
+
+    def _execute_sql(self, code: str, execution_id: str) -> dict:
+        result = self._create_default_result(execution_id)
+        conn = None
+
+        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:
+            if conn:
+                conn.close()
+
+        return result
+
+    def _execute_c(self, code: str, execution_id: str) -> dict:
+        result = self._create_default_result(execution_id)
+        temp_dir = tempfile.mkdtemp()
+
+        try:
+            source_path = os.path.join(temp_dir, "program.c")
+            binary_path = os.path.join(temp_dir, "program")
+
+            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:
+                result["stdout"] = compile_proc.stdout
+                result["stderr"] = compile_proc.stderr
+                return result
+
+            run_proc = subprocess.run([binary_path], capture_output=True, text=True, timeout=self.max_execution_time)
+
+            result["status"] = "success" if run_proc.returncode == 0 else "error"
+            result["stdout"] = run_proc.stdout
+            result["stderr"] = run_proc.stderr
+
+        except Exception as e:
+            result["stderr"] = str(e)
+        finally:
+            # Clean up temp directory
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+        return result
+
+    def _execute_java(self, code: str, execution_id: str) -> dict:
+        result = self._create_default_result(execution_id)
+        temp_dir = tempfile.mkdtemp()
+
+        try:
+            source_path = os.path.join(temp_dir, "Main.java")
+
+            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:
+                result["stdout"] = compile_proc.stdout
+                result["stderr"] = compile_proc.stderr
+                return result
+
+            run_proc = subprocess.run(
+                ["java", "-cp", temp_dir, "Main"], capture_output=True, text=True, timeout=self.max_execution_time
+            )
+
+            result["status"] = "success" if run_proc.returncode == 0 else "error"
+            result["stdout"] = run_proc.stdout
+            result["stderr"] = run_proc.stderr
+
+        except Exception as e:
+            result["stderr"] = str(e)
+        finally:
+            # Clean up temp directory
+            shutil.rmtree(temp_dir, ignore_errors=True)
+
+        return result
+
+
+@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 = CodeInterpreter.get_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)

gagent/tools/data.py

@@ -0,0 +1,116 @@
+"""Data analysis tools for agents."""
+
+import pandas as pd
+from langchain_core.tools import tool
+
+
+@tool
+def analyze_table(table_data: str) -> str:
+    """
+    Analyze table or matrix data.
+
+    Args:
+        table_data: String representation of table data
+
+    Returns:
+        Analysis of the table structure and content
+    """
+    try:
+        if not table_data or not isinstance(table_data, str):
+            return "Please provide valid table data for analysis."
+
+        # Basic table analysis logic
+        lines = table_data.strip().split("\n")
+        num_rows = len(lines)
+        num_cols = max(len(line.split()) for line in lines) if lines else 0
+
+        return f"Table contains {num_rows} rows and approximately {num_cols} columns.\nUse this for further detailed analysis."
+    except Exception as e:
+        return f"Error analyzing table: {str(e)}"
+
+
+@tool
+def analyze_list(list_data: str) -> str:
+    """
+    Analyze and categorize list items.
+
+    Args:
+        list_data: Comma-separated list of items
+
+    Returns:
+        Analysis of the list items
+    """
+    if not list_data:
+        return "No list data provided."
+    try:
+        items = [x.strip() for x in list_data.split(",")]
+        if not items:
+            return "Please provide a comma-separated list of items."
+
+        return f"List contains {len(items)} items. First few items: {', '.join(items[:5])}" + (
+            "..." if len(items) > 5 else ""
+        )
+    except Exception as e:
+        return f"Error analyzing list: {str(e)}"
+
+
+@tool
+def analyze_csv_file(file_path: str, query: str) -> str:
+    """
+    Analyze a CSV file based on a query using pandas.
+
+    Args:
+        file_path: Path to the CSV file
+        query: Query to analyze the data
+
+    Returns:
+        Analysis results as a string
+    """
+    try:
+        # Read the CSV file
+        df = pd.read_csv(file_path)
+
+        # Basic analysis based on query
+        if "describe" in query.lower():
+            return str(df.describe())
+        elif "info" in query.lower():
+            return str(df.info())
+        elif "head" in query.lower():
+            return str(df.head())
+        elif "columns" in query.lower():
+            return str(df.columns.tolist())
+        else:
+            return f"Available analysis options: describe, info, head, columns. Current query: {query}"
+    except Exception as e:
+        return f"Error analyzing CSV file: {e!s}"
+
+
+@tool
+def analyze_excel_file(file_path: str, query: str) -> str:
+    """
+    Analyze an Excel file based on a query using pandas.
+
+    Args:
+        file_path: Path to the Excel file
+        query: Query to analyze the data
+
+    Returns:
+        Analysis results as a string
+    """
+    try:
+        # Read the Excel file
+        df = pd.read_excel(file_path)
+
+        # Basic analysis based on query
+        if "describe" in query.lower():
+            return str(df.describe())
+        elif "info" in query.lower():
+            return str(df.info())
+        elif "head" in query.lower():
+            return str(df.head())
+        elif "columns" in query.lower():
+            return str(df.columns.tolist())
+        else:
+            return f"Available analysis options: describe, info, head, columns. Current query: {query}"
+    except Exception as e:
+        return f"Error analyzing Excel file: {e!s}"

gagent/tools/file.py

@@ -0,0 +1,105 @@
+"""File handling tools for agents."""
+
+import os
+import tempfile
+from urllib.parse import urlparse
+
+import requests
+from langchain_core.tools import tool
+
+
+@tool
+def save_and_read_file(content: str, filename: str | None | None) -> str:
+    """
+    Save content to a temporary file and return the path.
+    Useful for processing files from the GAIA API.
+
+    Args:
+        content: The content to save to the file
+        filename: Optional filename, will generate a random name if not provided
+
+    Returns:
+        Path to the saved file
+    """
+    temp_dir = tempfile.gettempdir()
+    if filename is None:
+        temp_file = tempfile.NamedTemporaryFile(delete=False)
+        filepath = temp_file.name
+    else:
+        filepath = os.path.join(temp_dir, filename)
+
+    # Write content to the file
+    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: str | None | None) -> str:
+    """
+    Download a file from a URL and save it to a temporary location.
+
+    Args:
+        url: The URL to download from
+        filename: Optional filename, will generate one based on URL if not provided
+
+    Returns:
+        Path to the downloaded file
+    """
+    try:
+        # Parse URL to get filename if not provided
+        if not filename:
+            path = urlparse(url).path
+            filename = os.path.basename(path)
+            if not filename:
+                # Generate a random name if we couldn't extract one
+                import uuid
+
+                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 now process this file."
+    except Exception as e:
+        return f"Error downloading file: {e!s}"
+
+
+@tool
+def extract_text_from_image(image_path: str) -> str:
+    """
+    Extract text from an image using pytesseract (if available).
+
+    Args:
+        image_path: Path to the image file
+
+    Returns:
+        Extracted text or error message
+    """
+    try:
+        # Try to import pytesseract
+        import pytesseract
+        from PIL import Image
+
+        # Open the image
+        image = Image.open(image_path)
+
+        # Extract text
+        text = pytesseract.image_to_string(image)
+
+        return f"Extracted text from image:\n\n{text}"
+    except ImportError:
+        return "Error: pytesseract is not installed. Please install it with 'pip install pytesseract' and ensure Tesseract OCR is installed on your system."
+    except Exception as e:
+        return f"Error extracting text from image: {e!s}"

gagent/tools/image.py

@@ -0,0 +1,289 @@
+"""Image processing tool implementations."""
+
+import base64
+import io
+import os
+import uuid
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+from langchain_core.tools import tool
+from PIL import Image, ImageDraw, ImageEnhance, ImageFilter, ImageFont
+
+
+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
+
+
+@tool
+def analyze_image(image_data: str) -> str:
+    """
+    Analyze image content.
+
+    Args:
+        image_data: URL or base64 encoded image data
+
+    Returns:
+        Analysis of the image content
+    """
+    try:
+        if not image_data or not isinstance(image_data, str):
+            return "Provide a valid image for analysis."
+
+        return (
+            "Analysis of the provided image:\n"
+            "1. Visual elements and objects\n"
+            "2. Colors and composition\n"
+            "3. Text or numbers (if present)\n"
+            "4. Overall context and meaning"
+        )
+
+    except Exception as e:
+        return f"Error analyzing image: {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: resize, rotate, crop, flip, brightness, contrast, blur, sharpen, grayscale.
+
+    Args:
+        image_base64: Base64 encoded input image
+        operation: Transformation operation (resize, rotate, crop, flip, adjust_brightness, adjust_contrast, blur, sharpen, grayscale)
+        params: Parameters for the operation (optional)
+
+    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: Base64 encoded input image
+        drawing_type: Drawing type (rectangle, circle, line, text)
+        params: Drawing parameters (color, coordinates, dimensions, text, etc.)
+
+    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).
+
+    Args:
+        image_type: Type of image (gradient, noise)
+        width: Image width in pixels
+        height: Image height in pixels
+        params: Specific parameters for the image type (optional)
+
+    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 (stack them horizontally or vertically).
+
+    Args:
+        images_base64: List of base64 encoded images
+        operation: Combination type (currently supports "stack")
+        params: Optional parameters, including "direction" ("horizontal" or "vertical")
+
+    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)}

gagent/tools/math.py

@@ -0,0 +1,102 @@
+"""Mathematical tool implementations."""
+
+from typing import Annotated
+import cmath
+
+from langchain_core.tools import tool
+
+
+@tool
+def multiply(
+    a: Annotated[int, "First number to multiply"],
+    b: Annotated[int, "Second number to multiply"],
+) -> Annotated[int, "Product of the two numbers"]:
+    """Multiply two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a * b
+
+
+@tool
+def add(
+    a: Annotated[int, "First number to add"], b: Annotated[int, "Second number to add"]
+) -> Annotated[int, "Sum of the two numbers"]:
+    """Add two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a + b
+
+
+@tool
+def subtract(
+    a: Annotated[int, "Number to subtract from"],
+    b: Annotated[int, "Number to subtract"],
+) -> Annotated[int, "Difference of the two numbers"]:
+    """Subtract two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a - b
+
+
+@tool
+def divide(
+    a: Annotated[int, "Number to divide"], b: Annotated[int, "Number to divide by"]
+) -> Annotated[float, "Quotient of the two numbers"]:
+    """Divide two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
+
+
+@tool
+def modulus(
+    a: Annotated[int, "Number to divide"], b: Annotated[int, "Number to divide by"]
+) -> Annotated[int, "Remainder of the division"]:
+    """Get the modulus of two numbers.
+
+    Args:
+        a: first int
+        b: second int
+    """
+    return a % b
+
+
+@tool
+def power(
+    a: Annotated[float, "Base number"], b: Annotated[float, "Exponent"]
+) -> Annotated[float, "Result of raising a to the power of b"]:
+    """Get the power of two numbers.
+
+    Args:
+        a: base number
+        b: exponent
+    """
+    return a**b
+
+
+@tool
+def square_root(
+    a: Annotated[float, "Number to get the square root of"],
+) -> Annotated[float | complex, "Square root of the number"]:
+    """Get the square root of a number. Returns complex number if input is negative.
+
+    Args:
+        a: number to get the square root of
+    """
+    if a >= 0:
+        return a**0.5
+    return cmath.sqrt(a)

gagent/tools/media.py

@@ -0,0 +1,76 @@
+"""Media-related tools for agents."""
+
+import yt_dlp
+from langchain_core.tools import tool
+from urllib.parse import urlparse
+
+
+@tool
+def analyze_video(url: str) -> str:
+    """
+    Analyze YouTube video content directly.
+
+    Args:
+        url: URL of the YouTube video
+
+    Returns:
+        Analysis of the video content
+    """
+    try:
+        # Validate URL
+        parsed_url = urlparse(url)
+        if not all([parsed_url.scheme, parsed_url.netloc]):
+            return "Provide a valid video URL with http:// or https:// prefix."
+
+        # Check if it's a YouTube URL
+        if "youtube.com" not in url and "youtu.be" not in url:
+            return "Only YouTube videos are supported at this time."
+
+        try:
+            # Configure yt-dlp with minimal extraction
+            ydl_opts = {
+                "quiet": True,
+                "no_warnings": True,
+                "extract_flat": True,
+                "no_playlist": True,
+                "youtube_include_dash_manifest": False,
+                "writesubtitles": True,
+                "writeautomaticsub": True,
+                "skip_download": True,
+                "subtitleslangs": ["en"],
+                "subtitlesformat": "srt",
+            }
+
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                try:
+                    # Try basic info extraction
+                    info = ydl.extract_info(url, download=False, process=False)
+                    if not info:
+                        return "Could not extract video information."
+
+                    title = info.get("title", "Unknown")
+                    description = info.get("description", "")
+
+                    # Create a detailed prompt for analysis
+                    return (
+                        f"Analyze this YouTube video:\n"
+                        f"Title: {title}\n"
+                        f"URL: {url}\n"
+                        f"Description: {description}\n"
+                        "Provide a detailed analysis focusing on:\n"
+                        "1. Main topic and key points from the title and description\n"
+                        "2. Expected visual elements and scenes\n"
+                        "3. Overall message or purpose\n"
+                        "4. Target audience"
+                    )
+
+                except Exception as e:
+                    if "Sign in to confirm" in str(e):
+                        return "This video requires age verification or sign-in. Provide a different video URL."
+                    return f"Error accessing video: {str(e)}"
+
+        except Exception as e:
+            return f"Error extracting video info: {str(e)}"
+
+    except Exception as e:
+        return f"Error analyzing video: {str(e)}"

gagent/tools/search.py

@@ -0,0 +1,140 @@
+"""Search tools for various sources."""
+
+import time
+from typing import Optional
+
+import requests
+from bs4 import BeautifulSoup
+from langchain_community.document_loaders import ArxivLoader, WikipediaLoader
+from langchain_core.tools import tool
+
+
+class WebSearchTool:
+    def __init__(self):
+        self.last_request_time = 0
+        self.min_request_interval = 2.0  # Minimum time between requests in seconds
+        self.max_retries = 10
+
+    def search(self, query: str, domain: Optional[str] = None) -> str:
+        """Perform web search with rate limiting and retries."""
+        for attempt in range(self.max_retries):
+            # Implement rate limiting
+            current_time = time.time()
+            time_since_last = current_time - self.last_request_time
+            if time_since_last < self.min_request_interval:
+                time.sleep(self.min_request_interval - time_since_last)
+
+            try:
+                # Make the search request
+                results = self._do_search(query, domain)
+                self.last_request_time = time.time()
+                return results
+            except Exception as e:
+                if "202 Ratelimit" in str(e):
+                    if attempt < self.max_retries - 1:
+                        # Exponential backoff
+                        wait_time = (2**attempt) * self.min_request_interval
+                        time.sleep(wait_time)
+                        continue
+                return f"Search failed after {self.max_retries} attempts: {str(e)}"
+
+        return "Search failed due to rate limiting"
+
+    def _do_search(self, query: str, domain: Optional[str] = None) -> str:
+        """Perform the actual search request."""
+        try:
+            # Construct search URL
+            base_url = "https://html.duckduckgo.com/html"
+            params = {"q": query}
+            if domain:
+                params["q"] += f" site:{domain}"
+
+            # Make request with increased timeout
+            response = requests.get(base_url, params=params, timeout=10)
+            response.raise_for_status()
+
+            if response.status_code == 202:
+                raise Exception("202 Ratelimit")
+
+            # Extract search results
+            results = []
+            soup = BeautifulSoup(response.text, "html.parser")
+            for result in soup.find_all("div", {"class": "result"}):
+                title = result.find("a", {"class": "result__a"})
+                snippet = result.find("a", {"class": "result__snippet"})
+                if title and snippet:
+                    results.append({"title": title.get_text(), "snippet": snippet.get_text(), "url": title.get("href")})
+
+            # Format results
+            formatted_results = []
+            for r in results[:10]:  # Limit to top 10 results
+                formatted_results.append(f"[{r['title']}]({r['url']})\n{r['snippet']}\n")
+
+            return "## Search Results\n\n" + "\n".join(formatted_results)
+
+        except requests.RequestException as e:
+            raise Exception(f"Search request failed: {str(e)}")
+
+
+@tool
+def web_search(query: str, domain: Optional[str] = None) -> str:
+    """
+    Search the web for information.
+
+    Args:
+        query: The search query
+        domain: Optional domain to restrict search to
+
+    Returns:
+        Search results as formatted text
+    """
+    search_tool = WebSearchTool()
+    return search_tool.search(query, domain)
+
+
+@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=query)
+#     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 {"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}

gagent/tools/wrappers.py

@@ -0,0 +1,35 @@
+"""Tool wrappers for compatibility between different agent frameworks."""
+
+from langchain.tools import BaseTool
+from smolagents import DuckDuckGoSearchTool, WikipediaSearchTool
+from pydantic import Field
+
+
+class SmolagentToolWrapper(BaseTool):
+    """Wrapper for smolagents tools to make them compatible with LangChain."""
+
+    wrapped_tool: object = Field(description="The wrapped smolagents tool")
+
+    def __init__(self, tool):
+        """Initialize the wrapper with a smolagents tool."""
+        super().__init__(
+            name=tool.name,
+            description=tool.description,
+            return_direct=False,
+            wrapped_tool=tool,
+        )
+
+    def _run(self, query: str) -> str:
+        """Use the wrapped tool to execute the query."""
+        try:
+            # For WikipediaSearchTool
+            if hasattr(self.wrapped_tool, "search"):
+                return self.wrapped_tool.search(query)
+            # For DuckDuckGoSearchTool and others
+            return self.wrapped_tool(query)
+        except Exception as e:
+            return f"Error using tool: {e!s}"
+
+
+duckduckgo_search_tool = SmolagentToolWrapper(DuckDuckGoSearchTool())
+wikipedia_search_tool = SmolagentToolWrapper(WikipediaSearchTool())

install.sh

@@ -0,0 +1,60 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+# Check if Python 3.8 or higher is installed
+if ! command -v python3 &> /dev/null; then
+    echo "Python 3 is not installed. Please install Python 3.8 or higher."
+    exit 1
+fi
+
+# Create and activate virtual environment
+if [ ! -d ".venv" ]; then
+    echo "Creating virtual environment..."
+    python3 -m venv .venv
+fi
+
+echo "Activating virtual environment..."
+source .venv/bin/activate
+
+# Upgrade pip
+echo "Upgrading pip..."
+pip install --upgrade pip
+
+# Install dependencies
+echo "Installing dependencies..."
+pip install -r requirements.txt
+
+# Install pre-commit hooks
+echo "Setting up pre-commit hooks..."
+pre-commit install
+
+# Create .env file if it doesn't exist
+if [ ! -f ".env" ]; then
+    echo "Creating .env file..."
+    echo "PYTHONPATH=$(pwd)/src" > .env
+    echo "Please update .env with your API keys and other configuration"
+fi
+
+# Create .env.example if it doesn't exist
+if [ ! -f ".env.example" ]; then
+    echo "Creating .env.example file..."
+    cat > .env.example << EOL
+# API Keys
+OPENAI_API_KEY=your_openai_api_key
+GOOGLE_API_KEY=your_google_api_key
+HUGGINGFACE_API_KEY=your_huggingface_api_key
+
+# Database Configuration
+SUPABASE_URL=your_supabase_url
+SUPABASE_KEY=your_supabase_key
+
+# Other Configuration
+PYTHONPATH=$(pwd)/src
+EOL
+fi
+
+echo "Installation complete! The gagent package is now available in your Python environment."
+echo "You can import it using: from gagent import GAIAAgent, GeminiAgent"
+echo "Don't forget to update your .env file with the necessary API keys and configuration!"

pyproject.toml

@@ -0,0 +1,89 @@
+[project]
+name = "gagent"
+version = "0.1.0"
+description = "An agentic AI system"
+authors = [
+    {name = "Uoc Nguyen", email = "[email protected]"}
+]
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "gradio>=5.27.0",
+    "requests>=2.32.3",
+    "langchain>=0.3.24",
+    "langchain-community>=0.2.3",
+    "langchain-core>=0.3.56",
+    "langchain-huggingface>=0.1.2",
+    "langchain-groq>=0.3.2",
+    "langchain-tavily>=0.1.5",
+    "langchain-chroma>=0.2.3",
+    "langchain-google-genai>=2.0.10",
+    "langchain-ollama>=0.3.2",
+    "langchain-openrouter>=0.0.1",
+    "langchain-openai>=0.3.14",
+    "langgraph>=0.3.34",
+    "huggingface-hub>=0.30.2",
+    "supabase>=2.15.0",
+    "arxiv>=2.2.0",
+    "pymupdf>=1.25.5",
+    "pgvector>=0.4.1",
+    "python-dotenv>=1.1.0",
+    "google-generativeai>=0.8.5",
+    "google-api-python-client>=2.168.0",
+    "duckduckgo-search>=8.0.1",
+    "tiktoken>=0.9.0",
+    "google-cloud-speech>=2.32.0",
+    "pydub>=0.25.1",
+    "yt-dlp>=2025.3.31",
+    "smolagents>=1.14.0",
+    "wikipedia>=1.4.0",
+    "wikipedia-api>=0.8.1",
+    "pillow>=11.2.1",
+    "pytesseract>=0.3.13",
+    "sentence-transformers>=4.1.0",
+    "bs4>=0.0.2",
+    "uuid>=1.30",
+    "pandas>=2.2.3",
+    "openpyxl>=3.1.5",
+    "datasets>=3.5.1",
+    "ipywidgets>=8.1.6",
+    "matplotlib>=3.10.3",
+    "ipykernel>=6.29.5",
+]
+
+[project.urls]
+Homepage = "https://huggingface.co/spaces/uoc/gagent"
+
+[tool.ruff]
+line-length = 120
+target-version = "py311"
+select = ["E", "F", "B", "I", "N", "UP", "PL", "RUF"]
+ignore = ["E501"]
+
+[tool.ruff.isort]
+known-first-party = ["gagent"]
+
+[tool.black]
+line-length = 120
+target-version = ["py311"]
+include = '\.pyi?$'
+
+[tool.mypy]
+python_version = "3.11"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = "-ra -q"
+testpaths = [
+    "tests",
+]

requirements.txt

@@ -1,2 +1,47 @@
-gradio
-requests
+arxiv>=2.2.0
+black>=25.1.0
+bs4>=0.0.2
+duckduckgo-search>=8.0.1
+google-api-python-client>=2.168.0
+google-cloud-speech>=2.32.0
+google-generativeai>=0.8.5
+# Core dependencies
+gradio>=5.27.0
+gradio[oauth]>=5.27.0
+huggingface-hub>=0.30.2
+langchain>=0.3.24
+langchain-chroma>=0.2.3
+langchain-community>=0.2.3
+langchain-core>=0.3.56
+langchain-google-genai>=2.0.10
+langchain-groq>=0.3.2
+langchain-huggingface>=0.1.2
+langchain-ollama>=0.3.2
+langchain-openai>=0.3.14
+langchain-openrouter>=0.0.1
+langchain-tavily>=0.1.5
+langgraph>=0.3.34
+mypy>=1.15.0
+openpyxl>=3.1.5
+pandas>=2.2.3
+pgvector>=0.4.1
+pillow>=11.2.1
+pre-commit>=4.2.0
+pydub>=0.25.1
+pymupdf>=1.25.5
+pytesseract>=0.3.13
+pytest>=8.3.5
+pytest-cov>=6.1.1
+python-dotenv>=1.1.0
+requests>=2.32.3
+
+# Development dependencies
+ruff>=0.11.7
+sentence-transformers>=4.1.0
+smolagents>=1.14.0
+supabase>=2.15.0
+tiktoken>=0.9.0
+uuid>=1.30
+wikipedia>=1.4.0
+wikipedia-api>=0.8.1
+yt-dlp>=2025.3.31

system_prompt.txt

@@ -0,0 +1,6 @@
+You are a helpful assistant tasked with answering questions using a set of tools.
+ALWAYS use tools to get information first, if no relevant information found, use your knowledge to solve it.
+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 above rules depending of whether the element to be put in the list is a number or a string.
+Your answer should only start with "FINAL ANSWER: ", then follows with the answer.

test.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+uv run pytest -vs

tests/agents/fixtures.py

@@ -0,0 +1,104 @@
+"""
+Pytest configuration for agent testing.
+"""
+
+import os
+import pytest
+from typing import Dict, List, Optional
+
+from gagent.agents import registry, BaseAgent, OllamaAgent, GeminiAgent, OpenAIAgent
+
+
+@pytest.fixture
+def agent_factory():
+    """
+    Factory fixture to create agent instances with flexible configuration.
+
+    Returns:
+        Function that creates and returns an agent instance
+    """
+
+    def _create_agent(
+        agent_type: str,
+        model_name: Optional[str] = None,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        **kwargs,
+    ) -> BaseAgent:
+        """
+        Create an agent with the specified configuration.
+
+        Args:
+            agent_type: The type of agent to create
+            model_name: The model name to use
+            api_key: The API key to use
+            base_url: The base URL to use
+            **kwargs: Additional parameters for the agent
+
+        Returns:
+            An initialized agent instance
+        """
+        # Get environment variables or defaults for any non-provided values
+        env_model = os.environ.get(f"{agent_type.upper()}_MODEL", "qwen3" if agent_type == "ollama" else None)
+        env_api_key = os.environ.get(f"{agent_type.upper()}_API_KEY", None)
+        env_base_url = os.environ.get(
+            f"{agent_type.upper()}_BASE_URL", "http://localhost:11434" if agent_type == "ollama" else None
+        )
+
+        return registry.get_agent(
+            agent_type=agent_type,
+            model_name=model_name or env_model,
+            api_key=api_key or env_api_key,
+            base_url=base_url or env_base_url,
+            **kwargs,
+        )
+
+    return _create_agent
+
+
+@pytest.fixture
+def ollama_agent(agent_factory) -> OllamaAgent:
+    """Fixture to provide an Ollama agent."""
+    return agent_factory("ollama")
+
+
+@pytest.fixture
+def gemini_agent(agent_factory) -> GeminiAgent:
+    """Fixture to provide a Gemini agent if environment variables are set."""
+    api_key = os.environ.get("GOOGLE_API_KEY", None)
+    if not api_key:
+        pytest.skip("GOOGLE_API_KEY environment variable not set")
+    return agent_factory("gemini")
+
+
+@pytest.fixture
+def openai_agent(agent_factory) -> OpenAIAgent:
+    """Fixture to provide an OpenAI agent if environment variables are set."""
+    api_key = os.environ.get("OPENAI_API_KEY", None)
+    if not api_key:
+        pytest.skip("OPENAI_API_KEY environment variable not set")
+    return agent_factory("openai")
+
+
+@pytest.fixture
+def gaia_questions() -> List[Dict]:
+    """Load GAIA questions for testing."""
+    import json
+
+    with open("exp/questions.json", "r") as f:
+        return json.load(f)
+
+
+@pytest.fixture
+def gaia_validation_data() -> Dict:
+    """Load GAIA validation data."""
+    import json
+
+    validation_data = {}
+
+    with open("metadata.jsonl", "r") as f:
+        for line in f:
+            data = json.loads(line)
+            validation_data[data["task_id"]] = data["Final answer"]
+
+    return validation_data

tests/agents/test_agents.py

@@ -0,0 +1,131 @@
+import json
+import os
+import pytest
+from pathlib import Path
+import functools
+from typing import Callable, Type, Any, Dict, Optional
+
+from gagent.agents import BaseAgent, GeminiAgent
+from tests.agents.fixtures import (
+    agent_factory,
+    ollama_agent,
+    gemini_agent,
+    openai_agent,
+)
+
+
+class TestAgents:
+    """Test suite for agents with GAIA data."""
+
+    @staticmethod
+    def load_questions():
+        """Load questions from questions.json file."""
+        with open("exp/questions.json", "r") as f:
+            return json.load(f)
+
+    @staticmethod
+    def load_validation_data():
+        """Load validation data from GAIA dataset metadata."""
+        validation_data = {}
+
+        with open("metadata.jsonl", "r") as f:
+            for line in f:
+                data = json.loads(line)
+                validation_data[data["task_id"]] = data["Final answer"]
+
+        return validation_data
+
+    def _run_agent_test(self, agent: BaseAgent, num_questions: int = 2):
+        """
+        Common test implementation for all agent types
+
+        Args:
+            agent: The agent to test
+            num_questions: Number of questions to test (default: 2)
+
+        Returns:
+            Tuple of (correct_count, total_tested)
+        """
+        questions = self.load_questions()
+        validation_data = self.load_validation_data()
+
+        # Limit number of questions for testing
+        questions = questions[:num_questions]
+
+        # Keep track of correct answers
+        correct_count = 0
+        total_tested = 0
+        total_questions = len(questions)
+        for i, question_data in enumerate(questions):
+            task_id = question_data["task_id"]
+            if task_id not in validation_data:
+                continue
+
+            question = question_data["question"]
+            expected_answer = validation_data[task_id]
+
+            print(f"Testing question {i + 1}: {question[:50]}...")
+
+            # Call the agent with the question
+            response = agent.run(question, question_number=i + 1, total_questions=total_questions)
+
+            # Extract the final answer from the response
+            # Assuming the agent follows the format with "FINAL ANSWER: [answer]"
+            if "FINAL ANSWER:" in response:
+                answer = response.split("FINAL ANSWER:")[1].strip()
+            else:
+                answer = response.strip()
+
+            # Check if the answer is correct (exact match)
+            is_correct = answer == expected_answer
+            if is_correct:
+                correct_count += 1
+
+            total_tested += 1
+
+            print(f"Expected: {expected_answer}")
+            print(f"Got: {answer}")
+            print(f"Result: {'✓' if is_correct else '✗'}")
+            print("-" * 80)
+
+        # Compute accuracy
+        accuracy = correct_count / total_tested if total_tested > 0 else 0
+        print(f"Accuracy: {accuracy:.2%} ({correct_count}/{total_tested})")
+
+        return correct_count, total_tested
+
+    # def test_ollama_agent_with_gaia_data(self, ollama_agent: BaseAgent):
+    #     """Test the Ollama agent with GAIA dataset questions and validate against ground truth."""
+    #     correct_count, total_tested = self._run_agent_test(agent)
+
+    #     # At least one correct answer required to pass the test
+    #     assert correct_count > 0, "Agent should get at least one answer correct"
+
+    # def test_gemini_agent_with_gaia_data(self, gemini_agent: GeminiAgent):
+    #     """Test the Gemini agent with the same GAIA test approach."""
+    #     correct_count, total_tested = self._run_agent_test(gemini_agent, num_questions=2)
+
+    #     # At least one correct answer required to pass the test
+    #     assert correct_count > 0, "Agent should get at least one answer correct"
+
+    @pytest.mark.parametrize("agent_type,model_name", [("ollama", "phi4-mini")])
+    def test_ollama_with_different_model(self, agent_factory, agent_type, model_name):
+        """Test Ollama agent with a different model."""
+        agent = agent_factory(agent_type=agent_type, model_name=model_name)
+        correct_count, total_tested = self._run_agent_test(agent, num_questions=3)
+
+        # Just verify it runs, not accuracy
+        assert correct_count > 0, "Should test at least one question"
+
+    # def test_ollama_with_different_model(self, ollama_agent: BaseAgent):
+    #     """Test Ollama agent with a different model."""
+    #     correct_count, total_tested = self._run_agent_test(ollama_agent, num_questions=3)
+
+    #     # Just verify it runs, not accuracy
+    #     assert correct_count > 0, "Should test at least one question"
+
+    # Can be uncommented when OpenAI API key is available
+    # def test_openai_agent_with_gaia_data(self, openai_agent: BaseAgent):
+    #     """Test the OpenAI agent with the same GAIA test approach."""
+    #     correct_count, total_tested = self._run_agent_test(agent)
+    #     assert correct_count > 0, "Agent should get at least one answer correct"