Upload 22 files

.gitignore

@@ -0,0 +1,31 @@
+.env
+
+# Exclude arterm folder (reference code)
+arterm/
+
+# Exclude downloads directory
+downloads/
+
+# Exclude log files
+*.log
+agent_run_*.log
+
+# Exclude cache file
+agent_cache.json
+
+# Exclude Python cache
+__pycache__/
+*.pyc
+*.pyo
+
+# Exclude downloaded files from evaluation
+*.xlsx
+*.mp3
+*.png
+*.jpg
+*.pdf
+downloaded_file.*
+
+# Exclude other temporary files
+rows.json
+OtherDS.py

ARCHITECTURE.md

@@ -0,0 +1,436 @@
+# Agent Architecture Documentation
+
+## Overview
+
+This is a LangGraph-based AI agent designed for the GAIA (General AI Assistants) benchmark evaluation. The agent uses GPT-4o/GPT-4o-mini with tool-calling capabilities to answer complex multi-step questions involving web search, file analysis, multimedia processing, and reasoning.
+
+## System Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         User Request                             │
+│                    (20 GAIA Questions)                           │
+└────────────────────────────┬────────────────────────────────────┘
+                             ↓
+┌─────────────────────────────────────────────────────────────────┐
+│                          app.py                                  │
+│  • Fetches questions from API                                    │
+│  • Downloads attached files (Excel, MP3, images, Python)         │
+│  • Saves files to downloads/ directory                           │
+│  • Calls BasicAgent for each question                            │
+│  • Submits answers to evaluation API                             │
+└────────────────────────────┬────────────────────────────────────┘
+                             ↓
+┌─────────────────────────────────────────────────────────────────┐
+│                      BasicAgent                                  │
+│                   (agent/basic_agent.py)                         │
+│                                                                   │
+│  1. Check Cache (agent_cache.json)                               │
+│     └─ If cached: Return answer instantly ✅                     │
+│                                                                   │
+│  2. If not cached:                                               │
+│     └─ Invoke LangGraph workflow                                 │
+│                                                                   │
+│  3. Clean & validate answer                                      │
+│     └─ Remove JSON, code blocks, explanations                    │
+│                                                                   │
+│  4. Cache answer to disk                                         │
+│     └─ Save to agent_cache.json for future use                   │
+└────────────────────────────┬────────────────────────────────────┘
+                             ↓
+┌─────────────────────────────────────────────────────────────────┐
+│                    LangGraph Workflow                            │
+│                     (agent/graph.py)                             │
+│                                                                   │
+│  ┌──────────────┐                                                │
+│  │ Agent Node   │ ← Decides next action                          │
+│  │ (GPT-4o)     │   • Analyze question                           │
+│  └──────┬───────┘   • Choose tool(s)                             │
+│         │           • Generate response                           │
+│         ↓                                                         │
+│  ┌──────────────┐                                                │
+│  │ Tools Node   │ ← Executes tools                               │
+│  │              │   • Search, calculate, read files              │
+│  └──────┬───────┘   • Returns results                            │
+│         │                                                         │
+│         ↓                                                         │
+│  ┌──────────────┐                                                │
+│  │ Agent Node   │ ← Processes results                            │
+│  │ (GPT-4o)     │   • Analyzes tool output                       │
+│  └──────┬───────┘   • Decides: more tools or final answer?       │
+│         │                                                         │
+│         └─────────→ Loop (max 50 iterations)                     │
+│                                                                   │
+│  Final Answer → Return to BasicAgent                             │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Core Components
+
+### 1. **app.py** - Main Application
+**Responsibilities:**
+- Fetch questions from evaluation API
+- Download attached files from `/files/{task_id}` endpoint
+- Orchestrate agent execution for all questions
+- Submit answers to evaluation API
+- Display results
+
+**Key Functions:**
+- `run_and_submit_all()` - Main evaluation loop
+- File download with error handling
+- Results aggregation and submission
+
+### 2. **agent/basic_agent.py** - Agent Wrapper
+**Responsibilities:**
+- Manage agent lifecycle
+- Implement caching system (persistent to disk)
+- Clean and validate answers
+- Logging to file
+
+**Key Features:**
+- **Persistent Caching:** Saves answers to `agent_cache.json`
+- **Answer Cleaning:** Removes JSON, code blocks, explanations
+- **Validation:** Ensures no empty answers submitted
+- **Logging:** All output saved to timestamped log files
+
+**Cache System:**
+```python
+{
+  "question_text": "answer",
+  "How many albums...": "4",
+  "What is 2+2?": "4"
+}
+```
+
+### 3. **agent/graph.py** - LangGraph Workflow
+**Responsibilities:**
+- Define agent workflow (nodes and edges)
+- Initialize LLM chains (primary + fallback)
+- Initialize and manage tools
+- Route between agent and tools nodes
+
+**Workflow Structure:**
+```
+START → Agent Node → [Tools Node] → Agent Node → END
+         ↑_______________|
+         (loop until answer found or max iterations)
+```
+
+**Key Components:**
+- `agent_node()` - LLM decision making
+- `tool_node()` - Tool execution
+- `should_continue()` - Routing logic
+- System prompt with detailed instructions
+
+**LLM Configuration:**
+- **Primary:** GPT-4o (with tools)
+- **Fallback:** GPT-4o-mini (with tools)
+- **Recursion Limit:** 50 iterations
+- **Rate Limiting:** Exponential backoff (5 retries)
+
+### 4. **agent/tools.py** - Tool Implementations
+**Responsibilities:**
+- Implement all tools available to the agent
+- Handle file path resolution (current dir + downloads/)
+- Integrate with external APIs (Gemini, search engines)
+
+**Available Tools:**
+
+#### Search & Research (5 tools)
+- `duckduckgo_search` - Web search
+- `tavily_search` - Advanced web search
+- `wikipedia` - Wikipedia lookup
+- `youtube_transcript` - Get YouTube transcripts
+- `arxiv_search` - Academic paper search
+
+#### File Operations (5 tools)
+- `list_files` - List files in current/downloads directory
+- `read_file` - Read text files
+- `read_excel` - Read and analyze Excel files
+- `download_file` - Download files from URLs
+- `execute_python_file` - Run Python scripts
+
+#### Multimedia Analysis (3 tools - Gemini-powered)
+- `understand_video` - Analyze YouTube videos
+- `understand_audio` - Transcribe and analyze MP3/audio
+- `analyze_image` - Analyze images (chess, diagrams, text)
+
+#### Computation (2 tools)
+- `calculator` - Safe math evaluation
+- `python_repl` - Execute Python code
+
+**File Path Resolution:**
+All file tools use `find_file()` helper that checks:
+1. Current directory
+2. `downloads/` directory
+3. Returns best match or downloads path
+
+## Data Flow
+
+### Question Processing Flow
+
+```
+1. API Request
+   └─ GET /questions
+   └─ Returns: [{task_id, question, Level, file_name}, ...]
+
+2. File Download (if file_name exists)
+   └─ GET /files/{task_id}
+   └─ Save to: downloads/{file_name}
+
+3. Agent Invocation
+   ├─ Check cache
+   │  └─ If hit: Return cached answer (0 LLM calls)
+   │
+   └─ If miss:
+      ├─ Create initial state with question
+      ├─ Invoke LangGraph workflow
+      │  ├─ Agent decides action
+      │  ├─ Execute tools
+      │  ├─ Agent processes results
+      │  └─ Loop until answer or max iterations
+      │
+      ├─ Extract answer from final message
+      ├─ Clean answer (remove JSON, explanations)
+      ├─ Validate answer (ensure not empty)
+      └─ Cache to disk
+
+4. Answer Submission
+   └─ POST /submit
+   └─ Body: {username, answers: [{task_id, submitted_answer}]}
+```
+
+## Tool Execution Flow
+
+```
+Agent Node (GPT-4o)
+  ↓
+Decides: "I need to use list_files tool"
+  ↓
+Tool Node
+  ├─ Finds tool by name
+  ├─ Validates parameters
+  ├─ Executes tool._run()
+  │  └─ Example: list_files()
+  │     ├─ Check current directory
+  │     ├─ Check downloads/ directory
+  │     └─ Return: "Files found:\n./app.py\ndownloads/data.xlsx"
+  └─ Returns ToolMessage with result
+  ↓
+Agent Node (GPT-4o)
+  ├─ Receives tool output
+  ├─ Analyzes results
+  └─ Decides: Use another tool OR provide final answer
+```
+
+## Key Design Decisions
+
+### 1. **Persistent Caching**
+**Why:** Reduce costs and enable fast re-runs
+**How:** JSON file on disk, loaded at startup, saved after each answer
+**Benefit:** 100% cost savings on repeated questions
+
+### 2. **File Path Resolution**
+**Why:** Files can be in current directory or downloads/
+**How:** `find_file()` helper checks both locations
+**Benefit:** Agent doesn't need to know exact file location
+
+### 3. **Gemini for Multimedia**
+**Why:** GPT-4o doesn't support direct video/audio analysis
+**How:** Upload files to Gemini API, get analysis
+**Benefit:** Can handle YouTube videos, MP3 files, images
+
+### 4. **Answer Cleaning Pipeline**
+**Why:** LLMs often return verbose explanations or JSON
+**How:** Multi-stage cleaning (JSON removal, pattern matching, validation)
+**Benefit:** Clean, concise answers that match expected format
+
+### 5. **Dual LLM Strategy**
+**Why:** Reliability and cost optimization
+**How:** Primary (GPT-4o) with fallback (GPT-4o-mini)
+**Benefit:** Continues working if primary fails
+
+### 6. **Tool-First Architecture**
+**Why:** Many questions require external data
+**How:** Rich tool suite with 15+ specialized tools
+**Benefit:** Can handle diverse question types
+
+## Configuration
+
+### Environment Variables (.env)
+```bash
+OPENAI_API_KEY=sk-...           # Required for GPT-4o
+GEMINI_API_KEY=...              # Required for video/audio/image analysis
+TAVILY_API_KEY=...              # Optional for advanced search
+HF_TOKEN=...                    # For HuggingFace API access
+```
+
+### Configurable Parameters
+
+**In BasicAgent:**
+- `log_to_file` - Enable/disable logging (default: True)
+- `use_cache` - Enable/disable caching (default: True)
+- `cache_file` - Cache file path (default: "agent_cache.json")
+
+**In LangGraph:**
+- `recursion_limit` - Max iterations (default: 50)
+- `temperature` - LLM temperature (default: 0.0)
+- `max_retries` - Rate limit retries (default: 5)
+
+## File Structure
+
+```
+Final_Assignment_Template/
+├── app.py                      # Main application
+├── agent/
+│   ├── __init__.py
+│   ├── basic_agent.py          # Agent wrapper with caching
+│   ├── graph.py                # LangGraph workflow
+│   └── tools.py                # Tool implementations
+├── downloads/                  # Downloaded files (gitignored)
+│   ├── file1.xlsx
+│   ├── audio.mp3
+│   └── image.png
+├── agent_cache.json            # Persistent cache (gitignored)
+├── agent_run_*.log             # Log files (gitignored)
+├── requirements.txt            # Python dependencies
+├── .env                        # Environment variables (gitignored)
+├── .gitignore
+├── ARCHITECTURE.md             # This file
+└── README.md                   # User documentation
+```
+
+## Performance Characteristics
+
+### Typical Question Processing Time
+- **Simple (cached):** < 0.1 seconds
+- **Simple (web search):** 2-5 seconds
+- **Medium (file analysis):** 5-15 seconds
+- **Complex (multi-step):** 15-60 seconds
+- **Multimedia (video/audio):** 30-120 seconds
+
+### LLM Token Usage (per question)
+- **Simple:** 500-2,000 tokens
+- **Medium:** 2,000-8,000 tokens
+- **Complex:** 8,000-20,000 tokens
+
+### Cost Estimates (GPT-4o)
+- **Per question (avg):** $0.01-0.05
+- **20 questions:** $0.20-1.00
+- **With caching (re-runs):** $0.00
+
+## Error Handling
+
+### Graceful Degradation
+1. **Cache file corrupted:** Start with empty cache
+2. **File download fails:** Continue without file, agent handles gracefully
+3. **Tool execution fails:** Return error message, agent tries alternative
+4. **LLM rate limit:** Exponential backoff, retry up to 5 times
+5. **Primary LLM fails:** Fallback to GPT-4o-mini
+6. **Recursion limit hit:** Return best answer so far
+
+### Validation
+- All answers validated (never empty)
+- File paths validated before access
+- API responses validated before processing
+- Tool parameters validated before execution
+
+## Testing & Development
+
+### Local Testing
+```bash
+# Run full evaluation
+python app.py
+
+# Check logs
+tail -f agent_run_*.log
+
+# View cache
+cat agent_cache.json
+
+# Clear cache for fresh run
+rm agent_cache.json
+```
+
+### Debugging
+- All tool calls logged with arguments and results
+- Agent reasoning logged at each step
+- Errors logged with full stack traces
+- Cache hits/misses logged
+
+## Future Enhancements
+
+### Potential Improvements
+1. **Pattern-based answering** - Skip LLM for simple questions
+2. **Parallel tool execution** - Run independent tools simultaneously
+3. **Smarter caching** - Fuzzy matching for similar questions
+4. **Cost tracking** - Log token usage and costs
+5. **A/B testing** - Compare different prompts/strategies
+6. **Streaming responses** - Show progress in real-time
+
+### Scalability Considerations
+- Cache can grow large (consider size limits or TTL)
+- Multiple concurrent runs need separate cache files
+- Rate limiting may need adjustment for production
+- Consider database instead of JSON for large-scale caching
+
+## Dependencies
+
+### Core
+- `langchain` - LLM framework
+- `langgraph` - Workflow orchestration
+- `langchain-openai` - OpenAI integration
+- `langchain-community` - Community tools
+
+### Tools
+- `google-generativeai` - Gemini API
+- `tavily-python` - Advanced search
+- `duckduckgo-search` - Web search
+- `youtube-transcript-api` - YouTube transcripts
+- `pandas` - Data analysis
+- `openpyxl` - Excel files
+
+### Utilities
+- `requests` - HTTP requests
+- `python-dotenv` - Environment variables
+- `gradio` - Web UI (optional)
+
+## Security Considerations
+
+### API Keys
+- Stored in `.env` file (gitignored)
+- Never hardcoded in source
+- Loaded via `python-dotenv`
+
+### Code Execution
+- `python_repl` uses AST-based REPL (safer than eval)
+- `execute_python_file` runs in subprocess with timeout
+- No shell injection vulnerabilities
+
+### File Access
+- All file operations use Path validation
+- No arbitrary file system access
+- Downloads isolated to `downloads/` directory
+
+## Monitoring & Observability
+
+### Logs
+- Timestamped log files for each run
+- Structured logging with emojis for easy parsing
+- Tool calls logged with full context
+- Errors logged with stack traces
+
+### Metrics (available in logs)
+- Questions processed
+- Cache hit rate
+- Tool usage frequency
+- LLM calls per question
+- Execution time per question
+- Error rate
+
+---
+
+**Version:** 1.0  
+**Last Updated:** 2025-09-30  
+**Author:** Leon Woo  
+**License:** MIT

