Enhance app.py with Langfuse integration and file handling; update requirements.txt with additional dependencies.

.gitignore

@@ -0,0 +1,120 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# PEP 582; __pypackages__
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE / Editor specific files
+.idea/
+.vscode/
+*.project
+*.pydevproject
+.project
+.settings/
+*.sublime-workspace
+
+# dotenv
+.env
+
+# OS specific files
+.DS_Store
+Thumbs.db

app.py

@@ -3,23 +3,43 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
-
+from graph.graph_builder import graph
+from langfuse.callback import CallbackHandler
+from typing import Optional
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+
+langfuse_secret_key = os.getenv("LANGFUSE_SECRET_KEY")
+langfuse_public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
+
+# Initialize Langfuse CallbackHandler for LangGraph/Langchain (tracing)
+langfuse_handler = CallbackHandler(
+    public_key=langfuse_public_key,
+    secret_key=langfuse_secret_key,
+    host="https://cloud.langfuse.com"
+)
+
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
+""" class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
-    def __call__(self, question: str) -> str:
+    def __call__(self, question: str, file_name: str | None = None) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
+        if file_name:
+            print(f"Agent received file_name: {file_name}")
+        # Qui puoi aggiungere la logica per utilizzare file_name se fornito.
+        # Per ora, lo aggiungiamo alla risposta di default per dimostrazione.
         fixed_answer = "This is a default answer."
+        if file_name:
+            fixed_answer += f" (File to use: {file_name})"
         print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        return fixed_answer """
 
-def run_and_submit_all( profile: gr.OAuthProfile | None):
+def run_and_submit_all( profile: Optional[gr.OAuthProfile]):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
@@ -40,7 +60,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = graph
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -76,13 +96,24 @@ 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")  # Estrai file_name
+
         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)
-            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})
+            if file_name and isinstance(file_name, str) and file_name.strip():
+                messages = HumanMessage(content=question_text + " Path: files/" + file_name)
+            else:
+                messages = HumanMessage(content=question_text)
+            submitted_answer = graph.invoke(input={"messages": messages}, config={"callbacks": [langfuse_handler]})
+            answers_payload.append({
+                "task_id": task_id,
+                "submitted_answer": submitted_answer['messages'][-1].content[-1] 
+                    if isinstance(submitted_answer['messages'][-1].content, list) 
+                    else submitted_answer['messages'][-1].content
+            })
+            results_log.append({"Task ID": task_id, "Question": question_text, "File Name": file_name if file_name and file_name.strip() else "N/A", "Submitted Answer": submitted_answer['messages'][-1].content})
         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}"})
@@ -146,11 +177,9 @@ with gr.Blocks() as demo:
     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).
@@ -193,4 +222,5 @@ if __name__ == "__main__":
     print("-"*(60 + len(" App Starting ")) + "\n")
 
     print("Launching Gradio Interface for Basic Agent Evaluation...")
-    demo.launch(debug=True, share=False)
+    demo.launch(debug=True, share=False)
+    

graph/graph_builder.py

@@ -0,0 +1,23 @@
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langgraph.prebuilt import ToolNode
+from nodes.core import assistant, tools
+from states.state import AgentState
+
+## The graph
+builder = StateGraph(AgentState)
+
+# Define nodes: these do the work
+builder.add_node("assistant", assistant)
+builder.add_node("tools", ToolNode(tools))
+
+# Define edges: these determine how the control flow moves
+builder.add_edge(START, "assistant")
+builder.add_conditional_edges(
+    "assistant",
+    # If the latest message requires a tool, route to tools
+    # Otherwise, provide a direct response
+    tools_condition,
+)
+builder.add_edge("tools", "assistant")
+graph = builder.compile()

graph_builder.py

