Skip to main content
Glama
enesjakozh
johnneerdael

Cursor MCP Server

by johnneerdael
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Hybrid

Cursor MCP (Protocolo de contexto de modelo)

Cursor MCP es un puente entre la aplicación de escritorio de Claude y el editor de Cursor, lo que permite una automatización fluida basada en IA y la gestión de múltiples instancias. Forma parte del ecosistema más amplio del Protocolo de Contexto de Modelo (MCP), lo que permite a Cursor interactuar con diversos modelos y servicios de IA mediante interfaces estandarizadas.

Descripción general

🤖 Integración de IA

  • Integración directa con la aplicación de escritorio de Claude

  • Capacidad de aprovechar otros servicios de IA compatibles con MCP

  • Intercambio de contexto en tiempo real entre la IA y el editor

  • Automatización y generación de código impulsadas por IA

🔌 Compatibilidad con el protocolo MCP

  • Comunicación estandarizada con modelos de IA

  • Sistema de complementos extensible para MCP adicionales

  • Ejecución de comandos según el contexto

  • Autenticación segura basada en tokens

🖥️ Gestión de ventanas multiplataforma

  • Administre sin problemas las ventanas del editor del cursor en todos los sistemas operativos

  • Enfocar, minimizar, restaurar y organizar ventanas mediante programación

  • Realizar un seguimiento de los cambios de estado y posiciones de las ventanas

  • Manejar múltiples instancias de Cursor simultáneamente

⌨️ Automatización de entrada

  • Entrada de teclado impulsada por IA con soporte para:

    • Generación e inserción de código

    • Operaciones de refactorización

    • Finalizaciones según el contexto

    • Edición con múltiples cursores

  • Automatización inteligente del mouse que incluye:

    • Selección inteligente

    • Operaciones del menú contextual

    • Navegación guiada por IA

🔄 Gestión de procesos

  • Gestión de instancias orquestada por IA

  • Organización inteligente del espacio de trabajo

  • Preservación automática del contexto

  • Recuperación de sesión inteligente

Related MCP server: Portkey MCP Server

Integración MCP

Integración de escritorio de Claude

import { ClaudeMCP } from 'cursor-mcp/claude'

// Connect to Claude's desktop app
const claude = await ClaudeMCP.connect()

// Execute AI-powered operations
await claude.generateCode({
    prompt: 'Create a React component',
    context: currentFileContent,
    language: 'typescript'
})

// Get AI suggestions
const suggestions = await claude.getSuggestions({
    code: selectedText,
    type: 'refactor'
})

Uso de múltiples MCP

import { MCPRegistry } from 'cursor-mcp/registry'

// Register available MCPs
MCPRegistry.register('claude', ClaudeMCP)
MCPRegistry.register('github-copilot', CopilotMCP)

// Use different AI services
const claude = await MCPRegistry.get('claude')
const copilot = await MCPRegistry.get('github-copilot')

// Compare suggestions
const claudeSuggestions = await claude.getSuggestions(context)
const copilotSuggestions = await copilot.getSuggestions(context)

Integración de MCP personalizada

import { BaseMCP, MCPProvider } from 'cursor-mcp/core'

class CustomMCP extends BaseMCP implements MCPProvider {
    async connect() {
        // Custom connection logic
    }

    async generateSuggestions(context: CodeContext) {
        // Custom AI integration
    }
}

// Register custom MCP
MCPRegistry.register('custom-ai', CustomMCP)

Configuración

La herramienta se puede configurar a través de variables de entorno o un archivo de configuración en:

  • Ventanas: %LOCALAPPDATA%\cursor-mcp\config\config.json

  • macOS: ~/Library/Application Support/cursor-mcp/config/config.json

  • Linux: ~/.config/cursor-mcp/config.json

Ejemplo de configuración:

{
    "mcp": {
        "claude": {
            "enabled": true,
            "apiKey": "${CLAUDE_API_KEY}",
            "contextWindow": 100000
        },
        "providers": {
            "github-copilot": {
                "enabled": true,
                "auth": "${GITHUB_TOKEN}"
            }
        }
    },
    "autoStart": true,
    "maxInstances": 4,
    "windowArrangement": "grid",
    "logging": {
        "level": "info",
        "file": "cursor-mcp.log"
    }
}

Instalación

Ventanas

