Upload 2 files

app.py

@@ -0,0 +1,626 @@
+import os
+import gradio as gr
+import requests
+import pandas as pd
+import asyncio
+import time
+from pathlib import Path
+
+# LlamaIndex and tool imports
+from llama_index.core.agent.workflow import AgentWorkflow, ReActAgent
+from llama_index.core.tools import FunctionTool
+from llama_index.tools.duckduckgo import DuckDuckGoSearchToolSpec
+from llama_index.llms.azure_openai import AzureOpenAI
+from youtube_transcript_api import YouTubeTranscriptApi, NoTranscriptFound
+from bs4 import BeautifulSoup
+import pdfplumber
+import docx
+import speech_recognition as sr
+import base64
+
+from io import BytesIO, StringIO
+from dotenv import load_dotenv
+load_dotenv()
+
+# ------------------------------
+# 0. Define Azure OpenAI LLM
+# ------------------------------
+api_key = os.getenv("AZURE_OPENAI_API_KEY")
+azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT")
+azure_api_version = os.getenv("AZURE_OPENAI_API_VERSION")
+azure_deployment_name = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME")
+azure_model_name = os.getenv("AZURE_OPENAI_MODEL_NAME")
+
+llm = AzureOpenAI(
+    engine=azure_deployment_name,
+    model=azure_model_name,
+    temperature=0.0,
+    azure_endpoint=azure_endpoint,
+    api_key=api_key,
+    api_version=azure_api_version,
+)
+
+# ------------------------------
+# 1. Helper Functions / Tools
+# ------------------------------
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+# File parsing tool
+def parse_file(file_url: str, file_type: str) -> str:
+    try:
+        # Download file
+        resp = requests.get(file_url, timeout=30)
+        resp.raise_for_status()
+        content = resp.content
+
+        # --- XLSX ---
+        if file_type == ".xlsx":
+            df = pd.read_excel(BytesIO(content))
+            return f"Excel Sheet Content:\n{df.to_string(index=False)}"
+
+        # --- CSV ---
+        if file_type == ".csv":
+            df = pd.read_csv(StringIO(content.decode()))
+            return f"CSV File Content:\n{df.to_string(index=False)}"
+
+        # --- TXT ---
+        if file_type == ".txt":
+            text = content.decode(errors='ignore')
+            return f"Text File Content:\n{text[:3500]}"
+
+        # --- PDF ---
+        if file_type == ".pdf" and pdfplumber:
+            with pdfplumber.open(BytesIO(content)) as pdf:
+                text = "\n".join(page.extract_text() or "" for page in pdf.pages)
+            return f"PDF Content (first 3500 chars):\n{text[:3500]}"
+
+        # --- DOCX ---
+        if file_type == ".docx" and docx:
+            d = docx.Document(BytesIO(content))
+            text = "\n".join(p.text for p in d.paragraphs)
+            return f"DOCX Content (first 3500 chars):\n{text[:3500]}"
+
+        # --- MP3 (Audio to Text) ---
+        if file_type == ".mp3" and sr:
+            # Save MP3 to local
+            mp3_path = "temp.mp3"
+            with open(mp3_path, "wb") as f:
+                f.write(content)
+            try:
+                # Convert MP3 to WAV using pydub if available
+                wav_path = "temp.wav"
+                try:
+                    from pydub import AudioSegment
+                    sound = AudioSegment.from_mp3(mp3_path)
+                    sound.export(wav_path, format="wav")
+                    audio_file = wav_path
+                except Exception:
+                    audio_file = mp3_path  # Try raw mp3 if conversion fails
+
+                recognizer = sr.Recognizer()
+                with sr.AudioFile(audio_file) as source:
+                    audio = recognizer.record(source)
+                transcript = recognizer.recognize_google(audio)
+                # Clean up
+                if os.path.exists(mp3_path): os.remove(mp3_path)
+                if os.path.exists(wav_path): os.remove(wav_path)
+                return f"Audio Transcript:\n{transcript}"
+            except Exception as e:
+                if os.path.exists(mp3_path): os.remove(mp3_path)
+                if os.path.exists("temp.wav"): os.remove("temp.wav")
+                return f"Could not transcribe audio: {e}"
+
+        # --- Python file ---
+        if file_type == ".py":
+            text = content.decode(errors='ignore')
+            return f"Python Script Content:\n{text[:3500]}"
+
+        # --- Fallback ---
+        return f"File type {file_type} is not supported yet, or required package is missing."
+
+    except Exception as e:
+        return f"Failed to parse file: {e}"
+    
+# YouTube transcript tool
+def get_youtube_transcript(url: str) -> str:
+    try:
+        video_id = url.split("v=")[-1]
+        transcript = YouTubeTranscriptApi.get_transcript(video_id)
+        return " ".join([e['text'] for e in transcript])
+    except Exception:
+        return "No transcript available."
+
+# ------------ DuckDuckGo Search and Extract -------------------------
+def scrape_text_from_url(url: str, max_chars=4000) -> str:
+    """Fetch and clean main text from a webpage (basic version)."""
+    try:
+        resp = requests.get(url, timeout=10)
+        soup = BeautifulSoup(resp.text, 'html.parser')
+        # Get visible text only, skip scripts/styles
+        text = ' '.join(soup.stripped_strings)
+        return text[:max_chars]
+    except Exception as e:
+        return f"Could not scrape {url}: {e}"
+
+def duckduckgo_search_and_scrape(question: str) -> str:
+    """
+    Performs a DuckDuckGo search, scrapes the top relevant link, and returns the scraped content for LLM-based answering.
+    """
+    # Step 1: Search
+    ddg_spec = DuckDuckGoSearchToolSpec()
+    results = ddg_spec.duckduckgo_full_search(question)
+    if not results or not isinstance(results, list):
+        return "No search results found."
+    
+    # Step 2: Find first Wikipedia or Discogs or similar music data site
+    for entry in results:
+        href = entry.get("href", "")
+        if href:
+            text = scrape_text_from_url(href)
+            # Step 3: Compose output for LLM or direct answer
+            return (
+                f"Here is content scraped from {href}:\n\n"
+                f"{text}\n\n"
+                "Based on this, please answer the original question."
+            )
+    # If no "trusted" link found, fallback to first result
+    text = scrape_text_from_url(results[0]["href"])
+    return (
+        f"Here is content scraped from {results[0]['href']}:\n\n"
+        f"{text}\n\n"
+        "Based on this, please answer the original question."
+    )
+
+# ------------ Image Processing Tool Functions -------------------------
+# MIME type mapping for images
+MIME_MAP = {
+    '.jpg': 'jpeg',
+    '.jpeg': 'jpeg',
+    '.png': 'png',
+    '.bmp': 'bmp',
+    '.gif': 'gif',
+    '.webp': 'webp'
+}
+
+# 3. Image agent with enhanced capabilities
+def process_image(file_url: str, question: str) -> str:
+    """
+    Download the image, send it to Azure's vision API, and return the reply text.
+    """
+    try:
+        print(f"Processing image via process_image function from URL: {file_url}")
+        resp = requests.get(file_url, timeout=30)
+        resp.raise_for_status()
+        raw = resp.content
+        # 2) Figure out the MIME type from headers (fallback to png)
+        mime = resp.headers.get("Content-Type", "image/png")
+        # 3) Build data URI
+        img_b64 = base64.b64encode(raw).decode()
+        data_uri = f"data:{mime};base64,{img_b64}"
+
+        print(f"Image downloaded and encoded successfully.")
+        from openai import AzureOpenAI
+        vision_client = AzureOpenAI(
+            api_key=api_key,
+            api_version=azure_api_version,
+            azure_endpoint=azure_endpoint,
+        )
+        messages = [
+            {"role": "system", "content": (
+                "You are a vision expert. Answer based *only* on the image content."
+            )},
+            {"role": "user", "content": [
+                {"type": "text", "text": question},
+                {"type": "image_url", "image_url": {"url": data_uri}}
+            ]},
+        ]
+        response = vision_client.chat.completions.create(
+            model=azure_model_name,
+            messages=messages,
+            temperature=0.0,
+            max_tokens=2000,
+        )
+        print(f"Vision API response received : {response.choices[0].message.content.strip()}")
+    
+        return response.choices[0].message.content.strip()
+    except Exception as e:
+        return f"Vision API error: {e}"
+
+# ------------------------------
+# 2. BasicAgent Class Definition
+# ------------------------------
+class BasicAgent:
+    def __init__(self):
+        """Initialize the BasicAgent with all tools and agent workflow."""
+        self.llm = llm
+        self.api_url = DEFAULT_API_URL
+        
+        # Initialize tools
+        self._setup_tools()
+        
+        # Initialize agents
+        self._setup_agents()
+        
+        # Initialize agent workflow
+        self._setup_workflow()
+        
+        # Define routing instruction
+        self.routing_instruction = (
+            "You are a multi-agent AI system responsible for routing and answering diverse user questions.\n"
+            "You have access to the following specialized agents:\n"
+            "- File Parser Agent → handles structured documents like PDFs, DOCXs, CSVs, etc.\n"
+            "- YouTube Transcript Agent → answers questions about YouTube video content.\n"
+            "- Web Search Agent → retrieves general or real-time information using web search.\n"
+            "- Image Agent → analyzes image files and answer visual questions.\n\n"
+            "Your responsibilities:\n"
+            "1. Analyze the user question and any attached file if any.\n"
+            "2. Select and route the task to the most appropriate agent.\n"
+            "3. Return ONLY the final answer from the selected agent.\n"
+            "4. If the file type is image file(png,jpg,jpeg, webp, gif etc..), you must immediately forward the question and the provided image path to the Image Agent. Once you hand off to the Image Agent, that agent will call the image_processing tool to fetch and analyze the image.\n\n"
+            "5. For all other file types(pdf, docx, xlsx, txt, mp3, wav, mov etc..), use the File Parser Agent to extract content and answer the question.\n"
+            "Strict guidelines:\n"
+            "- NEVER reply with filler phrases like 'please wait', 'I will await Agent's response.' or 'awaiting response', wait until the response received from any agent.\n"
+            "- ALWAYS use the most appropriate agent based on the task.\n"
+            "- For ambiguous, encoded, or reversed questions, attempt to interpret and resolve them logically.\n"
+            "- Do NOT skip or ignore input unless it clearly violates safety policies.\n\n"
+            "Answer formatting:\n"
+            "- Final responses must end with: FINAL ANSWER: [your answer].\n"
+            "- The answer must be a clean string, number, or comma-separated list — no currency symbols, percentages, or unnecessary words.\n"
+            "- Do NOT include the phrase 'FINAL ANSWER:' in the output. Return only the final clean answer string.\n\n"
+            "Now analyze and respond to the user question appropriately."
+        )
+    
+    def _setup_tools(self):
+        """Initialize all the tools."""
+        self.file_parser_tool = FunctionTool.from_defaults(parse_file)
+        self.youtube_transcript_tool = FunctionTool.from_defaults(get_youtube_transcript)
+        
+        self.ddg_tool = FunctionTool.from_defaults(
+            fn=duckduckgo_search_and_scrape,
+            name="web_search",
+            description="Performs a DuckDuckGo search and scrapes the top relevant link and fetch the webpage content of the link to answer the question."
+        )
+        
+        self.image_processing_tool = FunctionTool.from_defaults(
+            fn=process_image,
+            name="image_processing",
+            description="Downloads the image at `file_url` and answers `question` based on its visual content."
+        )
+    
+    def _setup_agents(self):
+        """Initialize all the specialized agents."""
+        # File Parsing ReActAgent
+        self.file_agent = ReActAgent(
+            name="file_agent",
+            description="Expert at reading and extracting info from files",
+            system_prompt="""You are a precise file analyst. 
+                                Steps to follow:
+                                1. Check if there's a file URL in the question
+                                2. Use parse_file tool to examine the file
+                                3. For all file types except images, extract content and answer
+                                4. Never attempt to analyze images yourself""",
+            tools=[self.file_parser_tool],
+            llm=self.llm,
+        )
+
+        # YouTube ReActAgent
+        self.youtube_agent = ReActAgent(
+            name="youtube_agent",
+            description="Expert at extracting info from YouTube videos by transcript.",
+            system_prompt="You are a video analyst. For YouTube questions, fetch and summarize or quote the video transcript.",
+            tools=[self.youtube_transcript_tool],
+            llm=self.llm,
+        )
+
+        # DuckDuckGo Web Search ReActAgent
+        self.search_agent = ReActAgent(
+            name="websearch_agent",
+            description="Web search expert. ALWAYS use the web search tool for any question you receive. Do NOT just say you are searching.",
+            system_prompt=(
+                "You are a web researcher. For any question, always use the DuckDuckGo search tool to get an answer. "
+                "Never ask the user to wait. Do not simply state that you are searching. "
+                "Return the answer from the tool as your only reply."
+            ),
+            tools=[self.ddg_tool],
+            llm=self.llm,
+        )
+
+        # Image Agent
+        self.image_agent = ReActAgent(
+            name="image_agent",
+            description="Analyzes images and answers questions using the image_processing tool.",
+            system_prompt=(
+                "You are a vision specialist. For *every* user query involving an image, "
+                "you **must** issue exactly one tool call:\n\n"
+                "```\nAction: image_processing\n"
+                "Action Input: {\"file_url\": <url>, \"question\": <user question>}\n```"
+                "\nThen immediately return *only* the tool's output."
+            ),
+            tools=[self.image_processing_tool],
+            llm=self.llm,
+        )
+    
+    def _setup_workflow(self):
+        """Initialize the agent workflow."""
+        self.agentflow = AgentWorkflow(
+            agents=[self.file_agent, self.youtube_agent, self.search_agent, self.image_agent],
+            root_agent=self.file_agent.name,  # the file_agent will detect image types and delegate to image_agent
+        )
+    
+    def _extract_final_answer(self, response_text: str) -> str:
+        """Extract the final answer from the response, removing 'FINAL ANSWER:' prefix if present."""
+        # Look for FINAL ANSWER: pattern and extract what comes after
+        if "FINAL ANSWER:" in response_text:
+            parts = response_text.split("FINAL ANSWER:", 1)
+            if len(parts) > 1:
+                return parts[1].strip()
+        
+        # If no FINAL ANSWER: pattern found, return the full response stripped
+        return response_text.strip()
+    
+    def __call__(self, question: str, task_id: str = None) -> str:
+        """
+        Main method to process a question and return an answer.
+        This method will be called by the evaluation system.
+        
+        Args:
+            question (str): The question to answer
+            task_id (str, optional): Task ID for file retrieval
+            
+        Returns:
+            str: The answer to the question
+        """
+        try:
+            # Check if there's a file associated with this question
+            # The evaluation system should provide file info in the question or via task_id
+            enhanced_question = question
+            
+            # If task_id is provided, we might need to construct file URL
+            if task_id:
+                # This assumes the evaluation system follows the same pattern
+                file_url = f"{self.api_url}/files/{task_id}"
+                # You might need to adjust this logic based on how files are provided
+                enhanced_question += f"\nFile URL: {file_url}"
+            
+            # Construct the full prompt with routing instructions
+            full_prompt = f"{self.routing_instruction}\n\nUser Question:\n{enhanced_question}"
+            
+            # Run the agent workflow
+            response = asyncio.run(self.agentflow.run(user_msg=full_prompt))
+            
+            # Extract and clean the final answer
+            final_answer = self._extract_final_answer(response.response.blocks[0].text)
+            
+            return final_answer
+            
+        except Exception as e:
+            print(f"Error in BasicAgent.__call__: {e}")
+            return f"Error processing question: {str(e)}"
+
+# ------------------------------
+# 3. Modified answer_questions_batch function (kept for reference)
+# ------------------------------
+async def answer_questions_batch(questions_data):
+    """
+    This function is kept for reference but is no longer used in the main flow.
+    The BasicAgent class now handles individual questions directly.
+    """
+    answers = []
+    agent = BasicAgent()
+    
+    for question_data in questions_data:
+        question = question_data.get("question", "")
+        file_name = question_data.get("file_name", "")
+        task_id = question_data.get("task_id", "")
+        
+        try:
+            # Let the BasicAgent handle the question processing
+            answer = agent(question, task_id)
+            
+            answers.append({
+                "task_id": task_id,
+                "question": question,
+                "submitted_answer": answer
+            })
+            
+        except Exception as e:
+            print(f"Error processing question {task_id}: {e}")
+            answers.append({
+                "task_id": task_id,
+                "question": question,
+                "submitted_answer": f"Error: {str(e)}"
+            })
+        
+        time.sleep(1)  # Rate limiting
+    
+    return answers
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+
+    if profile:
+        username = f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Agent
+    try:
+        agent = BasicAgent()
+        print("BasicAgent instantiated successfully.")
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+    
+    # In the case of an app running as a hugging Face space, this link points toward your codebase
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(agent_code)
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        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(f"Fetched {len(questions_data)} questions.")
+    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
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    
+    for item in questions_data:
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        file_name = item.get("file_name", "")
+        
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            continue
+            
+        try:
+            # Prepare enhanced question with file information if present
+            enhanced_question = question_text
+            if file_name:
+                file_type = Path(file_name).suffix.lower().split("?")[0]
+                file_url = f"{api_url}/files/{task_id}"
+                enhanced_question += f"\nThis question relates to the file at {file_url} (filename: {file_name} and file type: {file_type}). Please analyze its contents using the appropriate tool."
+            
+            # Call the agent
+            submitted_answer = agent(enhanced_question, task_id)
+            
+            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}"})
+
+    if not answers_payload:
+        print("Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
+    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 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_df = pd.DataFrame(results_log)
+        return final_status, results_df
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+    except Exception as e:
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks() as demo:
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        **Instructions:**
+
+        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
+        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
+        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
+
+        ---
+        **Disclaimers:**
+        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
+        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
+        """
+    )
+
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & Submit All Answers")
+
+    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
+
+    print("-"*(60 + len(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)

requirements.txt

@@ -0,0 +1,16 @@
+gradio
+requests
+torch==2.7.0
+wikipedia==1.4.0
+openpyxl==3.1.5
+python-docx==1.1.2
+youtube_transcript_api==1.0.3
+llama-index
+llama-index-tools-duckduckgo==0.3.0
+SpeechRecognition==3.14.3
+pdfplumber==0.11.6
+docx==0.2.4
+llama-index-embeddings-azure-openai==0.3.5 
+llama-index-llms-azure-openai==0.3.2
+beautifulsoup4
+python-dotenv