@@ -0,0 +1,23 @@
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langgraph.prebuilt import ToolNode
+from nodes.core import assistant, tools
+from states.state import AgentState
+
+## The graph
+builder = StateGraph(AgentState)
+
+# Define nodes: these do the work
+builder.add_node("assistant", assistant)
+builder.add_node("tools", ToolNode(tools))
+
+# Define edges: these determine how the control flow moves
+builder.add_edge(START, "assistant")
+builder.add_conditional_edges(
+    "assistant",
+    # If the latest message requires a tool, route to tools
+    # Otherwise, provide a direct response
+    tools_condition,
+)
+builder.add_edge("tools", "assistant")
+graph = builder.compile()

nodes/core.py

@@ -0,0 +1,54 @@
+from states.state import AgentState
+import os
+# Import the load_dotenv function from the dotenv library
+from dotenv import load_dotenv
+from langchain_google_genai import ChatGoogleGenerativeAI
+from tools.multimodal_tools import extract_text, analyze_image_tool, analyze_audio_tool
+from tools.math_tools import add, subtract, multiply, divide
+from tools.search_tools import search_tool, serpapi_search
+from tools.youtube_tools import extract_youtube_transcript
+from langfuse.callback import CallbackHandler
+
+load_dotenv()
+
+# Read your API key from the environment variable or set it manually
+api_key = os.getenv("GEMINI_API_KEY")
+langfuse_secret_key = os.getenv("LANGFUSE_SECRET_KEY")
+langfuse_public_key = os.getenv("LANGFUSE_PUBLIC_KEY")
+
+# Initialize Langfuse CallbackHandler for LangGraph/Langchain (tracing)
+langfuse_handler = CallbackHandler(
+    public_key=langfuse_public_key,
+    secret_key=langfuse_secret_key,
+    host="http://localhost:3000"
+)
+
+chat = ChatGoogleGenerativeAI(
+    model= "gemini-2.5-pro-preview-05-06",
+    temperature=0,
+    max_retries=2,
+    google_api_key=api_key,
+    thinking_budget= 0
+)
+
+tools = [
+    extract_text,
+    analyze_image_tool,
+    analyze_audio_tool,
+    extract_youtube_transcript,
+    add,
+    subtract,
+    multiply,
+    divide,
+    search_tool
+]
+
+chat_with_tools = chat.bind_tools(tools)
+
+def assistant(state: AgentState):
+    sys_msg = "You are a helpful assistant with access to tools. Understand user requests accurately. Use your tools when needed to answer effectively. Strictly follow all user instructions and constraints." \
+    "Pay attention: your output needs to contain only the final answer without any reasoning since it will be strictly evaluated against a dataset which contains only the specific response." \
+    "Your final output needs to be just the string or integer containing the answer, not an array or technical stuff."
+    return {
+        "messages": [chat_with_tools.invoke([sys_msg] + state["messages"])]
+    }

requirements.txt

