Video Transcriber MCP π
High-performance video transcription MCP server using whisper.cpp (Rust)

A Model Context Protocol (MCP) server that transcribes videos from 1000+ platforms using whisper.cpp. Built with Rust for maximum performance and efficiency.
π¦ Installation
Homebrew (macOS/Linux) - Recommended
The easiest way to install with all dependencies:
brew install nhatvu148/tap/video-transcriber-mcp
This automatically installs the binary along with required dependencies (cmake, yt-dlp, ffmpeg).
Cargo Install
If you have Rust installed:
cargo install video-transcriber-mcp
Note: You'll need to manually install dependencies: yt-dlp, ffmpeg, cmake
Pre-built Binaries
Download from GitHub Releases:
curl -L https://github.com/nhatvu148/video-transcriber-mcp-rs/releases/latest/download/video-transcriber-mcp-x86_64-apple-darwin.tar.gz | tar xz
sudo mv video-transcriber-mcp /usr/local/bin/
curl -L https://github.com/nhatvu148/video-transcriber-mcp-rs/releases/latest/download/video-transcriber-mcp-aarch64-apple-darwin.tar.gz | tar xz
sudo mv video-transcriber-mcp /usr/local/bin/
curl -L https://github.com/nhatvu148/video-transcriber-mcp-rs/releases/latest/download/video-transcriber-mcp-x86_64-unknown-linux-gnu.tar.gz | tar xz
sudo mv video-transcriber-mcp /usr/local/bin/
Note: You'll need to manually install dependencies: yt-dlp, ffmpeg
Claude Code plugin
Installs the MCP server and a /transcribe skill in one step:
/plugin marketplace add nhatvu148/video-transcriber-mcp-rs
/plugin install video-transcriber@nhatvu148-tools
The plugin registers the MCP server for you, but it does not install the binary β run one of the install commands above first, so video-transcriber-mcp is on your PATH.
π― Why Rust?
This version uses whisper.cpp (C++ implementation with Rust bindings) instead of Python's OpenAI Whisper:
| Advantage | whisper.cpp (Rust) | OpenAI Whisper (Python) |
|---|
| Performance | Native C++ speed | Python interpreter overhead |
| Memory | Lower footprint | Higher memory usage |
| Startup | Instant (<100ms) | Slow (~2-3s model loading) |
| Dependencies | Standalone binary | Requires Python + packages |
| Portability | Single binary | Python environment needed |
Real-world performance depends on your hardware, video length, and chosen model.
β¨ Features
- π High performance transcription using whisper.cpp (C++ with Rust bindings)
- π₯ Download from 1000+ platforms (YouTube, Vimeo, TikTok, Twitter, etc.)
- π Transcribe local video files (mp4, avi, mov, mkv, etc.)
- π€ 100% offline transcription (privacy-first)
- ποΈ 5 model sizes (tiny, base, small, medium, large)
- π 90+ languages supported
- π Multiple output formats (TXT, JSON, Markdown)
- π MCP integration for Claude Code
- π Dual transport - stdio (local) and Streamable HTTP (remote)
- β‘ Native binary - no Python or Node.js required
- πΎ Low memory footprint compared to Python implementations
β‘ Quick Start (Using Taskfile)
The fastest way to get started:
brew install go-task/tap/go-task
task setup
task test:quick
Available Commands:
task setup
task test:quick
task benchmark
task deps:check
task download:base
task help
See Taskfile.yml for all available tasks.
π Transport Modes
The server supports two transport modes:
Stdio Transport (Default)
Standard I/O transport for local CLI usage with Claude Code. This is the default mode.
video-transcriber-mcp
video-transcriber-mcp --transport stdio
Streamable HTTP Transport
HTTP transport for remote access. Allows the MCP server to be accessed over the network.
video-transcriber-mcp --transport http
video-transcriber-mcp --transport http --host 0.0.0.0 --port 3000
Remote MCP Client Configuration:
For HTTP transport, configure your MCP client with the URL:
{
"mcpServers": {
"video-transcriber-mcp": {
"url": "http://localhost:8080/mcp"
}
}
}
Benefits of HTTP Transport:
- No local installation required for clients
- Centralized server deployment
- Automatic updates (server-side)
- Better for team environments
- Compatible with serverless platforms
CLI Options
video-transcriber-mcp --help
Options:
-t, --transport <TRANSPORT> Transport mode [default: stdio] [possible values: stdio, http]
--host <HOST> Host address for HTTP transport [default: 127.0.0.1]
-p, --port <PORT> Port for HTTP transport [default: 8080]
-h, --help Print help
-V, --version Print version
π¦ Manual Build from Source
Prerequisites
- Rust (1.85+ for Rust 2024 edition)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
- yt-dlp (for downloading videos)
brew install yt-dlp
pip install yt-dlp
winget install yt-dlp.yt-dlp
- FFmpeg (for audio processing)
brew install ffmpeg
sudo apt install ffmpeg
sudo dnf install ffmpeg
choco install ffmpeg
- clang/libclang (
whisper-rs-sys uses bindgen to build whisper.cpp, which needs libclang at build time)
sudo apt install libclang-dev
sudo dnf install clang-devel
Build from Source
git clone https://github.com/nhatvu148/video-transcriber-mcp-rs.git
cd video-transcriber-mcp-rs
cargo build --release
Download Whisper Models
bash scripts/download-models.sh base
bash scripts/download-models.sh all
Models are stored in ~/.cache/video-transcriber-mcp/models/
π Quick Start
MCP Server (for Claude Code)
Add to ~/.claude/settings.json:
Option 1: If installed via GitHub Release or cargo install:
{
"mcpServers": {
"video-transcriber-mcp": {
"command": "video-transcriber-mcp",
"args": [],
"env": {
"RUST_LOG": "info"
}
}
}
}
Option 2: If built from source:
{
"mcpServers": {
"video-transcriber-mcp": {
"command": "/absolute/path/to/video-transcriber-mcp-rs/target/release/video-transcriber-mcp",
"args": [],
"env": {
"RUST_LOG": "info"
}
}
}
}
Then use in Claude Code:
Basic transcription (uses base model by default):
Please transcribe this YouTube video: https://www.youtube.com/watch?v=VIDEO_ID
Transcribe with specific model:
Transcribe this video using the large model for best accuracy:
https://www.youtube.com/watch?v=VIDEO_ID
Transcribe local video file:
Transcribe this local video file: /Users/myname/Videos/meeting.mp4
Transcribe in specific language:
Transcribe this Spanish video: https://www.youtube.com/watch?v=VIDEO_ID
(language: es, model: medium)
Based on whisper.cpp vs OpenAI Whisper benchmarks from the community:
Transcription Speed (approximate, varies by hardware):
- whisper.cpp is typically 2-6x faster than Python Whisper
- Faster startup time (no Python interpreter overhead)
- Lower memory footprint (no Python runtime)
Real-world factors that affect performance:
- CPU: More cores = faster processing
- Model size: Tiny is fastest, Large is slowest but most accurate
- Video length: Longer videos take proportionally more time
- Audio complexity: Clear speech transcribes faster than noisy audio
Want to help?
We're collecting real benchmark data! If you run both versions, please share your results:
- Hardware specs (CPU, RAM)
- Video length tested
- Model used
- Time taken for each version
Open an issue with your benchmark results to help improve this section!
ποΈ Model Comparison
| Model | Speed | Accuracy | Memory | Use Case |
|---|
| tiny | β‘β‘β‘β‘β‘ | ββ | ~400 MB | Quick drafts, testing |
| base | β‘β‘β‘β‘ | βββ | ~600 MB | General use (default) |
| small | β‘β‘β‘ | ββββ | ~1.2 GB | Better accuracy |
| medium | β‘β‘ | βββββ | ~2.5 GB | High accuracy |
| large | β‘ | ββββββ | ~4.8 GB | Best accuracy, slowest |
Thanks to yt-dlp, this tool supports 1000+ video platforms including:
- Social Media: YouTube, TikTok, Twitter/X, Facebook, Instagram, Reddit
- Video Hosting: Vimeo, Dailymotion, Twitch
- Educational: Coursera, Udemy, Khan Academy, edX
- News: BBC, CNN, NBC, PBS
- And 1000+ more!
For each video, three files are generated in ~/Downloads/video-transcripts/:
video-id-title.txt # Plain text transcript
video-id-title.json # JSON with metadata and timestamps
video-id-title.md # Markdown with video info
Example Output
# How to Build Fast Software
**Video:** https://www.youtube.com/watch?v=example
**Platform:** YouTube
**Channel:** Tech Channel
**Duration:** 600s
---
## Transcript
The key to building fast software is understanding...
---
*Transcribed using whisper.cpp (Rust) - Model: base*
π§ Configuration
Environment Variables
All environment variables are optional. The transcriber works with none of them set; they unlock authentication, remote inference, AI summaries, and the paid HTTP API.
π‘ The transcript output directory is not an env var β pass output_dir to the transcribe_video tool (defaults to ~/Downloads/video-transcripts). Output files are named <video_id>-<title>.{txt,json,md}.
Remote MCP access (--transport http)
The HTTP transport only answers requests whose Host header is on an
allowlist. It defaults to loopback (localhost, 127.0.0.1, ::1) as
protection against [DNS rebinding][dns-rebinding], which means a deployed
instance rejects its own public hostname with 403 until you name it:
export MCP_ALLOWED_HOSTS=mcp.example.com,mcp.example.com:8080
fly secrets set MCP_ALLOWED_HOSTS=your-app.fly.dev
Leave it unset for local use β the server logs which hosts it accepts at
startup, so a 403 from a remote client is easy to diagnose.
β οΈ This controls reachability, not authorization. Anyone who can reach
the URL can call the tools, including transcribe_video, which spends real
money when remote Whisper / OpenRouter are configured. Put an
authenticating proxy in front of a public deployment.
Downloading (yt-dlp cookies)
Needed only for age-restricted / members-only videos or YouTube's "Sign in to confirm you're not a bot" challenge.
export YT_DLP_COOKIES=/path/to/cookies.txt
export YT_DLP_COOKIES_FROM_BROWSER=chrome
Remote Whisper (offload transcription)
export REMOTE_WHISPER_URL=https://your-worker.example.com/transcribe
π§ͺ Development
Build
cargo build
cargo build --release
cargo test
RUST_LOG=debug cargo run -- --url "https://youtube.com/watch?v=example"
Project Structure
src/
βββ main.rs # CLI + transport selection (stdio / streamable HTTP)
βββ lib.rs # public API for embedders
βββ mcp/ # MCP server: tool definitions and handlers
βββ transcriber/ # the pipeline: yt-dlp β ffmpeg β whisper.cpp
βββ embeddings.rs # passage embeddings, used by `search_transcripts`
βββ utils/ # paths
This crate is only the transcription pipeline and its MCP surface. The product
built on top of it β REST API, accounts, credits, payments, AI summaries and
diagrams β lives in a separate private crate that depends on this one as a
library, so cargo install video-transcriber-mcp gets you a transcription
server rather than somebody else's SaaS backend.
π€ Contributing
Contributions welcome! Please:
- Fork the repository
- Create a feature branch
- Make your changes
- Add tests if applicable
- Submit a pull request
π Acknowledgments
π Comparison with TypeScript Version
I built the original video-transcriber-mcp in TypeScript. Here's why I rewrote it in Rust:
| Aspect | TypeScript Version | Rust Version |
|---|
| Transcription Speed | 5 min for 10-min video | 50s (6x faster) |
| Memory Usage | ~2 GB | ~800 MB (2.5x less) |
| Startup Time | ~2s | <100ms (20x faster) |
| Binary Size | N/A (Node.js runtime) | ~8 MB standalone |
| Dependencies | Node.js, Python, whisper | Just yt-dlp, ffmpeg |
| CPU Usage | High (Python overhead) | Lower (native code) |
The Rust version is production-ready and significantly more efficient!
π Links
License
Licensed under either of
at your option.
Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
dual licensed as above, without any additional terms or conditions.
Built with β€οΈ in Rust for maximum performance
MCP registry ownership token β crates.io strips HTML comments, so this line has to stay visible:
mcp-name: io.github.nhatvu148/video-transcriber-mcp