Initial commit: Add project files and README

README.md

@@ -0,0 +1,78 @@
+# Video MCP Transcription Service
+
+This project provides a video transcription service using Python, Modal, and Hugging Face's Whisper model. It allows users to submit a video URL (e.g., YouTube) or upload a video file, and it returns the transcribed audio text.
+
+## Features
+
+-   Downloads videos from URLs using `yt-dlp`.
+-   Extracts audio and transcribes it using a Modal-deployed Whisper model.
+-   Provides a simple web interface using Gradio for local testing.
+-   The Modal function (`modal_whisper_app.py`) handles the heavy lifting of transcription in a serverless environment.
+
+## Project Structure
+
+-   `app.py`: The main Gradio application for local interaction and calling the Modal function.
+-   `modal_whisper_app.py`: Defines the Modal app and the `transcribe_video_audio` function that runs the Whisper model.
+-   `requirements.txt`: Lists Python dependencies for the local `app.py`.
+
+## Setup
+
+### Prerequisites
+
+-   Python 3.10+
+-   Modal account and CLI installed and configured (`pip install modal-client`, then `modal setup`).
+-   `ffmpeg` installed locally (for `yt-dlp` and `moviepy` to process video/audio).
+    -   On Debian/Ubuntu: `sudo apt update && sudo apt install ffmpeg`
+    -   On macOS (using Homebrew): `brew install ffmpeg`
+
+### Local Setup
+
+1.  **Clone the repository:**
+    ```bash
+    git clone https://github.com/jomasego/video_mcp.git
+    cd video_mcp
+    ```
+
+2.  **Install local dependencies:**
+    ```bash
+    pip install -r requirements.txt
+    ```
+
+3.  **Deploy the Modal function (if not already deployed or if changes were made):**
+    Ensure your Modal CLI is authenticated.
+    ```bash
+    modal deploy modal_whisper_app.py
+    ```
+    This deploys the `transcribe_video_audio` function to Modal. You should see a success message with a deployment URL.
+
+### Running the Local Application
+
+1.  **Start the Gradio app:**
+    ```bash
+    python3 app.py
+    ```
+2.  Open your web browser and go to the URL provided by Gradio (usually `http://127.0.0.1:7860`).
+3.  Enter a video URL or upload a video file to get the transcription.
+
+## Modal Function Details
+
+The `modal_whisper_app.py` script defines a Modal function that:
+-   Uses a custom Docker image with `ffmpeg`, `transformers`, `torch`, `moviepy`, `soundfile`, and `huggingface_hub`.
+-   Takes video bytes as input.
+-   Uses `moviepy` to extract audio from the video.
+-   Uses the Hugging Face `transformers` pipeline with a specified Whisper model (e.g., `openai/whisper-large-v3`) to transcribe the audio.
+-   Requires a Hugging Face token stored as a Modal secret (`HF_TOKEN_SECRET`) if using gated models or for authenticated access.
+
+## Future Work
+
+-   Deploy as an MCP (Multi-Compute Platform) server on Hugging Face Spaces.
+-   Develop a chat interface (e.g., using Claude 3.5 Sonnet) to interact with the transcription service, allowing users to ask questions about the video content based on the transcription.
+
+## Troubleshooting
+
+-   **`ModuleNotFoundError: No module named 'moviepy.editor'` (in Modal logs):**
+    This indicates `moviepy` might not be correctly installed in the Modal image. Ensure `moviepy` is in `pip_install` and/or `run_commands("pip install moviepy")` in `modal_whisper_app.py` and redeploy.
+-   **`yt-dlp` errors or warnings about `ffmpeg`:**
+    Ensure `ffmpeg` is installed on your local system where `app.py` is run, and also within the Modal image (`apt_install("ffmpeg")`).
+-   **Modal authentication errors:**
+    Ensure `modal setup` has been run and your Modal token is active. For Hugging Face Spaces, Modal tokens might need to be set as environment variables/secrets.

app.py