@@ -1,2 +1,121 @@
-gradio
-requests
+aiofiles==24.1.0
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.7
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.9.0
+asttokens==3.0.0
+async-timeout==4.0.3
+attrs==25.3.0
+backoff==2.2.1
+cachetools==5.5.2
+certifi==2025.4.26
+charset-normalizer==3.4.2
+click==8.2.1
+colorama==0.4.6
+dataclasses-json==0.6.7
+decorator==5.2.1
+defusedxml==0.7.1
+exceptiongroup==1.3.0
+executing==2.2.0
+fastapi==0.115.12
+ffmpy==0.6.0
+filelock==3.18.0
+filetype==1.2.0
+frozenlist==1.6.0
+fsspec==2025.5.1
+google-ai-generativelanguage==0.6.18
+google-api-core==2.25.0
+google-auth==2.40.2
+google-search-results==2.4.2
+googleapis-common-protos==1.70.0
+gradio==5.32.1
+gradio_client==1.10.2
+greenlet==3.2.2
+groovy==0.1.2
+grpcio==1.72.1
+grpcio-status==1.72.1
+h11==0.16.0
+httpcore==1.0.9
+httpx==0.28.1
+httpx-sse==0.4.0
+huggingface-hub==0.32.4
+idna==3.10
+ipython==8.37.0
+jedi==0.19.2
+Jinja2==3.1.6
+jsonpatch==1.33
+jsonpointer==3.0.0
+langchain==0.3.25
+langchain-community==0.3.24
+langchain-core==0.3.63
+langchain-google-genai==2.1.5
+langchain-text-splitters==0.3.8
+langfuse==2.60.7
+langgraph==0.4.8
+langgraph-checkpoint==2.0.26
+langgraph-prebuilt==0.2.2
+langgraph-sdk==0.1.70
+langsmith==0.3.44
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+marshmallow==3.26.1
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+multidict==6.4.4
+mypy_extensions==1.1.0
+numpy==2.2.6
+orjson==3.10.18
+ormsgpack==1.10.0
+packaging==24.2
+pandas==2.2.3
+parso==0.8.4
+pillow==11.2.1
+prompt_toolkit==3.0.51
+propcache==0.3.1
+proto-plus==1.26.1
+protobuf==6.31.1
+pure_eval==0.2.3
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pydantic==2.11.5
+pydantic-settings==2.9.1
+pydantic_core==2.33.2
+pydub==0.25.1
+Pygments==2.19.1
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.0
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+requests==2.32.3
+requests-toolbelt==1.0.0
+rich==14.0.0
+rsa==4.9.1
+ruff==0.11.12
+safehttpx==0.1.6
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+SQLAlchemy==2.0.41
+stack-data==0.6.3
+starlette==0.46.2
+tenacity==9.1.2
+tomlkit==0.13.2
+tqdm==4.67.1
+traitlets==5.14.3
+typer==0.16.0
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.14.0
+tzdata==2025.2
+urllib3==2.4.0
+uvicorn==0.34.3
+wcwidth==0.2.13
+websockets==15.0.1
+wrapt==1.17.2
+xxhash==3.5.0
+yarl==1.20.0
+youtube-transcript-api==1.0.3
+zstandard==0.23.0

states/state.py

@@ -0,0 +1,7 @@
+from typing import TypedDict, Annotated
+from langchain_core.messages import AnyMessage
+from langgraph.graph.message import add_messages
+
+
+class AgentState(TypedDict):
+    messages: Annotated[list[AnyMessage], add_messages]

tools/math_tools.py

@@ -0,0 +1,61 @@
+from langchain_core.tools import tool
+import operator
+
+@tool("add_tool", parse_docstring=True)
+def add(a: float, b: float) -> float:
+    """
+    Adds two numbers.
+    
+    Args:
+        a: The first number.
+        b: The second number.
+    
+    Returns:
+        The sum of a and b.
+    """
+    return operator.add(a, b)
+
+@tool("subtract_tool", parse_docstring=True)
+def subtract(a: float, b: float) -> float:
+    """
+    Subtracts the second number from the first.
+    
+    Args:
+        a: The first number (minuend).
+        b: The second number (subtrahend).
+    
+    Returns:
+        The result of subtracting b from a.
+    """
+    return operator.sub(a, b)
+
+@tool("multiply_tool", parse_docstring=True)
+def multiply(a: float, b: float) -> float:
+    """
+    Multiplies two numbers.
+    
+    Args:
+        a: The first number.
+        b: The second number.
+    
+    Returns:
+        The product of a and b.
+    """
+    return operator.mul(a, b)
+
+@tool("divide_tool", parse_docstring=True)
+def divide(a: float, b: float) -> float:
+    """
+    Divides the first number by the second.
+    
+    Args:
+        a: The numerator.
+        b: The denominator.
+    
+    Returns:
+        The result of dividing a by b.
+               Returns an error message string if division by zero occurs.
+    """
+    if b == 0:
+        return "Error: Cannot divide by zero."
+    return operator.truediv(a, b)

tools/multimodal_tools.py

