Integraciones MCP

Qué es MCP (Model Context Protocol)

El Model Context Protocol (MCP) es un protocolo de comunicación estándar que permite a los editores de código como Cursor AI conectarse con herramientas externas y fuentes de datos de manera uniforme. 

Este protocolo actúa como un puente de comunicación entre el entorno de desarrollo y servicios externos, proporcionando al modelo de IA acceso a información contextual adicional que mejora la calidad de sus respuestas y sugerencias.

Arquitectura del protocolo

MCP funciona mediante un sistema cliente-servidor donde Cursor AI actúa como cliente y las herramientas externas implementan servidores MCP. 

Esta arquitectura permite que el editor acceda a recursos como bases de datos, APIs web, sistemas de archivos remotos o herramientas de análisis sin necesidad de implementaciones específicas para cada servicio.

El protocolo define un conjunto de mensajes estándar que facilitan la comunicación bidireccional. Los servidores MCP pueden exponer diferentes tipos de recursos:

• Recursos de datos: Archivos, bases de datos, contenido web
• Herramientas ejecutables: Scripts, comandos del sistema, APIs
• Prompts predefinidos: Plantillas de consulta especializadas
• Samplers: Generadores de contenido personalizado

Ventajas en el desarrollo con IA

La implementación de MCP en Cursor AI transforma la experiencia de desarrollo al proporcionar contexto enriquecido al modelo de IA. Cuando trabajas en un proyecto Python, por ejemplo, el protocolo puede conectar automáticamente con documentación técnica actualizada, repositorios de código relacionados o bases de datos de ejemplos.

Esta conectividad permite que las sugerencias de código sean más precisas y contextualmente relevantes. En lugar de generar código genérico, el modelo puede acceder a patrones específicos de tu proyecto, convenciones de tu equipo o mejores prácticas actualizadas desde fuentes externas.

Casos de uso prácticos

En el contexto de desarrollo con Python para IA generativa, MCP es muy útil para:

Acceso a documentación actualizada: Los servidores MCP pueden conectar con repositorios de documentación de librerías como TensorFlow, PyTorch o Hugging Face, proporcionando información actualizada sobre APIs y mejores prácticas.

Integración con bases de datos: Permite consultar esquemas de bases de datos, obtener ejemplos de consultas SQL o acceder a datasets de entrenamiento sin salir del editor.

Conexión con servicios de ML: Facilita la integración con plataformas como Weights & Biases, MLflow o servicios de cloud computing para obtener métricas, modelos preentrenados o configuraciones de infraestructura.

Funcionamiento técnico

El protocolo utiliza JSON-RPC 2.0 como formato de comunicación, lo que garantiza compatibilidad multiplataforma y facilita la implementación de nuevos servidores. Los mensajes se intercambian a través de diferentes transportes, siendo los más comunes:

• Stdio: Comunicación directa a través de entrada y salida estándar
• SSE (Server-Sent Events): Para conexiones web en tiempo real
• WebSocket: Para comunicación bidireccional persistente

Cada servidor MCP implementa un conjunto de capacidades que declara durante el proceso de inicialización. Cursor AI puede entonces consultar estas capacidades y utilizar solo aquellas que sean relevantes para el contexto actual de desarrollo.

La gestión de sesiones permite mantener estado entre diferentes interacciones, lo que es crucial para herramientas que requieren autenticación o mantienen conexiones persistentes con servicios externos.

Extensibilidad y personalización

Una de las características más destacadas de MCP es su naturaleza extensible. Los desarrolladores pueden crear servidores MCP personalizados para integrar herramientas específicas de su flujo de trabajo. Esto significa que puedes desarrollar conectores para sistemas internos de tu organización, herramientas de análisis personalizadas o fuentes de datos propietarias.

El protocolo también soporta composición de servicios, permitiendo que múltiples servidores MCP trabajen conjuntamente para proporcionar funcionalidades complejas. Por ejemplo, un servidor puede obtener datos de una API, otro puede procesarlos con herramientas de análisis, y un tercero puede generar visualizaciones, todo de manera coordinada.

Instalación y configuración de servidores MCP

La configuración de servidores MCP en Cursor AI se realiza a través del archivo de configuración del editor, donde defines qué servidores quieres activar y cómo deben conectarse. Este proceso requiere tanto la instalación de los servidores como su posterior configuración en el entorno de Cursor.

Acceso a la configuración MCP

Para configurar servidores MCP, Cursor utiliza archivos de configuración específicos:

Configuración por proyecto: Crea .cursor/mcp.json en tu proyecto para herramientas específicas del proyecto.

Configuración global: Crea ~/.cursor/mcp.json en tu directorio home para herramientas disponibles en todos los proyectos.

Pulsando en New MCP Server nos muestra el fichero mcp.json con la configuración donde podemos agregar servidores MCP.

La configuración se estructura mediante un objeto JSON que define cada servidor MCP con sus parámetros específicos:

{
  "mcp": {
    "servers": {
      "nombre-servidor": {
        "command": "ruta-al-ejecutable",
        "args": ["argumentos", "del", "servidor"],
        "env": {
          "VARIABLE": "valor"
        }
      }
    }
  }
}

