Guía completa de Cursor MCP: cómo conectar la IA con herramientas externas

Cuando escribes código con Cursor, hay un problema bastante molesto. Cada vez que pides a la IA una tarea relacionada con el proyecto, tienes que explicar de nuevo la estructura del proyecto, el diseño de las tablas de la base de datos y las interfaces de la API — como si estuvieras dándole clase una y otra vez.

La IA es inteligente, pero no puede «ver» los datos de la base de datos, no sabe qué archivos hay en el sistema de archivos y tampoco puede llamar directamente a una API. Tienes que copiar y pegar la información manualmente, y eso no es eficiente.

MCP (Model Context Protocol) ofrece una solución elegante a este problema. En pocas palabras, MCP es un protocolo estándar que permite a la IA conectarse con herramientas y fuentes de datos externas. Una vez configurado, la IA puede consultar bases de datos, leer archivos e invocar APIs por sí misma.

¿Qué es MCP?

Una analogía sencilla

Si tuviera que explicar MCP con las palabras más simples, diría: MCP es como instalar un puerto USB-C a la IA.

Antes, cada dispositivo tenía su propio conector de carga: iPhone con Lightning, Android con Micro-USB, portátiles con otro estándar distinto. Un caos. Luego llegó USB-C y un solo puerto resolvió todo.

MCP sigue la misma idea. Es un protocolo abierto desarrollado por Anthropic que ofrece una interfaz estándar para conectar la IA con herramientas externas. Con este estándar, las aplicaciones de IA no tienen que desarrollar integraciones desde cero cada vez.

¿Por qué hace falta MCP?

Antes de MCP, si querías conectar la IA a una base de datos, cada aplicación tenía que inventar su propia solución. Cursor una, Claude Desktop otra, y cada herramienta otra más. Los desarrolladores repetían trabajo, el coste de mantenimiento era alto y las herramientas no eran compatibles entre sí.

MCP cambió esto. Propone la idea de «escribir una vez, usar en todas partes». Solo hay que desarrollar un conector de base de datos según el estándar MCP para usarlo en cualquier aplicación de IA compatible. Así se gana eficiencia y se evita duplicar esfuerzos.

MCP frente a los plugins tradicionales

Seguramente te preguntes: ¿en qué se diferencia de los plugins o extensiones tradicionales?

La diferencia es notable. Los plugins tradicionales amplían funcionalidades a nivel de aplicación — por ejemplo, un bloqueador de anuncios en el navegador o un tema en VSCode. MCP, en cambio, amplía capacidades a nivel del modelo de IA.

La distinción clave: la IA decide de forma inteligente cuándo invocar una herramienta, sin que tengas que dar instrucciones explícitas.

Por ejemplo, le dices a Cursor: «Ayúdame a ver los pedidos de este usuario en la base de datos». Con MCP configurado, la IA entenderá automáticamente que debe:

1. Conectarse a la base de datos
2. Consultar la tabla de usuarios para encontrar el ID
3. Consultar la tabla de pedidos para obtener los pedidos relacionados
4. Organizar los resultados para ti

En todo el proceso no necesitas decir «ve a la base de datos» ni «ejecuta SQL». La IA ya sabe qué hacer.

Arquitectura central

Desde el punto de vista técnico, la arquitectura de MCP es clara:

• MCP Host: la aplicación de IA que usas, como Cursor o Claude Desktop
• MCP Client: gestiona la conexión entre el Host y el Server
• MCP Server: envuelve servicios externos (bases de datos, APIs, sistemas de archivos, etc.)
• Protocolo de comunicación: usa una interfaz JSON-RPC estándar

Como piezas de un puzzle, cada parte cumple su función. Solo tienes que configurar qué MCP Servers quieres usar; el resto lo gestiona la IA.

¿Qué puede hacer MCP?

Después de la teoría, veamos qué puede hacer MCP en la práctica. Estos son escenarios que he probado yo mismo.

Acceso a bases de datos

Esta función me ha ahorrado muchísimo tiempo.

Supón que estás haciendo un proyecto de comercio electrónico con tablas de usuarios, productos y pedidos. Antes, si querías que la IA te ayudara a escribir una consulta de «pedidos del último mes de un usuario», tenías que:

1. Copiar la estructura de las tablas para la IA
2. Explicar las relaciones entre tablas
3. Indicar los campos a consultar

Ahora, con MySQL MCP Server configurado, solo dices: «Ayúdame a consultar los pedidos del último mes del usuario con ID 123». La IA automáticamente:

• Se conecta a la base de datos
• Analiza la estructura de las tablas
• Genera SQL preciso
• Ejecuta la consulta
• Organiza los resultados en el formato que necesitas

Y el SQL que genera se basa en tu estructura real de tablas, no en código de ejemplo inventado.

Railway - Plataforma de despliegue moderna, sin ops complejas, en producción en minutos

Empezar ahora →Anuncio

Operaciones en el sistema de archivos

Uso mucho esta función para ordenar código.

Por ejemplo, en un proyecto con muchas librerías de terceros, con el tiempo quedan muchos import sin usar. Revisarlos uno a uno a mano es agotador.

Con el MCP Server del sistema de archivos configurado, puedo decirle directamente a Cursor: «Escanea todo el proyecto, encuentra todos los import sin usar y límpialos». La IA automáticamente:

• Recorre los directorios del proyecto
• Analiza los import de cada archivo
• Comprueba cuáles no se usan realmente
• Modifica los archivos para eliminarlos

Muy útil cuando refactorizas código.

Integración con APIs

MCP ofrece un soporte muy amplio para integración con APIs. Ya hay MCP Servers para muchos servicios habituales.

GitHub MCP

Si usas GitHub a menudo, esto es muy cómodo. Una vez configurado, puedes pedir a la IA:

• Ver Issues de un repositorio: «¿Qué Issues abiertos están etiquetados como bug?»
• Crear Pull Request: «Abre un PR con los cambios de esta rama»
• Gestionar ramas: «Crea una nueva rama feature»

Slack MCP

Lo uso para automatizar notificaciones al equipo. Por ejemplo:

• «Envía un mensaje al canal #dev avisando de que la nueva versión ya está en producción»
• «Mira si alguien me ha mencionado en el canal últimamente»

Google Workspace MCP

Cubre Gmail, Google Docs, Sheets, Drive y Calendar. Si tu flujo de trabajo depende del ecosistema de Google, configurarlo ahorra mucho tiempo.

Por ejemplo: «Organiza los resultados del análisis de ayer en Google Sheets» o «Muéstrame la agenda de mañana».

Automatización del navegador

Chrome DevTools MCP es una herramienta muy interesante.

Permite que la IA interactúe directamente con el navegador. Puedes pedirle que:

• Abra una página web
• Lea la estructura DOM
• Ejecute JavaScript
• Analice el rendimiento de la página

Lo he usado para pruebas automatizadas y análisis de rendimiento. Por ejemplo: «Abre nuestra página de inicio, analiza el tiempo de carga del first paint y dime qué recursos cargan más lento».

Extracción de contenido web

Fetch Server está pensado específicamente para extraer contenido de páginas web.

Convierte el contenido web a un formato amigable para la IA. Si quieres analizar un artículo, no hace falta copiarlo a mano: le das el enlace a la IA — «Analiza las ideas principales de este artículo» — y ella extrae el contenido y lo analiza.

¿Cómo configurar MCP?

Hasta aquí deberías tener una idea básica de MCP. A continuación explico en detalle cómo configurarlo.

Preparación antes de configurar

Antes de empezar, confirma dos cosas:

1. Versión de Cursor: asegúrate de usar la última versión. El soporte de MCP es relativamente reciente.
2. Método de transporte: conoce la diferencia entre los dos modos
   • stdio: entrada/salida estándar, el servicio corre en local, Cursor lo gestiona, uso individual
   • SSE/HTTP: comunicación por red, se puede desplegar en servidor remoto, admite uso compartido

En la mayoría de casos recomiendo stdio. La configuración es simple y no necesitas un servidor adicional.

Método 1: interfaz de ajustes de Cursor (recomendado)

Si es tu primera vez configurando MCP, este camino es el más sencillo.

Pasos:

1. Abre Cursor
2. Abre los ajustes con el atajo
   • Windows/Linux: Ctrl+Shift+J
   • macOS: Cmd+Shift+J
3. En el menú izquierdo, busca «Tools & Integrations»
4. Haz clic en «New MCP Servers» en la parte inferior
5. Cursor creará o abrirá automáticamente el archivo de configuración mcp.json

La ventaja es la interfaz visual y la validación en tiempo real. Si hay un error, te lo indica directamente.

Método 2: editar el archivo de configuración directamente

Si prefieres editar archivos a mano, puedes crearlo manualmente.

Hay dos ubicaciones para el archivo de configuración de MCP:

• Configuración de proyecto: .cursor/mcp.json (solo afecta al proyecto actual)
• Configuración global: ~/.cursor/mcp.json (afecta a todos los proyectos)

Suelo poner en la configuración global los MCP Servers habituales (GitHub, Fetch) y en la de proyecto los específicos (conexión a base de datos, etc.).