@@ -0,0 +1,179 @@
+import base64
+import os
+from langchain_core.messages import AnyMessage, SystemMessage, HumanMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.tools import Tool
+from langchain_core.tools import tool
+
+api_key = os.getenv("GEMINI_API_KEY")
+
+# Create LLM class
+vision_llm = ChatGoogleGenerativeAI(
+    model= "gemini-2.5-flash-preview-05-20",
+    temperature=0,
+    max_retries=2,
+    google_api_key=api_key
+)
+
+@tool("extract_text_tool", parse_docstring=True)
+def extract_text(img_path: str) -> str:
+    """
+    Extract text from an image file using a multimodal model.
+
+    Args:
+        img_path: The path to the image file from which to extract text.
+
+    Returns:
+        The extracted text from the image, or an empty string if an error occurs.
+    """
+    all_text = ""
+    try:
+        # Read image and encode as base64
+        with open(img_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+        # Prepare the prompt including the base64 image data
+        message = [
+            HumanMessage(
+                content=[
+                    {
+                        "type": "text",
+                        "text": (
+                            "Extract all the text from this image. "
+                            "Return only the extracted text, no explanations."
+                        ),
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{image_base64}"
+                        },
+                    },
+                ]
+            )
+        ]
+
+        # Call the vision-capable model
+        response = vision_llm.invoke(message)
+
+        # Append extracted text
+        all_text += response.content + "\n\n"
+
+        return all_text.strip()
+    except Exception as e:
+        # A butler should handle errors gracefully
+        error_msg = f"Error extracting text: {str(e)}"
+        print(error_msg)
+        return ""
+    
+@tool("analyze_image_tool", parse_docstring=True)
+def analyze_image_tool(user_query: str, img_path: str) -> str:
+    """
+    Answer the question reasoning on the image.
+
+    Args:
+        user_query: The question to be answered based on the image.
+        img_path: Path to the image file to be analyzed.
+
+    Returns:
+        The answer to the query based on image content, or an empty string if an error occurs.
+    """
+    all_text = ""
+    try:
+        # Read image and encode as base64
+        with open(img_path, "rb") as image_file:
+            image_bytes = image_file.read()
+
+        image_base64 = base64.b64encode(image_bytes).decode("utf-8")
+
+        # Prepare the prompt including the base64 image data
+        message = [
+            HumanMessage(
+                content=[
+                    {
+                        "type": "text",
+                        "text": (
+                            f"User query: {user_query}"
+                        ),
+                    },
+                    {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/png;base64,{image_base64}"
+                        },
+                    },
+                ]
+            )
+        ]
+
+        # Call the vision-capable model
+        response = vision_llm.invoke(message)
+
+        # Append extracted text
+        all_text += response.content + "\n\n"
+
+        return all_text.strip()
+    except Exception as e:
+        # A butler should handle errors gracefully
+        error_msg = f"Error analyzing image: {str(e)}"
+        print(error_msg)
+        return ""
+    
+@tool("analyze_audio_tool", parse_docstring=True)
+def analyze_audio_tool(user_query: str, audio_path: str) -> str:
+    """Answer the question by reasoning on the provided audio file.
+    
+    Args:
+        user_query: The question to be answered based on the audio content.
+        audio_path: Path to the audio file (e.g., .mp3, .wav, .flac, .aac, .ogg).
+    
+    Returns:
+        The answer to the query based on audio content, or an error message/empty string if an error occurs.
+    """
+    try:
+        # Determine MIME type from file extension
+        _filename, file_extension = os.path.splitext(audio_path)
+        file_extension = file_extension.lower()
+
+        supported_formats = {
+            ".mp3": "audio/mp3", ".wav": "audio/wav", ".flac": "audio/flac",
+            ".aac": "audio/aac", ".ogg": "audio/ogg"
+        }
+
+        if file_extension not in supported_formats:
+            return (f"Error: Unsupported audio file format '{file_extension}'. "
+                    f"Supported extensions: {', '.join(supported_formats.keys())}.")
+        mime_type = supported_formats[file_extension]
+
+        # Read audio file and encode as base64
+        with open(audio_path, "rb") as audio_file:
+            audio_bytes = audio_file.read()
+        audio_base64 = base64.b64encode(audio_bytes).decode("utf-8")
+
+        # Prepare the prompt including the base64 audio data
+        message = [ 
+        HumanMessage(
+            content=[
+                {
+                    "type": "text",
+                    "text": f"User query: {user_query}",
+                },
+                {
+                    "type": "audio",
+                    "source_type": "base64",
+                    "mime_type": mime_type,
+                    "data": audio_base64
+                },
+            ]
+        )
+        ]
+
+        # Call the vision-capable model
+        response = vision_llm.invoke(message)
+        return response.content.strip()
+    except Exception as e:
+        error_msg = f"Error analyzing audio: {str(e)}"
+        print(error_msg)
+        return ""

