#!/usr/bin/env node
/**
* MMAudio Desktop Extension - MCP Server
*
* This server implements the Model Context Protocol (MCP) to provide
* AI-powered video-to-audio and text-to-audio generation capabilities
* as a Desktop Extension compatible with Cursor and other MCP clients.
*/
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
CallToolRequestSchema,
ErrorCode,
ListToolsRequestSchema,
McpError,
} from '@modelcontextprotocol/sdk/types.js';
import { z } from 'zod';
import fetch from 'node-fetch';
import FormData from 'form-data';
import { readFileSync } from 'fs';
import { resolve } from 'path';
import dotenv from 'dotenv';
// Load environment variables
dotenv.config();
// Configuration schemas
const ConfigSchema = z.object({
apiKey: z.string().min(1, 'API key is required'),
baseUrl: z.string().url().default('https://mmaudio.net'),
timeout: z.number().min(5000).max(300000).default(60000),
});
// Input schemas for tools
const VideoToAudioInputSchema = z.object({
video_url: z.string().url('Invalid video URL'),
prompt: z.string().min(1, 'Prompt is required'),
negative_prompt: z.string().optional().default(''),
seed: z.number().int().optional().nullable(),
num_steps: z.number().int().min(1).max(50).default(25),
duration: z.number().min(1).max(30).default(8),
cfg_strength: z.number().min(1).max(10).default(4.5),
});
const TextToAudioInputSchema = z.object({
prompt: z.string().min(1, 'Prompt is required'),
duration: z.number().min(1).max(30).default(8),
num_steps: z.number().int().min(1).max(50).default(25),
cfg_strength: z.number().min(1).max(10).default(4.5),
negative_prompt: z.string().optional().default(''),
seed: z.number().int().optional().default(0),
});
// Response schemas
const AudioResponseSchema = z.object({
url: z.string().url(),
content_type: z.string(),
file_name: z.string(),
file_size: z.number(),
});
const VideoToAudioResponseSchema = z.object({
video: AudioResponseSchema,
});
const TextToAudioResponseSchema = z.object({
audio: AudioResponseSchema,
});
class MMAudioServer {
constructor() {
this.server = new Server(
{
name: 'mmaudio-mcp',
version: '1.0.0',
},
{
capabilities: {
tools: {},
},
}
);
this.config = null;
this.setupHandlers();
}
/**
* Load configuration from environment variables or manifest
*/
loadConfig() {
try {
const config = {
apiKey: process.env.MMAUDIO_API_KEY || process.env.apiKey,
baseUrl: process.env.MMAUDIO_BASE_URL || process.env.baseUrl || 'https://mmaudio.net',
timeout: parseInt(process.env.MMAUDIO_TIMEOUT || process.env.timeout || '60000'),
};
this.config = ConfigSchema.parse(config);
if (!this.config.apiKey) {
throw new Error('MMAudio API key is required. Please set MMAUDIO_API_KEY environment variable.');
}
console.error(`[MMAudio] Server configured with base URL: ${this.config.baseUrl}`);
} catch (error) {
throw new McpError(
ErrorCode.InvalidRequest,
`Configuration error: ${error.message}`
);
}
}
/**
* Setup MCP protocol handlers
*/
setupHandlers() {
// List available tools
this.server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: 'video_to_audio',
description: '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.',
inputSchema: {
type: 'object',
properties: {
video_url: {
type: 'string',
format: 'uri',
description: 'URL of the video file to generate audio for (supports mp4, webm, avi, mov formats)',
},
prompt: {
type: 'string',
description: 'Describe the audio you want to generate (e.g., "forest sounds with birds chirping", "urban traffic noise", "peaceful ocean waves")',
},
negative_prompt: {
type: 'string',
description: 'Describe what you want to avoid in the generated audio (optional)',
default: '',
},
seed: {
type: 'integer',
description: 'Random seed for reproducible results (optional)',
nullable: true,
},
num_steps: {
type: 'integer',
minimum: 1,
maximum: 50,
default: 25,
description: 'Number of inference steps (higher = better quality, slower)',
},
duration: {
type: 'number',
minimum: 1,
maximum: 30,
default: 8,
description: 'Duration of generated audio in seconds',
},
cfg_strength: {
type: 'number',
minimum: 1,
maximum: 10,
default: 4.5,
description: 'Classifier-free guidance strength (higher = more adherence to prompt)',
},
},
required: ['video_url', 'prompt'],
},
},
{
name: 'text_to_audio',
description: 'Generate AI-powered audio content from text descriptions using MMAudio technology. Create sound effects, ambient audio, music, and atmospheric soundscapes from natural language descriptions.',
inputSchema: {
type: 'object',
properties: {
prompt: {
type: 'string',
description: 'Describe the audio you want to generate (e.g., "rain falling on leaves", "coffee shop ambiance", "futuristic sci-fi sounds")',
},
duration: {
type: 'number',
minimum: 1,
maximum: 30,
default: 8,
description: 'Duration of generated audio in seconds',
},
num_steps: {
type: 'integer',
minimum: 1,
maximum: 50,
default: 25,
description: 'Number of inference steps (higher = better quality, slower)',
},
cfg_strength: {
type: 'number',
minimum: 1,
maximum: 10,
default: 4.5,
description: 'Classifier-free guidance strength (higher = more adherence to prompt)',
},
negative_prompt: {
type: 'string',
description: 'Describe what you want to avoid in the generated audio (optional)',
default: '',
},
seed: {
type: 'integer',
default: 0,
description: 'Random seed for reproducible results',
},
},
required: ['prompt'],
},
},
{
name: 'validate_api_key',
description: 'Validate MMAudio API key and check account credits/status',
inputSchema: {
type: 'object',
properties: {
api_key: {
type: 'string',
description: 'MMAudio API key to validate (optional, uses configured key if not provided)',
},
},
required: [],
},
},
],
};
});
// Handle tool calls
this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
try {
switch (name) {
case 'video_to_audio':
return await this.handleVideoToAudio(args);
case 'text_to_audio':
return await this.handleTextToAudio(args);
case 'validate_api_key':
return await this.handleValidateApiKey(args);
default:
throw new McpError(
ErrorCode.MethodNotFound,
`Unknown tool: ${name}`
);
}
} catch (error) {
if (error instanceof McpError) {
throw error;
}
console.error(`[MMAudio] Error in ${name}:`, error);
throw new McpError(
ErrorCode.InternalError,
`Tool execution failed: ${error.message}`
);
}
});
}
/**
* Handle video-to-audio generation
*/
async handleVideoToAudio(args) {
this.ensureConfigured();
try {
const input = VideoToAudioInputSchema.parse(args);
console.error(`[MMAudio] Starting video-to-audio generation for: ${input.video_url}`);
const response = await fetch(`${this.config.baseUrl}/api/video-to-audio`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${this.config.apiKey}`,
'User-Agent': 'MMAudio-MCP/1.0.0',
},
body: JSON.stringify(input),
timeout: this.config.timeout,
});
if (!response.ok) {
const errorText = await response.text();
let errorMessage = `HTTP ${response.status}`;
try {
const errorData = JSON.parse(errorText);
errorMessage = errorData.error || errorMessage;
} catch {
errorMessage = errorText || errorMessage;
}
if (response.status === 401) {
throw new McpError(ErrorCode.InvalidRequest, 'Invalid API key. Please check your MMAudio API key.');
} else if (response.status === 403) {
throw new McpError(ErrorCode.InvalidRequest, 'Insufficient credits for video-to-audio generation.');
} else if (response.status === 429) {
throw new McpError(ErrorCode.InvalidRequest, 'Rate limit exceeded. Please try again later.');
}
throw new Error(errorMessage);
}
const result = await response.json();
const validatedResult = VideoToAudioResponseSchema.parse(result);
console.error(`[MMAudio] Video-to-audio generation completed successfully`);
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
message: 'Audio generated successfully from video',
result: {
audio_url: validatedResult.video.url,
content_type: validatedResult.video.content_type,
file_name: validatedResult.video.file_name,
file_size: validatedResult.video.file_size,
duration: input.duration,
prompt: input.prompt,
}
}, null, 2),
},
],
};
} catch (error) {
if (error instanceof z.ZodError) {
throw new McpError(
ErrorCode.InvalidParams,
`Invalid input parameters: ${error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`
);
}
throw error;
}
}
/**
* Handle text-to-audio generation
*/
async handleTextToAudio(args) {
this.ensureConfigured();
try {
const input = TextToAudioInputSchema.parse(args);
console.error(`[MMAudio] Starting text-to-audio generation for prompt: "${input.prompt}"`);
const response = await fetch(`${this.config.baseUrl}/api/text-to-audio`, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
'Authorization': `Bearer ${this.config.apiKey}`,
'User-Agent': 'MMAudio-MCP/1.0.0',
},
body: JSON.stringify(input),
timeout: this.config.timeout,
});
if (!response.ok) {
const errorText = await response.text();
let errorMessage = `HTTP ${response.status}`;
try {
const errorData = JSON.parse(errorText);
errorMessage = errorData.error || errorMessage;
} catch {
errorMessage = errorText || errorMessage;
}
if (response.status === 401) {
throw new McpError(ErrorCode.InvalidRequest, 'Invalid API key. Please check your MMAudio API key.');
} else if (response.status === 403) {
throw new McpError(ErrorCode.InvalidRequest, 'Insufficient credits for text-to-audio generation.');
} else if (response.status === 429) {
throw new McpError(ErrorCode.InvalidRequest, 'Rate limit exceeded. Please try again later.');
}
throw new Error(errorMessage);
}
const result = await response.json();
const validatedResult = TextToAudioResponseSchema.parse(result);
console.error(`[MMAudio] Text-to-audio generation completed successfully`);
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
message: 'Audio generated successfully from text',
result: {
audio_url: validatedResult.audio.url,
content_type: validatedResult.audio.content_type,
file_name: validatedResult.audio.file_name,
file_size: validatedResult.audio.file_size,
duration: input.duration,
prompt: input.prompt,
}
}, null, 2),
},
],
};
} catch (error) {
if (error instanceof z.ZodError) {
throw new McpError(
ErrorCode.InvalidParams,
`Invalid input parameters: ${error.errors.map(e => `${e.path.join('.')}: ${e.message}`).join(', ')}`
);
}
throw error;
}
}
/**
* Handle API key validation
*/
async handleValidateApiKey(args) {
const apiKey = args.api_key || this.config?.apiKey;
if (!apiKey) {
throw new McpError(ErrorCode.InvalidRequest, 'No API key provided');
}
try {
console.error(`[MMAudio] Validating API key...`);
// Try to fetch credits/usage endpoint to validate the key
const response = await fetch(`${this.config?.baseUrl || 'https://mmaudio.net'}/api/credits`, {
method: 'GET',
headers: {
'Authorization': `Bearer ${apiKey}`,
'User-Agent': 'MMAudio-MCP/1.0.0',
},
timeout: 10000,
});
if (response.status === 401) {
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
valid: false,
message: 'Invalid API key',
error: 'Authentication failed'
}, null, 2),
},
],
};
}
if (!response.ok) {
throw new Error(`HTTP ${response.status}: ${await response.text()}`);
}
const data = await response.json();
console.error(`[MMAudio] API key validation successful`);
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: true,
valid: true,
message: 'API key is valid',
credits: data.credits || 'Unknown',
account_status: 'Active'
}, null, 2),
},
],
};
} catch (error) {
console.error(`[MMAudio] API key validation failed:`, error);
return {
content: [
{
type: 'text',
text: JSON.stringify({
success: false,
valid: false,
message: 'Failed to validate API key',
error: error.message
}, null, 2),
},
],
};
}
}
/**
* Ensure server is configured
*/
ensureConfigured() {
if (!this.config) {
this.loadConfig();
}
}
/**
* Start the MCP server
*/
async start() {
try {
this.loadConfig();
const transport = new StdioServerTransport();
await this.server.connect(transport);
console.error('[MMAudio] MCP Server started successfully');
console.error(`[MMAudio] API Base URL: ${this.config.baseUrl}`);
console.error('[MMAudio] Available tools: video_to_audio, text_to_audio, validate_api_key');
} catch (error) {
console.error('[MMAudio] Failed to start server:', error);
process.exit(1);
}
}
}
// Start the server
const server = new MMAudioServer();
server.start().catch((error) => {
console.error('[MMAudio] Fatal error:', error);
process.exit(1);
});
// Handle graceful shutdown
process.on('SIGINT', () => {
console.error('[MMAudio] Shutting down server...');
process.exit(0);
});
process.on('SIGTERM', () => {
console.error('[MMAudio] Shutting down server...');
process.exit(0);
});
