Cursor + MCP + Modelo Ajustado: IA de Dominio Dentro de Tu Editor de Código

Cursor es el editor de código nativo de IA que la mayoría de los vibecoders usan a diario. Soporta servidores MCP, lo que significa que puedes conectar tu modelo ajustado a Cursor e invocar capacidades de IA específicas de dominio directamente desde tu entorno de codificación, sin cambiar de contexto.

Los casos de uso: un modelo de documentación de código entrenado en el estilo de tu codebase, un generador de código específico de dominio entrenado en tus patrones, un modelo de contenido que escribe con la voz de tu producto, todos accesibles como herramientas de Cursor.

Por Qué los Modelos de Dominio Superan a los Modelos Generales en Cursor

La IA integrada de Cursor (Claude Sonnet, GPT-4o) es excelente para tareas generales de codificación. Tiene dificultades con:

Los patrones específicos de tu codebase: La IA genérica no conoce las convenciones de nombres de tu equipo, las decisiones de arquitectura o las bibliotecas que han elegido estandarizar. Generará código sintácticamente correcto que no encaja en tu codebase.

Tu estilo de documentación: La IA genérica escribe documentación genérica. Un modelo entrenado en tus documentos existentes escribe documentación que suena como el resto de tus documentos.

Lógica específica del dominio: Si tu aplicación maneja lógica de negocio compleja (cálculos fiscales, flujos de trabajo de salud, procesamiento de documentos legales), la IA genérica hace suposiciones educadas. Un modelo entrenado en tu lógica de dominio genera lógica de negocio correcta.

Un modelo ajustado entrenado en tu codebase y dominio produce resultados que un desarrollador senior de tu equipo reconocería como adecuados.

Configuración del Servidor MCP para Cursor

Cursor lee la configuración MCP desde ~/.cursor/mcp.json (o a nivel de proyecto .cursor/mcp.json).

Paso 1: Construir un servidor MCP enfocado en código

// cursor-domain-mcp/server.mjs
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';

const OLLAMA_URL = 'http://localhost:11434/api/chat';
const MODEL = 'my-codebase-model';

const server = new Server(
  { name: 'codebase-assistant', version: '1.0.0' },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: 'generate_code',
      description: 'Generate code following the project\'s specific patterns, naming conventions, and library choices. Use for creating new functions, components, or modules that should match existing code style.',
      inputSchema: {
        type: 'object',
        properties: {
          description: { type: 'string', description: 'What code to generate' },
          file_context: { type: 'string', description: 'Relevant existing code from the codebase for context' },
          language: { type: 'string', description: 'Programming language or framework' }
        },
        required: ['description']
      }
    },
    {
      name: 'write_documentation',
      description: 'Write documentation in the project\'s established style — same format, same level of detail, same terminology. Use for JSDoc, README sections, or inline comments.',
      inputSchema: {
        type: 'object',
        properties: {
          code: { type: 'string', description: 'The code to document' },
          doc_type: { type: 'string', description: 'jsdoc, readme, comment, or api-reference' }
        },
        required: ['code']
      }
    },
    {
      name: 'domain_query',
      description: 'Answer domain-specific questions about the business logic, industry rules, or specialized requirements that the codebase implements.',
      inputSchema: {
        type: 'object',
        properties: {
          question: { type: 'string', description: 'The domain question to answer' }
        },
        required: ['question']
      }
    }
  ]
}));

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  let prompt;
  if (name === 'generate_code') {
    prompt = `Generate code for: ${args.description}
${args.file_context ? `\nExisting code context:\n${args.file_context}` : ''}
${args.language ? `\nLanguage/Framework: ${args.language}` : ''}`;
  } else if (name === 'write_documentation') {
    prompt = `Write ${args.doc_type || 'documentation'} for this code:\n\n${args.code}`;
  } else if (name === 'domain_query') {
    prompt = args.question;
  } else {
    throw new Error(`Unknown tool: ${name}`);
  }

  const response = await fetch(OLLAMA_URL, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: MODEL,
      messages: [{ role: 'user', content: prompt }],
      stream: false
    })
  });

  const data = await response.json();
  return { content: [{ type: 'text', text: data.message.content }] };
});

const transport = new StdioServerTransport();
await server.connect(transport);

Paso 2: Agregar a la configuración MCP de Cursor

Crea o edita ~/.cursor/mcp.json:

{
  "mcpServers": {
    "codebase-assistant": {
      "command": "node",
      "args": ["/absolute/path/to/cursor-domain-mcp/server.mjs"]
    }
  }
}

Reinicia Cursor. Las herramientas aparecen en el panel de chat de Cursor.

Entrenando el Modelo Correcto para la Integración con Cursor

Para generación de código: Los datos de entrenamiento deben ser pares de (descripción de tarea, implementación correcta) de tu propio codebase. Extrae de tu historial de git: mensajes de commit + el diff = pares de (tarea, implementación).

Para documentación: Datos de entrenamiento: funciones documentadas existentes — pares de (bloque de código, docstring/sección de README correspondiente).

Para conocimiento de dominio: Datos de entrenamiento: wikis internas, registros de decisiones de arquitectura, glosarios de dominio, preguntas y respuestas existentes de Slack o Confluence. Convierte al formato (pregunta, respuesta).

Usando el Modelo en el Chat de Cursor

En el panel de chat de Cursor (Cmd+L / Ctrl+L), puedes invocar tus herramientas:

"Usa codebase-assistant para generar un nuevo endpoint de API para [descripción]"

O deja que Cursor lo invoque automáticamente cuando reconozca que el patrón coincide con la descripción de tu herramienta. Cuanto más específica sea la descripción de tu herramienta, más precisamente Cursor la enruta en lugar de su modelo integrado.

Flujo de trabajo práctico para un desarrollador independiente:

1. Abre el Chat de Cursor
2. Pega la firma / interfaz que quieres implementar
3. Cursor invoca la herramienta generate_code — tu modelo ajustado genera la implementación en tu estilo
4. Cursor muestra el código generado + lo explica
5. Aplica al archivo

El modelo no reemplaza la inteligencia integrada de Cursor — la complementa con conocimiento de tu codebase específico.

---

Lecturas Adicionales

• MCP + Modelo Local Ajustado — La visión general de la arquitectura
• Configuración de Modelo Local en Claude Desktop — El mismo patrón en Claude Desktop
• Configuración de Windsurf + Modelo Ajustado — Windsurf IDE + modelo local
• Herramientas MCP para Flujos de Trabajo de Agencias — Casos de uso para agencias