feat: implement tools and agentic behaviour

agent.py

@@ -0,0 +1,130 @@
+import asyncio
+import os
+import pprint
+from llama_index.core.agent.workflow.workflow_events import AgentInput, AgentOutput, AgentStream, ToolCall, ToolCallResult
+from llama_index.core.llms import ChatMessage
+# from llama_index.llms.ollama import Ollama
+from llama_index.core.agent.workflow import AgentWorkflow
+from llama_index.core.tools import FunctionTool
+from workflows.events import StopEvent, StartEvent, StepState, StepStateChanged
+from llama_index.tools.arxiv import ArxivToolSpec
+from llama_index.tools.wikipedia import WikipediaToolSpec
+from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+from llama_index.llms.nebius import NebiusLLM
+
+import tools
+
+"""
+TODO: 2. Update gradio app to include HF inference model instead of Ollama.
+TODO: 4. Run HF Space and submit answers to the scoring server.
+TODO: 5. Get a certificate for the course.
+"""
+
+class BasicAgent:
+    def __init__(self, verbose: bool = False):
+        self.verbose = verbose
+        self.system_prompt = """
+        You are a general AI assistant. I will ask you a question. 
+        Report your thoughts, and finish your answer with the following template: 
+        FINAL ANSWER: [YOUR FINAL ANSWER]. 
+        YOUR FINAL ANSWER should be a number OR as few words as possible 
+        OR a comma separated list of numbers and/or strings. 
+        If you are asked for a number, don't use comma to write your number 
+        neither use units such as $ or percent sign unless specified otherwise. 
+        If you are asked for a string, don't use articles, neither abbreviations 
+        (e.g. for cities), and write the digits in plain text unless specified 
+        otherwise. If you are asked for a comma separated list, apply the above 
+        rules depending of whether the element to be put in the list is a number 
+        or a string.
+        """
+        # llm = Ollama(
+        #     model="gpt-oss:20b",
+        #     request_timeout=120.0
+        # )
+        # llm = HuggingFaceInferenceAPI(
+        #     model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
+        # )
+        llm = NebiusLLM(
+            api_key=os.getenv("NEBIUS_API_KEY"),
+            model="Qwen/Qwen3-235B-A22B-Instruct-2507",
+            api_base="https://api.tokenfactory.nebius.com/v1"
+        )
+        self.workflow = AgentWorkflow.from_tools_or_functions(
+            [
+                FunctionTool.from_defaults(tools.multiply), 
+                FunctionTool.from_defaults(tools.add), 
+                # FunctionTool.from_defaults(tools.transcribeAudio),
+                # FunctionTool.from_defaults(tools.describeImage),
+                FunctionTool.from_defaults(tools.directFetchTool),
+                FunctionTool.from_defaults(tools.webSearchTool),
+                *ArxivToolSpec().to_tool_list(),
+                *WikipediaToolSpec().to_tool_list(),
+                ],
+            llm=llm,
+            system_prompt=self.system_prompt
+        )
+        print("BasicAgent initialized.")
+    
+    async def __call__(self, question: str) -> str:
+        """Async call method that returns the final result without streaming"""
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        
+        if self.verbose:
+            return await self.stream_answers(question)
+        
+        answer = await self.workflow.run(user_msg=question)
+        print(f"Agent returning answer: {answer}")
+        return answer
+    
+    def call_sync(self, question: str) -> str:
+        """Synchronous wrapper for __call__ method (for compatibility with sync code)"""
+        return asyncio.run(self.__call__(question))
+    
+    async def stream_answers(self, question: str) -> None:
+        
+        handler = self.workflow.run(user_msg=question, max_iterations=10)
+        async for event in handler.stream_events():
+            if isinstance(event, AgentInput):
+                # print(f"\nAgent input: {event.input}")
+                pass
+            elif isinstance(event, AgentOutput):
+                # print(f"\nAgent output: {event}")
+                pass
+            elif isinstance(event, ToolCall):
+                print(f"\n\tCalled tool: {event.tool_name} {event.tool_kwargs}")
+            elif isinstance(event, ToolCallResult):
+                print(f"\n\t{event.tool_name} {event.tool_kwargs} -> {event.tool_output}")
+            elif isinstance(event, StopEvent):
+                return event.result
+            elif isinstance(event, AgentStream):
+                if event.delta:
+                    print(event.delta, end="", flush=True)
+                elif event.thinking_delta:
+                    print(event.thinking_delta, end="", flush=True)
+            else:
+                pprint.pprint(f"Received event: {type(event)} {event}")
+
+
+if __name__ == "__main__":
+    async def main():
+        from dotenv import load_dotenv
+        load_dotenv()
+        # agent = BasicAgent()
+        
+        llm = NebiusLLM(
+            api_key=os.getenv("NEBIUS_API_KEY"),
+            model="Qwen/Qwen3-235B-A22B-Instruct-2507",
+            api_base="https://api.tokenfactory.nebius.com/v1"
+        )
+        # result = llm.complete("Hello!")
+        result = llm.chat([ChatMessage("Who are you?")])
+        print(result)
+        
+        # Example without streaming (using __call__)
+        # print("\n=== Non-Streaming Example ===")
+        # result = await agent("What is 5 + 7?")
+        # print(f"Final result: {result}")
+        # result = await agent.stream_answers("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.")
+        # print(f"\nFinal result: {result}")
+    
+    asyncio.run(main())

