Final agent working with 40% correct answers

app.py

@@ -1,36 +1,45 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
+from dotenv import load_dotenv
 from smolagents import CodeAgent
 from helpers import download_file_from_url
-from llm import model
 from prompts import SYSTEM_PROMPT
 from tools import agent_tools
-from dotenv import load_dotenv
-
-load_dotenv()
+from smolagents import LiteLLMModel
 
-# (Keep Constants as is)
-# --- Constants ---
+# Constants
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+load_dotenv()  # Load environment variables from .env file
+
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
-        agent = CodeAgent(model=model, tools=agent_tools, planning_interval=3)
-        self.agent = agent
-        self.agent.system_prompt = SYSTEM_PROMPT + "\n" + self.agent.system_prompt
+        print("Initializing the BasicAgent")
+
+        DEFAULT_MODEL = os.getenv("GEMINI_MODEL")
+
+        llm_model = LiteLLMModel(
+            model_id=DEFAULT_MODEL,
+            api_key=os.getenv("GEMINI_API_KEY"),
+            max_tokens=8192,
+            temperature=0.1,
+        )
+        # Initialize GeminiAgent
+        self.agent = CodeAgent(
+            model=llm_model,
+            tools=agent_tools,
+        )
+        self.agent.system_prompt += "\n" + SYSTEM_PROMPT
+        print("Smolagent initialized successfully")
 
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = self.agent.run(question)
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        final_answer = self.agent.run(question)
+        print(f"Agent returning fixed answer: {final_answer}")
+        return final_answer
 
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
@@ -51,7 +60,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
-    file_download_url = f"{api_url}/files"
+    file_url = f"{api_url}/files"
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
@@ -91,15 +100,16 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     for item in questions_data:
         task_id = item.get("task_id")
         question_text = item.get("question")
-        file_name = item.get("file_name")
-        if file_name:
-            file_url = f"{file_download_url}/{task_id}"
-            file_path = download_file_from_url(file_url, file_name)
-            question_text = f"{question_text} (File: {file_path})"
+        file_name = item.get("file_name", None)
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+
         try:
+            if file_name:
+                task_file_url = file_url + f"/{task_id}"
+                file_path = download_file_from_url(url=task_file_url)
+                question_text += f"\n\n[File for this question: {file_name}] is saved at filepath : ({file_path})"
             submitted_answer = agent(question_text)
             answers_payload.append(
                 {"task_id": task_id, "submitted_answer": submitted_answer}

helpers.py

@@ -1,6 +1,4 @@
-import base64
 import os
-from litellm import completion, create_file
 import requests
 from dotenv import load_dotenv
 
@@ -9,71 +7,103 @@ load_dotenv()
 DEFAULT_MODEL = os.getenv("GEMINI_MODEL")
 
 
-def analyze_file_with_gemini(file_path: str, file_name: str) -> str:
-    # 1. Read file and encode in base64
-    try:
-        with open(file_path, "rb") as f:
-            content = f.read()
-        mime_type = _get_mime_type(file_path)
-        base64_data = base64.b64encode(content).decode("utf-8")
-    except Exception as e:
-        return f"Error reading file: {e}"
-
-    file = create_file(
-        file=base64_data,
-        purpose="user_data",
-        extra_body={"custom_llm_provider": "gemini"},
-        api_key=os.getenv("GEMINI_API_KEY"),
-    )
-    # 2. Construct Gemini-style multimodal input
-    prompt = (
-        f"Analyze the following {mime_type} file and provide a detailed report. "
-        "The file is encoded in base64 format. "
-        "Please include any relevant information or insights."
-    )
-
-    try:
-        response = completion(
-            model=DEFAULT_MODEL,
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {"type": "text", "text": prompt},
-                        {
-                            "type": "file",
-                            "file": {
-                                "file_id": file.id,
-                                "filename": file_name,
-                                "format": "audio/wav",
-                            },
-                        },
-                    ],
-                },
-            ],
-        )
-
-        return response.choices[0].message
-    except Exception as e:
-        return f"Error from Gemini: {e}"
-
-
-def _get_mime_type(file_path: str) -> str:
-    if file_path.endswith(".png"):
-        return "image/png"
-    elif file_path.endswith(".jpg") or file_path.endswith(".jpeg"):
-        return "image/jpeg"
-    elif file_path.endswith(".mp3"):
-        return "audio/mpeg"
-    else:
-        raise ValueError(
-            "Unsupported file type: only .png, .jpg, .jpeg, .mp3 are supported"
-        )
+# def analyze_file_with_gemini(file_path: str, file_name: str) -> str:
+#     # 1. Read file and encode in base64
+#     try:
+#         with open(file_path, "rb") as f:
+#             content = f.read()
+#         mime_type = _get_mime_type(file_path)
+#         base64_data = base64.b64encode(content).decode("utf-8")
+#     except Exception as e:
+#         return f"Error reading file: {e}"
+
+#     file = create_file(
+#         file=base64_data,
+#         purpose="user_data",
+#         extra_body={"custom_llm_provider": "gemini"},
+#         api_key=os.getenv("GEMINI_API_KEY"),
+#     )
+#     # 2. Construct Gemini-style multimodal input
+#     prompt = (
+#         f"Analyze the following {mime_type} file and provide a detailed report. "
+#         "The file is encoded in base64 format. "
+#         "Please include any relevant information or insights."
+#     )
+
+#     try:
+#         time.sleep(5)
+#         response = completion(
+#             model=DEFAULT_MODEL,
+#             messages=[
+#                 {
+#                     "role": "user",
+#                     "content": [
+#                         {"type": "text", "text": prompt},
+#                         {
+#                             "type": "file",
+#                             "file": {
+#                                 "file_id": file.id,
+#                                 "filename": file_name,
+#                                 "format": "audio/wav",
+#                             },
+#                         },
+#                     ],
+#                 },
+#             ],
+#         )
+
+#         return response.choices[0].message
+#     except Exception as e:
+#         return f"Error from Gemini: {e}"
+
+
+# def _get_mime_type(file_path: str) -> str:
+#     if file_path.endswith(".png"):
+#         return "image/png"
+#     elif file_path.endswith(".jpg") or file_path.endswith(".jpeg"):
+#         return "image/jpeg"
+#     elif file_path.endswith(".mp3"):
+#         return "audio/mpeg"
+#     else:
+#         raise ValueError(
+#             "Unsupported file type: only .png, .jpg, .jpeg, .mp3 are supported"
+#         )
+
+
+# def download_file_from_url(url: str, save_dir: str = "./downloads") -> str:
+#     """
+#     Downloads a file from a public URL and saves it locally.
+
+#     Args:
+#         url (str): The direct URL to the file (must not be a blob: URL).
+#         save_dir (str): Directory to save the downloaded file (default: ./downloads).
+
+#     Returns:
+#         str: Full path to the downloaded file.
+#     """
+#     try:
+#         os.makedirs(save_dir, exist_ok=True)
+
+#         # Get file name from the URL or fallback
+#         local_filename = url.split("/")[-1] or "downloaded_file"
+#         file_path = os.path.join(save_dir, local_filename)
+
+#         # Perform streaming download
+#         with requests.get(url, stream=True) as r:
+#             r.raise_for_status()
+#             with open(file_path, "wb") as f:
+#                 for chunk in r.iter_content(chunk_size=8192):
+#                     f.write(chunk)
+
+#         return file_path
+#     except Exception as e:
+#         raise RuntimeError(f"Failed to download file from {url}: {e}")
+import mimetypes
 
 
 def download_file_from_url(url: str, save_dir: str = "./downloads") -> str:
     """
-    Downloads a file from a public URL and saves it locally.
+    Downloads a file from a public URL and saves it locally with the correct extension.
 
     Args:
         url (str): The direct URL to the file (must not be a blob: URL).
@@ -84,14 +114,32 @@ def download_file_from_url(url: str, save_dir: str = "./downloads") -> str:
     """
     try:
         os.makedirs(save_dir, exist_ok=True)
-
-        # Get file name from the URL or fallback
-        local_filename = url.split("/")[-1] or "downloaded_file"
-        file_path = os.path.join(save_dir, local_filename)
-
-        # Perform streaming download
         with requests.get(url, stream=True) as r:
             r.raise_for_status()
+
+            # Try to get filename from Content-Disposition header
+            cd = r.headers.get("content-disposition")
+            if cd and "filename=" in cd:
+                local_filename = cd.split("filename=")[-1].strip('"; ')
+            else:
+                # Fallback to URL
+                local_filename = url.split("/")[-1]
+
+            # If no extension, try to guess from Content-Type
+            if not os.path.splitext(local_filename)[1]:
+                content_type = r.headers.get("content-type")
+                ext = (
+                    mimetypes.guess_extension(content_type.split(";")[0])
+                    if content_type
+                    else ""
+                )
+                if ext:
+                    local_filename += ext
+                else:
+                    local_filename += ".bin"  # fallback
+
+            file_path = os.path.join(save_dir, local_filename)
+
             with open(file_path, "wb") as f:
                 for chunk in r.iter_content(chunk_size=8192):
                     f.write(chunk)

llm.py

