Modified files

agent.py

@@ -1,20 +1,16 @@
 import os
 import time
 import logging
-import urllib.parse as urlparse
-import io
-import contextlib
 import re
 from functools import lru_cache, wraps
-from typing import Optional, Dict, Any
+from typing import Optional, Dict
 
 from youtube_transcript_api import YouTubeTranscriptApi, TranscriptsDisabled, NoTranscriptFound
 from dotenv import load_dotenv
 from requests.exceptions import RequestException
-import serpapi
 import wikipedia
-from llama_index.core import VectorStoreIndex, download_loader
 from llama_index.core.schema import Document
+from llama_index.readers.web import BeautifulSoupWebReader
 
 from smolagents import (
     CodeAgent,
@@ -77,6 +73,7 @@ def normalize_answer_format(answer: str) -> str:
     answer = answer.strip().rstrip('.')
     is_list = ',' in answer and len(answer.split(',')) > 1
     try:
+        # Check if it can be a number, ignoring commas for list check
         is_numeric = not is_list and float(answer.replace(',', '')) is not None
     except ValueError:
         is_numeric = False
@@ -118,47 +115,50 @@ def initialize_agent():
 
     @tool
     @retry
-    def query_webpage(url: str, query: str) -> str:
+    @lru_cache(maxsize=128)
+    def get_webpage_content(url: str) -> str:
         """
-        Extracts specific information from a webpage by asking a targeted question.
+        Extracts the text content from a single webpage.
 
         Args:
-            url (str): The full URL of the webpage to query.
-            query (str): The specific question to ask about the webpage's content.
+            url (str): The full URL of the webpage to read.
         """
-        logging.info(f"📄 Querying webpage: {url}")
-        loader = download_loader("BeautifulSoupWebReader")()
+        logging.info(f"📄 Reading webpage content from: {url}")
+        loader = BeautifulSoupWebReader()
         docs = loader.load_data(urls=[url])
-        if not docs: raise ValueError(f"No content could be extracted from {url}")
-        index = VectorStoreIndex.from_documents(docs)
-        query_engine = index.as_query_engine(response_mode="tree_summarize")
-        response = query_engine.query(query)
-        return str(response)
+        if not docs or not docs[0].text:
+            raise ValueError(f"No content could be extracted from {url}")
+        # Return up to the first 15,000 characters to avoid overwhelming the context window.
+        return docs[0].text[:15000]
 
     @tool
     @retry
-    def query_youtube_video(video_url: str, query: str) -> str:
+    @lru_cache(maxsize=128)
+    def get_youtube_transcript(video_url: str) -> str:
         """
-        Extracts specific information from a YouTube video transcript.
+        Fetches the full transcript of a YouTube video as a single string.
 
         Args:
             video_url (str): The full URL of the YouTube video.
-            query (str): The specific question to ask about the video's content.
         """
-        logging.info(f"🎬 Querying YouTube video: {video_url}")
+        logging.info(f"🎬 Fetching YouTube transcript for: {video_url}")
         video_id_match = re.search(r'(?:v=|\/)([a-zA-Z0-9_-]{11}).*', video_url)
-        if not video_id_match: return "Error: Invalid YouTube URL."
+        if not video_id_match:
+            return "Error: Invalid YouTube URL provided."
         video_id = video_id_match.group(1)
         
-        transcript = YouTubeTranscriptApi.get_transcript(video_id)
-        doc = Document(text=' '.join([t['text'] for t in transcript]))
-        index = VectorStoreIndex.from_documents([doc])
-        query_engine = index.as_query_engine()
-        response = query_engine.query(query)
-        return str(response)
+        try:
+            transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+            transcript_text = ' '.join([t['text'] for t in transcript_list])
+            # Return up to the first 15,000 characters
+            return transcript_text[:15000]
+        except (TranscriptsDisabled, NoTranscriptFound) as e:
+            logging.error(f"Could not retrieve transcript for {video_url}: {e}")
+            raise YouTubeTranscriptApiError(f"Transcript not available for video {video_id}.") from e
             
     @tool
     @retry
+    @lru_cache(maxsize=32)
     def wikipedia_search(query: str) -> str:
         """
         Searches Wikipedia for a given query and returns a summary.
@@ -171,7 +171,7 @@ def initialize_agent():
         except wikipedia.exceptions.PageError:
             return f"No Wikipedia page found for '{query}'."
         except wikipedia.exceptions.DisambiguationError as e:
-            return f"Ambiguous query '{query}'. Options: {e.options[:3]}"
+            return f"Ambiguous query '{query}'. Options: {', '.join(e.options[:3])}"
         except Exception as e:
             return f"An error occurred during Wikipedia search: {e}"
 
@@ -187,7 +187,14 @@ def initialize_agent():
 
     google_search_tool = GoogleSearchTool(provider='serpapi', serpapi_api_key=api_keys['serpapi']) if api_keys['serpapi'] else None
 
-    tools_list = [tool for tool in [google_search_tool, query_webpage, query_youtube_video, wikipedia_search] if tool]
+    tools_list = [
+        tool for tool in [
+            google_search_tool, 
+            get_webpage_content, 
+            get_youtube_transcript, 
+            wikipedia_search
+        ] if tool
+    ]
     
     agent = CodeAgent(
         model=model,
@@ -195,18 +202,19 @@ def initialize_agent():
         instructions="""You are a master AI assistant for the GAIA benchmark. Your goal is to provide a single, precise, and final answer by writing and executing Python code.
 
         **STRATEGY:**
-        You have a powerful toolkit. You can write and execute any Python code you need. You also have access to pre-defined tools that you can call from within your code.
+        You have a powerful toolkit. You can write and execute any Python code you need. You also have access to pre-defined tools that you can call from within your code to gather information.
 
         1.  **Analyze**: Break down the user's question into logical steps.
-        2.  **Plan**: Decide if you need to search the web, query a webpage, or perform a calculation.
+        2.  **Plan**: Decide if you need to search the web, read a webpage, get a video transcript, or perform a calculation.
         3.  **Execute**: Write a Python script to perform the steps.
-            *   For web searches, use `GoogleSearchTool()`.
+            *   For general web searches, use `GoogleSearchTool()`.
             *   For Wikipedia lookups, use `wikipedia_search()`.
-            *   For complex calculations or data manipulation, write the Python code directly.
-            *   To query a specific webpage, use `query_webpage()`.
+            *   To read the text content of a specific webpage, use `get_webpage_content()`.
+            *   To get the transcript of a YouTube video, use `get_youtube_transcript()`.
+            *   For complex calculations or data manipulation, write the Python code directly using libraries like `math`.
 
         **HOW TO USE TOOLS IN YOUR CODE:**
-        To solve a problem, you will write a Python code block that calls the necessary tools.
+        To solve a problem, you will write a Python code block that calls the necessary tools. You then reason over the results of these tools to produce your final answer.
 
         *Example 1: Simple Calculation*
         ```python
@@ -216,14 +224,17 @@ def initialize_agent():
         print(int(result))
         ```
 
-        *Example 2: Multi-step question involving web search*
+        *Example 2: Multi-step question involving web search and reading a page*
         ```python
-        # Find the birth date of the author of 'Pride and Prejudice'
-        author_name_info = GoogleSearchTool(query="author of Pride and Prejudice")
-        # Let's assume the tool returns "Jane Austen"
-        # Now get the birth date from Wikipedia
-        birth_date_info = wikipedia_search(query="Jane Austen birth date")
-        print(birth_date_info)
+        # Find the name of the journal that published the article "A Rapid and Sensitive Method for the Quantitation of Microgram Quantities of Protein Utilizing the Principle of Protein-Dye Binding"
+        # First, find the URL of the paper.
+        search_results = GoogleSearchTool(query="A Rapid and Sensitive Method for the Quantitation of Microgram Quantities of Protein Utilizing the Principle of Protein-Dye Binding")
+        # Let's assume the first result has a good URL, like "https://www.sciencedirect.com/science/article/pii/0003269776905271"
+        # Now, read the content of that page to find the journal name.
+        page_content = get_webpage_content(url="https://www.sciencedirect.com/science/article/pii/0003269776905271")
+        # Now I will analyze the text `page_content` in my head to find the journal name.
+        # After reading the text, I found the journal is "Analytical Biochemistry".
+        print("Analytical Biochemistry")
         ```
 
         **CRITICAL INSTRUCTION:** You MUST end your entire response with the line `FINAL ANSWER: [Your Final Answer]`. This is the only part of your response that will be graded. Adhere to strict formatting: no extra words, no currency symbols, no commas in numbers.

requirements.txt

@@ -4,16 +4,11 @@ python-dotenv
 huggingface_hub
 gradio
 markdownify
-duckduckgo-search
 wikipedia
 serpapi
-llama-index
 youtube-transcript-api
 together
-python-chess
-transformers
-torch
 requests
-llama-index
+llama-index-readers-web
 beautifulsoup4
-lxml
+lxml