app.py

@@ -3,22 +3,79 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from agent import BasicAgent
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+def run_and_print_random():
+    api_url = DEFAULT_API_URL
+    random_question_url = f"{api_url}/random-question"
+    submit_url = f"{api_url}/submit"
+    
+    try:
+        agent = BasicAgent(verbose=True)
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    
+    try:
+        response = requests.get(random_question_url, timeout=15)
+        response.raise_for_status()
+        question_data = response.json()
+        if not question_data:
+            return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(question_data)} questions.")
+    except requests.exceptions.JSONDecodeError as e:
+        return f"Error decoding server response for questions: {e}", None
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching questions: {e}", None
+    except Exception as e:
+        return f"An unexpected error occurred fetching questions: {e}", None
+    
+    results_log = []
+    answers_payload = []
+    
+    task_id = question_data.get("task_id")
+    question_text = question_data.get("question")
+    if not task_id or question_text is None:
+        print(f"Skipping item with missing task_id or question: {question_data}")
+    try:
+        submitted_answer = agent.call_sync(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})
+    except Exception as e:
+        results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
+
+    if not answers_payload:
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    submission_data = {"username": 'agsagds', "agent_code": 'https://huggingface.co/spaces/agsagds/Unit_3_Agentic_RAG/tree/main', "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user agsagds..."
+    print(status_update)
 
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        print("Submission successful.")
+        results_log.append(final_status)
+        results_df = pd.DataFrame(results_log)
+        return results_df
+    except Exception as e:
+        return f"Error submitting answers: {e}", None
+    
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
@@ -40,7 +97,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = BasicAgent(verbose=True)
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -55,16 +112,16 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
+            print("Fetched questions list is empty.")
+            return "Fetched questions list is empty or invalid format.", None
         print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.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
     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
     except Exception as e:
         print(f"An unexpected error occurred fetching questions: {e}")
         return f"An unexpected error occurred fetching questions: {e}", None
@@ -76,16 +133,27 @@ 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:
+            print(f"Skipping item with file name: {file_name} because it is not supported yet.")
+            continue
+        if "youtube" in question_text.lower():
+            print(f"Skipping item with youtube link: {question_text} because it is not supported yet.")
+            continue
+        
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            print(f"Running agent on question: {task_id} {question_text}")
+            submitted_answer = agent.call_sync(question_text)
+            print(f"Submitted answer: {submitted_answer}")
             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})
         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.")
@@ -140,6 +208,10 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         return status_message, results_df
 
 
+# Load evns from .env file
+from dotenv import load_dotenv
+load_dotenv()
+
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
@@ -161,6 +233,7 @@ with gr.Blocks() as demo:
     gr.LoginButton()
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
+    run_once_button = gr.Button("Run Evaluation for random question")
 
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
     # Removed max_rows=10 from DataFrame constructor
@@ -170,6 +243,10 @@ with gr.Blocks() as demo:
         fn=run_and_submit_all,
         outputs=[status_output, results_table]
     )
+    run_once_button.click(
+        fn=run_and_print_random,
+        outputs=[results_table]
+    )
 
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)

requirements.txt