@@ -1,37 +0,0 @@
-# llm.py
-import os
-import litellm
-from smolagents import LiteLLMModel
-from dotenv import load_dotenv
-
-load_dotenv()
-# Set default model
-DEFAULT_MODEL = os.getenv("GEMINI_MODEL")
-
-
-def chat_with_llm(messages, model=DEFAULT_MODEL):
-    """
-    messages: list of {"role": "user"/"system"/"assistant", "content": "..."}
-    model: model string (e.g., "gemini-pro" or "gpt-3.5-turbo")
-    """
-    try:
-        response = litellm.completion(
-            model=model, messages=messages, api_key=os.getenv("GEMINI_API_KEY")
-        )
-        return response["choices"][0]["message"]["content"]
-    except Exception as e:
-        return f"[LLM Error] {e}"
-
-
-def ask_llm(prompt: str, model=DEFAULT_MODEL):
-    """
-    Simpler wrapper for single-turn prompts
-    """
-    return chat_with_llm([{"role": "user", "content": prompt}], model=model)
-
-
-model = LiteLLMModel(
-    model_id=DEFAULT_MODEL,
-    api_key=os.getenv("GEMINI_API_KEY"),
-    max_tokens=8192,
-)

requirements.txt

@@ -1,8 +1,21 @@
 gradio
-requests
-smolagents
-smolagents[litellm]
-pytesseract
-pillow
-pytube
-python-dotenv
+langchain>=0.1.0
+langchain-core>=0.1.0
+langchain-community>=0.0.10
+langchain-google-community==2.0.7
+langchain-google-genai>=0.0.6
+google-generativeai>=0.3.0
+python-dotenv>=1.0.0
+google-api-python-client>=2.108.0
+duckduckgo-search>=4.4
+tiktoken>=0.5.2
+google-cloud-speech>=2.24.0
+requests>=2.31.0
+pydub>=0.25.1
+yt-dlp>=2023.12.30
+smolagents>=0.1.3
+wikipedia>=1.4.0
+Pillow>=10.2.0
+wikipedia-api>=0.6.0
+openpyxl>=3.1.2
+tabulate==0.9.0

tools.py

@@ -1,79 +1,63 @@
 import base64
 import os
+from typing import ClassVar
+from urllib.parse import urlparse
+import requests
 from smolagents import Tool
 import math
 import datetime
 from PIL import Image
 import pandas as pd
 import litellm
+import yt_dlp
 from prompts import SYSTEM_PROMPT
 from pytube import YouTube
 from PIL import Image
 import pytesseract
-from smolagents import DuckDuckGoSearchTool
+from smolagents import DuckDuckGoSearchTool, WikipediaSearchTool
 from dotenv import load_dotenv
+import time
+from langchain_google_community import GoogleSearchAPIWrapper
+from google import genai
+from langchain_community.document_loaders import WikipediaLoader
+from langchain_community.document_loaders import ArxivLoader
+
 
 load_dotenv()
 
 
