de en es ja ko ru zh

Cursor MCP Installer

Name: Cursor MCP Installer
Author: matthewdcage

by matthewdcage

Overview Schema Source Related Servers Discussions Admin

TypeScript

Hybrid

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

License: MIT npm version MCP Compatible npm downloads

🚀 NUEVO: Universal MCP Installer v1.0.0 — Reescritura completa de cursor-mcp-installer. Ahora es compatible con 6 clientes de IA (Claude Desktop, Cursor, VS Code, OpenClaw, Claude Code, ChatGPT), multiplataforma (macOS, Windows, Linux), validación real de handshake MCP y un panel de control web con marca. Actualizado al SDK de MCP 1.29.0.

🖥️ ¡Panel de control web disponible! Inícialo con npx universal-mcp-installer --ui para gestionar todo desde una interfaz visual. Consulta Uso del panel de control a continuación.

Guía de inicio rápido

Paso 1: Instalar un servidor MCP (un solo comando)

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

Eso es todo. El instalador detecta qué clientes de IA tienes instalados y escribe la configuración correcta para cada uno.

Paso 2: O agrégalo como una herramienta MCP (deja que tu IA instale otros servidores MCP)

Agrega esto a la configuración MCP de tu cliente de IA:

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"]
    }
  }
}

Paso 3: Reinicia tu cliente de IA

Cierra y vuelve a abrir tu cliente de IA para aplicar los cambios de configuración.

Paso 4: Pide a tu IA que instale servidores

Install the filesystem MCP server

Install the web search MCP server

El instalador expone tres herramientas que tu IA puede llamar:

Herramienta	Descripción
`detect_system`	Devuelve el SO, la arquitectura, los entornos de ejecución disponibles y los clientes de IA detectados
`install_mcp_server`	Instala un servidor por nombre de paquete, URL de git o ruta local en los clientes seleccionados
`validate_mcp_server`	Valida un servidor mediante handshake MCP y devuelve el resultado

Related MCP server: hyper-mcp

Uso del panel de control

Inicia la interfaz visual:

npx universal-mcp-installer --ui

Esto abre la interfaz web en tu navegador en http://localhost:3939:

1. Panel del sistema — La sección superior detecta automáticamente tu SO y todos los entornos de ejecución disponibles (Node, npm, uvx, Python, git) para que puedas ver de un vistazo qué hay disponible en tu máquina.

2. Clientes de IA — Cada cliente detectado obtiene una tarjeta que muestra su nombre, la ruta del archivo de configuración y cuántos servidores MCP ya están configurados. Usa el interruptor en cada tarjeta para incluirlo o excluirlo de la próxima instalación. Los clientes no instalados aparecen atenuados.

3. Instalar — Escribe un nombre de paquete (paquete npm, URL de git o ruta local), elige un método del menú desplegable (Auto / npm / uvx / git / local) y presiona el botón verde Instalar. El instalador resuelve el paquete, escribe la configuración en cada cliente seleccionado y valida mediante handshake MCP.

4. Progreso y resultados — Una línea de tiempo en tiempo real muestra cada paso (resolución, escritura de configuración, validación) con actualizaciones de estado en vivo a través de WebSocket. Una vez completado, una cuadrícula de informe de salud muestra el éxito/fallo por cliente con recuentos de herramientas, latencia y sugerencias de recuperación para cualquier fallo.

Clientes compatibles

Cliente	Clave de configuración	Plataformas
Claude Desktop	`mcpServers`	macOS, Windows, Linux
Cursor	`mcpServers`	macOS, Windows, Linux
VS Code (Copilot)	`servers`	Todos (nivel de espacio de trabajo)
OpenClaw / NemoClaw	`mcp.servers`	macOS, Linux
Claude Code	`mcpServers`	macOS, Windows, Linux
ChatGPT Desktop	Puente HTTP	Todos (vía proxy HTTP local)

¿Dónde están los archivos de configuración?