OtherDS.py

@@ -0,0 +1,11 @@
+from datasets import load_dataset
+
+ds = load_dataset("arterm-sedov/agent-course-final-assignment", "init")  # default config
+rows = ds["train"][:200]  # grab 200 rows (dict of lists)
+
+# Convert to a list of dicts (row-wise) for JSON export:
+rowwise = [dict(zip(rows.keys(), values)) for values in zip(*rows.values())]
+
+import json
+with open("rows.json", "w", encoding="utf-8") as f:
+    json.dump(rowwise, f, ensure_ascii=False, indent=2)

README.md

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

agent_cache.json

@@ -0,0 +1,21 @@
+{
+  "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia.": "4",
+  "In the video https://www.youtube.com/watch?v=L1vXCYZAYYM, what is the highest number of bird species to be on camera simultaneously?": "4",
+  ".rewsna eht sa \"tfel\" drow eht fo etisoppo eht etirw ,ecnetnes siht dnatsrednu uoy fI": "right",
+  "Review the chess position provided in the image. It is black's turn. Provide the correct next move for black which guarantees a win. Please provide your response in algebraic notation.": "Qb1#",
+  "Who nominated the only Featured Article on English Wikipedia about a dinosaur that was promoted in November 2016?": "FunkMonk",
+  "Given this table defining * on the set S = {a, b, c, d, e}\n\n|*|a|b|c|d|e|\n|---|---|---|---|---|---|\n|a|a|b|c|b|d|\n|b|b|c|a|e|c|\n|c|c|a|b|b|a|\n|d|b|e|b|e|d|\n|e|d|b|a|d|c|\n\nprovide the subset of S involved in any possible counter-examples that prove * is not commutative. Provide your answer as a comma separated list of the elements in the set in alphabetical order.": "a,b,c,e",
+  "Examine the video at https://www.youtube.com/watch?v=1htKBjuUWec.\n\nWhat does Teal'c say in response to the question \"Isn't that hot?\"": "Indeed",
+  "What is the surname of the equine veterinarian mentioned in 1.E Exercises from the chemistry materials licensed by Marisa Alviar-Agnew & Henry Agnew under the CK-12 license in LibreText's Introductory Chemistry materials as compiled 08/21/2023?": "Louvrier",
+  "I'm making a grocery list for my mom, but she's a professor of botany and she's a real stickler when it comes to categorizing things. I need to add different foods to different categories on the grocery list, but if I make a mistake, she won't buy anything inserted in the wrong category. Here's the list I have so far:\n\nmilk, eggs, flour, whole bean coffee, Oreos, sweet potatoes, fresh basil, plums, green beans, rice, corn, bell pepper, whole allspice, acorns, broccoli, celery, zucchini, lettuce, peanuts\n\nI need to make headings for the fruits and vegetables. Could you please create a list of just the vegetables from my list? If you could do that, then I can figure out how to categorize the rest of the list into the appropriate categories. But remember that my mom is a real stickler, so make sure that no botanical fruits end up on the vegetable list, or she won't get them when she's at the store. Please alphabetize the list of vegetables, and place each item in a comma separated list.": "broccoli,celery,green beans,lettuce,sweet potatoes,zucchini",
+  "Hi, I'm making a pie but I could use some help with my shopping list. I have everything I need for the crust, but I'm not sure about the filling. I got the recipe from my friend Aditi, but she left it as a voice memo and the speaker on my phone is buzzing so I can't quite make out what she's saying. Could you please listen to the recipe and list all of the ingredients that my friend described? I only want the ingredients for the filling, as I have everything I need to make my favorite pie crust. I've attached the recipe as Strawberry pie.mp3.\n\nIn your response, please only list the ingredients, not any measurements. So if the recipe calls for \"a pinch of salt\" or \"two cups of ripe strawberries\" the ingredients on the list would be \"salt\" and \"ripe strawberries\".\n\nPlease format your response as a comma separated list of ingredients. Also, please alphabetize the ingredients.": "cornstarch,granulated sugar,lemon juice,ripe strawberries,vanilla extract",
+  "Who did the actor who played Ray in the Polish-language version of Everybody Loves Raymond play in Magda M.? Give only the first name.": "Wojciech",
+  "What is the final numeric output from the attached Python code?": "0",
+  "How many at bats did the Yankee with the most walks in the 1977 regular season have that same season?": "519",
+  "Hi, I was out sick from my classes on Friday, so I'm trying to figure out what I need to study for my Calculus mid-term next week. My friend from class sent me an audio recording of Professor Willowbrook giving out the recommended reading for the test, but my headphones are broken :(\n\nCould you please listen to the recording for me and tell me the page numbers I'm supposed to go over? I've attached a file called Homework.mp3 that has the recording. Please provide just the page numbers as a comma-delimited list. And please provide the list in ascending order.": "132133134197245",
+  "On June 6, 2023, an article by Carolyn Collins Petersen was published in Universe Today. This article mentions a team that produced a paper about their observations, linked at the bottom of the article. Find this paper. Under what NASA award number was the work performed by R. G. Arendt supported by?": "80GSFC21M0002",
+  "Where were the Vietnamese specimens described by Kuznetzov in Nedoshivina's 2010 paper eventually deposited? Just give me the city name without abbreviations.": "Saint Petersburg",
+  "What country had the least number of athletes at the 1928 Summer Olympics? If there's a tie for a number of athletes, return the first in alphabetical order. Give the IOC country code as your answer.": "CUB",
+  "Who are the pitchers with the number before and after Taishō Tamai's number as of July 2023? Give them to me in the form Pitcher Before, Pitcher After, use their last names only, in Roman characters.": "Yamasaki,Uehara",
+  "The attached Excel file contains the sales of menu items for a local fast-food chain. What were the total sales that the chain made from food (not including drinks)? Express your answer in USD with two decimal places.": "89706.00"
+}

app.py

@@ -1,38 +1,63 @@
 import os
+
+# Disable Hugging Face login for local execution
+os.environ["DISABLE_HF_LOGIN"] = "1"
+
 import gradio as gr
-import requests
-import inspect
 import pandas as pd
+import requests
+
+from dotenv import load_dotenv
+
+from agent import BasicAgent, agent_graph_mermaid
+from agent.graph import agent_graph_png_base64
+
+load_dotenv()
 
-# (Keep Constants as is)
-# --- Constants ---
+# Generate the agent graph visualizations
+try:
+    GRAPH_MERMAID = agent_graph_mermaid()
+except Exception as exc:
+    GRAPH_MERMAID = f"Error generating graph diagram: {exc}"
+
+GRAPH_PNG_BASE64 = agent_graph_png_base64()
+
+
+def _env_flag(name: str, default: bool = False) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "on"}
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+_SPACE_ENV_CONFIGURED = bool(os.getenv("SPACE_ID") or os.getenv("SPACE_HOST"))
+FORCE_LOCAL_MODE = _env_flag("FORCE_LOCAL_MODE") or _env_flag("DISABLE_HF_LOGIN") or _env_flag("GRADIO_FORCE_LOCAL")
+RUNNING_IN_SPACE = _SPACE_ENV_CONFIGURED and not FORCE_LOCAL_MODE
 
-# --- 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):
+def run_and_submit_all(profile: gr.OAuthProfile | None = None, username: str | None = None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+    space_id = os.getenv("SPACE_ID")  # Get the SPACE_ID for sending link to the code
 
-    if profile:
-        username= f"{profile.username}"
-        print(f"User logged in: {username}")
+    if profile and getattr(profile, "username", None):
+        username = f"{profile.username}".strip()
+        print(f"User logged in via OAuth: {username}")
+    elif username:
+        username = username.strip()
+        print(f"Using provided username: {username}")
     else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
+        env_username = (os.getenv("HF_USERNAME") or os.getenv("LOCAL_HF_USERNAME") or "").strip()
+        if env_username:
+            username = env_username
+            print(f"Using username from environment: {username}")
+        else:
+            print("User not logged in and no username supplied.")
+            return (
+                "Please login to Hugging Face, provide a username locally, or set the `HF_USERNAME`/`LOCAL_HF_USERNAME` environment variable.",
+                None,
+            )
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
@@ -55,16 +80,23 @@ 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.")
+        
+        # Debug: Print first question structure to understand format
+        if questions_data and len(questions_data) > 0:
+            print(f"\n🔍 DEBUG - First question structure:")
+            print(f"Keys: {list(questions_data[0].keys())}")
+            if len(questions_data[0].keys()) > 2:
+                print(f"Sample: {str(questions_data[0])[:300]}...\n")
     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
@@ -79,19 +111,51 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+        
+        # Check for attached files and download them
+        file_name = item.get("file_name", "")
+        if file_name and file_name.strip():
+            try:
+                from pathlib import Path
+                
+                # Create downloads directory if it doesn't exist
+                download_dir = Path("downloads")
+                download_dir.mkdir(exist_ok=True)
+                
+                # Construct file download URL
+                file_url = f"{api_url}/files/{task_id}"  # Note: /files/ (plural)
+                print(f"📥 Downloading file: {file_name} from {file_url}")
+                
+                # Download the file
+                file_response = requests.get(file_url, timeout=30)
+                file_response.raise_for_status()
+                
+                # Save file to downloads directory
+                filepath = download_dir / file_name
+                with open(filepath, 'wb') as f:
+                    f.write(file_response.content)
+                print(f"✅ Saved file: {filepath} ({len(file_response.content)} bytes)")
+            except Exception as e:
+                print(f"⚠️ Error downloading file {file_name}: {e}")
+        
         try:
             submitted_answer = agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
+            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}"})
 
     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)
+        results_df = pd.DataFrame(results_log, columns=["Task ID", "Question", "Submitted Answer"]).fillna("")
+        return "Agent did not produce any answers to submit.", results_df
 
-    # 4. Prepare Submission 
+    # 4. Prepare Submission
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
     status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
@@ -110,7 +174,7 @@ 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)
+        results_df = pd.DataFrame(results_log, columns=["Task ID", "Question", "Submitted Answer"]).fillna("")
         return final_status, results_df
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
@@ -121,26 +185,32 @@ 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)
+        results_df = pd.DataFrame(results_log, columns=["Task ID", "Question", "Submitted Answer"]).fillna("")
         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)
+        results_df = pd.DataFrame(results_log, columns=["Task ID", "Question", "Submitted Answer"]).fillna("")
         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)
+        results_df = pd.DataFrame(results_log, columns=["Task ID", "Question", "Submitted Answer"]).fillna("")
         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)
+        results_df = pd.DataFrame(results_log, columns=["Task ID", "Question", "Submitted Answer"]).fillna("")
         return status_message, results_df
 
 
 # --- Build Gradio Interface using Blocks ---
+
+
+def run_and_submit_all_local(username_input: str | None):
+    return run_and_submit_all(profile=None, username=username_input)
+
+
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
     gr.Markdown(
@@ -158,24 +228,57 @@ with gr.Blocks() as demo:
         """
     )
 
-    gr.LoginButton()
+    # Display the agent graph
+    gr.Markdown("## Agent Flow Graph")
+    gr.Markdown("This diagram shows how your agent processes questions using LangGraph:")
+    
+    if GRAPH_PNG_BASE64:
+        gr.HTML(
+            f'<img src="data:image/png;base64,{GRAPH_PNG_BASE64}" alt="Agent Flow Graph" style="max-width:100%;height:auto;border:1px solid #ddd;border-radius:4px;padding:10px;"/>'
+        )
+    else:
+        gr.Markdown("*Graph visualization not available. The agent is still functional.*")
+
+    login_button = None
+    username_box = None
+    if RUNNING_IN_SPACE:
+        login_button = gr.LoginButton()
+    else:
+        username_box = gr.Textbox(
+            label="Hugging Face Username",
+            placeholder="Enter the username to associate with your submission",
+            value=(os.getenv("HF_USERNAME") or os.getenv("LOCAL_HF_USERNAME") or ""),
+        )
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    # Removed max_rows=10 from DataFrame constructor
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
-
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
+    results_table = gr.DataFrame(
+        label="Questions and Agent Answers",
+        value=pd.DataFrame(columns=["Task ID", "Question", "Submitted Answer"]),
+        interactive=False,
+        wrap=True,
     )
 
+    if RUNNING_IN_SPACE:
+        run_button.click(
+            fn=run_and_submit_all,
+            inputs=[login_button],
+            outputs=[status_output, results_table],
+        )
+    else:
+        run_button.click(
+            fn=run_and_submit_all_local,
+            inputs=[username_box],
+            outputs=[status_output, results_table],
+        )
+
+
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
     # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
-    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+    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,7 +286,7 @@ 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")

cache/agent/__init__.py

@@ -0,0 +1,6 @@
+"""Agent package exposing the BasicAgent and graph utilities."""
+
+from .basic_agent import BasicAgent
+from .graph import agent_graph_mermaid, build_agent_graph
+
+__all__ = ["BasicAgent", "agent_graph_mermaid", "build_agent_graph"]

cache/agent/basic_agent.py

@@ -0,0 +1,211 @@
+"""A LangGraph-based agent implementation."""
+
+import re
+import sys
+import json
+from pathlib import Path
+from datetime import datetime
+from langchain_core.messages import AIMessage, HumanMessage
+
+from .graph import AgentState, build_agent_graph
+
+
+def ensure_valid_answer(answer: str) -> str:
+    """Ensure answer is never None or empty."""
+    if not answer or not isinstance(answer, str) or answer.strip() == "":
+        return "Unable to determine answer"
+    return answer.strip()
+
+
+class TeeOutput:
+    """Redirect stdout/stderr to both console and file."""
+    def __init__(self, file_path, mode='a'):
+        self.file = open(file_path, mode, encoding='utf-8')
+        self.terminal = sys.stdout if mode == 'a' else sys.stderr
+        
+    def write(self, message):
+        self.terminal.write(message)
+        self.file.write(message)
+        self.file.flush()
+        
+    def flush(self):
+        self.terminal.flush()
+        self.file.flush()
+        
+    def close(self):
+        self.file.close()
+
+
+class BasicAgent:
+    """A LangGraph-powered agent that uses tools to answer questions."""
+
+    def __init__(self, log_to_file=True, use_cache=True, cache_file="agent_cache.json") -> None:
+        """Initialize the agent with the compiled graph."""
+        self.graph = build_agent_graph()
+        self.log_file = None
+        self.use_cache = use_cache
+        self.cache_file = Path(cache_file)
+        self.answer_cache = {}  # Cache for question -> answer mapping
+        
+        # Load cache from disk if it exists
+        if self.use_cache:
+            self._load_cache()
+        
+        # Set up logging to file
+        if log_to_file:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            log_filename = f"agent_run_{timestamp}.log"
+            self.log_file = TeeOutput(log_filename, 'w')
+            sys.stdout = self.log_file
+            print(f"📝 Logging to: {log_filename}\n")
+            if self.use_cache and self.answer_cache:
+                print(f"💾 Loaded {len(self.answer_cache)} cached answers from {self.cache_file}\n")
+
+    def _load_cache(self):
+        """Load answer cache from disk."""
+        try:
+            if self.cache_file.exists():
+                with open(self.cache_file, 'r', encoding='utf-8') as f:
+                    self.answer_cache = json.load(f)
+        except Exception as e:
+            print(f"⚠️  Warning: Could not load cache from {self.cache_file}: {e}")
+            self.answer_cache = {}
+    
+    def _save_cache(self):
+        """Save answer cache to disk."""
+        try:
+            with open(self.cache_file, 'w', encoding='utf-8') as f:
+                json.dump(self.answer_cache, f, indent=2, ensure_ascii=False)
+        except Exception as e:
+            print(f"⚠️  Warning: Could not save cache to {self.cache_file}: {e}")
+
+    def _clean_answer(self, answer: str, question: str) -> str:
+        """
+        Clean the answer based on GAIA scoring rules.
+        Aggressively removes explanatory text to provide only the literal answer.
+        """
+        answer = answer.strip()
+        
+        # Remove JSON formatting and code blocks
+        if answer.startswith('```'):
+            # Extract content from code blocks
+            lines = answer.split('\n')
+            answer = '\n'.join([l for l in lines if not l.startswith('```')])
+            answer = answer.strip()
+        
+        # Remove JSON structures like {"name":"FINISH","answer":"value"}
+        if answer.startswith('{') and ('"name"' in answer or '"FINISH"' in answer):
+            try:
+                import json
+                # Try to parse as JSON
+                parsed = json.loads(answer)
+                # Extract the actual answer value from various possible keys
+                for key in ['answer', 'arguments', 'vegetables', 'surname', 'value', 'result', 'submitted_answer']:
+                    if key in parsed and parsed[key] and parsed[key] != "FINISH":
+                        answer = str(parsed[key])
+                        break
+                # If still has "name" field, it's probably still JSON - extract any non-name value
+                if isinstance(parsed, dict) and 'name' in parsed:
+                    for key, value in parsed.items():
+                        if key != 'name' and key != 'FINISH' and value and value != "FINISH":
+                            answer = str(value)
+                            break
+            except:
+                pass
+        
+        # Remove common prefixes and explanatory phrases
+        patterns_to_remove = [
+            r'^(the answer is|answer:|final answer:|thus,|therefore,|so,|hence,)\s*',
+            r'^(the\s+)?(correct\s+)?(number|city|country|name|value|total|result)\s+(is|are|was|were)\s*',
+            r'^\d+\.\s*',  # Remove leading numbers like "1. " or "2. "
+            r'^[-•]\s*',   # Remove bullet points
+        ]
+        
+        for pattern in patterns_to_remove:
+            answer = re.sub(pattern, '', answer, flags=re.IGNORECASE)
+            answer = answer.strip()
+        
+        # If answer contains multiple sentences, try to extract just the key info
+        sentences = answer.split('.')
+        if len(sentences) > 1:
+            # Look for the shortest sentence that contains key info
+            for sent in sentences:
+                sent = sent.strip()
+                # If it's short and contains a number or key word, use it
+                if len(sent) < 50 and (any(char.isdigit() for char in sent) or len(sent.split()) <= 5):
+                    answer = sent
+                    break
+        
+        # Remove trailing explanations in parentheses
+        answer = re.sub(r'\s*\([^)]*\)\s*$', '', answer)
+        
+        # If the question asks for a comma-separated list, ensure no spaces after commas
+        if 'comma' in question.lower() and ('list' in question.lower() or 'separated' in question.lower()):
+            answer = re.sub(r',\s+', ',', answer)
+        
+        # Clean numbers: remove currency symbols and commas
+        if len(answer.split()) <= 5:  # Short answer, likely a number
+            if any(char.isdigit() for char in answer):
+                cleaned = answer
+                for symbol in ['$', '€', '£', '¥', '%', ',']:
+                    cleaned = cleaned.replace(symbol, '')
+                
+                # If after cleaning it's still a valid number, use the cleaned version
+                try:
+                    float(cleaned.strip())
+                    answer = cleaned.strip()
+                except ValueError:
+                    pass  # Not a pure number, keep original
+        
+        # Final cleanup: remove quotes if they wrap the entire answer
+        answer = answer.strip('"\'')
+        
+        return answer
+
+    def __call__(self, question: str) -> str:
+        """Invoke the agent with a question and return the answer."""
+        try:
+            print("\n" + "="*80)
+            print(f"📋 QUESTION: {question[:150]}...")
+            print("="*80)
+            
+            # Check cache first
+            if self.use_cache and question in self.answer_cache:
+                cached_answer = self.answer_cache[question]
+                print("\n💾 Using cached answer (no LLM call!)")
+                print(f"\n🎯 FINAL ANSWER: {cached_answer}")
+                print("="*80 + "\n")
+                return cached_answer
+            
+            # Create the initial state with the user's question
+            state: AgentState = {"messages": [HumanMessage(content=question)]}
+            
+            # Run the graph with increased recursion limit
+            print("\n🚀 Starting agent execution...")
+            result = self.graph.invoke(state, config={"recursion_limit": 50})
+            
+            # Extract the final answer from the last AI message
+            for message in reversed(result["messages"]):
+                if isinstance(message, AIMessage):
+                    raw_answer = message.content
+                    # Clean the answer based on GAIA scoring rules
+                    cleaned_answer = self._clean_answer(raw_answer, question)
+                    # Ensure answer is never empty
+                    validated_answer = ensure_valid_answer(cleaned_answer)
+                    
+                    # Cache the answer and save to disk
+                    if self.use_cache:
+                        self.answer_cache[question] = validated_answer
+                        self._save_cache()  # Persist to disk immediately
+                    
+                    print(f"\n🎯 FINAL ANSWER: {validated_answer}")
+                    print("="*80 + "\n")
+                    return validated_answer
+            
+            print("\n⚠️  No answer found")
+            print("="*80 + "\n")
+            return ensure_valid_answer("")
+        except Exception as e:
+            print(f"\n❌ ERROR: {e}")
+            print("="*80 + "\n")
+            return ensure_valid_answer(f"Agent failed with error: {e}")

cache/agent/constants.py

@@ -0,0 +1,6 @@
+"""Shared constants for the agent."""
+
+from pathlib import Path
+
+CACHE_DIR = Path(__file__).resolve().parent.parent / "cache"
+CACHE_DIR.mkdir(exist_ok=True)

cache/agent/graph.py

@@ -0,0 +1,356 @@
+"""LangGraph state graph construction for the LLM-powered agent."""
+
+import base64
+import json
+import os
+import time
+import random
+from typing import Annotated, Literal, TypedDict
+
+from langchain_core.messages import AIMessage, BaseMessage, ToolMessage
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import render_text_description
+from langchain_openai import ChatOpenAI
+from langgraph.graph import StateGraph
+from langgraph.graph.message import add_messages
+from openai import RateLimitError
+
+from .constants import CACHE_DIR
+from .tools import tool_classes
+
+
+class AgentState(TypedDict):
+    messages: Annotated[list[BaseMessage], add_messages]
+
+
+class SimpleRateLimiter:
+    """Simple token bucket rate limiter to prevent hitting API limits."""
+    
+    def __init__(self, calls_per_minute=50):
+        self.calls_per_minute = calls_per_minute
+        self.call_times = []
+    
+    def wait_if_needed(self):
+        """Wait if we're about to exceed rate limit."""
+        now = time.time()
+        
+        # Remove calls older than 1 minute
+        self.call_times = [t for t in self.call_times if now - t < 60]
+        
+        # If we're at the limit, wait
+        if len(self.call_times) >= self.calls_per_minute:
+            sleep_time = 60 - (now - self.call_times[0]) + 1
+            if sleep_time > 0:
+                print(f"⏳ Rate limiter: waiting {sleep_time:.1f}s to avoid hitting limits...")
+                time.sleep(sleep_time)
+                self.call_times = []
+        
+        # Record this call
+        self.call_times.append(time.time())
+
+
+# Global variables that will be initialized in build_agent_graph()
+_tools = None
+_agent_chain = None
+_generation_chain = None
+_primary_llm = None
+_fallback_llm = None
+_rate_limiter = SimpleRateLimiter(calls_per_minute=40)  # Conservative limit
+
+def _call_llm_with_retry(chain, state, max_retries=5):
+    """
+    Call LLM with exponential backoff retry logic.
+    Falls back to cheaper model if primary keeps failing.
+    """
+    for attempt in range(max_retries):
+        try:
+            # Wait if we're approaching rate limits
+            _rate_limiter.wait_if_needed()
+            return chain.invoke(state)
+        except RateLimitError as e:
+            # Extract wait time from error if available
+            wait_time = min(60, (2 ** attempt) + random.random())
+            print(f"⚠️  Rate limit hit (attempt {attempt + 1}/{max_retries})")
+            print(f"   Waiting {wait_time:.1f}s before retry...")
+            time.sleep(wait_time)
+        except Exception as e:
+            # For other errors, don't retry
+            print(f"❌ LLM error: {e}")
+            raise
+    
+    # If all retries failed, try fallback model
+    print("🔄 All retries exhausted, switching to fallback model (gpt-4o-mini)...")
+    try:
+        # Rebuild chain with fallback LLM
+        if _fallback_llm is not None:
+            fallback_chain = chain.first | _fallback_llm
+            return fallback_chain.invoke(state)
+    except Exception as e:
+        print(f"❌ Fallback model also failed: {e}")
+        raise
+    
+    raise RuntimeError("All retry attempts and fallback failed")
+
+def _initialize_chains_and_tools():
+    """Initialize the tools and LLM chains. Called once when building the graph."""
+    global _tools, _agent_chain, _generation_chain, _primary_llm, _fallback_llm
+    
+    if _tools is not None:
+        return  # Already initialized
+    
+    # Initialize PRIMARY LLM (gpt-4o)
+    print("🔧 Initializing primary LLM: gpt-4o")
+    _primary_llm = ChatOpenAI(
+        #model="gpt-4o",
+        model="gpt-4.1",
+        temperature=0,
+        verbose=True,
+        request_timeout=60  # 60 second timeout
+    )
+    
+    # Initialize FALLBACK LLM (gpt-4o-mini - cheaper, faster)
+    print("🔧 Initializing fallback LLM: gpt-4o-mini")
+    _fallback_llm = ChatOpenAI(
+        model="gpt-4o-mini",
+        temperature=0,
+        verbose=True,
+        request_timeout=60
+    )
+    
+    llm = _primary_llm
+    
+    # Instantiate the tools
+    _tools = []
+    for tool in tool_classes:
+        if callable(tool) and not isinstance(tool, type):
+            # It's a function that returns a tool instance (like create_wikipedia_tool)
+            _tools.append(tool())
+        else:
+            # It's a class, instantiate it
+            _tools.append(tool())
+    
+    # CRITICAL: Bind tools to the LLM using OpenAI's native function calling
+    llm = llm.bind_tools(_tools)
+    
+    # Render the tools to a text description for the prompt
+    rendered_tools = render_text_description(_tools)
+    
+    # Create the system prompt
+    system_prompt = f"""You are a highly capable AI assistant designed to solve complex, real-world questions.
+
+REASONING STRATEGY (CRITICAL):
+1. **Decompose**: Break complex questions into smaller sub-questions
+2. **Plan**: Before using tools, outline your complete strategy
+3. **Execute**: Use tools systematically, one step at a time
+4. **Verify**: Check each result before proceeding to the next step
+5. **Self-correct**: If a tool fails or gives unexpected results, try alternative approaches
+6. **Synthesize**: Combine information from multiple sources to form your final answer
+
+FILE HANDLING - CRITICAL:
+⚠️ **Files mentioned as "attached" are ALREADY in the current directory!**
+- When question says "attached Excel file", "attached image", "attached .mp3" - use `list_files` to find them
+- Files are pre-downloaded before you start, so they WILL be in current directory
+- **NEVER** ask for URLs for "attached" files - they're already there!
+- Workflow:
+  1. Use `list_files` to see what's available
+  2. Find the relevant file (Excel, image, mp3, etc.)
+  3. Process it with appropriate tool:
+     - Excel (.xlsx, .xls): use `read_excel` tool to get summary and data
+     - CSV: use `python_repl` with pandas: `pd.read_csv('filename.csv')`
+     - Python files (.py): use `execute_python_file` tool to run and get output
+     - Text files: use `read_file` tool
+     - Images (.png, .jpg): use `analyze_image` tool (Gemini vision) - great for chess, diagrams, text in images
+     - MP3/Audio files: use `understand_audio` tool (Gemini audio) - transcribes and understands audio
+
+MULTIMEDIA HANDLING:
+- For YouTube videos: use `understand_video` tool with format: 'URL: <youtube_url> | QUESTION: <specific_question>'
+  Example: understand_video('URL: https://www.youtube.com/watch?v=abc | QUESTION: How many bird species are visible?')
+  This ensures Gemini knows exactly what to look for in the video
+- For audio files (.mp3): use `understand_audio` tool - Gemini will transcribe and answer questions
+- For images: use `analyze_image` tool - Gemini can read text, analyze chess positions, describe images
+- For web URLs: use `download_file` if you need to download something from the internet
+
+TOOL USAGE BEST PRACTICES:
+- Use `calculator` for precise mathematical operations (faster than python_repl)
+- Use `wikipedia` for factual knowledge about people, places, events
+- Use `tavily_search` for recent information or specific facts
+- Use `youtube_transcript` for YouTube video content analysis
+- Use `read_excel` for quick Excel file inspection
+- Use `python_repl` for complex data analysis and calculations
+- Chain multiple tools when needed (e.g., search → extract info → calculate)
+
+AVAILABLE TOOLS:
+{rendered_tools}
+
+RESPONSE FORMAT:
+- For tool calls: return JSON with 'name' and 'arguments' keys
+- When finished: return JSON with 'name' of 'FINISH'
+
+⚠️ CRITICAL - PROVIDE ONLY THE FINAL ANSWER ⚠️
+DO NOT include explanations, reasoning, or extra text in your final answer.
+Examples:
+- Question: "How many albums?" → Answer: "2" (NOT "Mercedes Sosa published 2 albums...")
+- Question: "What city?" → Answer: "Paris" (NOT "The city is Paris")
+- Question: "Total sales?" → Answer: "1234.56" (NOT "The total sales are $1,234.56")
+
+BE EXTREMELY CONCISE. The scoring system only wants the literal answer.
+
+CRITICAL - ANSWER FORMATTING RULES:
+The scoring system is very strict about format. Follow these rules EXACTLY:
+
+1. **For NUMBER answers**:
+   - Remove currency symbols ($, €, £)
+   - Remove percentage signs (%)
+   - Remove commas from large numbers
+   - Provide just the number: "1234.56" not "$1,234.56"
+
+2. **For LIST answers** (comma-separated):
+   - Use ONLY commas to separate items (or semicolons if specified)
+   - NO extra spaces around commas
+   - Count must match exactly
+   - Order matters!
+   - Example: "apple,banana,cherry" NOT "apple, banana, cherry"
+
+3. **For STRING answers**:
+   - Be concise - extra words will cause mismatch
+   - Capitalization doesn't matter
+   - Punctuation doesn't matter
+   - Spaces don't matter
+   - But be precise with the core answer
+
+4. **For NAMES**:
+   - Use full names if asked
+   - Use last names only if specified
+   - Check the question carefully for format requirements
+
+5. **For CODES** (IOC, airport, etc.):
+   - Use exact format requested (uppercase/lowercase)
+   - No extra characters
+
+DOUBLE-CHECK YOUR FINAL ANSWER FORMAT BEFORE RETURNING!
+"""
+    
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system_prompt),
+        ("placeholder", "{messages}"),
+    ])
+    
+    # Create the LLM chains
+    _agent_chain = prompt | llm
+    generation_prompt = ChatPromptTemplate.from_messages([
+        ("system", "You are a helpful assistant. Answer the user's question based on the conversation history."),
+        ("placeholder", "{messages}"),
+    ])
+    _generation_chain = generation_prompt | llm
+
+def agent_node(state: AgentState) -> dict:
+    """Invokes the LLM to decide on the next action with retry logic."""
+    print("\n🤖 [AGENT NODE] Deciding next action...")
+    
+    # Use retry logic
+    response = _call_llm_with_retry(_agent_chain, state)
+    
+    # Check if there are tool calls
+    if hasattr(response, 'tool_calls') and response.tool_calls:
+        print(f"📝 [AGENT NODE] Requesting {len(response.tool_calls)} tool call(s)")
+        for tc in response.tool_calls:
+            print(f"   - {tc['name']}")
+    else:
+        print(f"📝 [AGENT NODE] Response: {response.content[:200]}...")
+    
+    return {"messages": [response]}
+
+def generation_node(state: AgentState) -> dict:
+    """Invokes the LLM to generate a final answer."""
+    print("\n✨ [GENERATION NODE] Creating final answer...")
+    response = _generation_chain.invoke(state)
+    print(f"✅ [GENERATION NODE] Final answer: {response.content[:200]}...")
+    return {"messages": [AIMessage(content=response.content)]}
+
+def tool_node(state: AgentState) -> dict:
+    """Runs the tools using OpenAI's native tool calling."""
+    print("\n🔧 [TOOL NODE] Executing tools...")
+    last_message = state["messages"][-1]
+    
+    # Check if the message has tool_calls (OpenAI's native format)
+    if not hasattr(last_message, 'tool_calls') or not last_message.tool_calls:
+        print("⚠️  [TOOL NODE] No tool calls found")
+        return {"messages": []}
+    
+    tool_messages = []
+    for tool_call in last_message.tool_calls:
+        tool_name = tool_call['name']
+        tool_args = tool_call['args']
+        tool_call_id = tool_call['id']
+        
+        print(f"  🛠️  Calling tool: {tool_name}")
+        print(f"     Args: {str(tool_args)[:100]}...")
+        
+        tool_to_call = next((t for t in _tools if t.name == tool_name), None)
+        if tool_to_call:
+            try:
+                observation = tool_to_call.invoke(tool_args)
+                result_preview = str(observation)[:150]
+                print(f"  ✅ Result: {result_preview}...")
+                tool_messages.append(ToolMessage(
+                    content=str(observation),
+                    tool_call_id=tool_call_id
+                ))
+            except Exception as e:
+                print(f"  ❌ Error: {e}")
+                tool_messages.append(ToolMessage(
+                    content=f"Error: {e}",
+                    tool_call_id=tool_call_id
+                ))
+        else:
+            print(f"  ⚠️  Tool '{tool_name}' not found")
+    
+    print(f"🔧 [TOOL NODE] Executed {len(tool_messages)} tool(s)")
+    return {"messages": tool_messages}
+
+def should_continue(state: AgentState) -> Literal["tools", "__end__"]:
+    """Determines the next node to execute based on OpenAI's tool calls."""
+    last_message = state["messages"][-1]
+    
+    # If the last message has tool calls, go to tools node
+    if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
+        print("➡️  Routing to: TOOLS")
+        return "tools"
+    
+    # Otherwise, we're done
+    print("➡️  Routing to: END")
+    return "__end__"
+
+def build_agent_graph() -> StateGraph:
+    """Builds the state graph for the agent."""
+    # Initialize tools and chains (only happens once)
+    _initialize_chains_and_tools()
+    
+    workflow = StateGraph(AgentState)
+    workflow.add_node("agent", agent_node)
+    workflow.add_node("tools", tool_node)
+    workflow.set_entry_point("agent")
+    workflow.add_conditional_edges("agent", should_continue)
+    workflow.add_edge("tools", "agent")
+    return workflow.compile()
+
+def agent_graph_mermaid() -> str:
+    """Returns the LangGraph structure in Mermaid format."""
+    graph = build_agent_graph()
+    return graph.get_graph().draw_mermaid()
+
+def agent_graph_png_base64(filename: str = "agent_graph.png") -> str | None:
+    """Generates a PNG of the agent graph and returns it as a base64 string."""
+    graph = build_agent_graph()
+    output_path = CACHE_DIR / filename
+    try:
+        graph.get_graph().draw_png(str(output_path))
+    except Exception as exc:
+        print(f"Warning: Failed to render agent graph PNG: {exc}")
+        return None
+
+    try:
+        return base64.b64encode(output_path.read_bytes()).decode("ascii")
+    except Exception as exc:
+        print(f"Warning: Unable to read rendered graph PNG: {exc}")
+        return None

cache/agent/tools.py

@@ -0,0 +1,476 @@
+"""LangGraph tools for the agent."""
+
+import os
+from pathlib import Path
+from typing import Optional
+import time
+
+from langchain.tools import BaseTool
+from langchain_community.tools import DuckDuckGoSearchRun, WikipediaQueryRun
+from langchain_community.utilities import WikipediaAPIWrapper
+from langchain_experimental.tools import PythonAstREPLTool
+from langchain_tavily import TavilySearch
+from youtube_transcript_api import YouTubeTranscriptApi
+import re as regex
+import requests
+from urllib.parse import urlparse
+import google.generativeai as genai
+
+
+def find_file(filename: str) -> str:
+    """Helper function to find a file in multiple locations."""
+    # Try multiple locations in order
+    locations = [
+        Path(filename),  # Current directory
+        Path("downloads") / filename,  # Downloads directory
+        Path(".") / filename,  # Explicit current directory
+    ]
+    
+    for path in locations:
+        if path.exists():
+            return str(path)
+    
+    # File not found, return the downloads path as default
+    return str(Path("downloads") / filename)
+
+
+class ListFilesTool(BaseTool):
+    """Tool to list files in the current directory or a specified directory."""
+    
+    name: str = "list_files"
+    description: str = "Lists all files in the current directory or a specified directory. Input should be a directory path (optional, defaults to current directory)."
+    
+    def _run(self, directory: str = ".") -> str:
+        """List files in the specified directory."""
+        try:
+            # Check both current directory and downloads directory
+            paths_to_check = [Path(directory)]
+            if directory == ".":
+                paths_to_check.append(Path("downloads"))
+            
+            all_files = []
+            for path in paths_to_check:
+                if path.exists():
+                    location = "downloads/" if path.name == "downloads" else "./"
+                    for item in path.iterdir():
+                        if item.is_file():
+                            all_files.append(f"{location}{item.name} ({item.stat().st_size} bytes)")
+            
+            if not all_files:
+                return f"No files found in '{directory}'."
+            
+            return "Files found:\n" + "\n".join(all_files)
+        except Exception as e:
+            return f"Error listing files: {str(e)}"
+    
+    async def _arun(self, directory: str = ".") -> str:
+        """Async version."""
+        return self._run(directory)
+
+
+class ReadFileTool(BaseTool):
+    """Tool to read the contents of a text file."""
+    
+    name: str = "read_file"
+    description: str = "Reads the contents of a text file. Input should be the file path."
+    
+    def _run(self, file_path: str) -> str:
+        """Read the file contents."""
+        try:
+            # Find file in multiple locations
+            actual_path = find_file(file_path)
+            path = Path(actual_path)
+            if not path.exists():
+                return f"File '{file_path}' does not exist in current directory or downloads/."
+            
+            with open(path, 'r', encoding='utf-8') as f:
+                content = f.read()
+            
+            return content
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
+    
+    async def _arun(self, file_path: str) -> str:
+        """Async version."""
+        return self._run(file_path)
+
+
+class ExcelReaderTool(BaseTool):
+    """Tool for reading and analyzing Excel files."""
+    
+    name: str = "read_excel"
+    description: str = "Reads an Excel file and returns its contents as a pandas DataFrame. Input should be the file path to the Excel file (.xlsx or .xls)."
+    
+    def _run(self, file_path: str) -> str:
+        """Read Excel file and return summary."""
+        try:
+            import pandas as pd
+            
+            # Find file in multiple locations
+            actual_path = find_file(file_path)
+            path = Path(actual_path)
+            if not path.exists():
+                return f"File '{file_path}' does not exist in current directory or downloads/."
+            
+            # Read the Excel file
+            df = pd.read_excel(path)
+            
+            # Return a summary
+            result = f"Excel file loaded successfully.\n"
+            result += f"Shape: {df.shape[0]} rows, {df.shape[1]} columns\n"
+            result += f"Columns: {', '.join(df.columns.tolist())}\n\n"
+            result += f"First few rows:\n{df.head().to_string()}\n\n"
+            result += f"Data types:\n{df.dtypes.to_string()}\n\n"
+            result += f"Summary statistics:\n{df.describe().to_string()}"
+            
+            return result
+        except Exception as e:
+            return f"Error reading Excel file: {str(e)}"
+    
+    async def _arun(self, file_path: str) -> str:
+        """Async version."""
+        return self._run(file_path)
+
+
+class DownloadFileTool(BaseTool):
+    """Tool for downloading files from URLs."""
+    
+    name: str = "download_file"
+    description: str = "Downloads a file from a URL and saves it to the current directory. Input should be the URL of the file to download. Returns the local file path."
+    
+    def _run(self, url: str) -> str:
+        """Download file from URL."""
+        try:
+            # Parse URL to get filename
+            parsed = urlparse(url)
+            filename = os.path.basename(parsed.path)
+            
+            # If no filename in URL, generate one
+            if not filename or '.' not in filename:
+                # Try to get from Content-Disposition header
+                response = requests.head(url, allow_redirects=True, timeout=10)
+                if 'Content-Disposition' in response.headers:
+                    content_disp = response.headers['Content-Disposition']
+                    if 'filename=' in content_disp:
+                        filename = content_disp.split('filename=')[1].strip('"\'')
+                
+                # Still no filename? Generate one based on content type
+                if not filename or '.' not in filename:
+                    content_type = response.headers.get('Content-Type', '')
+                    ext = '.bin'
+                    if 'image' in content_type:
+                        ext = '.png' if 'png' in content_type else '.jpg'
+                    elif 'excel' in content_type or 'spreadsheet' in content_type:
+                        ext = '.xlsx'
+                    elif 'pdf' in content_type:
+                        ext = '.pdf'
+                    filename = f"downloaded_file{ext}"
+            
+            # Download the file
+            print(f"📥 Downloading: {url}")
+            response = requests.get(url, timeout=30)
+            response.raise_for_status()
+            
+            # Save to current directory
+            filepath = Path(filename)
+            with open(filepath, 'wb') as f:
+                f.write(response.content)
+            
+            file_size = len(response.content)
+            print(f"✅ Downloaded: {filename} ({file_size} bytes)")
+            
+            return f"File downloaded successfully: {filename} ({file_size} bytes)"
+        except Exception as e:
+            return f"Error downloading file: {str(e)}"
+    
+    async def _arun(self, url: str) -> str:
+        """Async version."""
+        return self._run(url)
+
+
+class YouTubeTranscriptTool(BaseTool):
+    """Tool for getting transcripts from YouTube videos."""
+    
+    name: str = "youtube_transcript"
+    description: str = "Gets the transcript/captions from a YouTube video. Input should be either a YouTube URL or video ID."
+    
+    def _run(self, video_input: str) -> str:
+        """Get YouTube transcript."""
+        try:
+            # Extract video ID from URL if needed
+            video_id = video_input
+            if 'youtube.com' in video_input or 'youtu.be' in video_input:
+                # Extract video ID from various YouTube URL formats
+                patterns = [
+                    r'(?:v=|\/)([0-9A-Za-z_-]{11}).*',
+                    r'(?:embed\/)([0-9A-Za-z_-]{11})',
+                    r'(?:watch\?v=)([0-9A-Za-z_-]{11})'
+                ]
+                for pattern in patterns:
+                    match = regex.search(pattern, video_input)
+                    if match:
+                        video_id = match.group(1)
+                        break
+            
+            # Get transcript using the correct API
+            try:
+                # Try to get transcript (auto-generated or manual)
+                transcript_data = YouTubeTranscriptApi.get_transcript(video_id, languages=['en'])
+            except:
+                # Try any available language
+                try:
+                    transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+                    transcript = next(iter(transcript_list))
+                    transcript_data = transcript.fetch()
+                except:
+                    return f"Error: No transcript available for video {video_id}"
+            
+            # Format transcript
+            full_transcript = "\n".join([f"[{item['start']:.1f}s] {item['text']}" for item in transcript_data])
+            
+            return f"YouTube Transcript for video {video_id}:\n\n{full_transcript}"
+        except Exception as e:
+            return f"Error getting YouTube transcript: {str(e)}"
+    
+    async def _arun(self, video_input: str) -> str:
+        """Async version."""
+        return self._run(video_input)
+
+
+class CalculatorTool(BaseTool):
+    """Tool for performing mathematical calculations safely."""
+    
+    name: str = "calculator"
+    description: str = "Useful for mathematical calculations. Input should be a mathematical expression as a string (e.g., '2 + 2', '(5 * 3) / 2')."
+    
+    def _run(self, expression: str) -> str:
+        """Evaluate a mathematical expression safely."""
+        try:
+            # Remove any potentially dangerous operations
+            if any(dangerous in expression.lower() for dangerous in ['import', 'exec', 'eval', '__']):
+                return "Error: Expression contains forbidden operations."
+            
+            # Evaluate using Python's eval with restricted namespace
+            result = eval(expression, {"__builtins__": {}}, {})
+            return str(result)
+        except Exception as e:
+            return f"Error calculating: {str(e)}"
+    
+    async def _arun(self, expression: str) -> str:
+        """Async version."""
+        return self._run(expression)
+
+
+class GeminiVideoTool(BaseTool):
+    """Tool for understanding YouTube videos using Google Gemini."""
+    
+    name: str = "understand_video"
+    description: str = """Analyzes YouTube videos using Google Gemini's native video understanding. 
+    Input format: 'URL: <youtube_url> | QUESTION: <specific_question>'
+    Example: 'URL: https://www.youtube.com/watch?v=abc123 | QUESTION: How many birds are visible?'
+    Can answer questions about video content without transcripts."""
+    
+    def _run(self, youtube_url: str) -> str:
+        """Analyze YouTube video using Gemini."""
+        try:
+            # Check if GEMINI_API_KEY is available
+            api_key = os.getenv("GEMINI_API_KEY")
+            if not api_key:
+                return "Error: GEMINI_API_KEY not set. Cannot analyze video."
+            
+            # Parse input - check if it contains both URL and question
+            url = youtube_url
+            question = None
+            
+            if '|' in youtube_url:
+                parts = youtube_url.split('|')
+                for part in parts:
+                    part = part.strip()
+                    if part.startswith('URL:'):
+                        url = part.replace('URL:', '').strip()
+                    elif part.startswith('QUESTION:'):
+                        question = part.replace('QUESTION:', '').strip()
+            
+            # Configure Gemini
+            genai.configure(api_key=api_key)
+            model = genai.GenerativeModel('gemini-2.0-flash-exp')
+            
+            # Create targeted prompt
+            if question:
+                prompt = f"Watch this YouTube video carefully and answer the following specific question: {question}\n\nProvide a direct, concise answer based only on what you observe in the video."
+            else:
+                prompt = "Analyze this YouTube video and describe what you see in detail. Pay attention to all visual details, objects, people, actions, and events."
+            
+            response = model.generate_content([prompt, url])
+            
+            return f"Video Analysis:\n{response.text}"
+        except Exception as e:
+            return f"Error analyzing video: {str(e)}"
+    
+    async def _arun(self, youtube_url: str) -> str:
+        """Async version."""
+        return self._run(youtube_url)
+
+
+class GeminiAudioTool(BaseTool):
+    """Tool for understanding audio files (MP3) using Google Gemini."""
+    
+    name: str = "understand_audio"
+    description: str = "Analyzes audio files (MP3) using Google Gemini's audio understanding. Input should be the file path to the audio file. Can transcribe and answer questions about audio content."
+    
+    def _run(self, file_path: str) -> str:
+        """Analyze audio file using Gemini."""
+        try:
+            # Check if GEMINI_API_KEY is available
+            api_key = os.getenv("GEMINI_API_KEY")
+            if not api_key:
+                return "Error: GEMINI_API_KEY not set. Cannot analyze audio."
+            
+            # Find file in multiple locations
+            actual_path = find_file(file_path)
+            if not os.path.exists(actual_path):
+                return f"Error: Audio file '{file_path}' not found in current directory or downloads/."
+            
+            file_path = actual_path  # Use the found path
+            
+            # Configure Gemini
+            genai.configure(api_key=api_key)
+            
+            # Upload audio file to Gemini
+            print(f"Uploading audio file to Gemini: {file_path}")
+            audio_file = genai.upload_file(path=file_path)
+            
+            # Wait for file to be processed
+            import time
+            while audio_file.state.name == "PROCESSING":
+                time.sleep(2)
+                audio_file = genai.get_file(audio_file.name)
+            
+            if audio_file.state.name == "FAILED":
+                return f"Error: Gemini failed to process audio file"
+            
+            # Analyze audio
+            model = genai.GenerativeModel('gemini-2.0-flash-exp')
+            prompt = "Please transcribe this audio file and provide the complete content. Pay attention to all details, numbers, names, and instructions mentioned."
+            
+            response = model.generate_content([audio_file, prompt])
+            
+            return f"Audio Transcription:\n{response.text}"
+        except Exception as e:
+            return f"Error analyzing audio: {str(e)}"
+    
+    async def _arun(self, file_path: str) -> str:
+        """Async version."""
+        return self._run(file_path)
+
+
+class ImageAnalysisTool(BaseTool):
+    """Tool for analyzing images using Google Gemini."""
+    
+    name: str = "analyze_image"
+    description: str = "Analyzes images using Google Gemini's vision capabilities. Input should be the file path to the image. Can describe images, read text, analyze chess positions, etc."
+    
+    def _run(self, file_path: str) -> str:
+        """Analyze image using Gemini."""
+        try:
+            # Check if GEMINI_API_KEY is available
+            api_key = os.getenv("GEMINI_API_KEY")
+            if not api_key:
+                return "Error: GEMINI_API_KEY not set. Cannot analyze image."
+            
+            # Find file in multiple locations
+            actual_path = find_file(file_path)
+            if not os.path.exists(actual_path):
+                return f"Error: Image file '{file_path}' not found in current directory or downloads/."
+            
+            file_path = actual_path  # Use the found path
+            
+            # Configure Gemini
+            genai.configure(api_key=api_key)
+            
+            # Upload image file to Gemini
+            print(f"Uploading image to Gemini: {file_path}")
+            image_file = genai.upload_file(path=file_path)
+            
+            # Analyze image
+            model = genai.GenerativeModel('gemini-2.0-flash-exp')
+            prompt = "Please analyze this image in detail. Describe everything you see including: objects, text, positions, colors, patterns, and any relevant information. If this is a chess board, provide the position in detail. If there's text, transcribe it."
+            
+            response = model.generate_content([image_file, prompt])
+            
+            return f"Image Analysis:\n{response.text}"
+        except Exception as e:
+            return f"Error analyzing image: {str(e)}"
+    
+    async def _arun(self, file_path: str) -> str:
+        """Async version."""
+        return self._run(file_path)
+
+
+class ExecutePythonFileTool(BaseTool):
+    """Tool for executing Python files and capturing output."""
+    
+    name: str = "execute_python_file"
+    description: str = "Executes a Python file and returns its output. Input should be the file path to the .py file. Captures stdout and returns the final output."
+    
+    def _run(self, file_path: str) -> str:
+        """Execute Python file and return output."""
+        try:
+            import subprocess
+            import sys
+            
+            # Find file in multiple locations
+            actual_path = find_file(file_path)
+            if not os.path.exists(actual_path):
+                return f"Error: Python file '{file_path}' not found in current directory or downloads/."
+            
+            # Execute the Python file
+            result = subprocess.run(
+                [sys.executable, actual_path],
+                capture_output=True,
+                text=True,
+                timeout=30  # 30 second timeout
+            )
+            
+            output = ""
+            if result.stdout:
+                output += f"Output:\n{result.stdout}\n"
+            if result.stderr:
+                output += f"Errors:\n{result.stderr}\n"
+            if result.returncode != 0:
+                output += f"Exit code: {result.returncode}\n"
+            
+            return output if output else "Script executed successfully with no output."
+        except subprocess.TimeoutExpired:
+            return "Error: Script execution timed out (30 seconds limit)."
+        except Exception as e:
+            return f"Error executing Python file: {str(e)}"
+    
+    async def _arun(self, file_path: str) -> str:
+        """Async version."""
+        return self._run(file_path)
+
+
+# Create Wikipedia tool wrapper
+def create_wikipedia_tool():
+    """Create a Wikipedia search tool."""
+    api_wrapper = WikipediaAPIWrapper(top_k_results=2, doc_content_chars_max=4000)
+    return WikipediaQueryRun(api_wrapper=api_wrapper)
+
+
+tool_classes = [
+    DuckDuckGoSearchRun, 
+    TavilySearch, 
+    PythonAstREPLTool,
+    ListFilesTool,
+    ReadFileTool,
+    ExcelReaderTool,
+    DownloadFileTool,
+    ExecutePythonFileTool,  # Execute Python files
+    YouTubeTranscriptTool,
+    GeminiVideoTool,  # Gemini video understanding
+    GeminiAudioTool,  # Gemini audio transcription (MP3)
+    ImageAnalysisTool,  # Gemini image analysis (chess, diagrams, etc.)
+    CalculatorTool,
+    create_wikipedia_tool  # This returns an instance, not a class
+]   

requirements.txt

@@ -1,2 +1,22 @@
+langchain
+langgraph
+langchain-huggingface
+langchain-community
+langchain-core
+huggingface_hub
+python-dotenv
 gradio
-requests
+requests
+lxml
+html5lib
+beautifulsoup4
+tavily-python
+duckduckgo-search
+langchain-openai
+langchain-experimental
+pandas
+openpyxl
+langchain-tavily
+wikipedia
+youtube-transcript-api
+google-generativeai