A Practical Guide to Generating Music from VS Code with MCP

You finish recording a programming walkthrough, play it back, and realize the tutorial is just your voice plus keyboard noise. Instead of breaking flow to hunt for background music, you can ask your editor agent to create a track from inside VS Code.

This guide walks through the documented VS Code + Suno MCP setup: install the MCP extension, store the API key safely, verify it from GitHub Copilot Agent mode, and keep a manual .vscode/mcp.json fallback for teams that prefer explicit project configuration.

What you can do

The document describes a Suno MCP workflow for VS Code. The main use case is simple: let GitHub Copilot Chat in Agent mode call Suno tools while you are still working in the editor.

The extension ID is:

acedatacloud.mcp-suno

The MCP server URL used by the optional manual config is:

https://suno.mcp.acedata.cloud/mcp

The Authorization header follows this shape:

Authorization: Bearer ${input:acedata-api-key}

The documented tools include:

Tool	What it is for
suno_generate_music	Generate a complete song from a one-sentence description
suno_generate_custom_music	Use your own lyrics, style, and vocal type
suno_extend_music	Continue a song from a specific time point
suno_cover_music	Cover an existing song in a different style
suno_mashup_music	Mash two songs into one
suno_stems_music	Separate vocals and accompaniment
suno_generate_lyrics	Generate lyrics
suno_create_persona	Save voice styles

That is enough to support practical builder workflows: background music for a tutorial, a short intro for a demo video, or fast iteration on game and podcast audio ideas.

Install the VS Code extension

Start with the extension path if you want the least configuration surface.

1. Open the VS Code extension marketplace with Cmd+Shift+X.
2. Search for Suno MCP, or search directly for the extension ID acedatacloud.mcp-suno.
3. Click Install.
4. Reload the VS Code window if prompted.

The key point is that the MCP integration lives where you are already working. You do not need to run a separate local MCP server process for this documented path.

Store the API key safely

After installing the extension, open the command palette with Cmd+Shift+P and run:

Suno MCP: Set Ace Data Cloud API Key

Paste your Ace Data Cloud API key and press Enter. The document says the key is stored in VS Code SecretStorage / the system keychain, not written into your project files.

If you need to rotate or replace it later, run:

Suno MCP: Clear Ace Data Cloud API Key

Then set the key again. This is a good habit if you test with temporary credentials, move between machines, or accidentally paste the wrong key.

Verify it from Copilot Agent mode

Open GitHub Copilot Chat and switch to Agent mode. Then ask for a task that clearly mentions suno, for example:

Use suno to help me generate a light and cheerful background music track for a programming tutorial, with a steady rhythm that does not distract from narration.

The first call should route through the plugin and use the saved API key. For a short demo video, you might ask:

Generate a 20-second sci-fi opening music, primarily with electronic synthesizers, powerful but not noisy.

For a podcast or branded intro, use the custom-music path:

Help me generate a song with custom lyrics. Lyrics: The moment the compilation passed, the world suddenly fell silent. Style: Lo-fi hip hop, lazy atmosphere.

The practical pattern is to describe the job as you would describe it to an editor: duration, mood, role in the video, and what the track should avoid. “Background music for narration” is a very different prompt from “energetic product launch intro.”

Optional: keep a manual .vscode/mcp.json

If you prefer project-level configuration, the document also shows a manual MCP config. Create .vscode/mcp.json and use an input prompt for the key instead of hardcoding the secret:

{
  "servers": {
    "suno": {
      "type": "http",
      "url": "https://suno.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer ${input:acedata-api-key}"
      }
    }
  },
  "inputs": [
    {
      "id": "acedata-api-key",
      "type": "promptString",
      "description": "Ace Data Cloud API Key",
      "password": true
    }
  ]
}

This version is useful when you want the MCP server definition to travel with a private repository while still asking each developer to provide their own key. The important part is the ${input:acedata-api-key} placeholder: it keeps the real value out of Git.

Useful workflows to try

Here are three concrete ways I would use this in a builder workflow.

1. Add quiet BGM to a coding tutorial

Ask for a light, steady, non-distracting track. Mention narration explicitly. If the first version feels too busy, ask for less percussion or a slower rhythm.

2. Create a short demo-day intro

For a product demo, ask for a 20-second opener and specify instrumentation. The document's example uses electronic synthesizers and a powerful-but-not-noisy direction, which is a good constraint for a tech demo.

3. Iterate on an existing track

If a section works but the energy drops later, use suno_extend_music conceptually through Copilot:

Continue this song starting from 01:40, speed up the rhythm, and add more beats and orchestral crescendos.

This is where editor-native generation feels useful: you can keep notes, scripts, and prompts in the same workspace as the video or tutorial project.

Wrap-up

The smallest useful path is: install acedatacloud.mcp-suno, set the API key from the command palette, switch Copilot Chat to Agent mode, and make one narrow request for a real piece of background music. If your team prefers explicit config, use .vscode/mcp.json with a password input instead of committing secrets.

The full setup details are in the VS Code with Suno MCP documentation.