audio-transcription-mcp
Provides real-time audio transcription using OpenAI's Whisper API, enabling AI agents to capture and transcribe system audio for meetings, videos, and more.
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-mcpStart transcribing my meeting audio"
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 Server
Real-time audio transcription using OpenAI Whisper. Capture and transcribe system audio (meetings, videos, music) automatically with AI assistance through Cursor or Claude Desktop.
β¨ Features
π€ Real-time transcription - Captures and transcribes audio as it plays
π Zero installation - Use with
npx, no global install neededπ€ AI-powered - Uses OpenAI's Whisper API for accurate transcription
π Timestamped transcripts - Every entry is timestamped in markdown format
π Session isolation - Each session gets its own unique transcript file
β‘ Smart silence detection - Automatically pauses when no audio detected
π― Automated setup - One command sets up audio routing
π§ͺ Built-in testing - Verify your setup before starting
Related MCP server: livechat-mcp
π Quick Start (5 Minutes)
Step 1: Run Automated Setup
The setup script installs everything you need and guides you through configuration:
npx audio-transcription-mcp setupWhat this does:
β Installs Homebrew (if needed)
β Installs ffmpeg for audio processing
β Installs BlackHole virtual audio driver
β Guides you through creating a Multi-Output Device (or does it automatically!)
β Takes 5 minutes, mostly automated
First time? The script will walk you through everything with clear instructions. Don't worry if it asks for your Mac password - that's normal for installing software!
Step 2: Test Your Setup
Verify everything works before using it:
npx audio-transcription-mcp testThis captures 5 seconds of audio and shows you if it's working correctly.
Step 3: Configure Your AI Assistant
Add to your Cursor or Claude Desktop config:
Edit ~/.cursor/config.json:
{
"mcpServers": {
"audio-transcription": {
"command": "npx",
"args": ["-y", "audio-transcription-mcp"],
"env": {
"OPENAI_API_KEY": "sk-your-key-here",
"INPUT_DEVICE_NAME": "BlackHole"
}
}
}
}Then restart Cursor and ask:
"Start transcribing audio"
Edit ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"audio-transcription": {
"command": "npx",
"args": ["-y", "audio-transcription-mcp"],
"env": {
"OPENAI_API_KEY": "sk-your-key-here",
"INPUT_DEVICE_NAME": "BlackHole",
"OUTFILE_DIR": "/Users/yourname/Documents/Transcripts"
},
"allowedDirectories": [
"/Users/yourname/Documents/Transcripts"
]
}
}
}Important:
Create the directory:
mkdir -p ~/Documents/TranscriptsReplace
yournamewith your actual usernameRestart Claude Desktop
Then ask:
"Start transcribing audio"
Step 4: Set System Output
Go to System Settings > Sound > Output and select "Multi-Output Device"
This routes audio to both your speakers (so you can hear) and BlackHole (for transcription).
Step 5: Start Transcribing!
In Cursor or Claude Desktop, just ask:
"Start transcribing audio"
Your AI assistant will start capturing and transcribing audio in real-time!
π What You Need
macOS 10.15+ (Catalina or later)
OpenAI API key - Get one here (pay-as-you-go, ~$0.36/hour - see detailed costs)
5 minutes for setup
π― Use Cases
Meeting transcription - Zoom, Google Meet, Teams calls
Content creation - Transcribe videos, podcasts, or music
Accessibility - Real-time captions for any audio
Note-taking - Automatic transcripts of lectures or presentations
Research - Transcribe interviews or focus groups
π§ Troubleshooting
Audio Not Being Captured
Problem: Test shows silent or very low audio levels
Solution:
Check System Settings > Sound > Output is set to "Multi-Output Device"
Open Audio MIDI Setup and verify both outputs are checked:
β Built-in Output
β BlackHole 2ch
Play some audio and run
npx audio-transcription-mcp testagain
BlackHole Not Showing Up
Problem: BlackHole doesn't appear in device list
Solution: Restart your Mac. Audio drivers require a restart to be recognized by the system.
Setup Script Fails
Problem: Automated setup doesn't work
Solution: The script will fall back to manual mode with clear instructions. This is normal on first run if accessibility permissions aren't granted. Just follow the 4-step guide shown.
Want to Start Over?
If you need to remove everything and start fresh:
# Uninstall BlackHole and ffmpeg
brew uninstall blackhole-2ch ffmpeg
# Delete Multi-Output Device
# 1. Open Audio MIDI Setup
# 2. Select "Multi-Output Device" in left sidebar
# 3. Press Delete key
# Then run setup again
npx audio-transcription-mcp setupNeed More Help?
π Detailed Setup Guide
π Report an Issue
π¬ Discussions
π Additional Documentation
π οΈ Advanced Usage
Standalone CLI Mode
You can use this as a standalone CLI without MCP:
# Start transcription (saves to meeting_transcript.md)
npx audio-transcription-mcp start
# Press Ctrl+C to stopConfigure via .env file:
OPENAI_API_KEY=sk-your-key-here
INPUT_DEVICE_NAME=BlackHole
CHUNK_SECONDS=8
OUTFILE=meeting_transcript.mdMCP Server Tools
When used with Cursor or Claude Desktop, these tools are available:
start_transcription- Start capturing and transcribing audiopause_transcription- Pause transcription temporarilyresume_transcription- Resume after pausestop_transcription- Stop and get session statsget_status- Check if transcription is runningget_transcript- Retrieve current transcript contentclear_transcript- Clear and start freshcleanup_transcript- Delete transcript file
Configuration Options
Environment variables you can customize:
Variable | Default | Description |
| (required) | Your OpenAI API key |
|
| Audio input device name |
|
| Seconds of audio per chunk |
|
| OpenAI Whisper model |
|
| Output directory for transcripts |
|
| Audio sample rate (Hz) |
|
| Number of audio channels |
ποΈ How It Works
Audio Routing: Multi-Output Device sends system audio to both your speakers and BlackHole
Capture: ffmpeg captures audio from BlackHole in 8-second chunks
Processing: Audio is converted to WAV format suitable for Whisper API
Transcription: Each chunk is sent to OpenAI Whisper for transcription
Output: Timestamped text is appended to a markdown file in real-time
Silence Detection: Automatically pauses after 32 seconds of silence to save API costs
π° Costs & Performance
What You're Paying For
You ONLY pay for OpenAI Whisper API calls - everything else runs locally for free!
β FREE (runs locally on your machine):
Audio capture with ffmpeg
Audio processing and buffer management
Silence detection and level analysis
File operations (writing/reading transcripts)
All MCP server operations
π° PAID (OpenAI API):
Only the transcription API calls to OpenAI Whisper
$0.006 per minute of audio transcribed
Silent chunks are automatically skipped to save money
Actual Costs
With default 8-second chunks:
Duration | API Calls | Approximate Cost |
1 minute | ~7.5 chunks | $0.006 |
1 hour | ~450 chunks | $0.36 |
8-hour workday | ~3,600 chunks | $2.88 |
Cost per chunk: ~$0.0008 (less than a tenth of a cent!)
Built-in Cost Savings
The tool includes smart silence detection that saves you money:
π Silent audio chunks are NEVER sent to OpenAI
π° Automatically tracks cost savings in the debug log
βΈοΈ Auto-pauses after 32 seconds of silence
π View statistics with
get_statusto see chunks skipped
Example: In a 1-hour meeting with 15 minutes of silence, you save ~$0.09 automatically!
Performance
Memory usage: 50-100 MB per session
CPU usage: Minimal (ffmpeg handles audio processing)
API latency: 1-3 seconds per chunk
Accuracy: 90-95% for clear speech
Network: Only during transcription API calls
Cost Optimization Tips
Increase chunk size - Fewer API calls (set
CHUNK_SECONDS=15)Use silence detection - Enabled by default, saves money automatically
Pause when not needed - Use
pause_transcriptionduring breaksMonitor usage - Check OpenAI dashboard for actual costs
Bottom line: Transcription is cheap (~36Β’/hour), runs mostly locally, and automatically saves money by skipping silence. You're only charged when actual speech is being transcribed.
π§ͺ Development & Testing
For contributors and developers:
π See MCP_SETUP.md for complete setup instructions
Just add to your config and restart - that's it!
See the npx configuration at the top of this README for Cursor and Claude Desktop.
For Standalone CLI (Local Development)
π See GETTING_STARTED.md for complete setup instructions
# Install dependencies
npm install
npm run build
# Configure environment
cp env.example .env # Then add your OpenAI API key
# Run standalone CLI
npm startπ License & Contributing
This project is licensed under the MIT License - see the LICENSE file for details.
Contributions are welcome! Please feel free to submit a Pull Request.
Development Resources
π MCP Setup Guide
π§ Installation Guide
Made with β€οΈ for transcribing meetings, content, and conversations.
Star β this repo if you find it useful!
Available Tools
8 toolscleanup_transcriptA
Delete the transcript file completely. Use this to remove the transcript file when you're done.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of revealing destructive behavior. It states 'Delete the transcript file completely,' implying irreversibility. However, it doesn't mention any additional behavioral details like permissions, side effects on active transcription, or what happens to the file handle.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, with the action front-loaded. Every word is functional; no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless deletion tool, the description is largely complete: it states the action, the object, and when to use it. The only notable gap is not addressing the potential confusion with clear_transcript, but given the explicit 'completely' and 'delete,' it may be sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the input schema provides no information. The description adds value by clarifying that the operation is a complete deletion rather than a reset, making the semantics clear. Baseline for 0 params is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Delete' with the resource 'transcript file' and adds 'completely' to indicate permanence. It clearly states the action, though it doesn't explicitly distinguish from the sibling clear_transcript.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear usage context ('when you're done'), but it doesn't explicitly contrast this with clear_transcript or mention scenarios where this should not be used (e.g., if you only need to clear content without deleting the file).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
clear_transcriptA
Clear the transcript file and reinitialize it with a fresh header.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses a destructive action (clearing the file) and the reinitialization behavior, adding value beyond the tool name. It could be more explicit about irreversibility, but the intent is clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one sentence, front-loaded with the verb, and includes no fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless tool with no annotations, the description sufficiently explains what happens and the resulting state. It is complete for the tool's simple functionality.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters, so the description need not explain them. The baseline 4 applies, and the description does not detract from this.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Clear' and resource 'transcript file', and adds detail about reinitializing with a fresh header, which distinguishes it from siblings like cleanup_transcript.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for resetting the transcript file but does not explicitly compare with alternatives like cleanup_transcript. It provides clear context (to clear and reinitialize) without exclusions or when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_statusA
Get the current status of the transcription session including whether it's running, number of chunks processed, errors, and session duration. CRITICAL: AI assistants should check this regularly (every 30-60 seconds) during active transcription to: 1) Catch audio routing issues or silence detection, 2) Monitor session duration and alert user if running 30+ minutes (prevents forgotten recordings and excessive API costs), 3) Detect paused states and warnings. The status.warning field will contain important alerts that should be shown to the user immediately.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full behavioral burden. It discloses the tool's purpose as a monitoring/read operation, explains the frequency of use, and details the status.warning field's importance. It does not contradict any annotations (none provided) and provides rich context beyond the basic tool name.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with the core purpose and includes a clearly structured critical usage section with numbered points. Each sentence adds value, but the CRITICAL section is somewhat lengthy for a no-parameter status tool. Still, it is well-organized and not wasteful.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite having no parameters, annotations, or output schema, the description is complete enough to use the tool correctly. It explains what data will be returned, how often to poll, and what actions to take based on the status. The sibling tool names provide further context on its role in the transcription workflow.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so schema coverage is 100% by default. The baseline for 0 params is 4. The description does not add parameter-specific details (none needed), but it does describe the output fields (running, chunks, errors, duration), which is relevant context even though not strictly about parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets the current status of a transcription session, listing specific components (running state, chunks processed, errors, duration). This specific verb+resource combination distinguishes it from sibling lifecycle tools like start, pause, and stop.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit when-to-use guidance: check every 30-60 seconds during active transcription, with concrete scenarios like catching audio routing issues, monitoring long sessions, and detecting paused states. It also instructs on what to do (show alerts to user), which is actionable and clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_transcriptA
Retrieve the current transcript content. Optionally get only the last N lines.
| Name | Required | Description | Default |
|---|---|---|---|
| lines | No | Optional: Return only the last N lines |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden. It does disclose the default behavior (full content) and optional behavior (last N lines), but it does not state explicitly that the operation is read-only/non-destructive, what happens when no transcript exists, or whether the transcript is available before/during/after transcription.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that front-loads the core purpose and adds the optional parameter. Every word earns its place, with no redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple getter with one optional parameter, the description is adequate but has gaps: it does not describe the return format (e.g., string, array of lines), behavior on empty transcript, or prerequisites (e.g., must be after start_transcription). The lack of an output schema increases the need for such detail.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the 'lines' parameter already described as 'Optional: Return only the last N lines'. The description essentially repeats this without adding constraints (e.g., positive integer, maximum value) or clarifying whether it's inclusive/exclusive.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Retrieve the current transcript content' uses a specific verb ('retrieve') and resource ('transcript'), clearly distinguishing it from sibling tools like start_transcription, clear_transcript, or get_status. The optional lines parameter adds a clear secondary behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage as a getter but provides no explicit guidance on when to use it versus alternatives, such as referencing get_status for status or noting whether an active transcription session is required. There are no exclusions or alternative tool names mentioned.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pause_transcriptionA
Pause the current transcription session. Audio capture continues but transcription is paused. Use resume_transcription to continue.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses the key behavioral nuance that audio capture continues while transcription pauses, which is essential for understanding the tool's effect. It lacks details about prerequisites or return values, but the core behavior is transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences with no wasted words. The first sentence states the action, the second clarifies a critical nuance and points to the next step. Very efficient and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with no parameters and no output schema, the description covers the essential context: what it does, how it behaves, and what to do next. It could mention prerequisites (e.g., an active session), but the sibling list and clarity make this adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema already provides complete information. The description adds no parameter-specific details, but none are needed. Baseline of 4 applies due to absence of parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Pause the current transcription session') and distinguishes it from related tools by noting that audio capture continues. It also directly references resume_transcription as the counterpart, effectively differentiating it from siblings.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to use resume_transcription to continue, providing clear guidance on the follow-up action. It implies when to use this tool (when you want to temporarily pause transcription but keep audio capture), though it does not explicitly contrast with stop or other alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
resume_transcriptionA
Resume transcription after it has been paused (either manually or due to silence detection).
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It explains the cause of the pause (manual or silence) and the action (resume), but it does not mention what happens if called when not paused, whether it returns any confirmation, or any side effects. This is minimal but acceptable for a simple tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise sentence that front-loads the main action and condition. Every word contributes to understanding, with no fluff or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters, no output schema), the description is complete enough to convey when and what. It could mention the behavior if invoked without a paused state, but that is an edge case; the core context is well covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the description does not need to explain parameter semantics. The baseline for 0 params is 4, and the description adds no unnecessary details.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the tool's purpose: resuming transcription after a pause. It specifies the action with a verb ('resume') and resource ('transcription'), and the phrase 'after it has been paused' distinguishes it from starting a new session (start_transcription) or pausing (pause_transcription).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description tells when to use the tool: when transcription has been paused, either manually or due to silence detection. It does not explicitly list exclusions or alternatives, but the 'after it has been paused' condition is clear enough to guide selection among siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
start_transcriptionA
Start capturing and transcribing system audio in real-time using OpenAI Whisper. Audio is captured in chunks and transcribed continuously. IMPORTANT: After starting, periodically check get_status (every 30-60 seconds) to monitor for issues. SAFETY FEATURES: The system will auto-pause in two scenarios: 1) After 32 seconds of silence, 2) After 30 minutes of NO user interaction (prevents forgotten recordings). User interaction = calling get_status, pause_transcription, resume_transcription, get_transcript, or clear_transcript. When paused, you'll see isPaused: true in status. User must explicitly call resume_transcription to continue.
| Name | Required | Description | Default |
|---|---|---|---|
| outputFile | No | Output transcript filename (default: auto-generated timestamped filename for privacy/isolation) | |
| inputDevice | No | Audio input device name (default: BlackHole) | |
| chunkSeconds | No | Seconds of audio per transcription chunk (default: 8) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full behavioral burden and excels. It discloses real-time chunked transcription, auto-pause conditions (32s silence, 30 min no interaction), defines which actions count as interaction, and instructs on detecting pause via isPaused: true and resuming. This gives the agent critical operational knowledge beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is moderately long but well-structured with 'IMPORTANT' and 'SAFETY FEATURES' sections. Every sentence provides actionable information, though it could be tightened without losing meaning. It's not overly verbose for the complexity it covers.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity (long-running live transcription) and lack of output schema, the description is largely complete: it covers monitoring, safety, and follow-up actions. However, it omits explicit instruction on how to fully end the session (e.g., using stop_transcription), which is only inferable from sibling tool names.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The tool description does not add any new parameter semantics; it omits mention of outputFile, inputDevice, or chunkSeconds. However, the schema's own descriptions are complete, so no compensation is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Start capturing and transcribing system audio in real-time using OpenAI Whisper.' It specifies the verb (start), resource (system audio), and method (OpenAI Whisper), and distinguishes it from sibling tools like pause_transcription and stop_transcription by positioning it as the entry point for the transcription workflow.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage as the initial step in a transcription session but does not explicitly contrast it with alternatives. It provides clear post-start guidance ('periodically check get_status every 30-60 seconds') and explains safety features, but it does not state when to use this tool vs. stopping or cleaning up, leaving that to inference from sibling tool names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
stop_transcriptionA
Stop the current transcription session completely and return statistics. This ends the session and stops audio capture.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It states that the tool ends the session, stops audio capture, and returns statistics, which are important side effects. It does not mention data retention/clearance or error behavior, but the core state-changing behavior is transparently described.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the main action, and no filler or redundant information. Every clause adds meaning: the action, completeness, return value, and side effect on audio capture.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (no params, no output schema), and the description sufficiently covers the purpose and side effects for invocation. It could mention what the returned statistics include, but this is not essential for selecting and calling the tool correctly, especially given the clear sibling context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters and the schema description coverage is 100%, so there are no parameter semantics to clarify. Baseline for zero-parameter tools is 4, and the description correctly focuses on behavior rather than parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Stop') and clearly identifies the resource ('the current transcription session'), while adding key scope ('completely' and 'return statistics'). It differentiates itself from sibling tools like pause_transcription by emphasizing that this is a full termination, not a temporary pause.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool: when you want to end the session entirely rather than pause it. However, it does not explicitly mention alternatives or state when not to use it. The context is clear enough for an agent to distinguish from pause/resume, but explicit exclusion of alternatives is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
8 tool updates
v0.7.1- First observed
cleanup_transcript - First observed
clear_transcript - First observed
get_status - First observed
get_transcript - First observed
pause_transcription - First observed
resume_transcription - First observed
start_transcription - First observed
stop_transcription
TDQS
Scored across 8 tools
Each tool targets a distinct action in the transcription lifecycle: start, pause, resume, stop, status check, transcript retrieval, clearing, and deleting. No two tools overlap in purpose, even pause vs. stop and clear vs. cleanup are clearly differentiated by their descriptions.
All tool names follow a consistent verb_noun pattern using snake_case: start_transcription, pause_transcription, get_status, etc. The naming is uniform and predictable, making it easy to infer the function of each tool.
With 8 tools, the set is well-scoped for an audio transcription server. Each tool covers a necessary part of the session lifecycle without redundancy or bloat, fitting comfortably within the ideal range.
The tool set provides full lifecycle coverage: start, manage (pause/resume), monitor (status), retrieve output, and clean up (clear/delete). There are no obvious dead ends or missing operations for the stated purpose.
Maintenance
Related MCP Connectors
Screen recording, meeting notes, and voice dictation - all with AI
Transcribe audio & video to text for AI agents: 100+ languages, speaker labels, webhooks.
- mcpOAuthso.transcribe
Transcribe audio and video into speaker-labelled transcripts, subtitles, clips, and cited Q&A.
Search speech in podcasts, government meetings, and your own audio: speakers, entities, timestamps.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceAI-powered voice transcription app for macOS using WhisperKit165MIT
- AlicenseNot gradedqualityDmaintenanceEnables continuous voice conversation with AI coding assistants by locally transcribing speech with Whisper and delivering utterances as text prompts.1MIT
- AlicenseNot gradedqualityCmaintenanceLocal MCP server for macOS that captures microphone input and/or system audio output into explicit, user-defined sessions and exposes the raw WAV audio to AI agents through MCP tools.8 npm6MIT
- AlicenseNot gradedqualityAmaintenanceLocal-first meeting capture and transcription for Claude Code. Records audio from meeting apps, transcribes locally with whisper.cpp, and produces structured notes via Claude.1Apache 2.0