Estructura del archivo de configuración

La estructura básica del archivo de configuración de MCP es esta:

{
  "mcpServers": {
    "nombre-del-servidor": {
      "command": "comando-a-ejecutar",
      "args": ["lista-de-argumentos"],
      "env": {
        "variable-de-entorno": "valor"
      }
    }
  }
}

• command: comando a ejecutar, como npx, node o python
• args: argumentos del comando, normalmente el nombre del paquete del MCP Server o la ruta del script
• env: variables de entorno para pasar API Token, contraseñas de base de datos y otra información sensible

Caso práctico 1: configurar GitHub MCP

Empecemos por GitHub MCP, que es muy habitual.

Código de configuración:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Explicación de la configuración:

Vultr - Servidor cloud NVMe de alto rendimiento, 32 ubicaciones globales, despliegue Docker con un clic

Ver precios →Anuncio

• command: "npx": usa el ejecutor de paquetes de Node.js, sin instalación global
• args: ["-y", "@modelcontextprotocol/server-github"]:
  • -y confirma automáticamente
  • @modelcontextprotocol/server-github es el paquete oficial del GitHub MCP Server
• env.GITHUB_PERSONAL_ACCESS_TOKEN: tu token de acceso personal de GitHub

Cómo obtener el GitHub Token:

1. Abre GitHub y entra en Settings
2. En el menú izquierdo, busca Developer settings
3. Haz clic en Personal access tokens → Tokens (classic)
4. Haz clic en Generate new token
5. Selecciona los permisos necesarios (como mínimo repo)
6. Tras generarlo, copia el Token y pégalo en el archivo de configuración

Nota: el Token solo se muestra una vez; guárdalo bien.

Caso práctico 2: configurar Fetch Server

Este es aún más simple porque no requiere API Token.

{
  "mcpServers": {
    "fetch": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"]
    }
  }
}

Así de simple. Tras configurarlo, puedes pedir a la IA que extraiga el contenido de cualquier página web.

Caso práctico 3: configurar MCP de base de datos

La configuración de base de datos es un poco más compleja porque hay que pasar la información de conexión.

Aquí un ejemplo con MySQL (nota: necesitas un MySQL MCP Server, propio o de la comunidad):

{
  "mcpServers": {
    "mysql": {
      "command": "node",
      "args": ["/path/to/mysql-mcp-server/index.js"],
      "env": {
        "DB_HOST": "localhost",
        "DB_USER": "root",
        "DB_PASSWORD": "your_password",
        "DB_NAME": "your_database"
      }
    }
  }
}

Avisos importantes:

• Sustituye /path/to/mysql-mcp-server/index.js por la ruta real
• No hardcodees la contraseña de la base de datos; usa variables de entorno
• Si la base de datos está en un servidor remoto, cambia DB_HOST por la dirección real

Ejemplo de configuración completa con varios MCP Servers

En la práctica, sueles configurar varios MCP Servers. Un archivo completo podría ser así:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    "fetch": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-fetch"]
    },
    "mysql": {
      "command": "node",
      "args": ["/Users/your-name/mcp-servers/mysql/index.js"],
      "env": {
        "DB_HOST": "localhost",
        "DB_USER": "root",
        "DB_PASSWORD": "your_password",
        "DB_NAME": "your_database"
      }
    }
  }
}

Verificar que la configuración funciona

Tras configurar, hay que comprobar que surte efecto.

Pasos:

1. Reinicia Cursor: los cambios en la configuración requieren reinicio
2. Prueba las funciones de MCP: en el chat de Cursor, prueba por ejemplo:
   • GitHub: «Muéstrame la lista de mis repositorios de GitHub»
   • Fetch: «Extrae el contenido principal de https://example.com»
3. Observa la respuesta de la IA: si la configuración es correcta, la IA invocará las herramientas MCP correspondientes

Si la IA dice «no tengo permiso para acceder…» o «no puedo conectar…», hay un problema en la configuración.

Resolución de problemas frecuentes

He tropezado con algunos fallos; comparto las soluciones:

Problema 1: formato incorrecto del archivo de configuración

Síntoma: error al iniciar Cursor o MCP no funciona

Solución:

• Revisa la sintaxis JSON, especialmente comas, comillas y paréntesis
• Usa una herramienta de validación JSON
• Evita una coma de más en el último elemento

Problema 2: permisos insuficientes del API Token

Síntoma: la IA se conecta al servicio pero falla en ciertas operaciones

Solución:

• Revisa el alcance de permisos del Token
• El Token de GitHub necesita al menos permiso repo
• Si falla una operación, puede que hagan falta más permisos

Problema 3: puerto ocupado

Síntoma: error al iniciar el MCP Server

Solución:

• Comprueba si otro programa usa el puerto
• Con stdio normalmente no ocurre
• Con SSE, prueba otro puerto

Problema 4: variables de entorno no aplicadas

Síntoma: configuraste variables de entorno pero el MCP Server no las lee

Solución:

• Revisa la ortografía de los nombres
• Confirma que guardaste el archivo de configuración
• En Windows, usa barras invertidas dobles o barras normales en las rutas

Consejos de uso avanzado

Configurar con éxito es solo el primer paso. Aquí van algunos trucos prácticos que he recopilado.

Elegir el método de transporte adecuado

stdio es ideal para:

• Desarrollo local
• Uso individual
• Configuración rápida sin servidor adicional

SSE/HTTP es ideal para:

• Compartir un MCP Server en equipo
• Base de datos o servicios en servidor remoto
• Gestión y monitorización centralizadas

Suelo usar stdio para herramientas personales (GitHub, Fetch) y SSE para bases de datos compartidas en equipo.

KiloClaw - OpenClaw gestionado para empresas: orquestación de agentes IA y enrutamiento inteligente

Empezar →Anuncio

Gestionar varios MCP Servers

Cuando configuras muchos MCP Servers, puede volverse caótico. Mi recomendación:

• Configuración global: servidores comunes y genéricos (GitHub, Fetch, Slack)
• Configuración de proyecto: servidores específicos (base de datos, API interna)
• Activar según necesidad: comenta los que no uses para no desperdiciar recursos al arrancar

Recomendaciones de seguridad

Configurar MCP implica mucha información sensible; cuida la seguridad:

No subas Tokens a Git:

• Añade .cursor/mcp.json a .gitignore
• O usa variables de entorno en lugar de valores hardcodeados

Renueva Tokens periódicamente:

• Los Tokens de GitHub pueden tener fecha de caducidad
• Actualiza contraseñas y Tokens con regularidad

Principio de mínimo privilegio:

• Al Token de GitHub solo dale los permisos necesarios
• Al usuario de base de datos, solo lectura si solo necesitas consultas

MCP Servers recomendados

Según mi experiencia, estos son los más útiles:

Herramientas de desarrollo:

• @modelcontextprotocol/server-github: integración con GitHub
• @modelcontextprotocol/server-gitlab: integración con GitLab

Bases de datos:

• PostgreSQL MCP Server
• MySQL MCP Server
• MongoDB MCP Server

Colaboración y oficina:

• Google Workspace MCP Server (Gmail, Docs, Sheets, etc.)
• Slack MCP Server

Obtención de datos:

• @modelcontextprotocol/server-fetch: extracción web
• Firecrawl MCP Server: crawling más potente

Automatización del navegador:

• Chrome DevTools MCP: depuración y automatización del navegador

Optimización del rendimiento

Con el uso intensivo de MCP puedes notar problemas de rendimiento. Algunos consejos:

Activa solo los Servers que necesites:

• Comenta o elimina los que no uses
• Reduce el consumo de recursos al arrancar

Ten en cuenta la latencia de red:

• Los servidores remotos añaden latencia
• Si la base de datos está en la nube, valora la calidad de la red

Configura timeouts razonables:

• Algunos MCP Servers permiten configurar timeout
• Evita que una petición bloquee todo el flujo

Resumen

Repasemos rápidamente:

Qué es MCP: un protocolo estándar para conectar la IA con herramientas y datos externos, como el puerto USB-C de la IA.

Qué puede hacer MCP:

• Acceder a bases de datos; la IA genera y ejecuta SQL automáticamente
• Operar el sistema de archivos y procesar archivos en lote
• Integrar GitHub, Slack, Google Workspace y otros servicios
• Automatizar el navegador y extraer contenido web

Cómo configurarlo:

• Desde la interfaz de ajustes de Cursor o editando mcp.json directamente
• El archivo incluye command, args y env
• Los más habituales son GitHub, Fetch y servidores de base de datos

Mi consejo: empieza por lo simple. Configura primero un Fetch Server para probar y sentir el poder de MCP. Cuando te familiarices, añade otros Servers según tus necesidades.

El ecosistema MCP crece muy rápido; casi cada semana aparecen nuevos MCP Servers. La visión de «escribir una vez, usar en todas partes» se está materializando. En el futuro, al cambiar de herramienta de IA, no tendrás que reconfigurar integraciones: los MCP Servers seguirán funcionando.