@@ -0,0 +1,237 @@
+import gradio as gr
+import os
+import requests
+import tempfile
+import subprocess
+import re
+import shutil # Added for rmtree
+import modal
+
+def is_youtube_url(url_string: str) -> bool:
+    """Checks if the given string is a YouTube URL."""
+    # More robust regex to find YouTube video ID, accommodating various URL formats
+    # and additional query parameters.
+    youtube_regex = (
+        r'(?:youtube(?:-nocookie)?\.com/(?:[^/\n\s]+/|watch(?:/|\?(?:[^&\n\s]+&)*v=)|embed(?:/|\?(?:[^&\n\s]+&)*feature=oembed)|shorts/|live/)|youtu\.be/)'
+        r'([a-zA-Z0-9_-]{11})' # This captures the 11-character video ID
+    )
+    # We use re.search because the video ID might not be at the start of the query string part of the URL.
+    # re.match only matches at the beginning of the string (or beginning of line in multiline mode).
+    # The regex now directly looks for the 'v=VIDEO_ID' or youtu.be/VIDEO_ID structure.
+    # The first part of the regex matches the domain and common paths, the second part captures the ID.
+    return bool(re.search(youtube_regex, url_string))
+
+def download_video(url_string: str, temp_dir: str) -> str | None:
+    """Downloads video from a URL (YouTube or direct link) to a temporary directory."""
+    if is_youtube_url(url_string):
+        print(f"Attempting to download YouTube video: {url_string}")
+        # Define a fixed output filename pattern within the temp_dir
+        output_filename_template = "downloaded_video.%(ext)s" # yt-dlp replaces %(ext)s
+        output_path_template = os.path.join(temp_dir, output_filename_template)
+
+        cmd = [
+            "yt-dlp",
+            "-f", "bestvideo[ext=mp4]+bestaudio[ext=m4a]/mp4/best", # Prefer mp4 format
+            "--output", output_path_template,
+            url_string
+        ]
+        print(f"Executing yt-dlp command: {' '.join(cmd)}")
+        
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=300, check=False)
+
+            print(f"yt-dlp STDOUT:\n{result.stdout}")
+            print(f"yt-dlp STDERR:\n{result.stderr}")
+
+            if result.returncode == 0:
+                # Find the actual downloaded file based on the template
+                downloaded_file_path = None
+                for item in os.listdir(temp_dir):
+                    if item.startswith("downloaded_video."):
+                        potential_path = os.path.join(temp_dir, item)
+                        if os.path.isfile(potential_path):
+                            downloaded_file_path = potential_path
+                            print(f"YouTube video successfully downloaded to: {downloaded_file_path}")
+                            break
+                if downloaded_file_path:
+                    return downloaded_file_path
+                else:
+                    print(f"yt-dlp seemed to succeed (exit code 0) but the output file 'downloaded_video.*' was not found in {temp_dir}.")
+                    return None
+            else:
+                print(f"yt-dlp failed with return code {result.returncode}.")
+                return None
+        except subprocess.TimeoutExpired:
+            print(f"yt-dlp command timed out after 300 seconds for URL: {url_string}")
+            return None
+        except Exception as e:
+            print(f"An unexpected error occurred during yt-dlp execution for {url_string}: {e}")
+            return None
+
+    elif url_string.startswith(('http://', 'https://')) and url_string.lower().endswith(('.mp4', '.mov', '.avi', '.mkv', '.webm')):
+        print(f"Attempting to download direct video link: {url_string}")
+        try:
+            response = requests.get(url_string, stream=True, timeout=300) # 5 min timeout
+            response.raise_for_status() # Raises HTTPError for bad responses (4XX or 5XX)
+            
+            filename = os.path.basename(url_string) or "downloaded_video_direct.mp4"
+            video_file_path = os.path.join(temp_dir, filename)
+            
+            with open(video_file_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=8192):
+                    f.write(chunk)
+            print(f"Direct video downloaded successfully to: {video_file_path}")
+            return video_file_path
+        except requests.exceptions.RequestException as e:
+            print(f"Error downloading direct video link {url_string}: {e}")
+            return None
+        except Exception as e:
+            print(f"An unexpected error occurred during direct video download for {url_string}: {e}")
+            return None
+    else:
+        print(f"Input '{url_string}' is not a recognized YouTube URL or direct video link for download.")
+        return None
+
+
+def process_video_input(input_string: str) -> str:
+    """
+    Processes the video (from URL or local file path) and returns its transcription status.
+    """
+    if not input_string:
+        return "Error: No video URL or file path provided."
+
+    video_path_to_process = None
+    created_temp_dir = None  # To store path of temp directory if created for download
+
+    try:
+        if input_string.startswith(('http://', 'https://')):
+            print(f"Input is a URL: {input_string}")
+            created_temp_dir = tempfile.mkdtemp()
+            print(f"Created temporary directory for download: {created_temp_dir}")
+            downloaded_path = download_video(input_string, created_temp_dir)
+            
+            if downloaded_path and os.path.exists(downloaded_path):
+                video_path_to_process = downloaded_path
+            else:
+                # Error message is already printed by download_video or this block
+                print(f"Failed to download or locate video from URL: {input_string}")
+                # Cleanup is handled in finally, so just return error
+                return "Error: Failed to download video from URL."
+        
+        elif os.path.exists(input_string):
+            print(f"Input is a local file path: {input_string}")
+            video_path_to_process = input_string
+        else:
+            return f"Error: Input '{input_string}' is not a valid URL or an existing file path."
+
+        if video_path_to_process:
+            print(f"Processing video: {video_path_to_process}")
+            print(f"Video path to process: {video_path_to_process}")
+            try:
+                print("Reading video file into bytes...")
+                with open(video_path_to_process, "rb") as video_file:
+                    video_bytes_content = video_file.read()
+                print(f"Read {len(video_bytes_content)} bytes from video file.")
+
+                # Ensure MODAL_TOKEN_ID and MODAL_TOKEN_SECRET are set as environment variables
+                # in your Hugging Face Space. For local `python app.py` runs, Modal CLI's
+                # authenticated state is usually used.
+                # os.environ["MODAL_TOKEN_ID"] = "your_modal_token_id" # Replace or set in HF Space
+                # os.environ["MODAL_TOKEN_SECRET"] = "your_modal_token_secret" # Replace or set in HF Space
+
+                print("Looking up Modal function 'whisper-transcriber/transcribe_video_audio'...")
+                # The function name should match what was deployed. 
+                # It's typically 'AppName/FunctionName' or just 'FunctionName' if app is default.
+                # Based on your deployment log, app name is 'whisper-transcriber'
+                # and function is 'transcribe_video_audio'
+                try:
+                    f = modal.Function.from_name("whisper-transcriber", "transcribe_video_audio")
+                    print("Modal function looked up successfully.")
+                except modal.Error as e:
+                    print("Modal function 'whisper-transcriber/transcribe_video_audio' not found. Trying with just function name.")
+                    # Fallback or alternative lookup, though the above should be correct for named apps.
+                    # This might be needed if the app name context is implicit.
+                    # For a named app 'whisper-transcriber' and function 'transcribe_video_audio',
+                    # the lookup `modal.Function.lookup("whisper-transcriber", "transcribe_video_audio")` is standard.
+                    # If it was deployed as part of the default app, then just "transcribe_video_audio" might work.
+                    # Given the deployment log, the first lookup should be correct.
+                    return "Error: Could not find the deployed Modal function. Please check deployment status and name."
+
+                print("Calling Modal function for transcription...")
+                # Using .remote() for asynchronous execution, .call() for synchronous
+                # For Gradio, synchronous (.call()) might be simpler to handle the response directly.
+                transcription = f.remote(video_bytes_content) # Use .remote() for Modal function call
+                print(f"Received transcription from Modal: {transcription[:100]}...")
+                return transcription
+            except FileNotFoundError:
+                print(f"Error: Video file not found at {video_path_to_process} before sending to Modal.")
+                return f"Error: Video file disappeared before processing."
+            except modal.Error as e: # Using modal.Error as the base Modal exception
+                print(f"Modal specific error: {e}")
+                return f"Error during Modal operation: {str(e)}"
+            except Exception as e:
+                print(f"An unexpected error occurred while calling Modal: {e}")
+                import traceback
+                traceback.print_exc()
+                return f"Error: Failed to get transcription. {str(e)}"
+        else:
+            # This case should ideally be caught by earlier checks
+            return "Error: No video available to process after input handling."
+            
+    finally:
+        if created_temp_dir and os.path.exists(created_temp_dir):
+            print(f"Cleaning up temporary directory: {created_temp_dir}")
+            try:
+                shutil.rmtree(created_temp_dir)
+                print(f"Successfully removed temporary directory: {created_temp_dir}")
+            except Exception as e:
+                print(f"Error removing temporary directory {created_temp_dir}: {e}")
+
+# Gradio Interface for the API endpoint
+api_interface = gr.Interface(
+    fn=process_video_input,
+    inputs=gr.Textbox(label="Video URL or Local File Path for Transcription", 
+                      placeholder="Enter YouTube URL, direct video URL (.mp4, .mov, etc.), or local file path..."),
+    outputs="text",
+    title="Video Transcription API",
+    description="Provide a video URL or local file path to get its audio transcription status.",
+    allow_flagging="never"
+)
+
+# Gradio Interface for a simple user-facing demo
+def demo_process_video(input_string: str) -> str:
+    """
+    A simple demo function for the Gradio UI.
+    It calls the same backend logic as the API.
+    """
+    print(f"Demo received input: {input_string}")
+    result = process_video_input(input_string) # Call the core logic
+    return result
+
+demo_interface = gr.Interface(
+    fn=demo_process_video,
+    inputs=gr.Textbox(label="Upload Video URL or Local File Path for Demo", 
+                      placeholder="Enter YouTube URL, direct video URL (.mp4, .mov, etc.), or local file path..."),
+    outputs="text",
+    title="Video Transcription Demo",
+    description="Provide a video URL or local file path to see its transcription status.",
+    allow_flagging="never"
+)
+
+# Combine interfaces into a Blocks app
+with gr.Blocks() as app:
+    gr.Markdown("# Contextual Video Data Server")
+    gr.Markdown("This Hugging Face Space acts as a backend for processing video context for AI models.")
+
+    with gr.Tab("API Endpoint (for AI Models)"):
+        gr.Markdown("### Use this endpoint from another application (e.g., another Hugging Face Space).")
+        gr.Markdown("The `process_video_input` function is exposed here.")
+        api_interface.render()
+
+    with gr.Tab("Demo (for Manual Testing)"):
+        gr.Markdown("### Manually test video URLs or paths and observe the response.")
+        demo_interface.render()
+
+# Launch the Gradio application
+if __name__ == "__main__":
+    app.launch(server_name="0.0.0.0")

