What can you do with this server?

This server allows you to install and configure MCP (Model Context Protocol) servers for AI clients, with primary focus on Cursor. * Install remote MCP servers (install_repo_mcp_server): Install an MCP server from a package registry via npx or uvx, with support for custom arguments and environment variables. * Install local MCP servers (install_local_mcp_server): Install an MCP server from a local directory on your machine, with support for custom arguments and environment variables. * Add any MCP server to Cursor's config (add_to_cursor_config): Manually register any MCP server (by command, path, or package) into Cursor's MCP configuration, with a custom display name, arguments, and environment variables. Additional capabilities include cross-platform support (macOS, Windows, Linux), automatic detection of installed AI clients (Claude Desktop, Cursor, VS Code, etc.), MCP protocol handshake validation, config backup and atomic writes for safety, and structured health reports with tool counts, latency, and recovery hints.

Which integrations are available for this server?

Provides access to GitHub repositories and data through the @modelcontextprotocol/server-github package, requiring a personal access token for authentication. Enables installation and configuration of MCP servers from npm packages, with support for Node.js-based MCP servers. Supports Python-based MCP servers, automatically configuring them to run as Python modules with proper environment variables.

How do I use Cursor MCP Installer?

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., "@Cursor MCP Installer install the web search MCP server" 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.

de en es ja ko ru zh

Cursor MCP Installer

by matthewdcage

Overview Schema Related Servers Score Discussions

TypeScript

Hybrid

             _   _ _   _ _____     _______ ____  ____    _    _     
            | | | | \ | |_ _\ \   / / ____|  _ \/ ___|  / \  | |    
            | | | |  \| || | \ \ / /|  _| | |_) \___ \ / _ \ | |    
            | |_| | |\  || |  \ V / | |___|  _ < ___) / ___ \| |___ 
             \___/|_| \_|___|  \_/  |_____|_| \_\____/_/   \_\_____|
                                                          
      __  __  ____ ____    ___ _   _ ____ _____  _    _     _     _____ ____  
     |  \/  |/ ___|  _ \  |_ _| \ | / ___|_   _|/ \  | |   | |   | ____|  _ \ 
     | |\/| | |   | |_) |  | ||  \| \___ \ | | / _ \ | |   | |   |  _| | |_) |
     | |  | | |___|  __/   | || |\  |___) || |/ ___ \| |___| |___| |___|  _ < 
     |_|  |_|\____|_|     |___|_| \_|____/ |_/_/   \_\_____|_____|_____|_| \_\

License: MIT npm version MCP Compatible npm downloads

🚀 NEW: Universal MCP Installer v1.0.0 — Complete rewrite of cursor-mcp-installer. Now supports 6 AI clients (Claude Desktop, Cursor, VS Code, OpenClaw, Claude Code, ChatGPT), cross-platform (macOS, Windows, Linux), real MCP handshake validation, and a branded web dashboard. Upgraded to MCP SDK 1.29.0.

🖥️ Web Dashboard Available! Launch with npx universal-mcp-installer --ui to manage everything from a visual interface. See Using the Dashboard below.

Quick Start Guide

Step 1: Install an MCP Server (One Command)

npx universal-mcp-installer install @modelcontextprotocol/server-memory

That's it. The installer detects which AI clients you have installed and writes the correct config for each one.

Step 2: Or Add as an MCP Tool (Let Your AI Install Other MCP Servers)

Add this to your AI client's MCP configuration:

Cursor (`~/.cursor/mcp.json`)

{
  "mcpServers": {
    "MCP Installer": {
      "command": "npx",
      "type": "stdio",
      "args": ["-y", "universal-mcp-installer"]
    }
  }
}

Claude Desktop (`claude_desktop_config.json`)

{
  "mcpServers": {
    "MCP Installer": {
      "command": "npx",
      "args": ["-y", "universal-mcp-installer"]
    }
  }
}

VS Code (`.vscode/mcp.json`)

{
  "servers": {
    "mcpInstaller": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "universal-mcp-installer"]
    }
  }
}

Step 3: Restart Your AI Client

Close and reopen your AI client to apply the configuration changes.

Step 4: Ask Your AI to Install Servers

Install the filesystem MCP server

Install the web search MCP server

The installer exposes three tools your AI can call:

Tool	Description
`detect_system`	Returns OS, architecture, available runtimes, and detected AI clients
`install_mcp_server`	Installs a server by package name, git URL, or local path to selected clients
`validate_mcp_server`	Validates a server via MCP handshake and returns the result

Related MCP server: hyper-mcp

Using the Dashboard

Launch the visual interface:

npx universal-mcp-installer --ui

This opens web interface in your browser at http://localhost:3939:

1. System Panel — The top section automatically detects your OS and all available runtimes (Node, npm, uvx, Python, git) so you can see at a glance what's available on your machine.