Instalación de servidores oficiales

Los servidores MCP oficiales se distribuyen principalmente como paquetes de Python que puedes instalar mediante pip. Para proyectos de IA generativa, algunos de los más útiles incluyen:

Servidor de sistema de archivos:

pip install mcp-server-filesystem

Este servidor permite acceso controlado al sistema de archivos local, útil para proyectos que manejan datasets o archivos de configuración.

Servidor de SQLite:

pip install mcp-server-sqlite

Proporciona acceso a bases de datos SQLite, común en proyectos de machine learning para almacenar métricas y resultados.

Servidor web:

pip install mcp-server-web

Permite realizar consultas web y scraping de contenido, útil para obtener datos actualizados o documentación online.

Configuración básica de servidores

Una vez instalados los servidores, configúralos en Cursor añadiendo las entradas correspondientes. Para el servidor de sistema de archivos:

{
  "mcp": {
    "servers": {
      "filesystem": {
        "command": "python",
        "args": ["-m", "mcp_server_filesystem", "/ruta/a/tu/proyecto"],
        "env": {
          "PYTHONPATH": "/ruta/a/tu/entorno/virtual"
        }
      }
    }
  }
}

Para el servidor SQLite, especifica la ruta a tu base de datos:

{
  "mcp": {
    "servers": {
      "sqlite": {
        "command": "python",
        "args": ["-m", "mcp_server_sqlite", "--db-path", "/ruta/a/tu/database.db"],
        "env": {
          "PYTHONPATH": "/ruta/a/tu/entorno/virtual"
        }
      }
    }
  }
}

Configuración de entornos virtuales

Para proyectos Python de IA generativa, es fundamental configurar los servidores MCP para que utilicen el entorno virtual correcto. Esto asegura que tengan acceso a las librerías específicas de tu proyecto como TensorFlow, PyTorch o Hugging Face.

Modifica la configuración para apuntar al intérprete de Python de tu entorno virtual:

{
  "mcp": {
    "servers": {
      "mi-servidor": {
        "command": "/ruta/a/tu/venv/bin/python",
        "args": ["-m", "nombre_del_servidor"],
        "env": {
          "VIRTUAL_ENV": "/ruta/a/tu/venv",
          "PATH": "/ruta/a/tu/venv/bin:$PATH"
        }
      }
    }
  }
}

Configuración de variables de entorno

Los servidores MCP a menudo requieren variables de entorno para autenticación o configuración específica. Para proyectos de IA, esto incluye claves de API para servicios como OpenAI, Hugging Face o Weights & Biases:

{
  "mcp": {
    "servers": {
      "ml-tools": {
        "command": "python",
        "args": ["-m", "mi_servidor_ml"],
        "env": {
          "OPENAI_API_KEY": "tu-clave-api",
          "HUGGINGFACE_TOKEN": "tu-token-hf",
          "WANDB_API_KEY": "tu-clave-wandb",
          "PYTHONPATH": "/ruta/a/tu/proyecto"
        }
      }
    }
  }
}

Verificación de la instalación

Después de configurar los servidores, reinicia Cursor AI para que los cambios surtan efecto. Puedes verificar que los servidores están funcionando correctamente observando el panel de salida de Cursor o utilizando el comando de desarrollador para inspeccionar las conexiones MCP activas.

Si un servidor no se inicia correctamente, revisa:

• Rutas de archivos: Asegúrate de que todas las rutas especificadas existen y son accesibles
• Permisos: Verifica que Cursor tiene permisos para ejecutar los comandos especificados
• Dependencias: Confirma que todas las librerías Python requeridas están instaladas en el entorno correcto
• Variables de entorno: Valida que las claves de API y tokens son correctos y están activos

Configuración avanzada

Para proyectos complejos de IA generativa, puedes configurar múltiples servidores MCP que trabajen conjuntamente. Por ejemplo, combinar un servidor de base de datos para métricas, otro para acceso a modelos preentrenados y un tercero para documentación:

{
  "mcp": {
    "servers": {
      "metrics-db": {
        "command": "python",
        "args": ["-m", "mcp_server_sqlite", "--db-path", "./metrics.db"]
      },
      "model-hub": {
        "command": "python",
        "args": ["-m", "mcp_server_huggingface"],
        "env": {
          "HUGGINGFACE_TOKEN": "tu-token"
        }
      },
      "docs": {
        "command": "python",
        "args": ["-m", "mcp_server_web", "--allowed-domains", "pytorch.org,tensorflow.org"]
      }
    }
  }
}

Esta configuración proporciona a Cursor AI acceso simultáneo a múltiples fuentes de información, mejorando la calidad del contexto disponible para generar código y sugerencias específicas para tu proyecto de IA.

Ejemplo: configurar servidor MCP de GitHub

Agregar en el archivo mcp.json la configuración, requiere token de GitHub y tener docker instalado:

{
  "mcpServers": {
    "github": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "xxxx"
      }
    }

  }
}

Después una vez activado, podemos realizar preguntas que impliquen el uso de ese servidor MCP, por ejemplo: