Initial commit: LLM Analysis Quiz Solver Agent

.env.example

@@ -0,0 +1,3 @@
+GOOGLE_API_KEY=your_gemini_api_key
+EMAIL=your_email
+SECRET=your_secret

.gitignore

@@ -0,0 +1,12 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+.env
+# Virtual environments
+.venv
+tests
+LLMFiles

.python-version

@@ -0,0 +1 @@
+3.12

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.10-slim
+
+# --- System deps required by Playwright browsers ---
+RUN apt-get update && apt-get install -y \
+    wget gnupg ca-certificates curl unzip \
+    libnss3 libatk1.0-0 libatk-bridge2.0-0 libcups2 libxkbcommon0 \
+    libgtk-3-0 libgbm1 libasound2 libxcomposite1 libxdamage1 libxrandr2 \
+    libxfixes3 libpango-1.0-0 libcairo2 \
+    && rm -rf /var/lib/apt/lists/*
+
+# --- Install Playwright + Chromium ---
+RUN pip install playwright && playwright install --with-deps chromium
+
+# --- Install uv package manager ---
+RUN pip install uv
+
+# --- Copy app to container ---
+WORKDIR /app
+
+COPY . .
+
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONIOENCODING=utf-8
+
+# --- Install project dependencies using uv ---
+RUN uv sync --frozen
+
+# HuggingFace Spaces exposes port 7860
+EXPOSE 7860
+
+# --- Run your FastAPI app ---
+# uvicorn must be in pyproject dependencies
+CMD ["uv", "run", "main.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sai Vijay Ragav
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,389 @@
+---
+title: LLM Analysis Quiz Solver
+emoji: 🏃
+colorFrom: red
+colorTo: blue
+sdk: docker
+pinned: false
+app_port: 7860
+---
+
+# LLM Analysis - Autonomous Quiz Solver Agent
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![FastAPI](https://img.shields.io/badge/FastAPI-0.121.3+-green.svg)](https://fastapi.tiangolo.com/)
+
+An intelligent, autonomous agent built with LangGraph and LangChain that solves data-related quizzes involving web scraping, data processing, analysis, and visualization tasks. The system uses Google's Gemini 2.5 Flash model to orchestrate tool usage and make decisions.
+
+## 📋 Table of Contents
+
+- [Overview](#overview)
+- [Architecture](#architecture)
+- [Features](#features)
+- [Project Structure](#project-structure)
+- [Installation](#installation)
+- [Configuration](#configuration)
+- [Usage](#usage)
+- [API Endpoints](#api-endpoints)
+- [Tools & Capabilities](#tools--capabilities)
+- [Docker Deployment](#docker-deployment)
+- [How It Works](#how-it-works)
+- [License](#license)
+
+## 🔍 Overview
+
+This project was developed for the TDS (Tools in Data Science) course project, where the objective is to build an application that can autonomously solve multi-step quiz tasks involving:
+
+- **Data sourcing**: Scraping websites, calling APIs, downloading files
+- **Data preparation**: Cleaning text, PDFs, and various data formats
+- **Data analysis**: Filtering, aggregating, statistical analysis, ML models
+- **Data visualization**: Generating charts, narratives, and presentations
+
+The system receives quiz URLs via a REST API, navigates through multiple quiz pages, solves each task using LLM-powered reasoning and specialized tools, and submits answers back to the evaluation server.
+
+## 🏗️ Architecture
+
+The project uses a **LangGraph state machine** architecture with the following components:
+
+```
+┌─────────────┐
+│   FastAPI   │  ← Receives POST requests with quiz URLs
+│   Server    │
+└──────┬──────┘
+       │
+       ▼
+┌─────────────┐
+│   Agent     │  ← LangGraph orchestrator with Gemini 2.5 Flash
+│   (LLM)     │
+└──────┬──────┘
+       │
+       ├────────────┬────────────┬─────────────┬──────────────┐
+       ▼            ▼            ▼             ▼              ▼
+   [Scraper]   [Downloader]  [Code Exec]  [POST Req]  [Add Deps]
+```
+
+### Key Components:
+
+1. **FastAPI Server** (`main.py`): Handles incoming POST requests, validates secrets, and triggers the agent
+2. **LangGraph Agent** (`agent.py`): State machine that coordinates tool usage and decision-making
+3. **Tools Package** (`tools/`): Modular tools for different capabilities
+4. **LLM**: Google Gemini 2.5 Flash with rate limiting (9 requests per minute)
+
+## ✨ Features
+
+- ✅ **Autonomous multi-step problem solving**: Chains together multiple quiz pages
+- ✅ **Dynamic JavaScript rendering**: Uses Playwright for client-side rendered pages
+- ✅ **Code generation & execution**: Writes and runs Python code for data tasks
+- ✅ **Flexible data handling**: Downloads files, processes PDFs, CSVs, images, etc.
+- ✅ **Self-installing dependencies**: Automatically adds required Python packages
+- ✅ **Robust error handling**: Retries failed attempts within time limits
+- ✅ **Docker containerization**: Ready for deployment on HuggingFace Spaces or cloud platforms
+- ✅ **Rate limiting**: Respects API quotas with exponential backoff
+
+## 📁 Project Structure
+
+```
+LLM-Analysis-TDS-Project-2/
+├── agent.py                    # LangGraph state machine & orchestration
+├── main.py                     # FastAPI server with /solve endpoint
+├── pyproject.toml              # Project dependencies & configuration
+├── Dockerfile                  # Container image with Playwright
+├── .env                        # Environment variables (not in repo)
+├── tools/
+│   ├── __init__.py
+│   ├── web_scraper.py          # Playwright-based HTML renderer
+│   ├── code_generate_and_run.py # Python code executor
+│   ├── download_file.py        # File downloader
+│   ├── send_request.py         # HTTP POST tool
+│   └── add_dependencies.py     # Package installer
+└── README.md
+```
+
+## 📦 Installation
+
+### Prerequisites
+
+- Python 3.12 or higher
+- [uv](https://github.com/astral-sh/uv) package manager (recommended) or pip
+- Git
+
+### Step 1: Clone the Repository
+
+```bash
+git clone https://github.com/saivijayragav/LLM-Analysis-TDS-Project-2.git
+cd LLM-Analysis-TDS-Project-2
+```
+
+### Step 2: Install Dependencies
+
+#### Option A: Using `uv` (Recommended)
+
+
+Ensure you have uv installed, then sync the project:
+
+```
+# Install uv if you haven't already  
+pip install uv
+
+# Sync dependencies  
+uv sync
+uv run playwright install chromium
+```
+
+Start the FastAPI server:
+```
+uv run main.py
+```
+The server will start at ```http://0.0.0.0:7860```.
+
+#### Option B: Using `pip`
+
+```bash
+# Create virtual environment
+python -m venv venv
+.\venv\Scripts\activate  # Windows
+# source venv/bin/activate  # macOS/Linux
+
+# Install dependencies
+pip install -e .
+
+# Install Playwright browsers
+playwright install chromium
+```
+
+## ⚙️ Configuration
+
+### Environment Variables
+
+Create a `.env` file in the project root:
+
+```env
+# Your credentials from the Google Form submission
+EMAIL=your.email@example.com
+SECRET=your_secret_string
+
+# Google Gemini API Key
+GOOGLE_API_KEY=your_gemini_api_key_here
+```
+
+### Getting a Gemini API Key
+
+1. Visit [Google AI Studio](https://aistudio.google.com/app/apikey)
+2. Create a new API key
+3. Copy it to your `.env` file
+
+## 🚀 Usage
+
+### Local Development
+
+Start the FastAPI server:
+
+```bash
+# If using uv
+uv run main.py
+
+# If using standard Python
+python main.py
+```
+
+The server will start on `http://0.0.0.0:7860`
+
+### Testing the Endpoint
+
+Send a POST request to test your setup:
+
+```bash
+curl -X POST http://localhost:7860/solve \
+  -H "Content-Type: application/json" \
+  -d '{
+    "email": "your.email@example.com",
+    "secret": "your_secret_string",
+    "url": "https://tds-llm-analysis.s-anand.net/demo"
+  }'
+```
+
+Expected response:
+
+```json
+{
+  "status": "ok"
+}
+```
+
+The agent will run in the background and solve the quiz chain autonomously.
+
+## 🌐 API Endpoints
+
+### `POST /solve`
+
+Receives quiz tasks and triggers the autonomous agent.
+
+**Request Body:**
+
+```json
+{
+  "email": "your.email@example.com",
+  "secret": "your_secret_string",
+  "url": "https://example.com/quiz-123"
+}
+```
+
+**Responses:**
+
+| Status Code | Description                    |
+| ----------- | ------------------------------ |
+| `200`     | Secret verified, agent started |
+| `400`     | Invalid JSON payload           |
+| `403`     | Invalid secret                 |
+
+### `GET /healthz`
+
+Health check endpoint for monitoring.
+
+**Response:**
+
+```json
+{
+  "status": "ok",
+  "uptime_seconds": 3600
+}
+```
+
+## 🛠️ Tools & Capabilities
+
+The agent has access to the following tools:
+
+### 1. **Web Scraper** (`get_rendered_html`)
+
+- Uses Playwright to render JavaScript-heavy pages
+- Waits for network idle before extracting content
+- Returns fully rendered HTML for parsing
+
+### 2. **File Downloader** (`download_file`)
+
+- Downloads files (PDFs, CSVs, images, etc.) from direct URLs
+- Saves files to `LLMFiles/` directory
+- Returns the saved filename
+
+### 3. **Code Executor** (`run_code`)
+
+- Executes arbitrary Python code in an isolated subprocess
+- Returns stdout, stderr, and exit code
+- Useful for data processing, analysis, and visualization
+
+### 4. **POST Request** (`post_request`)
+
+- Sends JSON payloads to submission endpoints
+- Includes automatic error handling and response parsing
+- Prevents resubmission if answer is incorrect and time limit exceeded
+
+### 5. **Dependency Installer** (`add_dependencies`)
+
+- Dynamically installs Python packages as needed
+- Uses `uv add` for fast package resolution
+- Enables the agent to adapt to different task requirements
+
+## 🐳 Docker Deployment
+
+### Build the Image
+
+```bash
+docker build -t llm-analysis-agent .
+```
+
+### Run the Container
+
+```bash
+docker run -p 7860:7860 \
+  -e EMAIL="your.email@example.com" \
+  -e SECRET="your_secret_string" \
+  -e GOOGLE_API_KEY="your_api_key" \
+  llm-analysis-agent
+```
+
+### Deploy to HuggingFace Spaces
+
+1. Create a new Space with Docker SDK
+2. Push this repository to your Space
+3. Add secrets in Space settings:
+   - `EMAIL`
+   - `SECRET`
+   - `GOOGLE_API_KEY`
+4. The Space will automatically build and deploy
+
+## 🧠 How It Works
+
+### 1. Request Reception
+
+- FastAPI receives a POST request with quiz URL
+- Validates the secret against environment variables
+- Returns 200 OK and starts the agent in the background
+
+### 2. Agent Initialization
+
+- LangGraph creates a state machine with two nodes: `agent` and `tools`
+- The initial state contains the quiz URL as a user message
+
+### 3. Task Loop
+
+The agent follows this loop:
+
+```
+┌─────────────────────────────────────────┐
+│ 1. LLM analyzes current state           │
+│    - Reads quiz page instructions       │
+│    - Plans tool usage                   │
+└─────────────────┬───────────────────────┘
+                  ▼
+┌─────────────────────────────────────────┐
+│ 2. Tool execution                       │
+│    - Scrapes page / downloads files     │
+│    - Runs analysis code                 │
+│    - Submits answer                     │
+└─────────────────┬───────────────────────┘
+                  ▼
+┌─────────────────────────────────────────┐
+│ 3. Response evaluation                  │
+│    - Checks if answer is correct        │
+│    - Extracts next quiz URL (if exists) │
+└─────────────────┬───────────────────────┘
+                  ▼
+┌─────────────────────────────────────────┐
+│ 4. Decision                             │
+│    - If new URL exists: Loop to step 1  │
+│    - If no URL: Return "END"            │
+└─────────────────────────────────────────┘
+```
+
+### 4. State Management
+
+- All messages (user, assistant, tool) are stored in state
+- The LLM uses full history to make informed decisions
+- Recursion limit set to 200 to handle long quiz chains
+
+### 5. Completion
+
+- Agent returns "END" when no new URL is provided
+- Background task completes
+- Logs indicate success or failure
+
+## 📝 Key Design Decisions
+
+1. **LangGraph over Sequential Execution**: Allows flexible routing and complex decision-making
+2. **Background Processing**: Prevents HTTP timeouts for long-running quiz chains
+3. **Tool Modularity**: Each tool is independent and can be tested/debugged separately
+4. **Rate Limiting**: Prevents API quota exhaustion (9 req/min for Gemini)
+5. **Code Execution**: Dynamically generates and runs Python for complex data tasks
+6. **Playwright for Scraping**: Handles JavaScript-rendered pages that `requests` cannot
+7. **uv for Dependencies**: Fast package resolution and installation
+
+## 📄 License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+---
+
+**Author**: Syph0n9 
+**Course**: Tools in Data Science (TDS)
+**Institution**: IIT Madras

agent.py

@@ -0,0 +1,156 @@
+from langgraph.graph import StateGraph, END, START
+from langchain_core.rate_limiters import InMemoryRateLimiter
+from langgraph.prebuilt import ToolNode
+from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+from tools import get_rendered_html, download_file, post_request, run_code, add_dependencies
+from typing import TypedDict, Annotated, List, Any
+from langchain.chat_models import init_chat_model
+from langgraph.graph.message import add_messages
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+EMAIL = os.getenv("EMAIL")
+SECRET = os.getenv("SECRET")
+RECURSION_LIMIT =  5000
+# -------------------------------------------------
+# STATE
+# -------------------------------------------------
+class AgentState(TypedDict):
+    messages: Annotated[List, add_messages]
+
+
+TOOLS = [run_code, get_rendered_html, download_file, post_request, add_dependencies]
+
+
+# -------------------------------------------------
+# GEMINI LLM
+# -------------------------------------------------
+rate_limiter = InMemoryRateLimiter(
+    requests_per_second=9/60,  
+    check_every_n_seconds=1,  
+    max_bucket_size=9  
+)
+llm = init_chat_model(
+   model_provider="google_genai",
+   model="gemini-2.5-flash",
+   rate_limiter=rate_limiter
+).bind_tools(TOOLS)   
+
+
+# -------------------------------------------------
+# SYSTEM PROMPT
+# -------------------------------------------------
+SYSTEM_PROMPT = f"""
+You are an autonomous quiz-solving agent.
+
+Your job is to:
+1. Load the quiz page from the given URL.
+2. Extract ALL instructions, required parameters, submission rules, and the submit endpoint.
+3. Solve the task exactly as required.
+4. Submit the answer ONLY to the endpoint specified on the current page (never make up URLs).
+5. Read the server response and:
+   - If it contains a new quiz URL → fetch it immediately and continue.
+   - If no new URL is present → return "END".
+
+STRICT RULES — FOLLOW EXACTLY:
+
+GENERAL RULES:
+- NEVER stop early. Continue solving tasks until no new URL is provided.
+- NEVER hallucinate URLs, endpoints, fields, values, or JSON structure.
+- NEVER shorten or modify URLs. Always submit the full URL.
+- NEVER re-submit unless the server explicitly allows or it's within the 3-minute limit.
+- ALWAYS inspect the server response before deciding what to do next.
+- ALWAYS use the tools provided to fetch, scrape, download, render HTML, or send requests.
+
+TIME LIMIT RULES:
+- Each task has a hard 3-minute limit.
+- The server response includes a "delay" field indicating elapsed time.
+- If your answer is wrong retry again.
+
+STOPPING CONDITION:
+- Only return "END" when a server response explicitly contains NO new URL.
+- DO NOT return END under any other condition.
+
+ADDITIONAL INFORMATION YOU MUST INCLUDE WHEN REQUIRED:
+- Email: {EMAIL}
+- Secret: {SECRET}
+
+YOUR JOB:
+- Follow pages exactly.
+- Extract data reliably.
+- Never guess.
+- Submit correct answers.
+- Continue until no new URL.
+- Then respond with: END
+"""
+
+prompt = ChatPromptTemplate.from_messages([
+    ("system", SYSTEM_PROMPT),
+    MessagesPlaceholder(variable_name="messages")
+])
+
+llm_with_prompt = prompt | llm
+
+
+# -------------------------------------------------
+# AGENT NODE
+# -------------------------------------------------
+def agent_node(state: AgentState):
+    result = llm_with_prompt.invoke({"messages": state["messages"]})
+    return {"messages": state["messages"] + [result]}
+
+
+# -------------------------------------------------
+# GRAPH
+# -------------------------------------------------
+def route(state):
+    last = state["messages"][-1]
+    # support both objects (with attributes) and plain dicts
+    tool_calls = None
+    if hasattr(last, "tool_calls"):
+        tool_calls = getattr(last, "tool_calls", None)
+    elif isinstance(last, dict):
+        tool_calls = last.get("tool_calls")
+
+    if tool_calls:
+        return "tools"
+    # get content robustly
+    content = None
+    if hasattr(last, "content"):
+        content = getattr(last, "content", None)
+    elif isinstance(last, dict):
+        content = last.get("content")
+
+    if isinstance(content, str) and content.strip() == "END":
+        return END
+    if isinstance(content, list) and content[0].get("text").strip() == "END":
+        return END
+    return "agent"
+graph = StateGraph(AgentState)
+
+graph.add_node("agent", agent_node)
+graph.add_node("tools", ToolNode(TOOLS))
+
+
+
+graph.add_edge(START, "agent")
+graph.add_edge("tools", "agent")
+graph.add_conditional_edges(
+    "agent",    
+    route       
+)
+
+app = graph.compile()
+
+
+# -------------------------------------------------
+# TEST
+# -------------------------------------------------
+def run_agent(url: str) -> str:
+    app.invoke({
+        "messages": [{"role": "user", "content": url}]},
+        config={"recursion_limit": RECURSION_LIMIT},
+    )
+    print("Tasks completed succesfully")
+

main.py

@@ -0,0 +1,55 @@
+from fastapi import FastAPI, Request, BackgroundTasks
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from agent import run_agent
+from dotenv import load_dotenv
+import uvicorn
+import os
+import time
+
+load_dotenv()
+
+EMAIL = os.getenv("EMAIL") 
+SECRET = os.getenv("SECRET")
+
+app = FastAPI()
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # or specific domains
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+START_TIME = time.time()
+@app.get("/healthz")
+def healthz():
+    """Simple liveness check."""
+    return {
+        "status": "ok",
+        "uptime_seconds": int(time.time() - START_TIME)
+    }
+
+@app.post("/solve")
+async def solve(request: Request, background_tasks: BackgroundTasks):
+    try:
+        data = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+    if not data:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+    url = data.get("url")
+    secret = data.get("secret")
+    if not url or not secret:
+        raise HTTPException(status_code=400, detail="Invalid JSON")
+    
+    if secret != SECRET:
+        raise HTTPException(status_code=403, detail="Invalid secret")
+    print("Verified starting the task...")
+    background_tasks.add_task(run_agent, url)
+
+    return JSONResponse(status_code=200, content={"status": "ok"})
+
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=7860)

pyproject.toml

@@ -0,0 +1,21 @@
+[project]
+name = "tdsproject2"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "playwright>=1.56.0",
+    "beautifulsoup4>=4.14.2",
+    "langgraph>=1.0.3",
+    "langchain>=0.2.0",
+    "langchain-community>=0.2.0",
+    "langchain-google-genai>=1.0.0",
+    "google-genai>=0.17.0",
+    "jsonpatch>=1.33",
+    "python-dotenv>=1.2.1",
+    "pandas>=2.3.3",
+    "fastapi>=0.121.3",
+    "uvicorn>=0.38.0",
+    "requests>=2.32.5",
+]

tools/__init__.py

@@ -0,0 +1,5 @@
+from .web_scraper import get_rendered_html
+from .run_code import run_code 
+from .send_request import post_request
+from .download_file import download_file
+from .add_dependencies import add_dependencies

tools/add_dependencies.py

@@ -0,0 +1,38 @@
+from typing import List
+from langchain_core.tools import tool
+import subprocess
+
+
+@tool
+def add_dependencies(dependencies: List[str]) -> str:
+    """
+    Install the given Python packages into the environment.
+
+    Parameters:
+        dependencies (List[str]):
+            A list of Python package names to install. Each name must match the 
+            corresponding package name on PyPI.
+
+    Returns:
+        str:
+            A message indicating success or failure.
+    """
+
+    try:
+        subprocess.check_call(
+            ["uv", "add"] + dependencies,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True
+        )
+        return "Successfully installed dependencies: " + ", ".join(dependencies)
+    
+    except subprocess.CalledProcessError as e:
+        return (
+            "Dependency installation failed.\n"
+            f"Exit code: {e.returncode}\n"
+            f"Error: {e.stderr or 'No error output.'}"
+        )
+    
+    except Exception as e:
+        return f"Unexpected error while installing dependencies: {e}" 

tools/download_file.py

@@ -0,0 +1,31 @@
+from langchain_core.tools import tool
+import requests
+import os
+
+@tool
+def download_file(url: str, filename: str) -> str:
+    """
+    Download a file from a URL and save it with the given filename
+    in the current working directory.
+
+    Args:
+        url (str): Direct URL to the file.
+        filename (str): The filename to save the downloaded content as.
+
+    Returns:
+        str: Full path to the saved file.
+    """
+    try:
+        response = requests.get(url, stream=True)
+        response.raise_for_status()
+        directory_name = "LLMFiles"
+        os.makedirs(directory_name, exist_ok=True)
+        path = os.path.join(directory_name, filename)
+        with open(path, "wb") as f:
+            for chunk in response.iter_content(chunk_size=8192):
+                if chunk:
+                    f.write(chunk)
+
+        return filename
+    except Exception as e:
+        return f"Error downloading file: {str(e)}"

tools/run_code.py

@@ -0,0 +1,70 @@
+from google import genai
+import subprocess
+from langchain_core.tools import tool
+from dotenv import load_dotenv
+import os
+from google.genai import types
+load_dotenv()
+client = genai.Client()
+
+def strip_code_fences(code: str) -> str:
+    code = code.strip()
+    # Remove ```python ... ``` or ``` ... ```
+    if code.startswith("```"):
+        # remove first line (```python or ```)
+        code = code.split("\n", 1)[1]
+    if code.endswith("```"):
+        code = code.rsplit("\n", 1)[0]
+    return code.strip()
+
+@tool
+def run_code(code: str) -> dict:
+    """
+    Executes a Python code 
+    This tool:
+      1. Takes in python code as input
+      3. Writes code into a temporary .py file
+      4. Executes the file
+      5. Returns its output
+
+    Parameters
+    ----------
+    code : str
+        Python source code to execute.
+
+    Returns
+    -------
+    dict
+        {
+            "stdout": <program output>,
+            "stderr": <errors if any>,
+            "return_code": <exit code>
+        }
+    """
+    try: 
+        filename = "runner.py"
+        os.makedirs("LLMFiles", exist_ok=True)
+        with open(os.path.join("LLMFiles", filename), "w") as f:
+            f.write(code)
+
+        proc = subprocess.Popen(
+            ["uv", "run", filename],
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            cwd="LLMFiles"
+        )
+        stdout, stderr = proc.communicate()
+
+        # --- Step 4: Return everything ---
+        return {
+            "stdout": stdout,
+            "stderr": stderr,
+            "return_code": proc.returncode
+        }
+    except Exception as e:
+        return {
+            "stdout": "",
+            "stderr": str(e),
+            "return_code": -1
+        }

tools/send_request.py

@@ -0,0 +1,64 @@
+from langchain_core.tools import tool
+import requests
+import json
+from typing import Any, Dict, Optional
+
+@tool
+def post_request(url: str, payload: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> Any:
+    """
+    Send an HTTP POST request to the given URL with the provided payload.
+
+    This function is designed for LangGraph applications, where it can be wrapped
+    as a Tool or used inside a Runnable to call external APIs, webhooks, or backend
+    services during graph execution.
+    REMEMBER: This a blocking function so it may take a while to return. Wait for the response.
+    Args:
+        url (str): The endpoint to send the POST request to.
+        payload (Dict[str, Any]): The JSON-serializable request body.
+        headers (Optional[Dict[str, str]]): Optional HTTP headers to include
+            in the request. If omitted, a default JSON header is applied.
+
+    Returns:
+        Any: The response body. If the server returns JSON, a parsed dict is
+        returned. Otherwise, the raw text response is returned.
+
+    Raises:
+        requests.HTTPError: If the server responds with an unsuccessful status.
+        requests.RequestException: For network-related errors.
+    """
+    headers = headers or {"Content-Type": "application/json"}
+    try:
+        print(f"\nSending Answer \n{json.dumps(payload, indent=4)}\n to url: {url}")
+        response = requests.post(url, json=payload, headers=headers)
+
+        # Raise on 4xx/5xx
+        response.raise_for_status()
+
+        # Try to return JSON, fallback to raw text
+        data = response.json()
+        delay = data.get("delay", 0)
+        delay = delay if isinstance(delay, (int, float)) else 0
+        correct = data.get("correct")
+        if not correct and delay < 180:
+            del data["url"]
+        if delay >= 180:
+            data = {
+                "url": data.get("url")
+            }
+        print("Got the response: \n", json.dumps(data, indent=4), '\n')
+        return data
+    except requests.HTTPError as e:
+        # Extract server’s error response
+        err_resp = e.response
+
+        try:
+            err_data = err_resp.json()
+        except ValueError:
+            err_data = err_resp.text
+
+        print("HTTP Error Response:\n", err_data)
+        return err_data
+
+    except Exception as e:
+        print("Unexpected error:", e)
+        return str(e)

tools/web_scraper.py

@@ -0,0 +1,46 @@
+from langchain_core.tools import tool
+from playwright.sync_api import sync_playwright
+from bs4 import BeautifulSoup
+
+@tool
+def get_rendered_html(url: str) -> str:
+    """
+    Fetch and return the fully rendered HTML of a webpage.
+
+    This function uses Playwright to load a webpage in a headless Chromium
+    browser, allowing all JavaScript on the page to execute. Use this for
+    dynamic websites that require rendering.
+
+    IMPORTANT RESTRICTIONS:
+    - ONLY use this for actual HTML webpages (articles, documentation, dashboards).
+    - DO NOT use this for direct file links (URLs ending in .csv, .pdf, .zip, .png).
+      Playwright cannot render these and will crash. Use the 'download_file' tool instead.
+
+    Parameters
+    ----------
+    url : str
+        The URL of the webpage to retrieve and render.
+
+    Returns
+    -------
+    str
+        The fully rendered and cleaned HTML content.
+    """
+    # ... existing code ...
+    print("\nFetching and rendering:", url)
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            page = browser.new_page()
+
+            # Load the page (let JS execute)
+            page.goto(url, wait_until="networkidle")
+
+            # Extract rendered HTML
+            content = page.content()
+
+            browser.close()
+            return content
+
+    except Exception as e:
+        return f"Error fetching/rendering page: {str(e)}"