Read, edit, and build your Helix Stadium presets by talking to your AI assistant.

Overview

Point your AI assistant at a .hsp preset and ask what it does. You get the whole signal chain back in plain English: the model names you see in the app, on/off state, footswitch and snapshot assignments, and every parameter in the units you'd read off the hardware (dB, Hz, ms, %). Ask how two snapshots differ and it tells you exactly what changes.

Then it makes changes for you. Say "roll the cab's high cut back to tame the fizz" or "add a boost in front of the amp," and it edits the preset directly — the right block, the right parameter, written back to the file. It can dial in tones, rearrange the chain, set up snapshots, build a preset from a blank slate, and line up a set. Every write goes through a safety check and keeps a backup, so changes are reversible.

What you can do

• Understand any preset — the full signal chain, in plain English, with every parameter in real units, plus footswitch and snapshot assignments
• Compare snapshots — exactly what changes between two snapshots (e.g. Rhythm vs Lead)
• Edit tones — change any parameter in real units ("set the high cut to 6 kHz"), toggle effects on or off, and add, remove, or reorder blocks
• Set up snapshots — name your scenes and store per-snapshot parameter and bypass values, then choose which one the preset opens on
• Build from scratch — start a blank preset and grow it, or line your presets up in playing order with a printable pre-gig checklist
• Browse the model catalog — list, describe, and search every amp, cab, and effect, read at runtime from your own install
• Reversible by default — every change is validated and written atomically with a .bak backup, and stays on your machine

Requirements

• Line 6 Helix Stadium installed (Windows confirmed; macOS support in progress). The server reads the model catalog from your install at runtime.
• Python 3.10+ (handled for you by uv in the steps below)
• An MCP-compatible AI client — the app your assistant runs in (e.g. Claude Desktop, Cursor, VS Code, and other clients with built-in MCP support)

Installation

No programming needed — but you will paste a couple of commands into a terminal and edit one settings file. Here's the whole thing, start to finish.

Step 1: Confirm the server runs

Your AI client will start the server for you (that's Step 2) — you don't normally run it by hand. Running it once just confirms it downloads and starts:

uvx twelvetake-helix-stadium-mcp serve
# or: pipx run twelvetake-helix-stadium-mcp serve

It will sit quietly, waiting for a client to connect — that silence is normal, not a freeze. Press Ctrl+C to stop it and move on.

Step 2: Add it to your AI client

Nearly every MCP client uses the same JSON — an mcpServers entry with a command and its args. Add this to your client's MCP configuration:

{
  "mcpServers": {
    "helix-stadium": {
      "command": "uvx",
      "args": ["twelvetake-helix-stadium-mcp", "serve"]
    }
  }
}

Where you put it depends on your client:

• Claude Desktop — Settings → Developer → Edit Config (opens claude_desktop_config.json); paste the block above.
• Claude Code — skip the JSON and just run: claude mcp add helix-stadium -- uvx twelvetake-helix-stadium-mcp serve
• Cursor — Settings → MCP → Add, or paste the block above into ~/.cursor/mcp.json (everywhere) or .cursor/mcp.json (one project) — same shape.
• Windsurf — in the Cascade panel, click the MCP icon → Configure, or edit ~/.codeium/windsurf/mcp_config.json — same shape.
• VS Code — Command Palette → "MCP: Add Server," or edit .vscode/mcp.json. VS Code is the one exception to the shape — it uses a top-level servers key with "type": "stdio":

{
  "servers": {
    "helix-stadium": {
      "type": "stdio",
      "command": "uvx",
      "args": ["twelvetake-helix-stadium-mcp", "serve"]
    }
  }
}

Using a different client? Add the same command and args wherever it lists MCP servers, and check its MCP docs for the exact spot. After adding it, fully quit and reopen your client.

Step 3: Check it's working

Ask your assistant to "detect my Helix Stadium install" — it should report the catalog path. Or run the built-in check from a terminal:

uvx twelvetake-helix-stadium-mcp doctor

If the catalog isn't found automatically, point the server at it with the HELIX_STADIUM_RES setting (see Optional settings) — it's your install's res/ folder, the one containing P35ModelCatalog.json.

Optional settings

These are environment variables — named settings the server reads when it starts. The simplest way to set them is right in the config from Step 2, in an env block (in VS Code, put the env block inside the servers entry instead):

"helix-stadium": {
  "command": "uvx",
  "args": ["twelvetake-helix-stadium-mcp", "serve"],
  "env": {
    "HELIX_MCP_READONLY": "1"
  }
}

• HELIX_MCP_READONLY — start with the editing tools removed, so it can read and explain but never change anything
• HELIX_STADIUM_DEVICE — set to xl if you have the Helix Stadium XL (the regular Stadium is the default)
• HELIX_STADIUM_RES — the path to your install's res/ folder, if it isn't found automatically

Troubleshooting

• Server doesn't show up in your client? Fully quit and reopen it after editing the config, and check the config is valid JSON (a stray trailing comma is the usual culprit).
• Not sure it's connected? Ask your assistant to "detect my Helix Stadium install" — a healthy server reports the catalog path.
• Catalog not found? Set HELIX_STADIUM_RES to your install's res/ folder (the one with P35ModelCatalog.json).

Working with your preset files

The server works on .hsp preset files on your computer — it never touches the hardware or your app's library directly. The round trip is simple:

1. Export a preset from the Helix Stadium app to a .hsp file (you choose where to save it).
2. Point your assistant at it — drag the file into the chat or paste its full path, then ask for the change you want.
3. It edits the file in place, keeping a .bak backup right next to it.
4. Import the .hsp back into the Helix Stadium app to load it onto your device, the same way you'd import any preset.

Because it only ever reads and writes the file you hand it, your device and your app's preset library are never modified behind your back.

Available tools (19)

You don't call these directly — you ask in plain language and your assistant picks the right one. Here's everything it can do.

Every write goes through the safety gate below. Set HELIX_MCP_READONLY to leave the edit and build tools out.

Usage examples

Just talk to your assistant. A few of the things you can ask:

Read & understand

Read MyTone.hsp and explain the signal chain

What changes between the Rhythm and Lead snapshots?

Search the model catalog for tape delays

Edit

Roll the cab's high cut back to 6 kHz to tame the fizz

Bump the amp mids up so the lead cuts through the mix

Add a Scream 808 boost in front of the amp

Turn the reverb off in this preset

Build

Create a blank preset and set up Rhythm, Lead, and Clean snapshots

Put these five presets in playing order and make me a pre-gig checklist

Safety & backups

Editing a preset should never risk the file. Every change your assistant makes goes through a single safety gate before it's saved:

• Validates the preset's structure first
• Round-trip checks the file byte-for-byte, so nothing else in the preset drifts
• Writes atomically and keeps a .bak backup right next to the file
• If any step fails, the write is blocked — the original file is left untouched

To undo a change, restore that .bak file (rename it back over the .hsp, or just ask your assistant to restore it). The backup holds the version from immediately before the last write, so if you want a longer history, keep your own copies as you go. Prefer it never write at all? Start it with HELIX_MCP_READONLY set and the editing tools are removed.

It also runs entirely on your own computer: it talks to your assistant through a direct local pipe (stdio), opens no network connection, and sends nothing anywhere. Your presets and your install stay on your machine.

FAQ