@@ -1,2 +1,145 @@
-gradio
-requests
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.13.2
+aiosignal==1.4.0
+aiosqlite==0.21.0
+annotated-doc==0.0.3
+annotated-types==0.7.0
+anyio==4.11.0
+arxiv==2.3.0
+attrs==25.4.0
+Authlib==1.6.5
+banks==2.2.0
+beautifulsoup4==4.14.2
+Brotli==1.1.0
+certifi==2025.10.5
+cffi==2.0.0
+chardet==5.2.0
+charset-normalizer==3.4.4
+click==8.3.0
+colorama==0.4.6
+cryptography==46.0.3
+cssselect==1.3.0
+dataclasses-json==0.6.7
+ddgs==9.9.0
+defusedxml==0.7.1
+Deprecated==1.2.18
+dirtyjson==1.0.8
+distro==1.9.0
+duckduckgo_search==6.4.2
+fastapi==0.121.0
+feedparser==6.0.12
+ffmpy==0.6.4
+filelock==3.20.0
+filetype==1.2.0
+frozenlist==1.8.0
+fsspec==2025.10.0
+gradio==5.49.1
+gradio_client==1.13.3
+greenlet==3.2.4
+griffe==1.14.0
+groovy==0.1.2
+h11==0.16.0
+h2==4.3.0
+hf-xet==1.2.0
+hpack==4.1.0
+html5lib==1.1
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.36.0
+hyperframe==6.1.0
+idna==3.11
+itsdangerous==2.2.0
+Jinja2==3.1.6
+jiter==0.11.1
+joblib==1.5.2
+llama-cloud==0.1.35
+llama-cloud-services==0.6.54
+llama-index==0.14.8
+llama-index-cli==0.5.3
+llama-index-core==0.14.8
+llama-index-embeddings-openai==0.5.1
+llama-index-indices-managed-llama-cloud==0.9.4
+llama-index-instrumentation==0.4.2
+llama-index-llms-huggingface-api==0.6.1
+llama-index-llms-nebius==0.2.1
+llama-index-llms-ollama==0.9.0
+llama-index-llms-openai==0.6.7
+llama-index-llms-openai-like==0.5.3
+llama-index-readers-file==0.5.4
+llama-index-readers-llama-parse==0.5.1
+llama-index-tools-arxiv==0.4.1
+llama-index-tools-duckduckgo==0.4.1
+llama-index-tools-wikipedia==0.4.1
+llama-index-workflows==2.10.3
+llama-parse==0.6.54
+lxml==6.0.2
+lxml_html_clean==0.4.3
+markdown-it-py==4.0.0
+MarkupSafe==3.0.3
+marshmallow==3.26.1
+mdurl==0.1.2
+multidict==6.7.0
+mypy_extensions==1.1.0
+nest-asyncio==1.6.0
+networkx==3.5
+nltk==3.9.2
+numpy==2.3.4
+ollama==0.6.0
+openai==1.109.1
+orjson==3.11.4
+packaging==25.0
+pandas==2.2.3
+pillow==11.3.0
+platformdirs==4.5.0
+primp==0.15.0
+propcache==0.4.1
+pycparser==2.23
+pydantic==2.11.10
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.2
+pypdf==6.2.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.2.1
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.3
+readabilipy==0.3.0
+readability-lxml==0.8.4.1
+regex==2025.11.3
+requests==2.32.5
+rich==14.2.0
+ruff==0.14.3
+safehttpx==0.1.7
+safetensors==0.6.2
+semantic-version==2.10.0
+setuptools==80.9.0
+sgmllib3k==1.0.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+socksio==1.0.0
+soupsieve==2.8
+SQLAlchemy==2.0.44
+starlette==0.49.3
+striprtf==0.0.26
+tenacity==9.1.2
+tiktoken==0.12.0
+tokenizers==0.22.1
+tomlkit==0.13.3
+tqdm==4.67.1
+transformers==4.57.1
+typer==0.20.0
+typer-slim==0.20.0
+typing-inspect==0.9.0
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.2
+urllib3==2.5.0
+uvicorn==0.38.0
+webencodings==0.5.1
+websockets==15.0.1
+wikipedia==1.4.0
+wrapt==1.17.3
+yarl==1.22.0

tools.py

