audio-transcription-mcp
Allows transcribing audio files with speaker diarization through GitHub Copilot CLI.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@audio-transcription-mcptranscribe meeting_recording.mp3 with speaker diarization and summary"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Audio Transcription MCP
MCP (Model Context Protocol) server for audio transcription with speaker diarization. Transcribes MP3/WAV files using Faster-Whisper and pyannote.audio, outputting markdown with speaker labels, timestamps, summaries, and action items.
⨠Features
š¤ Speaker Diarization - Identifies and labels different speakers (Speaker 1, Speaker 2, etc.)
š Markdown Output - Clean, formatted transcripts with timestamps
š³ Docker Ready - CPU and GPU containers for easy deployment
š MCP Protocol - Integrates with GitHub Copilot CLI and other MCP clients
š Offline Capable - Models cached locally after first run
ā” GPU Acceleration - NVIDIA CUDA support for faster processing
Related MCP server: Open Router Audio Transcription MCP
š Requirements
Prerequisites
Python 3.11+ (for local development)
Docker (recommended for deployment)
Hugging Face Account (free, for model access)
NVIDIA GPU + CUDA 12.3 (optional, for GPU acceleration)
Hugging Face Setup (Required)
Create a free account at huggingface.co
Accept model terms:
Generate a token at huggingface.co/settings/tokens
š Quick Start
Option 1: Docker (Recommended)
# Clone the repository
git clone https://github.com/ebmarquez/audio-transcription-mcp.git
cd audio-transcription-mcp
# Create .env file with your HF token
echo "HF_TOKEN=hf_your_token_here" > .env
# Build and run with Docker Compose
cd docker
docker compose up -d
# Container is now running at http://localhost:8080/mcpOption 2: Docker Run (One-Shot)
# CPU version
docker run --rm \
-e HF_TOKEN="hf_your_token" \
-v $(pwd)/input:/input:ro \
-v $(pwd)/output:/output \
-v $(pwd)/models:/root/.cache \
-p 8080:8080 \
audio-transcription-mcp:cpu
# GPU version (NVIDIA)
docker run --rm --gpus all \
-e HF_TOKEN="hf_your_token" \
-v $(pwd)/input:/input:ro \
-v $(pwd)/output:/output \
-v $(pwd)/models:/root/.cache \
-p 8080:8080 \
audio-transcription-mcp:gpuOption 3: Local Development
# Clone and install
git clone https://github.com/ebmarquez/audio-transcription-mcp.git
cd audio-transcription-mcp
pip install -e .
# Set up environment
cp .env.example .env
# Edit .env and add your HF_TOKEN
# Run MCP server
python -m audio_transcription_mcpš§ MCP Client Configuration
GitHub Copilot CLI (Docker Mode)
Add to your mcp.json:
{
"mcpServers": {
"audio-transcription": {
"url": "http://localhost:8080/mcp",
"transport": "streamable-http"
}
}
}GitHub Copilot CLI (Local Mode)
{
"mcpServers": {
"audio-transcription": {
"command": "python",
"args": ["-m", "audio_transcription_mcp"],
"env": {
"HF_TOKEN": "${HF_TOKEN}",
"OUTPUT_DIR": "./transcriptions"
}
}
}
}š ļø MCP Tools
transcribe_audio
Transcribe a single audio file with speaker diarization.
transcribe_audio(
file_path="/input/meeting.mp3",
output_dir="/output",
model_size="large-v3",
include_timestamps=True,
generate_summary=True
)transcribe_directory
Batch transcribe all audio files in a directory.
transcribe_directory(
directory_path="/input",
output_dir="/output",
recursive=False
)get_transcription_status
Check if an audio file has been transcribed.
get_transcription_status(file_path="/input/meeting.mp3")š Output Format
Transcriptions are saved as markdown files:
# Audio Transcription: meeting-recording.mp3
## Metadata
- **Source File**: meeting-recording.mp3
- **Duration**: 45:32
- **Speakers Detected**: 3
- **Transcription Date**: 2026-01-29
- **Model**: faster-whisper large-v3
---
## Transcript
### [00:00:00] **Speaker 1**
Good morning everyone. Let's get started with our weekly sync.
### [00:00:05] **Speaker 2**
Thanks for organizing this. I have a few updates on the project.
...
---
## Summary
[AI-generated summary placeholder]
## Key Points
- Point 1 extracted from conversation
- Point 2 extracted from conversation
## Action Items
- [ ] Action item 1 - Assigned to: Speaker 1
- [ ] Action item 2 - Assigned to: Speaker 2āļø Configuration
Environment Variables
Variable | Description | Default |
| Hugging Face token (required) | - |
| Model size: tiny/base/small/medium/large-v3 |
|
| Transcription language (ISO 639-1) |
|
| Maximum file size in GB |
|
| Input directory for audio files |
|
| Output directory for transcriptions |
|
| Transport mode: stdio/streamable-http |
|
| HTTP port (for streamable-http) |
|
| GPU device ID (-1 for CPU) |
|
Model Size Comparison
Model | Accuracy | Speed | Memory |
| ā | Fastest | ~1GB |
| āā | Fast | ~1GB |
| āāā | Moderate | ~2GB |
| āāāā | Slow | ~5GB |
| āāāāā | Slowest | ~10GB |
š Project Structure
audio-transcription-mcp/
āāā docker/
ā āāā Dockerfile.cpu # CPU container
ā āāā Dockerfile.gpu # GPU container (NVIDIA)
ā āāā docker-compose.yml # Development compose
ā āāā docker-compose.prod.yml # Production compose
ā āāā entrypoint.sh # Container startup
āāā src/
ā āāā audio_transcription_mcp/
ā āāā __init__.py
ā āāā __main__.py # Entry point
ā āāā server.py # MCP server
ā āāā config.py # Configuration
ā āāā audio_processor.py # File handling
ā āāā transcriber.py # Faster-Whisper
ā āāā diarizer.py # pyannote.audio
ā āāā segment_merger.py # Align segments
ā āāā markdown_generator.py
āāā tests/
āāā input/ # Audio files (mount point)
āāā output/ # Transcriptions (mount point)
āāā models/ # Model cache (mount point)
āāā .env.example
āāā pyproject.toml
āāā requirements.txtš³ Docker Volumes
Mount Point | Purpose | Mode |
| Audio files to transcribe | Read-only |
| Transcription results | Read-write |
| Model cache (persistent) | Read-write |
ā ļø Known Limitations
Speaker Diarization: Works best with 2-6 distinct speakers
Audio Quality: May struggle with background noise, overlapping speech, or phone/video call audio
Large Files: Files over 30 minutes may take significant processing time
First Run: Initial model download requires internet connection (~3GB)
š Security
HF_TOKEN: Store securely, never commit to repository
Input Validation: Strict file type and size validation
Path Traversal: All file paths are sanitized
Container Isolation: Runs with minimal privileges
š License
MIT License - see LICENSE for details.
š Acknowledgments
Faster-Whisper - Fast Whisper implementation
pyannote.audio - Speaker diarization
Model Context Protocol - MCP specification MCP server for audio transcription with speaker diarization. Transcribes MP3/WAV files using Faster-Whisper and pyannote.audio, outputs markdown with speaker labels, timestamps, summaries, and action items. Dockerized for easy deployment (CPU/GPU).
This server cannot be deployed
Maintenance
Related MCP Connectors
MCP server for RiverScript, an AI transcription platform - fetches transcripts shared via a link.
MCP server for Speech-to-Text
MCP server for structured access to Lenny Rachitsky podcast transcripts. For content creators.
An MCP server that gives any LLM or agent clean YouTube transcripts on demand: a single video, a whole channel, or a playlist, plus AI cleanup of auto-generated captions. API-key auth, credit-based, same backend as the public v1 API. Get a free API key with 25 free credits at youtubetranscriptdownload.com/account.
Related MCP Servers
- AlicenseAqualityAmaintenanceMCP server for audio transcription using local faster-whisper or OpenAI Whisper API, enabling multilingual transcription with optional GPT post-processing.3MIT
- AlicenseAqualityCmaintenanceMCP server for audio transcription using OpenRouter models, supporting verbatim, cleaned, and custom transcription modes.28 npm1MIT
- FlicenseNot gradedqualityDmaintenanceAn MCP server that provides speech-to-text transcription and speaker diarization using OpenAI Whisper and pyannote.audio.-
- FlicenseNot gradedqualityCmaintenanceMCP server for whisper-based transcription and translation, supporting local stdio and remote HTTP transports with file workflow safety.-