How do I use MMAudio MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@MMAudio MCP create audio for a meditation video with peaceful nature sounds" 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.

MMAudio MCP

Official

by mmaudio

Overview Schema Related Servers Score Discussions

JavaScript

Remote

MMAudio MCP

License: MIT Node.js Version MCP Compatible

AI-powered video-to-audio and text-to-audio generation using MMAudio's advanced AI technology. This Desktop Extension implements the Model Context Protocol (MCP) to provide seamless integration with Cursor, Claude Desktop, and other MCP-compatible clients.

🌟 Features

Video-to-Audio Generation: Transform video content into synchronized audio with AI-powered analysis
Text-to-Audio Generation: Create professional audio content from text descriptions
API Key Validation: Verify MMAudio API credentials and check account status
MCP Protocol: Full Model Context Protocol implementation for universal compatibility
Error Handling: Comprehensive error handling with detailed feedback
Type Safety: Full TypeScript support with Zod schema validation
Configurable: Flexible configuration options for different use cases

Related MCP server: MusicGPT MCP Server

🚀 Quick Start

Prerequisites

Node.js >= 18.0.0
MMAudio API key (Get one here)
MCP-compatible client (Cursor, Claude Desktop, etc.)

Installation

Clone or download this extension:
```
cd mcp
npm install
```

Configure your API key:

# Set environment variable
export MMAUDIO_API_KEY="sk-your-api-key-here"

# Or create a config.js file (copy from config.example.js)
cp config.example.js config.js
# Edit config.js with your API key

Test the installation:
```
npm start
```
Link the package:
```
npm link
```

Usage with Cursor

Add to your Cursor MCP configuration:

