What Are the Dependencies for bradautomates/claude-video? Complete Setup Guide

The bradautomates/claude-video repository requires only two external binaries (yt-dlp and ffmpeg) and optionally Groq or OpenAI API keys for transcription, using zero third-party Python packages.

Claude-Video is a pure-standard-library Python skill that orchestrates system-level tools rather than installing Python dependencies. Understanding the dependencies for bradautomates/claude-video is essential before running the tool, as it relies entirely on external binaries for video acquisition, frame extraction, and audio processing. This guide breaks down every requirement with specific file references from the source code.

Core Binary Dependencies

Unlike typical Python projects, Claude-Video contains no requirements.txt or pyproject.toml—it uses only the Python standard library. Instead, you must install two external binaries that the Python scripts invoke via subprocess calls.

yt-dlp for Video Acquisition

The skills/watch/scripts/download.py file wraps yt-dlp (the actively maintained fork of youtube-dl) to handle all video interactions. This binary pulls video streams from hosting platforms, extracts native caption tracks when available, and streams media directly when only audio extraction is required for transcription.

ffmpeg for Frame Processing

Located in skills/watch/scripts/frames.py, the ffmpeg dependency decodes video streams, scales frames to 512px width for consistency, generates thumbnails for deduplication algorithms, and extracts audio tracks for Whisper processing. The frames.py module constructs ffmpeg command-line arguments dynamically based on the --detail parameter you provide.

Optional Cloud Transcription Services

While the tool functions for frame extraction without them, transcription capabilities require external API credentials. The skills/watch/scripts/whisper.py file implements a pure-standard-library HTTP client supporting two backends.

Groq Whisper API (Preferred)

Set GROQ_API_KEY in your environment to use Groq's Whisper implementation. According to the source code at line 29 of whisper.py, this is the preferred backend configured via the GROQ_ENDPOINT constant. It utilizes the whisper-large-v3 model and offers faster processing at lower cost than alternatives.

OpenAI Whisper API (Fallback)

If no Groq key is detected, the logic at line 98 of whisper.py automatically falls back to OpenAI's Whisper API when OPENAI_API_KEY is present. The code checks for Groq credentials first, then attempts OpenAI initialization only if the primary key is missing.

Configuration File Requirements

The application expects persistent configuration in your home directory rather than environment variables alone.

The .env Configuration File

The skills/watch/scripts/config.py module loads runtime settings from ~/.config/watch/.env. This file stores optional API keys and the default WATCH_DETAIL setting. The skills/watch/scripts/setup.py script automatically scaffolds this file at line 60 during first-run verification if it does not exist.

Installing Dependencies by Platform

Install the required binaries using your system package manager before running the skill.

macOS via Homebrew:

brew install yt-dlp ffmpeg

Debian/Ubuntu via apt:

sudo apt-get install yt-dlp ffmpeg

Windows via winget:

winget install yt-dlp ffmpeg

Configuring API Keys

After installing binaries, create your configuration file to enable transcription:

mkdir -p ~/.config/watch
cat > ~/.config/watch/.env <<EOF

# Preferred transcription backend – groq or openai

WATCH_BACKEND=groq

# Groq API key (cheaper & faster) – get at https://console.groq.com/keys

GROQ_API_KEY=your_groq_key_here

# OpenAI API key (fallback) – get at https://platform.openai.com/api-keys

OPENAI_API_KEY=your_openai_key_here
EOF
chmod 600 ~/.config/watch/.env

Verifying Your Setup

Validate your environment by running the pre-flight check script:

python skills/watch/scripts/setup.py

This utility verifies that yt-dlp and ffmpeg are available on your PATH and that the .env file exists in ~/.config/watch/.

Summary

• bradautomates/claude-video uses zero third-party Python packages, relying exclusively on the standard library.
• Required system binaries: yt-dlp (video download/captions) and ffmpeg (frame/audio processing) must be installed and available on PATH.
• Optional cloud services: Groq Whisper API (preferred) or OpenAI Whisper API for audio transcription, configured via ~/.config/watch/.env.
• Entry point: The main orchestration occurs in skills/watch/scripts/watch.py, which coordinates these external tools through subprocess calls.
• Setup automation: The skills/watch/scripts/setup.py script handles initial environment validation and configuration file creation.

Frequently Asked Questions

Do I need to install Python packages for bradautomates/claude-video?

No. The project is built using only Python's standard library modules such as subprocess, pathlib, and urllib. All heavy lifting is delegated to external system binaries (yt-dlp and ffmpeg) that you install separately using your operating system's package manager.

Can I run Claude-Video without API keys?

Yes, but you will not have audio transcription capabilities. The tool can still download videos and extract frames using yt-dlp and ffmpeg without any API configuration, as implemented in skills/watch/scripts/download.py and skills/watch/scripts/frames.py. The Whisper integration is entirely optional.

Which transcription service does the code prefer?

The source code in skills/watch/scripts/whisper.py prioritizes Groq when available, falling back to OpenAI only if Groq credentials are missing. Groq is configured as the primary endpoint because it offers faster processing at lower cost while using the same underlying whisper-large-v3 model.

Where does the application store configuration?

Configuration resides in ~/.config/watch/.env, not in the project directory. The skills/watch/scripts/setup.py utility creates this file automatically during initial setup if it does not exist, and skills/watch/scripts/config.py loads these values at runtime.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}