2. AI Clients — Each detected client gets a card showing its name, config file path, and how many MCP servers are already configured. Use the toggle switch on each card to include or exclude it from the next installation. Uninstalled clients appear dimmed.

3. Install — Type a package name (npm package, git URL, or local path), pick a method from the dropdown (Auto / npm / uvx / git / local), and hit the green Install button. The installer resolves the package, writes config to every toggled client, and validates via MCP handshake.

4. Progress & Results — A real-time timeline shows each step (resolving, writing config, validating) with live status updates via WebSocket. Once complete, a health report grid shows pass/fail per client with tool counts, latency, and recovery hints for any failures.

Supported Clients

Client	Config Key	Platforms
Claude Desktop	`mcpServers`	macOS, Windows, Linux
Cursor	`mcpServers`	macOS, Windows, Linux
VS Code (Copilot)	`servers`	All (workspace-level)
OpenClaw / NemoClaw	`mcp.servers`	macOS, Linux
Claude Code	`mcpServers`	macOS, Windows, Linux
ChatGPT Desktop	HTTP Bridge	All (via local HTTP proxy)

Where Are the Config Files?

Client	macOS	Windows	Linux
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json`	`%APPDATA%\Claude\claude_desktop_config.json`	`~/.config/Claude/claude_desktop_config.json`
Cursor	`~/.cursor/mcp.json`	`%USERPROFILE%\.cursor\mcp.json`	`~/.cursor/mcp.json`
VS Code	`.vscode/mcp.json` (workspace)	`.vscode/mcp.json` (workspace)	`.vscode/mcp.json` (workspace)
OpenClaw	`~/.openclaw/openclaw.json`	-	`~/.openclaw/openclaw.json`
Claude Code	`.mcp.json` (project root)	`.mcp.json` (project root)	`.mcp.json` (project root)

Features

Auto-detection of installed AI clients and their config paths
Runtime detection for Node.js, npm, npx, uvx, Python, and git
Multiple install methods: npm, uvx, git clone, local path
Config safety: backs up existing configs, atomic writes, never clobbers unrelated keys
Real MCP handshake validation: spawns the server, sends initialize/initialized, calls tools/list
Health reports: structured pass/fail per client with tool count, latency, and recovery hints
Known-issue recovery: 13+ error codes with actionable fix suggestions
Cross-platform: Windows cmd /c npx wrapping, Linux XDG paths, macOS launchd support
Service templates: generate launchd (macOS), systemd (Linux), or Task Scheduler (Windows) configs
Web dashboard: branded React UI with real-time WebSocket progress updates

Prerequisites

Node.js v18 or later
At least one supported AI client installed

Optional:

uv/uvx for Python MCP servers
git for installing from repositories

CLI Reference

# Detect your system, runtimes, and installed AI clients
npx universal-mcp-installer detect

# Install an MCP server to all detected clients
npx universal-mcp-installer install @modelcontextprotocol/server-memory

# Install to specific clients only
npx universal-mcp-installer install my-server --clients cursor,claude-desktop

# Install with environment variables
npx universal-mcp-installer install my-server --env API_KEY=sk-123

# Install from a git repository
npx universal-mcp-installer install https://github.com/user/mcp-server.git

# Install from a local directory
npx universal-mcp-installer install ./my-local-server --method local

# Validate an MCP server by running the handshake
npx universal-mcp-installer validate npx -y @modelcontextprotocol/server-memory

# Launch the web dashboard
npx universal-mcp-installer --ui

CLI Options

Option	Description
`--clients <ids>`	Comma-separated client IDs: `cursor`, `claude-desktop`, `vscode`, `openclaw`, `claude-code`, `chatgpt`
`--method <method>`	Install method: `auto`, `npm`, `uvx`, `git`, `local`
`--env KEY=value`	Environment variable (repeatable)
`--args <arg>`	Server argument (repeatable)
`--no-validate`	Skip MCP handshake validation after install
`--port <number>`	Dashboard port (default: 3939)

API Endpoints (Dashboard Mode)

When running with --ui, a local API is available:

Endpoint	Method	Description
`/api/system`	GET	System info, runtimes, detected clients
`/api/clients`	GET	Client detection details
`/api/install`	POST	Trigger installation
`/api/validate`	POST	Trigger MCP handshake validation
`/ws`	WebSocket	Real-time progress events

Development

# Clone and install
git clone https://github.com/matthewdcage/cursor-mcp-installer.git
cd cursor-mcp-installer
npm install

# Build the server
npm run build

# Build the dashboard
cd dashboard && npm install && npm run build && cd ..

# Run tests (real MCP handshake, no mocks)
npm test

# Watch mode
npm run dev

Project Structure

src/
  index.ts               MCP server entry (stdio)
  cli.ts                 CLI entry (npx)
  detect/                OS, runtime, client detection
  clients/               Config writers per AI client
  install/               Package resolution (npm, uvx, git, local)
  validate/              MCP handshake + health reports
  api/                   HTTP/WebSocket API for dashboard
  utils/                 Config I/O, logging, errors, platform utils
dashboard/               React + Vite + Tailwind web UI
tests/                   Unit, integration, E2E tests
docs/                    Localized official MCP docs

Changelog

v1.0.0 (Universal Rewrite)

Complete rewrite from cursor-mcp-installer (v0.1.3) to universal-mcp-installer
Upgraded MCP SDK from ^1.0.1 to ^1.29.0 (28 minor versions)
Added support for 6 AI clients (was Cursor-only)
Added real MCP handshake validation (was none)
Added cross-platform support with platform-specific config paths
Added CLI with detect, install, validate commands
Added web dashboard with React + Tailwind + WebSocket
Added 50+ real tests (was echo "No tests specified")
Added known-issue error recovery database
Added service template generation (launchd, systemd, Task Scheduler)
Replaced rimraf/spawn-rx with Node built-ins
Fixed: require.resolve in ESM context
Fixed: console.error/console.warn corrupting stdio JSON-RPC stream
Full TypeScript source (was compiled JS-only artifact)

License

MIT

Available Tools

3 tools

add_to_cursor_configC

Add any MCP server to Cursor's configuration

ParametersJSON Schema

Name	Required	Description
`args`	No	Arguments to pass to the command
`command`	No	Command to execute (e.g., node, npx, python)
`env`	No	Environment variables to set, delimited by =
`name`	Yes	Display name for the MCP server in Cursor
`path`	No	Path to the MCP server on disk (optional, used instead of command+args)

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Add') but doesn't explain what this entails—whether it modifies configuration files, requires specific permissions, has side effects, or what happens on success/failure. For a configuration mutation tool, this is a significant gap in transparency.

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, clear sentence that efficiently conveys the core purpose without unnecessary words. It's front-loaded and wastes no space, making it easy for an agent 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 tool that mutates configuration (implied by 'Add') with 5 parameters, no annotations, and no output schema, the description is insufficient. It doesn't address behavioral aspects like permissions, side effects, or error handling, nor does it help differentiate from sibling tools, leaving the agent with incomplete context for safe and effective use.

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 already documents all 5 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, such as explaining relationships between parameters (e.g., 'path' vs 'command+args') or usage examples. Baseline 3 is appropriate when schema does the heavy lifting.

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 action ('Add') and resource ('any MCP server to Cursor's configuration'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'install_local_mcp_server' or 'install_repo_mcp_server', which likely handle more specific installation scenarios.

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 its siblings ('install_local_mcp_server', 'install_repo_mcp_server'), nor does it mention any prerequisites, alternatives, or exclusion criteria. This leaves 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.

install_local_mcp_serverC

Install an MCP server whose code is cloned locally on your computer

ParametersJSON Schema

Name	Required	Description
`args`	No	The arguments to pass along
`env`	No	The environment variables to set, delimited by =
`path`	Yes	The path to the MCP server code cloned on your computer

TDQS

C2.9/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 states the action is 'Install', implying a write operation, but doesn't cover permissions needed, side effects (e.g., system changes), error handling, or output format. This leaves significant gaps for a tool that likely modifies the local environment.

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 directly states the tool's purpose without unnecessary words. It is front-loaded and appropriately sized, 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?

Given the complexity of an installation tool with no annotations and no output schema, the description is insufficient. It lacks details on behavioral traits (e.g., what 'Install' entails operationally), prerequisites, or expected outcomes, leaving the agent with incomplete context for safe and effective use.

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 already documents all three parameters (path, args, env) with clear descriptions. The description adds no additional parameter semantics beyond what's in the schema, such as examples or constraints, resulting in the baseline score for high schema coverage.

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 action ('Install') and the resource ('an MCP server whose code is cloned locally on your computer'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'install_repo_mcp_server' beyond the 'cloned locally' detail, which is implied but not contrasted.

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 'install_repo_mcp_server' or 'add_to_cursor_config'. It mentions the resource is 'cloned locally', which hints at a prerequisite, but lacks explicit when/when-not instructions or named alternatives.

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

install_repo_mcp_serverC

Install an MCP server via npx or uvx

ParametersJSON Schema

Name	Required	Description
`args`	No	The arguments to pass along
`env`	No	The environment variables to set, delimited by =
`name`	Yes	The package name of the MCP server

TDQS

C2.9/5.0

Behavior2/5

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

With no annotations provided, the description carries full burden but lacks behavioral details. It states the installation action but doesn't disclose critical traits like required permissions, side effects (e.g., system changes), error handling, or output format. This leaves significant gaps for an 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.

Conciseness5/5

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core action and methods, making it easy to parse quickly without unnecessary elaboration.

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 installing software (a mutation operation with potential side effects), no annotations, and no output schema, the description is incomplete. It lacks details on prerequisites, success/failure outcomes, and behavioral context, making it insufficient for safe and effective tool invocation.

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 already documents all parameters (name, args, env). The description adds no additional meaning beyond what the schema provides, such as examples or usage context for parameters. Baseline 3 is appropriate as the schema handles parameter documentation adequately.

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 action ('Install') and resource ('MCP server'), specifying the installation methods ('via npx or uvx'). However, it doesn't differentiate from sibling tools like 'install_local_mcp_server', which likely handles local installations versus this tool's package-based approach.

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?

No explicit guidance on when to use this tool versus alternatives is provided. The description mentions installation methods but doesn't clarify scenarios where 'install_repo_mcp_server' is preferred over 'install_local_mcp_server' or other siblings, leaving usage context ambiguous.

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

Install Server

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

TDQS

A3.5/5.0

Disambiguation5/5

Each tool has a clearly distinct purpose: adding servers to config, installing from local code, and installing from remote repositories. There is no overlap or ambiguity between these three installation-related operations.

Naming Consistency4/5

The tools follow a consistent verb_object pattern (add_to..., install_..., install_...), though 'add_to_cursor_config' uses a prepositional phrase while the others use adjective-noun modifiers. This minor deviation doesn't significantly impact readability.

Tool Count5/5

Three tools is perfectly appropriate for an MCP installer server. Each tool covers a distinct installation scenario (config addition, local install, remote install), and there are no missing or redundant tools for this focused purpose.

Completeness5/5

The toolset provides complete coverage for MCP server installation workflows: adding to configuration, installing from local sources, and installing from remote repositories. There are no obvious gaps in the installation lifecycle for this domain.

Maintenance

ActivityInactive

ResponsivenessUnresponsive

Resources

Need Help?

Reddit Discussion

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

hithereiamaliff-mcp-nextcloudOAuth
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
237
docs
dev.continue
An MCP server for docs.continue.dev
Documentation Access Developer Tools Search
2
Mercado Pago
com.mercadopago.mcp
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
Finance E-commerce & Retail App Automation
2
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2

Related MCP Servers

DevEnvInfoServer
Developer Tools Databases
carterlasalle
A
license
Not graded
quality
D
maintenance
An MCP server that provides detailed information about your development environment to the Cursor code editor, enabling more context-aware assistance.
Updated 4 months ago (2026-05-04 06:24 UTC)
7
MIT
hyper-mcp
Agent Orchestration Developer Tools
kranners
A
license
Not graded
quality
F
maintenance
A configurable MCP server wrapper for Cursor that eliminates tool count limits when using the Model Context Protocol.
Updated 6 months ago (2026-02-27 04:56 UTC)
21
10
GPL 3.0
Awesome-MCP-Scaffold
Developer Tools Code Execution App Automation
WW-AI-Lab
A
license
Not graded
quality
C
maintenance
A production-ready development scaffold for MCP servers, optimized for Cursor IDE with built-in tools, resources, and prompts that enables quick development of Model Context Protocol servers with 5-minute startup and 10-minute development capabilities.
Updated a year ago (2025-07-11 07:34 UTC)
26
MIT
Shellagent MCP Server
Shell Access Command Line Code Execution
myshell-joe
F
license
B
quality
D
maintenance
A Model Context Protocol (MCP) server that can be deployed locally via stdio or remotely via SSE/HTTP endpoints, supporting multiple MCP clients including VS Code, Cursor, Windsurf, and Claude Desktop.
Updated a year ago (2025-06-19 16:14 UTC)
1

Appeared in Searches

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/matthewdcage/cursor-mcp-installer'

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

Quick Start Guide

Step 1: Install an MCP Server (One Command)

Step 2: Or Add as an MCP Tool (Let Your AI Install Other MCP Servers)

Cursor (~/.cursor/mcp.json)

Claude Desktop (claude_desktop_config.json)

VS Code (.vscode/mcp.json)

Step 3: Restart Your AI Client

Step 4: Ask Your AI to Install Servers

Using the Dashboard

Supported Clients

Where Are the Config Files?

Features

Prerequisites

CLI Reference

CLI Options

API Endpoints (Dashboard Mode)

Development

Project Structure

Changelog

v1.0.0 (Universal Rewrite)

License

Available Tools

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Appeared in Searches

Latest Blog Posts

MCP directory API

Cursor (`~/.cursor/mcp.json`)

Claude Desktop (`claude_desktop_config.json`)

VS Code (`.vscode/mcp.json`)