@@ -0,0 +1,274 @@
+import asyncio
+import os
+import mimetypes
+import httpx
+from llama_index.core.llms import ChatMessage, TextBlock, ImageBlock
+from llama_index.llms.nebius import NebiusLLM
+from ddgs import DDGS
+from ddgs.exceptions import DDGSException
+import bs4
+from readability import Document
+
+def multiply(a: float, b: float) -> float:
+    """Multiply two numbers and returns the product"""
+    return a * b
+
+
+def add(a: float, b: float) -> float:
+    """Add two numbers and returns the sum"""
+    return a + b
+
+
+def webSearchTool(
+    query: str,
+    region: str = "us-en",
+    timelimit: str | None = None
+) -> list[dict[str, str]]:
+    """
+    Perform a web search using DuckDuckGo metasearch across multiple backends.
+    
+    This tool searches the web using DuckDuckGo's metasearch engine, which can query
+    multiple search backends including Bing, Brave, DuckDuckGo, Google, Mojeek, 
+    Yandex, Yahoo, and Wikipedia. Returns a list of search results with titles,
+    snippets, and URLs.
+    
+    Args:
+        query: The search query text. Supports advanced search operators:
+            - "exact phrase" - Search for exact phrase
+            - term1 -term2 - Exclude term2 from results
+            - term1 +term2 - Emphasize term2 in results
+            - term filetype:pdf - Search for specific file types (pdf, doc, docx, xls, xlsx, ppt, pptx, html)
+            - term site:example.com - Search within a specific site
+            - term -site:example.com - Exclude a specific site
+            - intitle:term - Search in page titles
+            - inurl:term - Search in page URLs
+        
+        region: Search region/locale. Examples: "us-en", "uk-en", "ru-ru", etc. Defaults to "us-en".
+        
+        timelimit: Limit results to a specific time period. Options: "d" (day), "w" (week), 
+                "m" (month), "y" (year). Defaults to None (no time limit).
+    
+    Returns:
+        A list of dictionaries, where each dictionary contains search result information
+        with keys such as 'title', 'body', 'href', etc.
+    
+    Example:
+        >>> results = webSearchTool("Python programming")
+        >>> results = webSearchTool("machine learning filetype:pdf")
+        >>> results = webSearchTool("news site:example.com")
+    """
+    try:
+        return list(DDGS().text(
+            query=query,
+            region=region,
+            timelimit=timelimit
+        ))
+    except DDGSException:
+        # If no results found, return empty list
+        return []
+
+
+async def directFetchTool(url: str, offset: int = 0) -> str:
+    """
+    Fetch and extract only the meaningful readable content from a webpage,
+    similar to Chrome/Firefox Reader Mode. Removes navigation, ads, sidebars,
+    comments, and other non-essential content, keeping only the main article text.
+    
+    Args:
+        url: The URL of the webpage to fetch. Must be a valid HTTP or HTTPS URL.
+        offset: position from start of the web page content. Default  = 0
+    Returns:
+        The extracted meaningful text content of the webpage as a string.
+        If result length more then 2000 symbols than return only first 2000. Use `offset` option to show another part of the web page content.
+        If an error occurs, returns an empty string.
+    
+    Example:
+        >>> content = await direct_fetch_tool("https://example.com/article")
+        >>> # Use after webSearchTool to get full page content
+        >>> results = webSearchTool("Python tutorial")
+        >>> if results:
+        >>>     first_url = results[0].get('href')
+        >>>     full_content = await direct_fetch_tool(first_url)
+    """
+    try:
+        async with httpx.AsyncClient(timeout=30.0, follow_redirects=True) as client:
+            response = await client.get(url, headers={
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            })
+            response.raise_for_status()
+            html = response.text
+        
+        # Use readability-lxml to extract meaningful content (like Reader Mode)
+        # This uses Mozilla's Readability algorithm
+        doc = Document(html)
+        readable_html = doc.summary()
+        
+        # Parse the cleaned HTML and extract text
+        soup = bs4.BeautifulSoup(readable_html, "html.parser")
+        
+        # Remove any remaining script and style elements
+        for elem in soup(['script', 'style', 'nav', 'header', 'footer', 'aside']):
+            elem.decompose()
+        
+        # Extract text with proper formatting
+        text = soup.get_text(separator='\n', strip=True)
+        
+        # Clean up excessive whitespace while preserving paragraph breaks
+        lines = [line.strip() for line in text.split('\n') if line.strip()]
+        text = '\n'.join(lines)
+        
+        if len(text)>2000:
+            return f"Result is too big: {len(text)} chars. Return only slice ${offset}:${offset+2000}: \n\n" + text[offset:offset+2000]
+            
+        return text
+    except httpx.HTTPStatusError as e:
+        error_msg = f"Error fetching webpage (HTTP {e.response.status_code}): {url}"
+        print(error_msg)
+        return ""
+    except httpx.TimeoutException:
+        error_msg = f"Timeout while fetching webpage: {url}"
+        print(error_msg)
+        return ""
+    except httpx.RequestError as e:
+        error_msg = f"Error fetching webpage: {str(e)}"
+        print(error_msg)
+        return ""
+    except Exception as e:
+        error_msg = f"Unexpected error fetching webpage: {str(e)}"
+        print(error_msg)
+        return ""
+
+
+async def describeImage(imgUrl: str, instructions: str = "Describe the image.") -> str:
+    """
+    Describe an image using a image-to-text model.
+    """
+    vision_llm = NebiusLLM(
+        api_key=os.getenv("NEBIUS_API_KEY"),
+        model="nvidia/Nemotron-Nano-V2-12b",
+        api_base="https://api.tokenfactory.nebius.com/v1"
+    )
+    try:
+        messages = [
+            ChatMessage(
+                role="user",
+                blocks=[
+                    TextBlock(text=instructions),
+                    ImageBlock(url=imgUrl),
+                ],
+            ),
+        ]
+
+        # response = vision_llm.stream_chat(messages)
+        # for r in response:
+        #     print(r.delta, end="")
+        response = await vision_llm.achat(messages)
+
+        return str(response.message).split("</think>")[-1].strip()
+    except Exception as e:
+        error_msg = f"Error extracting text: {str(e)}"
+        print(error_msg)
+        return ""
+
+
+async def transcribeAudio(audioUrlOrPath: str, language_code: str = None) -> str:
+    """
+    Transcribe an audio or video file using ElevenLabs speech-to-text API.
+    
+    Args:
+        audioUrlOrPath: URL or local file path to the audio/video file
+        language_code: Optional language code (e.g., 'en', 'es', 'fr')
+    
+    Returns:
+        The transcribed text as a string
+    """
+    api_key = os.getenv("ELEVENLABS_STT_API_KEY")
+    if not api_key:
+        error_msg = "Error: ELEVENLABS_STT_API_KEY not found in environment variables"
+        print(error_msg)
+        return ""
+    
+    try:
+        # Determine if input is a URL or file path
+        is_url = audioUrlOrPath.startswith(('http://', 'https://'))
+        
+        # Prepare the audio file
+        if is_url:
+            # Download the file from URL
+            async with httpx.AsyncClient() as client:
+                response = await client.get(audioUrlOrPath)
+                response.raise_for_status()
+                audio_data = response.content
+                # Try to get filename from URL or Content-Disposition header
+                filename = audioUrlOrPath.split('/')[-1].split('?')[0] or 'audio_file'
+        else:
+            # Read from local file path
+            with open(audioUrlOrPath, 'rb') as f:
+                audio_data = f.read()
+            filename = os.path.basename(audioUrlOrPath)
+        
+        # Detect MIME type from filename extension, fallback to octet-stream
+        content_type, _ = mimetypes.guess_type(filename)
+        if not content_type:
+            content_type = 'application/octet-stream'
+        
+        # Prepare multipart form data
+        files = {
+            'file': (filename, audio_data, content_type)
+        }
+        
+        data = { 'model_id': 'scribe_v1' }
+        if language_code:
+            data['language_code'] = language_code
+        
+        # Make the API request
+        async with httpx.AsyncClient() as client:
+            response = await client.post(
+                'https://api.elevenlabs.io/v1/speech-to-text',
+                headers={
+                    'xi-api-key': api_key
+                },
+                files=files,
+                data=data,
+                timeout=300.0  # 5 minutes timeout for large files
+            )
+            response.raise_for_status()
+            result = response.json()
+            
+            # Extract transcript from response
+            if 'text' in result:
+                return result['text']
+            else:
+                # Fallback: return the entire response as string
+                return str(result)
+                
+    except httpx.HTTPStatusError as e:
+        error_msg = f"Error transcribing audio (HTTP {e.response.status_code}): {e.response.text}"
+        print(error_msg)
+        return ""
+    except Exception as e:
+        error_msg = f"Error transcribing audio: {str(e)}"
+        print(error_msg)
+        return ""
+
+
+if __name__ == "__main__":
+    from dotenv import load_dotenv
+    load_dotenv()
+
+    # print(extract_shape("https://developers.llamaindex.ai/python/_astro/llamaindex-light.BJap_D_H.svg"))
+    
+    async def main():
+        
+        url = "https://external-content.duckduckgo.com/iu/?u=https%3A%2F%2Fstpagmaster.blob.core.windows.net%2Fcontainer-queensgambitaccepted-jpeg%2Fintro.png&f=1&nofb=1&ipt=1c348904c4fe4508d241e5527be8203e4cc2c029ed7e0cdeba3bbf372ab30a96"
+        print(await describeImage(url))
+        
+        # url = 'https://www.voiptroubleshooter.com/open_speech/american/OSR_us_000_0011_8k.wav'
+        # print(await transcribeAudio(url, 'en'))
+        # results = webSearchTool("Diplodocus nominated FA 2016")
+        # print(results)
+        # wp = await directFetchTool('https://en.wikipedia.org/wiki/Capital_of_France')
+        # print(wp[:3000])
+        # print('\n\n', len(wp))
+    asyncio.run(main())
+