# Run as Administrator
Invoke-WebRequest -Uri "https://github.com/your-org/cursor-mcp/releases/latest/download/cursor-mcp-windows.zip" -OutFile "cursor-mcp.zip"
Expand-Archive -Path "cursor-mcp.zip" -DestinationPath "."
.\windows.ps1

macOS

# Run with sudo
curl -L "https://github.com/your-org/cursor-mcp/releases/latest/download/cursor-mcp-macos.zip" -o "cursor-mcp.zip"
unzip cursor-mcp.zip
sudo ./macos.sh

Linux

# Run with sudo
curl -L "https://github.com/your-org/cursor-mcp/releases/latest/download/cursor-mcp-linux.zip" -o "cursor-mcp.zip"
unzip cursor-mcp.zip
sudo ./linux.sh

Uso

Uso básico

import { CursorInstanceManager } from 'cursor-mcp'

// Get the instance manager
const manager = CursorInstanceManager.getInstance()

// Start a new Cursor instance
await manager.startNewInstance()

// Get all running instances
const instances = await manager.getRunningInstances()

// Focus a specific instance
await manager.focusInstance(instances[0])

// Close all instances
await manager.closeAllInstances()

Gestión de ventanas

import { WindowManager } from 'cursor-mcp'

const windowManager = WindowManager.getInstance()

// Find all Cursor windows
const windows = await windowManager.findCursorWindows()

// Focus a window
await windowManager.focusWindow(windows[0])

// Arrange windows side by side
await windowManager.arrangeWindows(windows, 'sideBySide')

// Minimize all windows
for (const window of windows) {
    await windowManager.minimizeWindow(window)
}

Automatización de entrada

import { InputAutomationService } from 'cursor-mcp'

const inputService = InputAutomationService.getInstance()

// Type text
await inputService.typeText('Hello, World!')

// Send keyboard shortcuts
if (process.platform === 'darwin') {
    await inputService.sendKeys(['command', 'c'])
} else {
    await inputService.sendKeys(['control', 'c'])
}

// Mouse operations
await inputService.moveMouse(100, 100)
await inputService.mouseClick('left')
await inputService.mouseDrag(100, 100, 200, 200)

Cómo funciona

Arquitectura de puentes

Esta herramienta actúa como una capa de middleware entre Cursor y los servidores MCP:

  1. Integración del cursor :

    • Monitorea los eventos del sistema de archivos del cursor

    • Captura el estado y el contexto del editor.

    • Inyecta respuestas nuevamente en el editor

    • Gestiona la automatización de ventanas y procesos.

  2. Traducción del protocolo MCP :

    • Traduce los eventos internos del Cursor en mensajes de protocolo MCP

    • Convierte las respuestas de MCP en acciones compatibles con el cursor

    • Mantiene el estado y el contexto de la sesión.

    • Maneja la autenticación y la seguridad

  3. Comunicación del servidor :

    • Se conecta al servidor MCP de la aplicación de escritorio de Claude

    • Envía solicitudes a los proveedores de IA adecuados

    • Administra conexiones simultáneas a múltiples MCP

    • Maneja los retrocesos y la recuperación de errores

graph LR
    A[Cursor Editor] <--> B[Cursor MCP Bridge]
    B <--> C[Claude Desktop MCP]
    B <--> D[GitHub Copilot MCP]
    B <--> E[Custom AI MCPs]

Ejemplo de flujo de trabajo

  1. Solicitud de finalización de código :

    // 1. Cursor Event (File Change)