{
  "mcpServers": {
    "mmaudio": {
      "command": "npx",
      "args": ["-y", "mmaudio-mcp@latest"],
      "env": {
        "MMAUDIO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Restart Cursor and the MMAudio tools will be available in your AI assistant.

Usage with Claude Desktop

Add to your Claude Desktop configuration (claude_desktop_config.json):

{
  "mcpServers": {
    "mmaudio": {
      "command": "npx",
      "args": ["-y", "mmaudio-mcp@latest"],
      "env": {
        "MMAUDIO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Restart Claude Desktop to load the extension.

🛠️ Available Tools

1. Video-to-Audio Generation

Generate AI-powered audio from video content.

Tool Name: video_to_audio

Parameters:

video_url (required): URL of the video file
prompt (required): Description of the audio you want to generate
negative_prompt (optional): What to avoid in the generated audio
duration (optional): Audio duration in seconds (1-30, default: 8)
num_steps (optional): Number of inference steps (1-50, default: 25)
cfg_strength (optional): Guidance strength (1-10, default: 4.5)
seed (optional): Random seed for reproducible results

Example:

Generate audio for this video: https://example.com/video.mp4 with the prompt "peaceful forest sounds with birds chirping and gentle wind"

2. Text-to-Audio Generation

Create audio content from text descriptions.

Tool Name: text_to_audio

Parameters:

prompt (required): Description of the audio you want to generate
duration (optional): Audio duration in seconds (1-30, default: 8)
num_steps (optional): Number of inference steps (1-50, default: 25)
cfg_strength (optional): Guidance strength (1-10, default: 4.5)
negative_prompt (optional): What to avoid in the generated audio
seed (optional): Random seed for reproducible results

Example:

Create audio with the description "coffee shop ambiance with gentle chatter and espresso machine sounds"

3. API Key Validation

Validate your MMAudio API key and check account status.

Tool Name: validate_api_key

Parameters:

api_key (optional): API key to validate (uses configured key if not provided)

Example:

Validate my MMAudio API key

⚙️ Configuration

Environment Variables

Variable	Description	Required	Default
`MMAUDIO_API_KEY`	Your MMAudio API key	Yes	-
`MMAUDIO_BASE_URL`	Base URL for MMAudio API	No	`https://mmaudio.net`
`MMAUDIO_TIMEOUT`	Request timeout in milliseconds	No	`60000`
`LOG_LEVEL`	Log level (error, warn, info, debug)	No	`error`
`DEBUG`	Enable debug mode	No	`false`

Configuration File

You can also use a config.js file for configuration:

export const config = {
  apiKey: "sk-your-api-key-here",
  baseUrl: "https://mmaudio.net",
  timeout: 60000,
  // ... other options
};

📝 Example Usage

Video-to-Audio Example

// In your MCP client (Cursor, Claude Desktop, etc.)
"Please generate audio for this video URL: https://example.com/nature_video.mp4";
"I want forest sounds with birds chirping and a gentle breeze";
"Duration should be 10 seconds";

Text-to-Audio Example

// Create ambient audio
"Generate 15 seconds of coffee shop ambiance with gentle background chatter";

// Create sound effects
"Create the sound of rain falling on a wooden roof for 8 seconds";

// Create atmospheric audio
"Generate futuristic sci-fi ambient sounds for a space station";

🔧 Development

Project Structure

mcp/
├── server/index.js              # Main MCP server implementation
├── package.json           # Node.js dependencies and scripts
├── manifest.json          # DXT extension manifest
├── config.example.js      # Configuration example
└── README.md              # This file

Testing

Test the server directly:
```
npm start
```

Test with a simple MCP client:

echo '{"jsonrpc": "2.0", "method": "tools/list", "id": 1}' | npm start

Development Mode

Run the server in development mode with debugging:

npm run dev

This enables additional logging and the Node.js inspector for debugging.

🚨 Troubleshooting

Common Issues

1. "API key is required" Error

Problem: The extension can't find your API key.

Solution:

Ensure you've set the MMAUDIO_API_KEY environment variable
Or create a config.js file with your API key
Verify the API key is correct and active

2. "Connection refused" or Network Errors

Problem: Can't connect to MMAudio API.

Solution:

Check your internet connection
Verify the base URL is correct
Check if there are any firewall restrictions

3. "Insufficient credits" Error

Problem: Your MMAudio account doesn't have enough credits.

Solution:

Check your account balance at mmaudio.net/dashboard
Purchase additional credits if needed
Use the validate_api_key tool to check your account status

4. MCP Client Not Detecting Extension

Problem: Your MCP client (Cursor, Claude Desktop) doesn't show MMAudio tools.

Solution:

Verify the configuration path in your MCP client settings
Ensure Node.js is in your PATH
Check the server logs for errors
Restart your MCP client

Debug Mode

Enable debug mode for detailed logging:

DEBUG=true MMAUDIO_API_KEY=your-key node server/index.js

Logs

The server logs to stderr. You can redirect logs to a file:

node server/index.js 2> mmaudio.log

📄 API Reference

Response Format

All tools return responses in this format:

{
  "content": [
    {
      "type": "text",
      "text": "{\"success\": true, \"message\": \"...\", \"result\": {...}}"
    }
  ]
}

Success Response Example

{
  "success": true,
  "message": "Audio generated successfully from text",
  "result": {
    "audio_url": "https://example.com/generated_audio.wav",
    "content_type": "audio/wav",
    "file_name": "generated_audio.wav",
    "file_size": 1024000,
    "duration": 8,
    "prompt": "coffee shop ambiance"
  }
}

Error Response Example

{
  "success": false,
  "error": "Invalid API key. Please check your MMAudio API key.",
  "code": "INVALID_REQUEST"
}

🔒 Security

API keys are handled securely and not logged
All requests use HTTPS
The extension runs in a sandboxed environment
No sensitive data is stored locally

🤝 Contributing

Fork the repository
Create a feature branch
Make your changes
Add tests if applicable
Submit a pull request

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.

💬 Support

Made with ❤️ by the MMAudio Team

Available Tools

3 tools

text_to_audioB

Generate AI-powered audio content from text descriptions using MMAudio technology. Create sound effects, ambient audio, music, and atmospheric soundscapes from natural language descriptions.

ParametersJSON Schema

Name	Required	Description
`prompt`	Yes	Describe the audio you want to generate (e.g., "rain falling on leaves", "coffee shop ambiance", "futuristic sci-fi sounds")
`duration`	No	Duration of generated audio in seconds
`num_steps`	No	Number of inference steps (higher = better quality, slower)
`cfg_strength`	No	Classifier-free guidance strength (higher = more adherence to prompt)
`negative_prompt`	No	Describe what you want to avoid in the generated audio (optional)
`seed`	No	Random seed for reproducible results

TDQS

B3.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'AI-powered' and 'MMAudio technology' but doesn't cover critical aspects like rate limits, authentication needs, output format, or potential costs/latency. The description is insufficient for a tool with 6 parameters and no annotation support.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is efficiently structured in two sentences: the first states the core functionality, and the second provides concrete examples. Every word earns its place with no redundancy or wasted text, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a complex audio generation tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (audio format, file type, size), error conditions, or practical constraints. The examples help but don't compensate for missing behavioral and output information.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents all 6 parameters. The description adds no specific parameter information beyond what's in the schema, meeting the baseline of 3 where the schema does the heavy lifting. No additional semantic context is provided for parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate AI-powered audio content from text descriptions using MMAudio technology.' It specifies the action (generate), resource (audio content), and technology (MMAudio), and distinguishes itself from siblings by focusing on text-to-audio generation rather than validation or video conversion.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage through examples ('sound effects, ambient audio, music, and atmospheric soundscapes'), but lacks explicit guidance on when to use this tool versus alternatives like 'video_to_audio'. It provides context for generating audio from text but doesn't state exclusions or compare to sibling tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

validate_api_keyC

Validate MMAudio API key and check account credits/status

ParametersJSON Schema

Name	Required	Description	Default
`api_key`	No	MMAudio API key to validate (optional, uses configured key if not provided)

TDQS

C2.9/5.0

Behavior2/5

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 states the tool validates an API key and checks account credits/status, but doesn't disclose behavioral traits such as what happens on validation failure (e.g., error messages), whether it makes network calls, rate limits, authentication requirements beyond the key, or the format of the status response. This is a significant gap for a tool with no annotation coverage.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part earns its place by specifying the tool's actions and targets, making it appropriately sized for its function.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (validation with potential network interaction), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., credit balance, validation result), error conditions, or behavioral details, leaving gaps for an AI agent to use it correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the parameter 'api_key' fully documented in the schema. The description adds no additional meaning beyond what the schema provides (e.g., it doesn't explain key format or validation rules). With high schema coverage, the baseline is 3, as the description doesn't compensate but doesn't need to.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with specific verbs ('validate', 'check') and resources ('MMAudio API key', 'account credits/status'). It distinguishes this as a validation/status-checking tool rather than a processing tool like its siblings (text_to_audio, video_to_audio). However, it doesn't explicitly differentiate from potential sibling validation tools (none listed), so it falls short of a perfect 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., before using text_to_audio), when not to use it, or how it relates to sibling tools. The only implied usage is for validation, but this is basic and lacks context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

video_to_audioB

Generate AI-powered audio from video content using MMAudio technology. Analyzes video frames and generates synchronized audio including sound effects, ambient noise, and atmospheric elements.

ParametersJSON Schema

Name	Required	Description
`video_url`	Yes	URL of the video file to generate audio for (supports mp4, webm, avi, mov formats)
`prompt`	Yes	Describe the audio you want to generate (e.g., "forest sounds with birds chirping", "urban traffic noise", "peaceful ocean waves")
`negative_prompt`	No	Describe what you want to avoid in the generated audio (optional)
`seed`	No	Random seed for reproducible results (optional)
`num_steps`	No	Number of inference steps (higher = better quality, slower)
`duration`	No	Duration of generated audio in seconds
`cfg_strength`	No	Classifier-free guidance strength (higher = more adherence to prompt)

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that the tool 'analyzes video frames and generates synchronized audio', implying processing and creation, but fails to disclose critical traits like whether it's a read-only or destructive operation, rate limits, authentication needs, or output format (e.g., file type, size). This leaves significant gaps for an AI agent to understand the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded, with two sentences that directly state the tool's purpose and key functionality. Every sentence earns its place by explaining the core action and the types of audio generated, though it could be slightly more structured by explicitly listing output details.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of a 7-parameter tool with no annotations and no output schema, the description is incomplete. It lacks information on the output (e.g., audio format, how to access it), error handling, performance expectations, or any constraints beyond what's implied. This makes it inadequate for an AI agent to fully understand the tool's context and usage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema description coverage is 100%, so the input schema already documents all parameters thoroughly. The description adds no additional meaning beyond what's in the schema, such as explaining interactions between parameters or providing usage examples. However, since the schema is comprehensive, a baseline score of 3 is appropriate as the description doesn't need to compensate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose with specific verbs ('generate AI-powered audio from video content') and resources ('video content'), distinguishing it from sibling tools like 'text_to_audio' by specifying video input. It also mentions the technology used ('MMAudio technology'), which adds specificity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'text_to_audio' or 'validate_api_key'. It lacks explicit instructions on prerequisites, such as whether the video must be pre-processed or if there are usage limits, leaving the agent without context for tool selection.

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. Dates show when Glama detected each change.

3 tool updatesDec 29, 2025
- First observedtext_to_audio
- First observedvalidate_api_key
- First observedvideo_to_audio

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.4/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: text_to_audio generates audio from text, video_to_audio generates audio from video, and validate_api_key handles authentication. There is no overlap in functionality, making it easy for an agent to select the right tool.

Naming Consistency5/5

All tool names follow a consistent snake_case pattern with clear verb_noun structure (text_to_audio, video_to_audio, validate_api_key). The naming is predictable and readable throughout the set.

Tool Count3/5

With only 3 tools, the server feels thin for its apparent audio generation domain. While the core functions are covered, typical MCP servers in this space might include additional tools for managing audio files, adjusting parameters, or retrieving generated content.

Completeness4/5

The toolset covers the essential operations for AI-powered audio generation from text and video, plus API validation. However, there are minor gaps such as no tools for editing, listing, or deleting generated audio, which could limit agent workflows in more complex scenarios.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

rostro AOAuth
dev.rostro
Turn any LLM multimodal; generate images, voices, videos, 3D models, music, and more.
Multimedia Processing Image & Video Processing Audio Processing
2
aicut
pro.aicut
Generate AI videos, images, audio and staged AI Video Story episodes, and publish them to social.
AI & Machine Learning Image & Video Processing Social Media
1
RendobarOAuth
com.rendobar
Transform video, audio and images, and generate media from prompts. FFmpeg, captions, models.
Multimedia Processing Image & Video Processing
21
FOTOhub Creative AI
app.fotohub
Generate images, video, music, voice and 3D through one API. 30 tools, 200+ models.
Image & Video Processing Audio Processing AI & Machine Learning
2

Related MCP Servers

MCP Veo 3 Video Generation
Multimedia Processing Image & Video Processing Entertainment & Media
dayongd1
A
license
Not graded
quality
D
maintenance
Enables video generation from text prompts or images using Google's Veo 3 API. Supports multiple models, audio generation, and various aspect ratios for creating high-quality videos.
Updated a year ago (2025-08-14 02:15 UTC)
2
MIT
MusicGPT MCP Server
Audio Processing Multimedia Processing Text-to-Speech
pasie15
A
license
B
quality
D
maintenance
Provides AI-powered audio generation and processing through the MusicGPT API, enabling music creation, voice conversion, audio manipulation, stem extraction, and audio analysis capabilities.
Updated 9 months ago (2025-12-13 02:38 UTC)
24
17
1
MIT
MCP MiniMax Music Server
Audio Processing Multimedia Processing
falahgs
F
license
B
quality
D
maintenance
Enables AI agents to generate music and audio content using the MiniMax Music API through text prompts, with support for reference audio and lyric generation.
Updated a year ago (2025-04-17 05:32 UTC)
1
5
-
MathMind MCP Server
Multimedia Processing Image & Video Processing Audio Processing
Runninghcm
F
license
A
quality
D
maintenance
Provides a audio/video creation toolbox via MCP protocol, enabling natural language-based video editing tasks such as image-to-video, video merging, subtitle extraction, and more.
Updated a year ago (2025-08-09 17:53 UTC)
9
3
-

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/mmaudio/mmaudio-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

MMAudio MCP

🌟 Features

🚀 Quick Start

Prerequisites

Installation

Usage with Cursor

Usage with Claude Desktop

🛠️ Available Tools

1. Video-to-Audio Generation

2. Text-to-Audio Generation

3. API Key Validation

⚙️ Configuration

Environment Variables

Configuration File

📝 Example Usage

Video-to-Audio Example

Text-to-Audio Example

🔧 Development

Project Structure

Testing

Development Mode

🚨 Troubleshooting

Common Issues

1. "API key is required" Error

2. "Connection refused" or Network Errors

3. "Insufficient credits" Error

4. MCP Client Not Detecting Extension

Debug Mode

Logs

📄 API Reference

Response Format

Success Response Example

Error Response Example

🔒 Security

📖 Related Documentation

🤝 Contributing

📝 License

💬 Support

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API