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

• 📚 Documentación

• 🐛 Rastreador de problemas

• 💬 Discusiones

• 🔒 Seguridad

Expresiones de gratitud

• Editor de cursores : el editor de código basado en IA

• Claude AI - Asistente avanzado de IA

• @nut-tree/nut-js - Automatización multiplataforma

• active-win - Detección de ventanas