// When user types in Cursor:
function calculateTotal(items) {
  // Calculate the total price of items|  <-- cursor position

// 2. Bridge Translation
const event = {
  type: 'completion_request',
  context: {
    file: 'shopping-cart.ts',
    line: 2,
    prefix: '// Calculate the total price of items',
    language: 'typescript',
    cursor_position: 43
  }
}

// 3. MCP Protocol Message
await mcpServer.call('generate_completion', {
  prompt: event.context,
  max_tokens: 150,
  temperature: 0.7
})

// 4. Response Translation
// Bridge converts MCP response:
const response = `return items.reduce((total, item) => {
  return total + (item.price * item.quantity);
}, 0);`

// 5. Cursor Integration
// Bridge injects the code at cursor position

  2. Refactorización de código :

    // 1. Cursor Event (Command)
// User selects code and triggers refactor command
const oldCode = `
  if (user.age >= 18) {
    if (user.hasLicense) {
      if (car.isAvailable) {
        rentCar(user, car);
      }
    }
  }
`

// 2. Bridge Translation
const event = {
  type: 'refactor_request',
  context: {
    selection: oldCode,
    command: 'simplify_nesting'
  }
}

// 3. MCP Protocol Message
await mcpServer.call('refactor_code', {
  code: event.context.selection,
  style: 'simplified',
  maintain_logic: true
})

// 4. Response Translation
const response = `
  const canRentCar = user.age >= 18 
    && user.hasLicense 
    && car.isAvailable;
  
  if (canRentCar) {
    rentCar(user, car);
  }
`

// 5. Cursor Integration
// Bridge replaces selected code

  3. Contexto de múltiples archivos :

    // 1. Cursor Event (File Dependencies)
// When user requests help with a component

// 2. Bridge Translation
const event = {
  type: 'context_request',
  files: {
    'UserProfile.tsx': '...',
    'types.ts': '...',
    'api.ts': '...'
  },
  focus_file: 'UserProfile.tsx'
}

// 3. MCP Protocol Message
await mcpServer.call('analyze_context', {
  files: event.files,
  primary_file: event.focus_file,
  analysis_type: 'component_dependencies'
})

// 4. Response Processing
// Bridge maintains context across requests

Métodos de integración

  1. Monitoreo del sistema de archivos :

    import { FileSystemWatcher } from 'cursor-mcp/watcher'

const watcher = new FileSystemWatcher({
  paths: ['/path/to/cursor/workspace'],
  events: ['change', 'create', 'delete']
})

watcher.on('change', async (event) => {
  const mcpMessage = await bridge.translateEvent(event)
  await mcpServer.send(mcpMessage)
})

  2. Integración de ventanas :

    import { CursorWindow } from 'cursor-mcp/window'

const window = new CursorWindow()

// Inject AI responses
await window.injectCode({
  position: cursorPosition,
  code: mcpResponse.code,
  animate: true  // Smooth typing animation
})

// Handle user interactions
window.onCommand('refactor', async (selection) => {
  const mcpMessage = await bridge.createRefactorRequest(selection)
  const response = await mcpServer.send(mcpMessage)
  await window.applyRefactoring(response)
})

  3. Gestión del contexto :

    import { ContextManager } from 'cursor-mcp/context'

const context = new ContextManager()

// Track file dependencies
await context.addFile('component.tsx')
await context.trackDependencies()

// Maintain conversation history
context.addMessage({
  role: 'user',
  content: 'Refactor this component'
})

// Send to MCP server
const response = await mcpServer.send({
  type: 'refactor',
  context: context.getFullContext()
})

Seguridad

  • Autenticación segura basada en tokens para servicios de IA

  • Canales de comunicación cifrados

  • Entorno de ejecución en espacio aislado

  • Controles de permisos de grano fino

Requisitos

Ventanas

  • Windows 10 o posterior

  • Node.js 18 o posterior

  • Privilegios de administrador para la instalación

macOS

  • macOS 10.15 (Catalina) o posterior

  • Node.js 18 o posterior

  • Herramientas de línea de comandos de Xcode

  • Permisos de accesibilidad para la Terminal

Linux

  • Servidor de visualización X11

  • Node.js 18 o posterior

  • herramienta xdotool

  • libxtst-dev

  • libpng++-dev

  • construcción esencial

Desarrollo

Configuración

# Clone the repository
git clone https://github.com/your-org/cursor-mcp.git
cd cursor-mcp

# Install dependencies
npm install

# Build the project
npm run build

# Run tests
npm test

Ejecución de pruebas

# Run all tests
npm test

# Run specific test suite
npm test -- window-management

# Run with coverage
npm run test:coverage

Contribuyendo

¡Agradecemos sus contribuciones! Consulte nuestra Guía de Contribución para más detalles.

Licencia

Este proyecto está licenciado bajo la licencia MIT: consulte el archivo de LICENCIA para obtener más detalles.

Apoyo

Expresiones de gratitud

This server cannot be installed

-
security - not tested
A
license - permissive license
-
quality - not tested

How are these scores calculated?

Resources

Appeared in Searches

Latest Blog Posts

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/johnneerdael/multiplatform-cursor-mcp'

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