tools/search_tools.py

@@ -0,0 +1,54 @@
+import os
+from langchain.tools import Tool
+from serpapi import GoogleSearch
+from dotenv import load_dotenv
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_core.tools import tool
+
+# Carica le variabili d'ambiente se hai la chiave API in un file .env
+load_dotenv()
+
+SERPAPI_API_KEY = os.getenv("SERPAPI_API_KEY")
+
+search_tool = TavilySearchResults(
+    name="tavily_web_search", # Puoi personalizzare il nome se vuoi
+    description="Esegue una ricerca web avanzata utilizzando Tavily per informazioni aggiornate e complete. Utile per domande complesse o che richiedono dati recenti. Può essere utile fare più ricerche modificando la query per ottenere risultati migliori.", # Descrizione per l'LLM
+    max_results=5
+)
+
+@tool("serpapi_search_tool", parse_docstring=True)
+def serpapi_search(query: str, num_results: int = 5, gl: str = "it", hl: str = "it") -> str:
+    """
+    Esegue una ricerca sul web utilizzando SerpAPI con Google Search e restituisce i risultati formattati.
+    Questo tool ha un costo elevato, pertanto sono da preferire altri tool se disponibili.
+    Richiamare questo tool soltanto in caso gli altri tool non siano stati soddisfacenti.
+    
+    Args:
+        query: La query di ricerca.
+        num_results: Il numero di risultati da restituire.
+        gl: Codice del paese per la geolocalizzazione dei risultati (es. "it" per Italia).
+        hl: Codice della lingua per i risultati della ricerca (es. "it" per Italiano).
+    
+    Returns:
+        Una stringa formattata con i risultati della ricerca o un messaggio di errore.
+    """
+    if not SERPAPI_API_KEY:
+        return "Errore: La variabile d'ambiente SERPAPI_API_KEY non è impostata."
+
+    params = {
+        "engine": "google",
+        "q": query,
+        "api_key": SERPAPI_API_KEY,
+        "num": num_results,
+        "gl": gl,
+        "hl": hl
+    }
+    search = GoogleSearch(params)
+    results = search.get_dict()
+    organic_results = results.get("organic_results", [])
+
+    if not organic_results:
+        return f"Nessun risultato trovato per '{query}'."
+
+    formatted_results = "\n\n".join([f"Title: {res.get('title')}\nLink: {res.get('link')}\nSnippet: {res.get('snippet')}" for res in organic_results])
+    return formatted_results

tools/youtube_tools.py

@@ -0,0 +1,26 @@
+from langchain_core.tools import tool
+from youtube_transcript_api import YouTubeTranscriptApi, NoTranscriptFound, TranscriptsDisabled
+
+@tool("youtube_transcript_extractor", parse_docstring=True)
+def extract_youtube_transcript(youtube_url: str) -> str:
+    """
+    Extracts the transcript from a given YouTube video URL.
+    
+    Args:
+        youtube_url: The URL of the YouTube video.
+    
+    Returns:
+        The transcript as a single string, or an error message if the transcript
+             cannot be found or an error occurs.
+    """
+    try:
+        video_id = youtube_url.split("v=")[1].split("&")[0]
+        transcript_list = YouTubeTranscriptApi.get_transcript(video_id)
+        transcript = " ".join([item['text'] for item in transcript_list])
+        return transcript
+    except NoTranscriptFound:
+        return "Error: No transcript found for this video. It might be disabled or not available in English."
+    except TranscriptsDisabled:
+        return "Error: Transcripts are disabled for this video."
+    except Exception as e:
+        return f"Error extracting transcript: {str(e)}"