Cliente	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` (espacio de trabajo)	`.vscode/mcp.json` (espacio de trabajo)	`.vscode/mcp.json` (espacio de trabajo)
OpenClaw	`~/.openclaw/openclaw.json`	-	`~/.openclaw/openclaw.json`
Claude Code	`.mcp.json` (raíz del proyecto)	`.mcp.json` (raíz del proyecto)	`.mcp.json` (raíz del proyecto)

Características

Autodetección de clientes de IA instalados y sus rutas de configuración
Detección de entorno de ejecución para Node.js, npm, npx, uvx, Python y git
Múltiples métodos de instalación: npm, uvx, git clone, ruta local
Seguridad de configuración: realiza copias de seguridad de las configuraciones existentes, escrituras atómicas, nunca sobrescribe claves no relacionadas
Validación real de handshake MCP: inicia el servidor, envía initialize/initialized, llama a tools/list
Informes de salud: éxito/fallo estructurado por cliente con recuento de herramientas, latencia y sugerencias de recuperación
Recuperación de problemas conocidos: más de 13 códigos de error con sugerencias de solución accionables
Multiplataforma: envoltorio cmd /c npx para Windows, rutas XDG para Linux, soporte para launchd en macOS
Plantillas de servicio: genera configuraciones para launchd (macOS), systemd (Linux) o Programador de tareas (Windows)
Panel de control web: interfaz React con marca y actualizaciones de progreso en tiempo real mediante WebSocket

Requisitos previos

Node.js v18 o posterior
Al menos un cliente de IA compatible instalado

Opcional:

uv/uvx para servidores MCP de Python
git para instalar desde repositorios

Referencia de CLI

# 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

Opciones de CLI

Opción	Descripción
`--clients <ids>`	IDs de cliente separados por comas: `cursor`, `claude-desktop`, `vscode`, `openclaw`, `claude-code`, `chatgpt`
`--method <method>`	Método de instalación: `auto`, `npm`, `uvx`, `git`, `local`
`--env KEY=value`	Variable de entorno (repetible)
`--args <arg>`	Argumento del servidor (repetible)
`--no-validate`	Saltar la validación de handshake MCP después de la instalación
`--port <number>`	Puerto del panel de control (predeterminado: 3939)

Puntos finales de API (modo panel de control)

Al ejecutar con --ui, hay una API local disponible:

Punto final	Método	Descripción
`/api/system`	GET	Información del sistema, entornos de ejecución, clientes detectados
`/api/clients`	GET	Detalles de detección de clientes
`/api/install`	POST	Disparar instalación
`/api/validate`	POST	Disparar validación de handshake MCP
`/ws`	WebSocket	Eventos de progreso en tiempo real

Desarrollo

# 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

Estructura del proyecto

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

Registro de cambios

v1.0.0 (Reescritura universal)

Reescritura completa de cursor-mcp-installer (v0.1.3) a universal-mcp-installer
Actualización del SDK de MCP de ^1.0.1 a ^1.29.0 (28 versiones menores)
Se agregó soporte para 6 clientes de IA (antes solo Cursor)
Se agregó validación real de handshake MCP (antes no había)
Se agregó soporte multiplataforma con rutas de configuración específicas de la plataforma
Se agregó CLI con comandos detect, install, validate
Se agregó panel de control web con React + Tailwind + WebSocket
Se agregaron más de 50 pruebas reales (antes era echo "No tests specified")
Se agregó base de datos de recuperación de errores de problemas conocidos
Se agregó generación de plantillas de servicio (launchd, systemd, Programador de tareas)
Se reemplazó rimraf/spawn-rx con funciones integradas de Node
Corregido: require.resolve en contexto ESM
Corregido: console.error/console.warn corrompiendo el flujo JSON-RPC de stdio
Fuente completa en TypeScript (antes era un artefacto compilado solo en JS)

Licencia

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.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

3 tool updatesv1.0.0Aug 15, 2025
- First observedadd_to_cursor_config
- First observedinstall_local_mcp_server
- First observedinstall_repo_mcp_server

Deploy Server

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

TDQS

A3.5/5.0

Scored 2026-04-18 11:15 across 3 tools

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

ResponsivenessNo issues

Resources

Need Help?

Reddit Discussion

Related Servers

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
238
docs
dev.continue
An MCP server for docs.continue.dev
Documentation Access Developer Tools Search
2
Mercado PagoOAuth
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
MCP Registry Search: Find, Discover & Install MCP Servers & Tools | Directory, Catalog, Marketplace A
io.github.lbesecker195
MCP registry & directory: search, find & install 31k+ MCP servers & tools. Catalog and marketplace.
Developer Tools Search
311

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 5 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 7 months ago (2026-02-27 04:56 UTC)
16 npm
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
-

Guía de inicio rápido

Paso 1: Instalar un servidor MCP (un solo comando)

Paso 2: O agrégalo como una herramienta MCP (deja que tu IA instale otros servidores MCP)

Cursor (~/.cursor/mcp.json)

Claude Desktop (claude_desktop_config.json)

VS Code (.vscode/mcp.json)

Paso 3: Reinicia tu cliente de IA

Paso 4: Pide a tu IA que instale servidores

Uso del panel de control

Clientes compatibles

¿Dónde están los archivos de configuración?

Características

Requisitos previos

Referencia de CLI

Opciones de CLI

Puntos finales de API (modo panel de control)

Desarrollo

Estructura del proyecto

Registro de cambios

v1.0.0 (Reescritura universal)

Licencia

Available Tools

Tool Schema Changelog

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

Appeared in Searches

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

Claude Desktop (`claude_desktop_config.json`)

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