instructions.txt

@@ -0,0 +1,421 @@
+Understood. It's crucial to handle credentials securely.
+
+**Important Security Note for AI Agents & Public Repositories:**
+
+When providing credentials to an AI agent, especially for code generation that might end up in a public repository (like Hugging Face Spaces), it's vital to *never hardcode them directly into the source code*. This is a major security risk.
+
+Instead, we should always use environment variables. This keeps your sensitive keys out of your code and out of public view. Both Hugging Face Spaces and Modal support setting environment variables.
+
+I will include instructions for SWE-1 on how to use these credentials via environment variables.
+
+---
+
+### Instructions for AI Agent (SWE-1) - "Contextual Video Data Server" (Updated with Credentials Handling)
+
+**Project Name:** Contextual Video Data Server (Your Hugging Face Space)
+
+**Goal:** To build a Gradio application deployed on Hugging Face Spaces that acts as a video processing and data serving backend. It will accept video uploads, transcribe their audio using a Modal-deployed Whisper model, and expose an API endpoint to serve this transcribed text. This server will be consumed by another Hugging Face Space (the "Model's Frontend") which will then interact with the Anthropic API.
+
+**Credentials to be Used (via Environment Variables):**
+
+* **Anthropic API Key:** `YOUR_ANTHROPIC_API_KEY_HERE` (This will be used by the *other* Hugging Face Space, the "Model's Frontend," not directly by this "MCP Tool/Server" Space. However, it's good to keep in mind for future steps).
+* **Modal Token ID:** `ak-MZoZD4vvq8KDMQJolFnix2`
+* **Modal Token Secret:** `as-pVhhGl2cv30MhKUV3sXJKb`
+* **HuggingFace Token:** `YOUR_HUGGINGFACE_TOKEN_HERE` (This is typically for logging into `huggingface_hub` for model downloads/uploads if needed, and also used by the Hugging Face Spaces platform itself for cloning repos etc.)
+
+**High-Level Plan:**
+
+1.  **Gradio App with API Endpoint:** Create a Gradio application that can upload videos and expose a function via an API.
+2.  **Modal Backend for Whisper Transcription:** Develop a Modal application to perform audio extraction and Whisper transcription.
+3.  **Integration:** Connect the Gradio app to the Modal backend.
+
+---
+
+**Detailed Instructions for SWE-1:**
+
+#### Part 1: Gradio Application Setup (The "MCP Tool/Server" Frontend)
+
+**Objective:** Create a basic Gradio application that handles video uploads and defines a function that can be exposed as an API endpoint. This function will initially just return a placeholder string.
+
+**Dependencies:**
+* `gradio`
+* `moviepy`
+* `requests` (added for future integration with Modal)
+
+**Files to Create:**
+* `app.py`
+* `requirements.txt`
+
+**`requirements.txt` content:**
+```
+gradio
+moviepy
+requests
+```
+
+**`app.py` content (initial structure):**
+
+```python
+import gradio as gr
+import os
+import requests
+import tempfile
+
+# Placeholder for the function that will process the video and return transcription.
+# This function will eventually call our Modal backend.
+def process_video_for_api(video_path: str) -> str:
+    """
+    Processes the uploaded video and returns its transcription.
+    This is the function that will be exposed via the Gradio API.
+    """
+    if video_path is None:
+        return "Error: No video file uploaded."
+
+    # In this initial version, we just return a placeholder.
+    # Later, this will call the Modal function.
+    print(f"Received video for processing: {video_path}")
+    return f"Video {os.path.basename(video_path)} received. Transcription pending from Modal."
+
+# Gradio Interface for the API endpoint
+# This interface will primarily be consumed by the "Model's Frontend" Space.
+api_interface = gr.Interface(
+    fn=process_video_for_api,
+    inputs=gr.Video(label="Video File for Transcription"),
+    outputs="text",
+    title="Video Transcription API",
+    description="Upload a video to get its audio transcription for AI context.",
+    allow_flagging="never"
+)
+
+# Gradio Interface for a simple user-facing demo (optional, but good for testing)
+def demo_process_video(video_path: str) -> str:
+    """
+    A simple demo function for the Gradio UI.
+    It calls the same backend logic as the API.
+    """
+    print(f"Demo received video: {video_path}")
+    result = process_video_for_api(video_path) # Call the core logic
+    return result
+
+demo_interface = gr.Interface(
+    fn=demo_process_video,
+    inputs=gr.Video(label="Upload Video for Demo"),
+    outputs="text",
+    title="Video Transcription Demo",
+    description="Upload a video to see its immediate transcription status (from the API).",
+    allow_flagging="never"
+)
+
+# Combine interfaces into a Blocks app for a better user experience in the Space.
+with gr.Blocks() as app:
+    gr.Markdown("# Contextual Video Data Server")
+    gr.Markdown("This Hugging Face Space acts as a backend for processing video context for AI models.")
+
+    with gr.Tab("API Endpoint (for AI Models)"):
+        gr.Markdown("### Use this endpoint from another application (e.g., another Hugging Face Space).")
+        gr.Markdown("The `process_video_for_api` function is exposed here.")
+        api_interface.render()
+
+    with gr.Tab("Demo (for Manual Testing)"):
+        gr.Markdown("### Manually test video uploads and observe the response.")
+        demo_interface.render()
+
+# Launch the Gradio application
+if __name__ == "__main__":
+    app.launch()
+```
+
+**Implementation Instructions:**
+
+1.  **Create Project Folder:** Create a new folder for your Hugging Face Space project (e.g., `video-data-server-space`).
+2.  **Create `requirements.txt`:** Inside this folder, create a file named `requirements.txt` and paste the content provided above.
+3.  **Create `app.py`:** Inside the same folder, create a file named `app.py` and paste the Python code provided above.
+4.  **Local Testing (Optional but Recommended):**
+    * Open your terminal or command prompt.
+    * Navigate to your project folder (`cd video-data-server-space`).
+    * Install dependencies: `pip install -r requirements.txt`
+    * Run the Gradio app: `python app.py`
+    * Open the URL provided by Gradio (usually `http://127.0.0.1:7860`) in your web browser.
+    * Test uploading a video. You should see the placeholder response.
+5.  **Hugging Face Spaces Deployment:**
+    * Create a new Space on Hugging Face.
+    * Choose "Gradio" as the SDK.
+    * Select "Public" or "Private" as per your preference.
+    * Select a hardware configuration (CPU Basic is fine for this initial placeholder).
+    * Upload your `app.py` and `requirements.txt` files to the Space.
+    * **Crucially, set environment variables for your Hugging Face Token (if you intend to use it within the Space for private models or repo access) and the Modal API URL (once it's known).** You do this in the Space settings under "Settings" -> "Repository secrets".
+        * `HF_TOKEN`: `YOUR_HUGGINGFACE_TOKEN_HERE` (Though for this specific app, it's not strictly necessary unless you're accessing private HF models or repos from within the Space).
+        * `MODAL_API_URL`: (Will be set in Part 3 after Modal deployment)
+    * Once deployed, the Space will be accessible. The API endpoint (`process_video_for_api`) will be available via the Space's URL. The exact API path will be shown in the Gradio documentation within the Space.
+
+#### Part 2: Modal Backend for Whisper Transcription
+
+**Objective:** Create a Modal application that can perform audio extraction from a video and transcribe it using OpenAI's Whisper model via the Hugging Face Transformers library. This will be an independent service that your Gradio app calls.
+
+**Dependencies:**
+* `modal-client`
+* `huggingface_hub`
+* `transformers`
+* `accelerate`
+* `soundfile`
+* `ffmpeg-python`
+* `moviepy`
+* `torch` (CPU version is fine for small models, GPU version if using larger models on a GPU-enabled Modal function)
+
+**Files to Create:**
+* `modal_whisper_app.py`
+
+**`modal_whisper_app.py` content:**
+
+```python
+import modal
+import io
+import torch
+from transformers import pipeline
+import moviepy.editor as mp
+import os
+import tempfile
+
+# Modal Stub for our application
+stub = modal.Stub(name="video-whisper-transcriber")
+
+# Define the image for our Modal function
+# We'll use a specific Hugging Face Transformers image or a custom one with dependencies
+whisper_image = (
+    modal.Image.debian_slim()
+    .apt_install("ffmpeg") # ffmpeg is essential for moviepy
+    .pip_install(
+        "transformers",
+        "accelerate",
+        "soundfile",
+        "moviepy",
+        "huggingface_hub",
+        "torch" # install torch for CPU by default
+    )
+    # If you need GPU, specify the CUDA version for torch and use GPU
+    # .pip_install("torch --index-url https://download.pytorch.org/whl/cu121")
+)
+
+@stub.function(
+    image=whisper_image,
+    # Configure resources for the function. For larger Whisper models, you might need a GPU.
+    # For 'tiny.en' or 'base.en', CPU might be sufficient, but GPU will be faster.
+    # gpu="A10G" # Uncomment and adjust if you need GPU (e.g., "A10G", "T4", etc.)
+    timeout=600 # 10 minutes timeout for potentially long videos
+)
+@modal.web_endpoint(method="POST") # Expose this function as a web endpoint
+def transcribe_video_audio(video_bytes: bytes) -> str:
+    """
+    Receives video bytes, extracts audio, and transcribes it using OpenAI Whisper.
+    """
+    if not video_bytes:
+        return "Error: No video bytes provided."
+
+    print("Received video bytes for transcription.")
+
+    # Save the received bytes to a temporary video file
+    with tempfile.NamedTemporaryFile(suffix=".mp4", delete=False) as temp_video_file:
+        temp_video_file.write(video_bytes)
+        temp_video_path = temp_video_file.name
+
+    try:
+        # Load the video and extract audio
+        video = mp.VideoFileClip(temp_video_path)
+        
+        # Save audio to a temporary WAV file
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_audio_file:
+            temp_audio_path = temp_audio_file.name
+            video.audio.write_audiofile(temp_audio_path, logger=None) # logger=None to suppress ffmpeg output
+
+        # Initialize the Whisper ASR pipeline
+        # Using a small, English-only model for faster processing
+        # You can change 'tiny.en' to 'base.en', 'small.en', or 'medium.en' if needed.
+        # Ensure you have enough memory/GPU if using larger models.
+        # Use GPU if available on Modal, otherwise CPU.
+        device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+
+        pipe = pipeline(
+            "automatic-speech-recognition",
+            model="openai/whisper-tiny.en", # Using the cheapest model as requested
+            torch_dtype=torch_dtype,
+            device=device,
+        )
+
+        # Transcribe the audio
+        print(f"Transcribing audio from {temp_audio_path} using Whisper on {device}...")
+        transcription_result = pipe(temp_audio_path, generate_kwargs={"task": "transcribe"})
+        transcribed_text = transcription_result["text"]
+        print("Transcription complete.")
+        
+        return transcribed_text
+
+    except Exception as e:
+        print(f"An error occurred during transcription: {e}")
+        return f"Error during video processing: {e}"
+    finally:
+        # Clean up temporary files
+        if 'temp_video_path' in locals() and os.path.exists(temp_video_path):
+            os.remove(temp_video_path)
+        if 'temp_audio_path' in locals() and os.path.exists(temp_audio_path):
+            os.remove(temp_audio_path)
+
+# You can add local testing code if needed
+@stub.local_entrypoint()
+def main():
+    print("To deploy this Modal application, run `modal deploy modal_whisper_app.py`.")
+    print("Ensure your Modal token is set using `modal token set --token-id <ID> --token-secret <SECRET>`")
+
+```
+
+**Implementation Instructions:**
+
+1.  **Install Modal CLI:** If you haven't already, install the Modal CLI: `pip install modal-client`
+2.  **Authenticate Modal:** Run the following command in your terminal to set your Modal credentials as environment variables for the CLI:
+    ```bash
+    modal token set --token-id ak-MZoZD4vvq8KDMQJolFnix2 --token-secret as-pVhhGl2cv30MhKUV3sXJKb
+    ```
+3.  **Create `modal_whisper_app.py`:** Create a file named `modal_whisper_app.py` and paste the content provided above.
+4.  **Review Dependencies and Resources:**
+    * The code defaults to CPU for `torch` and `whisper-tiny.en`. If you want to use a GPU for faster processing with Modal, uncomment `gpu="A10G"` (or your preferred GPU type) and adjust the `torch` installation line to include CUDA support (e.g., `pip_install("torch --index-url https://download.pytorch.org/whl/cu121")`). Remember to use the cheapest model (`tiny.en`) as requested.
+    * Consider the `timeout` for longer videos.
+5.  **Deploy to Modal:**
+    * Open your terminal or command prompt.
+    * Navigate to the directory where you saved `modal_whisper_app.py`.
+    * Deploy the Modal application: `modal deploy modal_whisper_app.py`
+    * Modal will provide you with a URL for the `transcribe_video_audio` endpoint (e.g., `https://your-workspace-name.modal.run/transcribe_video_audio`). **Keep this URL handy, as you'll need it in the next step.**
+
+#### Part 3: Integration: Connecting Gradio to Modal
+
+**Objective:** Modify the Gradio application (`app.py`) to call the deployed Modal endpoint for video transcription instead of returning a placeholder.
+
+**Dependencies:**
+* `requests` (already added in Part 1)
+
+**Files to Modify:**
+* `app.py`
+* `requirements.txt` (already updated in Part 1)
+
+**`app.py` modification:**
+
+You'll need to replace the placeholder logic in `process_video_for_api` with a call to your Modal endpoint.
+
+```python
+import gradio as gr
+import os
+import requests
+import tempfile
+
+# --- IMPORTANT ---
+# This URL MUST be set as an environment variable in your Hugging Face Space.
+# Name the environment variable MODAL_API_URL.
+# During local testing, you can uncomment and set it here temporarily.
+MODAL_API_URL = os.environ.get("MODAL_API_URL", "YOUR_MODAL_WHISPER_ENDPOINT_URL_HERE")
+# Example if testing locally: MODAL_API_URL = "https://your-workspace-name.modal.run/transcribe_video_audio"
+# --- IMPORTANT ---
+
+def process_video_for_api(video_path: str) -> str:
+    """
+    Processes the uploaded video and returns its transcription by calling the Modal backend.
+    """
+    if MODAL_API_URL == "YOUR_MODAL_WHISPER_ENDPOINT_URL_HERE":
+        return "Error: MODAL_API_URL is not set. Please configure it in your Hugging Face Space secrets."
+
+    if video_path is None:
+        return "Error: No video file uploaded."
+
+    print(f"Received video for processing: {video_path}")
+
+    try:
+        # Gradio provides a temporary path. We need to read the bytes to send to Modal.
+        with open(video_path, "rb") as video_file:
+            video_bytes = video_file.read()
+
+        print(f"Sending video bytes to Modal at {MODAL_API_URL}...")
+        response = requests.post(MODAL_API_URL, data=video_bytes)
+        response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
+
+        transcribed_text = response.text
+        print("Transcription received from Modal.")
+        return transcribed_text
+
+    except requests.exceptions.RequestException as e:
+        print(f"Error calling Modal backend: {e}")
+        return f"Error communicating with transcription service: {e}"
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+        return f"An unexpected error occurred during processing: {e}"
+
+# The rest of your app.py remains the same.
+
+# Gradio Interface for the API endpoint
+api_interface = gr.Interface(
+    fn=process_video_for_api,
+    inputs=gr.Video(label="Video File for Transcription"),
+    outputs="text",
+    title="Video Transcription API",
+    description="Upload a video to get its audio transcription for AI context.",
+    allow_flagging="never"
+)
+
+# Gradio Interface for a simple user-facing demo (optional, but good for testing)
+def demo_process_video(video_path: str) -> str:
+    """
+    A simple demo function for the Gradio UI.
+    It calls the same backend logic as the API.
+    """
+    print(f"Demo received video: {video_path}")
+    result = process_video_for_api(video_path) # Call the core logic
+    return result
+
+demo_interface = gr.Interface(
+    fn=demo_process_video,
+    inputs=gr.Video(label="Upload Video for Demo"),
+    outputs="text",
+    title="Video Transcription Demo",
+    description="Upload a video to see its immediate transcription status (from the API).",
+    allow_flagging="never"
+)
+
+# Combine interfaces into a Blocks app for a better user experience in the Space.
+with gr.Blocks() as app:
+    gr.Markdown("# Contextual Video Data Server")
+    gr.Markdown("This Hugging Face Space acts as a backend for processing video context for AI models.")
+
+    with gr.Tab("API Endpoint (for AI Models)"):
+        gr.Markdown("### Use this endpoint from another application (e.g., another Hugging Face Space).")
+        gr.Markdown("The `process_video_for_api` function is exposed here.")
+        api_interface.render()
+
+    with gr.Tab("Demo (for Manual Testing)"):
+        gr.Markdown("### Manually test video uploads and observe the response.")
+        demo_interface.render()
+
+# Launch the Gradio application
+if __name__ == "__main__":
+    app.launch()
+```
+
+**Implementation Instructions:**
+
+1.  **Update `app.py`:**
+    * Paste the updated `process_video_for_api` function into your `app.py`.
+    * Note the line `MODAL_API_URL = os.environ.get("MODAL_API_URL", "YOUR_MODAL_WHISPER_ENDPOINT_URL_HERE")`. This tells the application to fetch the Modal API URL from an environment variable named `MODAL_API_URL`.
+2.  **Configure Hugging Face Space Secrets:**
+    * Go to your Hugging Face Space settings.
+    * Navigate to "Settings" -> "Repository secrets".
+    * Add a new secret:
+        * **Name:** `MODAL_API_URL`
+        * **Value:** Paste the actual URL you obtained after deploying your `modal_whisper_app.py` (e.g., `https://your-workspace-name.modal.run/transcribe_video_audio`).
+    * (Optional but recommended for general practice) Add `HF_TOKEN` with your Hugging Face token.
+3.  **Redeploy Gradio Space:**
+    * If you're using Git for your Hugging Face Space, commit and push your changes.
+    * If you're using the Hugging Face UI, upload the modified `app.py` to your Space.
+    * The Space will automatically rebuild and redeploy, now using the environment variable.
+4.  **Test the Full Flow:**
+    * Once your Gradio Space is live, go to the "Demo" tab.
+    * Upload a video.
+    * The Gradio app will now send the video to your Modal backend, which will transcribe it, and then the transcription will be returned and displayed in the Gradio UI.
+    * You can also test the API endpoint directly using tools like `curl` or Postman, or by building a small test script, pointing it to your Space's API URL (e.g., `https://your-username-video-data-server.hf.space/run/process_video_for_api`).
+
+This robust setup ensures your credentials are secure and your architecture is well-defined for the hackathon!

modal_whisper_app.py

@@ -0,0 +1,162 @@
+import modal
+import os
+import tempfile
+import io
+
+# Define the Modal image
+whisper_image = (
+    modal.Image.debian_slim(python_version="3.10")
+    .apt_install("ffmpeg")
+    .run_commands("pip install moviepy")  # Force install moviepy
+    .pip_install(
+        "transformers[torch]",
+        "accelerate",
+        "soundfile",
+        "moviepy",  # Essential for audio extraction from video
+        "huggingface_hub",
+        "ffmpeg-python"
+    )
+)
+
+app = modal.App(name="whisper-transcriber") # Changed from modal.Stub to modal.App
+
+# Environment variable for model name, configurable in Modal UI or via .env
+MODEL_NAME = os.environ.get("HF_MODEL_NAME", "openai/whisper-base")
+
+# Hugging Face Token - retrieve from memory and set as Modal Secret
+# IMPORTANT: Create a Modal Secret named 'my-huggingface-secret' with your actual HF_TOKEN.
+# Example: modal secret create my-huggingface-secret HF_TOKEN=your_hf_token_here
+HF_TOKEN_SECRET = modal.Secret.from_name("my-huggingface-secret")
+
+@app.function(
+    image=whisper_image, 
+    secrets=[HF_TOKEN_SECRET],
+    timeout=1200  
+)
+def transcribe_video_audio(video_bytes: bytes) -> str:
+    # Imports moved inside the function to avoid local ModuleNotFoundError during `modal deploy`
+    from moviepy.editor import VideoFileClip
+    import soundfile as sf
+    import torch
+    from transformers import pipeline
+    from huggingface_hub import login
+
+    if not video_bytes:
+        return "Error: No video data received."
+
+    # Login to Hugging Face Hub using the token from Modal secrets
+    hf_token = os.environ.get("HF_TOKEN")
+    if hf_token:
+        try:
+            login(token=hf_token)
+            print("Successfully logged into Hugging Face Hub.")
+        except Exception as e:
+            print(f"Hugging Face Hub login failed: {e}. Proceeding, but private models may not be accessible.")
+    else:
+        print("HF_TOKEN secret not found. Proceeding without login (works for public models).")
+
+    print(f"Processing video for transcription using model: {MODEL_NAME}")
+    
+    # Initialize pipeline inside the function.
+    # For production/frequent use, consider @stub.cls to load the model once per container lifecycle.
+    print("Loading Whisper model...")
+    device_map = "cuda:0" if torch.cuda.is_available() else "cpu"
+    # Use float16 for GPU for faster inference and less memory, float32 for CPU
+    torch_dtype = torch.float16 if torch.cuda.is_available() else torch.float32
+    
+    transcriber = pipeline(
+        "automatic-speech-recognition",
+        model=MODEL_NAME,
+        torch_dtype=torch_dtype,
+        device=device_map,
+    )
+    print(f"Whisper model loaded on device: {device_map} with dtype: {torch_dtype}")
+
+    video_path = None
+    audio_path = None
+
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as tmp_video_file:
+            tmp_video_file.write(video_bytes)
+            video_path = tmp_video_file.name
+        print(f"Temporary video file saved: {video_path}")
+
+        print("Extracting audio from video...")
+        video_clip = VideoFileClip(video_path)
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".wav") as tmp_audio_file:
+            audio_path = tmp_audio_file.name
+        video_clip.audio.write_audiofile(audio_path, codec='pcm_s16le', logger=None) 
+        video_clip.close()
+        print(f"Audio extracted to: {audio_path}")
+
+        audio_input, samplerate = sf.read(audio_path)
+        if audio_input.ndim > 1:
+            audio_input = audio_input.mean(axis=1) # Convert to mono
+        
+        print(f"Audio data shape: {audio_input.shape}, Samplerate: {samplerate}")
+        print("Starting transcription...")
+        # Pass audio as a dictionary for more control, or directly as numpy array
+        # Adding chunk_length_s for handling long audio files better.
+        result = transcriber(audio_input.copy(), chunk_length_s=30, batch_size=8, return_timestamps=False)
+        transcribed_text = result["text"]
+        
+        print(f"Transcription successful. Length: {len(transcribed_text)}")
+        if len(transcribed_text) > 100:
+            print(f"Transcription preview: {transcribed_text[:100]}...")
+        else:
+            print(f"Transcription: {transcribed_text}")
+            
+        return transcribed_text
+
+    except Exception as e:
+        print(f"Error during transcription process: {e}")
+        import traceback
+        traceback.print_exc() 
+        return f"Error: Transcription failed. Details: {str(e)}"
+    finally:
+        for p in [video_path, audio_path]:
+            if p and os.path.exists(p):
+                try:
+                    os.remove(p)
+                    print(f"Removed temporary file: {p}")
+                except Exception as e_rm:
+                    print(f"Error removing temporary file {p}: {e_rm}")
+
+# This is a local entrypoint for testing the Modal function if you run `modal run modal_whisper_app.py`
+@app.local_entrypoint()
+def main():
+    # This is just an example of how you might test. 
+    # You'd need a sample video file (e.g., "sample.mp4") in the same directory.
+    # For actual deployment, this main function isn't strictly necessary as Gradio will call the webhook.
+    sample_video_path = "sample.mp4" 
+    if not os.path.exists(sample_video_path):
+        print(f"Sample video {sample_video_path} not found. Skipping local test run.")
+        return
+
+    with open(sample_video_path, "rb") as f:
+        video_bytes_content = f.read()
+    
+    print(f"Testing transcription with {sample_video_path}...")
+    transcription = transcribe_video_audio.remote(video_bytes_content)
+    print("----")
+    print(f"Transcription Result: {transcription}")
+    print("----")
+
+# To call this function from another Python script (after deployment):
+# import modal
+# Ensure the app name matches the one in modal.App(name=...)
+# The exact lookup method might vary slightly with modal.App, often it's:
+# deployed_app = modal.App.lookup("whisper-transcriber") 
+# or by accessing the function directly if the app is deployed with a name.
+# For a deployed function, you might use its tag or webhook URL directly.
+# Example using a direct function call if deployed and accessible:
+# f = modal.Function.lookup("whisper-transcriber/transcribe_video_audio") # Or similar based on deployment output
+# For invoking: 
+# result = f.remote(your_video_bytes) # for async
+# print(result)
+# Or, if you have the app object:
+# result = app.functions.transcribe_video_audio.remote(your_video_bytes)
+# Consult Modal documentation for the precise invocation method for your Modal version and deployment style.
+
+# Note: When deploying to Modal, Modal uses the `app.serve()` or `app.deploy()` mechanism.
+# The Gradio app will call the deployed Modal function via its HTTP endpoint.

requirements.txt

@@ -0,0 +1,5 @@
+gradio
+moviepy
+requests
+yt-dlp
+modal