# Mcp Launcher For Claude Code

> Per-session MCP server loadouts for Claude Code - launch lean, measure the cost. Unofficial Windows desktop app (PySide6).

- **Type:** MCP server
- **Install:** `agentstack add mcp-maxii-vr-mcp-launcher-for-claude-code`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [Maxii-VR](https://agentstack.voostack.com/s/maxii-vr)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [Maxii-VR](https://github.com/Maxii-VR)
- **Source:** https://github.com/Maxii-VR/mcp-launcher-for-claude-code

## Install

```sh
agentstack add mcp-maxii-vr-mcp-launcher-for-claude-code
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# MCP Launcher for Claude Code

**Per-session MCP server loadouts — launch lean, measure the cost.**

A compact Windows desktop app (PySide6) that keeps **Claude Code's context
light** by launching each session with only the MCP servers it needs.

> Unofficial, community-made tool. Not affiliated with or endorsed by Anthropic.

The real cost of MCP servers isn't CPU/RAM (an idle server costs almost
nothing) — it's **context**: every *connected* server injects all its tool
definitions into the model's context on every request. This app lets you pick a
loadout, see its token weight, and launch a Claude session that loads exactly
those tools.

> A configured loadout — 2 of 7 servers selected, each server's tool count and
> token weight shown, with the running total in the header. Tick the servers a
> task needs, then **Launch** a Claude session scoped to exactly those.

On first run with no servers configured yet, it starts clean and seeds from
your Claude Code config:

## Download

Grab the latest standalone build from the **[Releases](../../releases)** page —
unzip it, open the `MCP Launcher` folder, and run `MCP Launcher.exe`. It's
self-contained: **no Python or other install needed**. Prefer to run from
source instead? See [Run from source](#run-from-source) below.

## Requirements

- Windows 10/11 (64-bit).
- The **Claude Code CLI** (`claude`) installed and on `PATH` — this app
  launches it, it doesn't replace it. Only needed when you actually *Launch* a
  session; the app opens fine without it.
- Python 3.12+ (only when running from source; the packaged build bundles it).

## Run from source

Just double-click **`run.bat`**. On the first run it creates the `venv`,
installs the dependencies from `requirements.txt`, and then launches; every
run after that skips straight to launching. (It needs Python 3.12+ on `PATH`
to do the one-time setup; it'll tell you if it can't find one.)

Prefer to set it up by hand? That's all `run.bat` does:

```bat
python -m venv venv
venv\Scripts\python -m pip install -r requirements.txt
run.bat
```

The app runs windowless via `pythonw` (no console). If you launch `run.pyw`
directly with a Python that doesn't have the dependencies installed, it shows
a message box pointing you back to `run.bat` instead of failing silently.

## How it works

- **Catalog** — keeps your MCP servers in
  `%LOCALAPPDATA%\mcp-launcher\store.json`, seeded on first run from
  `~/.claude.json` (both user-scope and per-project servers).

- **Loadout** — tick the servers you want for a task. The header shows the
  total estimated token cost of that selection.

- **Launch** — opens a new terminal running
  `claude --mcp-config .json --strict-mcp-config` in a folder you
  choose. `--strict-mcp-config` makes that session use **only** those servers,
  ignoring the global `~/.claude.json` entirely.

  Because each session is launched with its **own** private config, two sessions
  never share a mutable MCP config, so they can't clobber each other (and a
  running session can't overwrite your changes). Verified: a strict session with
  a one-server preset sees only that server; with an empty preset it has no MCP
  tools at all.

- **Presets** — save a selection as a named loadout (e.g. `3D`, `Audio`,
  `Unity`, `Minimal`) and recall it from the dropdown.

- **Measure context cost** — spins each server up briefly, lists its tools, and
  estimates the tokens its definitions add per request. Per-server badges are
  colour-graded (green/amber/red) and the header sums the current loadout.

- **Set as global default** — writes the current selection into `~/.claude.json`
  so a plain `claude` launch (without this app) loads exactly that set. Atomic
  write, timestamped backup in `%LOCALAPPDATA%\mcp-launcher\backups` (last 15
  kept), and all other config keys preserved.

- **Add / Edit / Delete** servers — edit shows the raw JSON record (with an
  "OVERWRITE?" confirm); delete confirms too.

## What it touches

- Reads, and (only via *Set as global default*) writes, the `mcpServers` blocks
  of Claude Code's config (`~/.claude.json`, or `$CLAUDE_CONFIG_DIR/.claude.json`
  if you've relocated it). It never reads or modifies any other key (prompts,
  history, auth, project settings stay untouched).
- Its own data (catalog, presets, backups, generated launch configs) lives under
  `%LOCALAPPDATA%\mcp-launcher`.

## Security & privacy

This is a local utility with a deliberately small footprint:

- **No network, no telemetry, no listeners.** It opens no sockets, makes no
  outbound requests, and phones nothing home. Everything happens on your machine.
- **It reads only the `mcpServers` blocks** of `~/.claude.json` — never your
  prompt templates, conversation/project history, OAuth tokens, or other keys.
  The safety backup it writes before *Set as global default* contains **only**
  those MCP blocks, so no personal data is ever copied into the app folder.
- **It runs MCP server commands** — that's inherent to MCP. Claude launches them
  per session, and *Measure context cost* launches each briefly to read its
  tools (it asks first). **Only add servers you trust.** When you add or edit a
  record, the dialog validates its shape and shows the exact command + args, and
  you confirm before it's saved — nothing runs unseen.
- **Launching is injection-safe by construction.** Claude and each argument are
  handed to the OS as a list (no shell command string is built), the working
  folder is passed via the process `cwd` parameter and verified to exist, and
  the config path is an app-generated file with a sanitized name — so a crafted
  folder name or path can't smuggle in an extra command.
- **Secrets stay local.** A server's `env` may hold API keys; those live in
  `store.json` and the generated launch files under `%LOCALAPPDATA%\mcp-launcher`
  (a per-user, OS-protected location) — the same exposure as your existing
  `~/.claude.json`. Don't commit or share those files; `.gitignore` already keeps
  the repo clean of local data and the bundled `venv`.

No personal or machine-specific data is embedded in the source or this README.

## Platform note

Windows-only for now (uses Windows Terminal / PowerShell and `%LOCALAPPDATA%`).
The launcher could be extended for macOS/Linux later.

## Project layout

```
mcp_launcher/
  paths.py          app data locations + bundled-asset/AppUserModelID ids
  claude_config.py  safe atomic read/write of ~/.claude.json + launch-config writer
  store.py          catalog of servers + presets + selection (store.json)
  prober.py         measure each server's tool/token context cost (FastMCP)
  launcher.py       build a --mcp-config file and open a Claude session
  app.py            entry point + global excepthook + taskbar identity
  assets/
    icon.ico        multi-resolution "M" app icon (window/taskbar/.exe)
  ui/
    branding.py     the "M" logo: live QIcon + icon.ico generator
    style.py        dark theme (QSS)
    record_row.py   one server row (checkbox + cost badge + edit/delete)
    dialogs.py      add/edit record, confirmations
    main_window.py  loadout list, presets, launch
run.pyw / run.bat   launchers (run.bat self-bootstraps the venv on first run)
build_exe.bat       build a standalone .exe (PyInstaller, icon wired in)
requirements.txt    runtime dependencies
docs/               screenshots used in this README
```

## License

[MIT](LICENSE) © Maxii-VR.

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [Maxii-VR](https://github.com/Maxii-VR)
- **Source:** [Maxii-VR/mcp-launcher-for-claude-code](https://github.com/Maxii-VR/mcp-launcher-for-claude-code)
- **License:** MIT

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-maxii-vr-mcp-launcher-for-claude-code
- Seller: https://agentstack.voostack.com/s/maxii-vr
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.