-class GeminiFileAnalyzerTool(Tool):
-    name = "gemini_file_analyzer"
-    description = "Analyze an image or audio file using Gemini via LiteLLM. Supports jpg, png, and mp3."
-    inputs = {
-        "file_path": {"type": "string", "description": "Path to image/audio file"},
-        "file_name": {
+class AnyTypeFileAnalyzerTool(Tool):
+    name: ClassVar[str] = "any_type_file_analyzer_tool"
+    description: ClassVar[str] = (
+        "Analyze an image or audio mp3 file using Gemini. Supports jpg, png, and mp3."
+    )
+    inputs: ClassVar[dict] = {
+        "analysis_description": {
             "type": "string",
-            "description": "Name of the file (e.g., photo.jpg, audio.mp3)",
+            "description": "Describe what you want to analyze from the file",
         },
+        "file_path": {"type": "string", "description": "Path to image/audio file"},
     }
-    output_type = "string"
+    output_type: ClassVar[str] = "string"
 
-    def forward(self, file_path: str, file_name: str):
-        try:
-            with open(file_path, "rb") as f:
-                content = f.read()
-            mime_type = self._get_mime_type(file_path)
-            base64_data = base64.b64encode(content).decode("utf-8")
-        except Exception as e:
-            return f"Error reading file: {e}"
+    def forward(self, analysis_description: str, file_path: str):
 
+        client = genai.Client(
+            api_key=os.getenv("GEMINI_API_KEY"),
+        )
         try:
-            file = litellm.create_file(
-                file=base64_data,
-                purpose="user_data",
-                extra_body={"custom_llm_provider": "gemini"},
-                api_key=os.getenv("GEMINI_API_KEY"),
-            )
+            file = client.files.upload(file=file_path)
         except Exception as e:
             return f"Error uploading file: {e}"
 
-        prompt = (
-            f"Analyze the following {mime_type} file and provide a detailed report. "
-            "The file is encoded in base64 format. "
-            "Please include any relevant information or insights."
-        )
-
         try:
-            response = litellm.completion(
-                model=os.getenv("GEMINI_MODEL", "gemini-pro-vision"),
-                messages=[
-                    {
-                        "role": "user",
-                        "content": [
-                            {"type": "text", "text": prompt},
-                            {
-                                "type": "file",
-                                "file": {
-                                    "file_id": file.id,
-                                    "filename": file_name,
-                                    "format": mime_type.split("/")[-1],  # e.g., "mp3"
-                                },
-                            },
-                        ],
-                    },
-                ],
+            full_description = SYSTEM_PROMPT + f"\n\n{analysis_description}"
+            GENAI_MODEL = os.getenv("GENAI_MODEL")
+            response = client.models.generate_content(
+                model=GENAI_MODEL,
+                contents=[full_description, file],
             )
-            return response["choices"][0]["message"]["content"]
+            return response.text
         except Exception as e:
             return f"Error from Gemini: {e}"
 
@@ -90,36 +74,63 @@ class GeminiFileAnalyzerTool(Tool):
             )
 
 
-class ImageTextExtractorTool(Tool):
-    name = "image_text_extractor"
-    description = "Extract text from an image using OCR."
-    inputs = {
-        "image_path": {
-            "type": "string",
-            "description": "Path to the image file (jpg, png, etc.)",
-        }
+class CodeFileReadTool(Tool):
+    name: ClassVar[str] = "read_code_file"
+    description: ClassVar[str] = (
+        "Read a code or text file (Python, JavaScript, Java, HTML, CSS, etc.) and return its content as a formatted code block with the correct language extension."
+    )
+    inputs: ClassVar[dict] = {
+        "file_path": {"type": "string", "description": "Path to the code or text file"},
     }
-    output_type = "string"
+    output_type: ClassVar[str] = "string"
 
-    def forward(self, image_path: str):
+    def forward(self, file_path: str):
         try:
-            image = Image.open(image_path)
-            text = pytesseract.image_to_string(image)
-            return text.strip() or "No text found in image."
+            # Detect extension and map to language
+            ext = os.path.splitext(file_path)[-1].lower()
+            ext_to_lang = {
+                ".py": "python",
+                ".js": "javascript",
+                ".java": "java",
+                ".html": "html",
+                ".css": "css",
+                ".json": "json",
+                ".txt": "",
+                ".md": "markdown",
+                ".c": "c",
+                ".cpp": "cpp",
+                ".ts": "typescript",
+                ".sh": "bash",
+                ".xml": "xml",
+                ".yml": "yaml",
+                ".yaml": "yaml",
+            }
+            lang = ext_to_lang.get(ext, "")
+
+            with open(file_path, "r", encoding="utf-8") as f:
+                content = f.read()
+
+            # Format as markdown code block
+            if lang:
+                return f"```{lang}\n{content}\n```"
+            else:
+                return f"```\n{content}\n```"
         except Exception as e:
-            return f"Error extracting text: {e}"
+            return f"Error reading file: {e}"
 
 
-class TableInspectorTool(Tool):
-    name = "table_inspector"
-    description = "Load a CSV or Excel file and return table info and summary stats in Markdown format."
-    inputs = {
+class ExcelAndCSVTableInspectorTool(Tool):
+    name: ClassVar[str] = "excel_csv_file_analyzer"
+    description: ClassVar[str] = (
+        "Load a CSV or Excel file and return table info and summary stats in Markdown format."
+    )
+    inputs: ClassVar[dict] = {
         "file_path": {
             "type": "string",
             "description": "Path to CSV or Excel file (.csv, .xls, .xlsx)",
         }
     }
-    output_type = "string"
+    output_type: ClassVar[str] = "string"
 
     def forward(self, file_path: str):
         try:
@@ -130,25 +141,7 @@ class TableInspectorTool(Tool):
             else:
                 return "Unsupported file type. Only CSV and Excel (.xls/.xlsx) are supported."
 
-            # Get basic info
-            n_rows, n_cols = df.shape
-            headers = list(df.columns)
-            summary = (
-                df.describe(include="all", datetime_is_numeric=True)
-                .fillna("")
-                .astype(str)
-            )
-
-            # Markdown output
-            md = f"### File loaded: **{file_path}**\n"
-            md += f"- Rows: **{n_rows}**\n"
-            md += f"- Columns: **{n_cols}**\n"
-            md += f"- Column Headers:\n"
-            for col in headers:
-                md += f"  - `{col}`\n"
-
-            md += "\n### Summary Statistics (markdown table):\n\n"
-            md += summary.to_markdown()
+            md = df.to_markdown(index=False, tablefmt="pipe")
 
             return md
 
@@ -157,63 +150,62 @@ class TableInspectorTool(Tool):
 
 
 class YouTubeVideoAnalyzerTool(Tool):
-    name = "youtube_video_analyzer"
-    description = "Given a YouTube URL, extracts metadata and comments, then analyzes it for summary, highlights, and visuals."
-    inputs = {
+    name: ClassVar[str] = "youtube_video_analyzer"
+    description: ClassVar[str] = (
+        "Given a YouTube URL, extracts metadata, analyzes the video content, and answers user queries about it."
+    )
+    inputs: ClassVar[dict] = {
         "url": {"type": "string", "description": "Full YouTube video URL"},
         "user_prompt": {
             "type": "string",
             "description": "What you want to analyze from the video content",
         },
     }
-    output_type = "string"
+    output_type: ClassVar[str] = "string"
 
     def forward(self, url: str, user_prompt: str):
         try:
-            yt = YouTube(url)
-            title = yt.title
-            description = yt.description
-            comments = yt.comments[:5] if yt.comments else []
-
-            comment_text = (
-                "\n".join([f"- {c}" for c in comments])
-                if comments
-                else "No comments found."
-            )
-
-            system_prompt = f"""You are an AI video analyzer. A user wants to analyze the following YouTube video.
-
-### Title
-{title}
-
-### Description
-{description or 'No description.'}
-
-### Top Comments
-{comment_text}
-
-### User Request
-{user_prompt}
-
-### Instructions:
-- Identify the main topic of the video.
-- List any unique characteristics or production traits.
-- Mention key highlights or scenes if they are implied.
-- Give an overall summary based on description and social sentiment.
-
-Respond in structured markdown.
-"""
-
-            response = litellm.completion(
-                api_key=os.getenv("GEMINI_API_KEY"),
-                model=os.getenv("GEMINI_MODEL"),
-                messages=[
-                    {"role": "system", "content": SYSTEM_PROMPT},
-                    {"role": "user", "content": system_prompt},
-                ],
-            )
-
-            return response["choices"][0]["message"]["content"]
+            parsed_url = urlparse(url)
+            if (
+                parsed_url.scheme not in ["http", "https"]
+                or "youtube.com" not in parsed_url.netloc
+            ):
+                return "Invalid YouTube URL. Please provide a valid URL."
+
+            try:
+
+                user_final_prompt = """
+                You are an AI video analyzer. A user wants to analyze the following YouTube video. 
+                Use your tools to extract information and analyze the video content.
+                ### User Request
+                {user_prompt}
+                ### Video URL
+                {url}
+                ### Instructions:
+                - Analyze the video content based on the user's request.
+                - Identify the main key thing needed to be analyzed.
+                - Provide the answer as per system prompt.
+                """
+
+                response = litellm.completion(
+                    api_key=os.getenv("GEMINI_API_KEY"),
+                    model=os.getenv("GEMINI_MODEL"),
+                    messages=[
+                        {"role": "system", "content": SYSTEM_PROMPT},
+                        {
+                            "role": "user",
+                            "content": user_final_prompt.format(
+                                user_prompt=user_prompt, url=url
+                            ),
+                        },
+                    ],
+                )
+
+                return response["choices"][0]["message"]["content"]
+            except Exception as e:
+                if "Sign in" in str(e):
+                    return "This video requires age verification or sign-in. Please provide a different video URL."
+                return f"Error accessing video: {str(e)}"
 
         except Exception as e:
             return f"Error analyzing video: {e}"
@@ -221,17 +213,17 @@ Respond in structured markdown.
 
 # --- Math Tools ---
 class CalculatorTool(Tool):
-    name = "calculator"
-    description = (
+    name: ClassVar[str] = "calculator"
+    description: ClassVar[str] = (
         "Evaluate a basic mathematical expression (supports +, -, *, /, **, %, etc.)."
     )
-    inputs = {
+    inputs: ClassVar[dict] = {
         "expression": {
             "type": "string",
             "description": "A mathematical expression to evaluate",
         }
     }
-    output_type = "number"
+    output_type: ClassVar[str] = "number"
 
     def forward(self, expression: str):
         # Safely evaluate the expression using ast
@@ -262,26 +254,26 @@ class CalculatorTool(Tool):
 
 # Optionally, separate basic operations could be defined (e.g., add, subtract).
 class AddTool(Tool):
-    name = "add"
-    description = "Add two numbers together."
-    inputs = {
+    name: ClassVar[str] = "add"
+    description: ClassVar[str] = "Add two numbers together."
+    inputs: ClassVar[dict] = {
         "a": {"type": "number", "description": "First number"},
         "b": {"type": "number", "description": "Second number"},
     }
-    output_type = "number"
+    output_type: ClassVar[str] = "number"
 
     def forward(self, a: float, b: float):
         return a + b
 
 
 class MultiplyTool(Tool):
-    name = "multiply"
-    description = "Multiply two numbers."
-    inputs = {
+    name: ClassVar[str] = "multiply"
+    description: ClassVar[str] = "Multiply two numbers."
+    inputs: ClassVar[dict] = {
         "a": {"type": "number", "description": "First number"},
         "b": {"type": "number", "description": "Second number"},
     }
-    output_type = "number"
+    output_type: ClassVar[str] = "number"
 
     def forward(self, a: float, b: float):
         return a * b
@@ -289,10 +281,12 @@ class MultiplyTool(Tool):
 
 # --- Date/Time Tools ---
 class DayOfWeekTool(Tool):
-    name = "day_of_week"
-    description = "Return the day of week for a given date (YYYY-MM-DD)."
-    inputs = {"date": {"type": "string", "description": "Date in format YYYY-MM-DD"}}
-    output_type = "string"
+    name: ClassVar[str] = "day_of_week"
+    description: ClassVar[str] = "Return the day of week for a given date (YYYY-MM-DD)."
+    inputs: ClassVar[dict] = {
+        "date": {"type": "string", "description": "Date in format YYYY-MM-DD"}
+    }
+    output_type: ClassVar[str] = "string"
 
     def forward(self, date: str):
         year, month, day = map(int, date.split("-"))
@@ -301,13 +295,13 @@ class DayOfWeekTool(Tool):
 
 
 class AddDaysTool(Tool):
-    name = "add_days"
-    description = "Add a number of days to a date (YYYY-MM-DD)."
-    inputs = {
+    name: ClassVar[str] = "add_days"
+    description: ClassVar[str] = "Add a number of days to a date (YYYY-MM-DD)."
+    inputs: ClassVar[dict] = {
         "date": {"type": "string", "description": "Start date (YYYY-MM-DD)"},
         "days": {"type": "integer", "description": "Number of days to add"},
     }
-    output_type = "string"
+    output_type: ClassVar[str] = "string"
 
     def forward(self, date: str, days: int):
         year, month, day = map(int, date.split("-"))
@@ -316,13 +310,15 @@ class AddDaysTool(Tool):
 
 
 class DateDiffTool(Tool):
-    name = "date_diff"
-    description = "Compute difference in days between two dates (YYYY-MM-DD)."
-    inputs = {
+    name: ClassVar[str] = "date_diff"
+    description: ClassVar[str] = (
+        "Compute difference in days between two dates (YYYY-MM-DD)."
+    )
+    inputs: ClassVar[dict] = {
         "start_date": {"type": "string", "description": "First date (YYYY-MM-DD)"},
         "end_date": {"type": "string", "description": "Second date (YYYY-MM-DD)"},
     }
-    output_type = "integer"
+    output_type: ClassVar[str] = "integer"
 
     def forward(self, start_date: str, end_date: str):
         y1, m1, d1 = map(int, start_date.split("-"))
@@ -334,13 +330,13 @@ class DateDiffTool(Tool):
 
 # --- Unit Conversion Tools ---
 class TempConvertTool(Tool):
-    name = "convert_temperature"
-    description = "Convert temperature between Celsius and Fahrenheit."
-    inputs = {
+    name: ClassVar[str] = "convert_temperature"
+    description: ClassVar[str] = "Convert temperature between Celsius and Fahrenheit."
+    inputs: ClassVar[dict] = {
         "value": {"type": "number", "description": "Temperature value to convert"},
         "from_unit": {"type": "string", "description": "Unit of input ('C' or 'F')"},
     }
-    output_type = "number"
+    output_type: ClassVar[str] = "number"
 
     def forward(self, value: float, from_unit: str):
         unit = from_unit.strip().upper()
@@ -355,9 +351,11 @@ class TempConvertTool(Tool):
 
 
 class LengthConvertTool(Tool):
-    name = "convert_length"
-    description = "Convert length between kilometers, miles, meters, and feet."
-    inputs = {
+    name: ClassVar[str] = "convert_length"
+    description: ClassVar[str] = (
+        "Convert length between kilometers, miles, meters, and feet."
+    )
+    inputs: ClassVar[dict] = {
         "value": {"type": "number", "description": "Length value to convert"},
         "from_unit": {
             "type": "string",
@@ -368,7 +366,7 @@ class LengthConvertTool(Tool):
             "description": "Target unit ('km','mi','m','ft')",
         },
     }
-    output_type = "number"
+    output_type: ClassVar[str] = "number"
 
     def forward(self, value: float, from_unit: str, to_unit: str):
         u1 = from_unit.lower()
@@ -398,23 +396,25 @@ class LengthConvertTool(Tool):
 
 # --- Text Tools ---
 class WordCountTool(Tool):
-    name = "word_count"
-    description = "Count the number of words in a text string."
-    inputs = {"text": {"type": "string", "description": "Input text"}}
-    output_type = "integer"
+    name: ClassVar[str] = "word_count"
+    description: ClassVar[str] = "Count the number of words in a text string."
+    inputs: ClassVar[dict] = {"text": {"type": "string", "description": "Input text"}}
+    output_type: ClassVar[str] = "integer"
 
     def forward(self, text: str):
         return len(text.split())
 
 
 class FindTextTool(Tool):
-    name = "find_text"
-    description = "Find occurrences of a substring in a text; returns count."
-    inputs = {
+    name: ClassVar[str] = "find_text"
+    description: ClassVar[str] = (
+        "Find occurrences of a substring in a text; returns count."
+    )
+    inputs: ClassVar[dict] = {
         "text": {"type": "string", "description": "Text to search in"},
         "query": {"type": "string", "description": "Substring to search for"},
     }
-    output_type = "integer"
+    output_type: ClassVar[str] = "integer"
 
     def forward(self, text: str, query: str):
         return text.count(query)
@@ -422,20 +422,26 @@ class FindTextTool(Tool):
 
 # --- List/Sequence Tools ---
 class SortListTool(Tool):
-    name = "sort_list"
-    description = "Sort a list of items (numbers or strings)."
-    inputs = {"items": {"type": "array", "description": "List of items to sort"}}
-    output_type = "array"
+    name: ClassVar[str] = "sort_list"
+    description: ClassVar[str] = "Sort a list of items (numbers or strings)."
+    inputs: ClassVar[dict] = {
+        "items": {"type": "array", "description": "List of items to sort"}
+    }
+    output_type: ClassVar[str] = "array"
 
     def forward(self, items):
         return sorted(items)
 
 
 class UniqueListTool(Tool):
-    name = "unique_list"
-    description = "Return a list with duplicate items removed (preserving order)."
-    inputs = {"items": {"type": "array", "description": "List of items"}}
-    output_type = "array"
+    name: ClassVar[str] = "unique_list"
+    description: ClassVar[str] = (
+        "Return a list with duplicate items removed (preserving order)."
+    )
+    inputs: ClassVar[dict] = {
+        "items": {"type": "array", "description": "List of items"}
+    }
+    output_type: ClassVar[str] = "array"
 
     def forward(self, items):
         seen = []
@@ -447,10 +453,12 @@ class UniqueListTool(Tool):
 
 # --- File I/O Tools ---
 class ReadFileTool(Tool):
-    name = "read_file"
-    description = "Read and return the contents of a text file."
-    inputs = {"file_path": {"type": "string", "description": "Path to a text file"}}
-    output_type = "string"
+    name: ClassVar[str] = "read_file"
+    description: ClassVar[str] = "Read and return the contents of a text file."
+    inputs: ClassVar[dict] = {
+        "file_path": {"type": "string", "description": "Path to a text file"}
+    }
+    output_type: ClassVar[str] = "string"
 
     def forward(self, file_path: str):
         try:
@@ -461,13 +469,13 @@ class ReadFileTool(Tool):
 
 
 class WriteFileTool(Tool):
-    name = "write_file"
-    description = "Write a string to a text file (overwrites if exists)."
-    inputs = {
+    name: ClassVar[str] = "write_file"
+    description: ClassVar[str] = "Write a string to a text file (overwrites if exists)."
+    inputs: ClassVar[dict] = {
         "file_path": {"type": "string", "description": "Path to write the file"},
         "content": {"type": "string", "description": "Content to write"},
     }
-    output_type = "string"
+    output_type: ClassVar[str] = "string"
 
     def forward(self, file_path: str, content: str):
         with open(file_path, "w") as f:
@@ -477,10 +485,12 @@ class WriteFileTool(Tool):
 
 # --- Image Tool (stub) ---
 class ImageInfoTool(Tool):
-    name = "image_info"
-    description = "Load an image and report basic info (size and mode)."
-    inputs = {"image_path": {"type": "string", "description": "Path to an image file"}}
-    output_type = "string"
+    name: ClassVar[str] = "image_info"
+    description: ClassVar[str] = "Load an image and report basic info (size and mode)."
+    inputs: ClassVar[dict] = {
+        "image_path": {"type": "string", "description": "Path to an image file"}
+    }
+    output_type: ClassVar[str] = "string"
 
     def forward(self, image_path: str):
         try:
@@ -490,11 +500,129 @@ class ImageInfoTool(Tool):
             return f"Error loading image: {e}"
 
 
+class WikipediaTool(Tool):
+    name: ClassVar[str] = "wikipedia_search_summary"
+    description: ClassVar[str] = "Search Wikipedia and return max 3 results"
+    inputs: ClassVar[dict] = {
+        "query": {
+            "type": "string",
+            "description": "Search Query for Wikipedia",
+        }
+    }
+    output_type: ClassVar[str] = "string"
+
+    def forward(self, query: str) -> str:
+        try:
+            search_docs = WikipediaLoader(query=query, load_max_docs=3).load()
+            formatted_search_docs = "\n\n---\n\n".join(
+                [
+                    f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content}\n</Document>'
+                    for doc in search_docs
+                ]
+            )
+            return {"wiki_results": formatted_search_docs}
+
+        except Exception as e:
+            return f"Error using Wikipedia API: {e}"
+
+
+class ArvixSearchTool(Tool):
+    name: ClassVar[str] = "arvix_search"
+    description: ClassVar[str] = "Search Arvix for a query and return maximum 3 result"
+    inputs: ClassVar[dict] = {
+        "query": {
+            "type": "string",
+            "description": "Search Query for Arvix",
+        }
+    }
+    output_type: ClassVar[str] = "string"
+
+    def forward(self, query: str) -> str:
+        try:
+            search_docs = ArxivLoader(query=query, load_max_docs=3).load()
+            formatted_search_docs = "\n\n---\n\n".join(
+                [
+                    f'<Document source="{doc.metadata["source"]}" page="{doc.metadata.get("page", "")}"/>\n{doc.page_content[:1000]}\n</Document>'
+                    for doc in search_docs
+                ]
+            )
+            return {"arvix_results": formatted_search_docs}
+
+        except Exception as e:
+            return f"Error using Arvix Tool: {e}"
+
+
+class GoogleSearchTool(Tool):
+    name: ClassVar[str] = "google_search"
+    description: ClassVar[str] = (
+        "Search the web  using Google Search Engine and return results"
+    )
+    inputs: ClassVar[dict] = {
+        "query": {
+            "type": "string",
+            "description": "Search term to find information on Web",
+        }
+    }
+    output_type: ClassVar[str] = "string"
+
+    def forward(self, query: str) -> str:
+        try:
+            # Initialize Google Search API Wrapper
+            google_search = GoogleSearchAPIWrapper(
+                google_api_key=os.getenv("GOOGLE_API_KEY"),
+                google_cse_id=os.getenv("GOOGLE_CSE_ID"),
+            )
+
+            # Perform the search
+            results = google_search.results(query, num_results=5)
+            if not results:
+                return f"No results found for: '{query}'"
+
+            formatted = "\n\n".join(
+                f"{i+1}. **{r['title']}**\n{r['link']}\n{r['snippet']}"
+                for i, r in enumerate(results)
+            )
+
+            return f"**Search Results for '{query}':**\n\n{formatted}"
+
+        except Exception as e:
+            return f"Error using Google Search API: {e}"
+
+
+class AdvanceGoogleAISearchTool(Tool):
+    name: ClassVar[str] = "google_ai_search"
+    description: ClassVar[str] = (
+        "Search the web using Google AI Search Engine and return results"
+    )
+    inputs: ClassVar[dict] = {
+        "query": {
+            "type": "string",
+            "description": "Search term to find information on Web",
+        }
+    }
+    output_type: ClassVar[str] = "string"
+
+    def forward(self, query: str) -> str:
+        try:
+            client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))
+            response = client.models.generate_content(
+                model=os.getenv("GENAI_MODEL"),
+                contents=[query],
+            )
+
+            if not response:
+                return f"No results found for: '{query}'"
+
+            return f"**Search Results for '{query}':**\n\n{response.text}"
+
+        except Exception as e:
+            return f"Error using Google AI Search API: {e}"
+
+
 # List of all available tools
 agent_tools = [
-    GeminiFileAnalyzerTool(),
-    ImageTextExtractorTool(),
-    TableInspectorTool(),
+    AnyTypeFileAnalyzerTool(),
+    ExcelAndCSVTableInspectorTool(),
     YouTubeVideoAnalyzerTool(),
     CalculatorTool(),
     AddTool(),
@@ -508,8 +636,7 @@ agent_tools = [
     FindTextTool(),
     SortListTool(),
     UniqueListTool(),
-    ReadFileTool(),
-    WriteFileTool(),
-    ImageInfoTool(),
-    DuckDuckGoSearchTool(),
+    GoogleSearchTool(),
+    WikipediaSearchTool(),
+    AdvanceGoogleAISearchTool(),
 ]