MCP Servers: Qué Son, Para Qué Sirven y Cómo Usarlos en Cursor y Copilot

Llevabas meses copiando y pegando contexto en el chat de tu IA. El schema de la base de datos. El output del último error. La documentación de la API. Con MCP servers, tu agente consulta todo eso directamente, sin que tú hagas nada.

MCP (Model Context Protocol) es el cambio más importante en cómo funcionan los agentes de IA desde que apareció el autocompletado. Aquí te explico qué es, cómo funciona y cómo configurarlo en Cursor y GitHub Copilot con ejemplos reales.

¿Qué es MCP exactamente?

MCP es un protocolo abierto creado por Anthropic (los de Claude) que define cómo un modelo de IA puede comunicarse con herramientas externas de forma estandarizada.

Antes de MCP, si querías que tu IA leyera tu base de datos tenías dos opciones:

1. Copiar y pegar el schema manualmente en el chat
2. Escribir function calling personalizado para cada herramienta y cada modelo

Con MCP:

1. Configuras un MCP server una sola vez
2. Cualquier cliente compatible (Cursor, Copilot, Claude Desktop, Cline) puede usarlo

Sin MCP:
Tú → copias schema → pegas en chat → IA responde

Con MCP:
Tú → "qué tablas tiene mi BD?" → IA consulta MCP server → IA responde con datos reales

La arquitectura MCP en 3 capas

┌─────────────────────────────────────────┐
│           MCP Client                    │
│  (Cursor, GitHub Copilot, Cline...)     │
└──────────────────┬──────────────────────┘
                   │ JSON-RPC sobre stdio/HTTP
┌──────────────────▼──────────────────────┐
│           MCP Server                    │
│  (proceso local o remoto)               │
│  - Expone "tools" que el modelo invoca  │
│  - Expone "resources" (contexto estático)│
│  - Expone "prompts" (plantillas)        │
└──────────────────┬──────────────────────┘
                   │
┌──────────────────▼──────────────────────┐
│           Fuente de datos               │
│  (PostgreSQL, GitHub API, filesystem,   │
│   Jira, Slack, tu propia API...)        │
└─────────────────────────────────────────┘

El modelo decide cuándo llamar al MCP server. Si le preguntas “¿cuántos usuarios se registraron ayer?”, el agente invoca el tool de SQL, ejecuta la query y te devuelve la respuesta — sin que tú hayas escrito ninguna query.

---

MCP vs Function Calling: la diferencia real

Esta confusión es muy común. Son cosas distintas que se complementan:

Concepto	Qué es	Dónde vive
Function calling	Capacidad del modelo de invocar funciones definidas en el prompt	En el modelo (OpenAI, Anthropic, Gemini)
MCP	Protocolo de transporte para comunicar cliente ↔ servidor de herramientas	En el cliente y el servidor

MCP usa function calling por debajo. El MCP server registra sus tools como funciones que el modelo puede invocar. La diferencia es que MCP estandariza el protocolo, así que el mismo servidor funciona con cualquier modelo compatible.

---

MCP servers que uso en el día a día

1. @modelcontextprotocol/server-filesystem

Accede a archivos y carpetas fuera del proyecto abierto. Útil cuando trabajas con monorepos o necesitas que el agente lea documentación en otra ruta.

npm install -g @modelcontextprotocol/server-filesystem

Caso de uso real: “Lee el README del proyecto de infraestructura y explícame cómo desplegar el backend.” El agente lee directamente /home/fran/infra/README.md sin que yo copie nada.

---

2. @modelcontextprotocol/server-github

Conecta con la API de GitHub. El agente puede leer issues, PRs, código de otros repos y comentarios.

npm install -g @modelcontextprotocol/server-github

Caso de uso real: “¿Hay algún issue abierto sobre el timeout de la transcripción?” El agente busca en tus issues de GitHub y te resume los relevantes. Sin salir del editor.

---

3. @modelcontextprotocol/server-postgres

Conecta directamente a PostgreSQL. El agente puede ejecutar queries, inspeccionar schemas y analizar datos.

npm install -g @modelcontextprotocol/server-postgres

Caso de uso real: “¿Cuántos tenants activos hay en producción y cuál es el que más requests genera?” El agente escribe y ejecuta la query, sin que tú la escribas.

Usa siempre un usuario de solo lectura para esto. Nunca conectes el MCP server con credenciales de superusuario.

---

4. @modelcontextprotocol/server-sqlite

Igual que Postgres pero para SQLite. Muy útil en proyectos con base de datos local o para desarrollo.

---

5. mcp-server-fetch

Permite al agente hacer peticiones HTTP. Útil para consultar documentación online, APIs REST o webhooks.

npm install -g mcp-server-fetch

Caso de uso real: “Mira la documentación de Coolify y dime cómo configurar las variables de entorno.” El agente consulta docs.coolify.io directamente.

---

Configurar MCP en Cursor

Cursor guarda la configuración de MCP en ~/.cursor/mcp.json (global) o .cursor/mcp.json en la raíz del proyecto (local, tiene prioridad).

Configuración básica

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/fran/proyectos",
        "/Users/fran/documentos"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_tu_token_aqui"
      }
    },
    "postgres": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-postgres",
        "postgresql://readonly_user:password@localhost:5432/mi_bd"
      ]
    }
  }
}

Verificar que funciona

1. Abre Cursor
2. Ve a Settings → MCP (o Cmd/Ctrl+Shift+P → “MCP”)
3. Deberías ver los servidores listados con estado ✅ o ❌
4. En el chat, empieza con @ para ver las herramientas disponibles

Si un servidor falla, comprueba el log en la pestaña MCP de Settings. El error más común es que npx no encuentra el paquete — en ese caso instálalo globalmente primero.

---

Configurar MCP en GitHub Copilot (VS Code)

GitHub Copilot añadió soporte MCP en VS Code. La configuración va en settings.json o en .vscode/mcp.json del proyecto.

Via .vscode/mcp.json (recomendado por proyecto)

{
  "servers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:GITHUB_TOKEN}"
      }
    },
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "${workspaceFolder}"
      ]
    }
  }
}

Via settings.json (global)

{
  "github.copilot.chat.mcp.enabled": true,
  "mcp": {
    "servers": {
      "postgres": {
        "type": "stdio",
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://..."]
      }
    }
  }
}

Para usar las herramientas MCP en Copilot, abre el chat en modo agente (icono de agente) y el modelo las invocará automáticamente cuando sea relevante.

---

Crear tu propio MCP server en Node.js

Si quieres conectar el agente a tu propia API o lógica personalizada, puedes crear un MCP server en minutos.

Estructura mínima

npm init -y
npm install @modelcontextprotocol/sdk

// server.js
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 server = new Server(
  { name: "mi-api-server", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

// Definir los tools disponibles
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "get_clientes_activos",
      description: "Devuelve el número de clientes activos en la plataforma",
      inputSchema: {
        type: "object",
        properties: {
          tenant_id: {
            type: "string",
            description: "ID del tenant a consultar",
          },
        },
        required: ["tenant_id"],
      },
    },
  ],
}));

// Implementar la lógica de cada tool
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "get_clientes_activos") {
    const { tenant_id } = request.params.arguments;

    // Tu lógica real aquí: consulta a BD, llamada a API, etc.
    const count = await fetchClientesActivos(tenant_id);

    return {
      content: [
        {
          type: "text",
          text: `El tenant ${tenant_id} tiene ${count} clientes activos.`,
        },
      ],
    };
  }

  throw new Error(`Tool desconocido: ${request.params.name}`);
});

// Arrancar el servidor
const transport = new StdioServerTransport();
await server.connect(transport);

Luego añades el server a tu configuración de Cursor o Copilot:

{
  "mcpServers": {
    "mi-api": {
      "command": "node",
      "args": ["/ruta/a/tu/server.js"],
      "env": {
        "API_KEY": "tu_clave"
      }
    }
  }
}

---

Casos de uso reales donde MCP marca la diferencia

Debugging con contexto de producción

Sin MCP: “Tengo este error en producción: [error]” → la IA adivina
Con MCP: el agente consulta los logs reales de tu servidor y el estado actual de la BD para dar una respuesta precisa

Revisión de PRs con contexto del proyecto

Sin MCP: pegar el diff en el chat
Con MCP + GitHub server: “revisa el PR #47 y dime si hay problemas de seguridad” — el agente lee el PR, los archivos cambiados y el historial de la rama

Esto enlaza directamente con lo que cuento en Cómo usar IA para revisar Pull Requests — los MCP servers son la pieza que hace esa revisión realmente útil.

Generación de código con schema real

Sin MCP: pegar el schema de la BD
Con MCP + Postgres server: “crea el DTO de TypeScript para la tabla campaigns” — el agente inspecciona la tabla directamente y genera el DTO correcto al 100%

Documentación actualizada siempre

Sin MCP: documentación desactualizada en el contexto
Con MCP + Fetch server: el agente consulta la documentación oficial en tiempo real antes de responder

---

Errores comunes al configurar MCP

El servidor no aparece en Cursor

Error: spawn npx ENOENT

Node.js no está en el PATH que usa Cursor. Solución: usa la ruta absoluta:

{
  "command": "/usr/local/bin/node",
  "args": ["/usr/local/bin/npx", "-y", "@modelcontextprotocol/server-github"]
}

El servidor aparece pero las tools no se invocan

El modelo no invoca tools automáticamente si la pregunta no es lo suficientemente específica. Sé explícito:

❌ "¿Cómo van los usuarios?"
✅ "Consulta la tabla users de la base de datos y dime cuántos se registraron esta semana"

Errores de autenticación con GitHub

El token debe tener permisos repo (lectura) y read:org si necesitas repos de organización. Genera uno en GitHub → Settings → Developer settings → Personal access tokens.

---

MCP vs Agentes con herramientas propias

Si ya usas agentes con LangChain o function calling propio, ¿para qué migrar a MCP?

La ventaja principal es la portabilidad. Un MCP server funciona con Cursor, con Copilot, con Claude Desktop y con Cline sin cambiar nada. Si mañana cambias de editor, tus herramientas siguen funcionando.

Si solo usas un editor y ya tienes herramientas personalizadas, no hay urgencia. MCP brilla especialmente cuando:

• Quieres compartir herramientas entre varios editores o agentes
• Usas herramientas estándar (GitHub, Postgres, Filesystem) y no quieres implementarlas desde cero
• Trabajas en equipo y quieres que todos tengan el mismo contexto disponible

---

El ecosistema MCP en 2026

El catálogo oficial de MCP servers está en modelcontextprotocol.io/servers. Algunos destacados además de los mencionados:

• Sentry — el agente puede buscar errores y trazas directamente
• Jira / Linear — gestión de tareas sin salir del editor
• Slack — leer mensajes y contexto de canales
• Puppeteer — automatización de navegador
• Redis — consultar caché y datos en memoria
• Docker — inspeccionar contenedores y logs

La comunidad está creciendo rápido. Si construyes un MCP server para una herramienta que usas, considera publicarlo — es una buena forma de contribuir al ecosistema.

---

Conclusión

MCP no es una moda pasajera — es la pieza que faltaba para que los agentes de IA dejen de ser asistentes que responden preguntas y se conviertan en herramientas que actúan sobre contexto real.

Si usas Cursor o GitHub Copilot a diario, configurar los MCP servers de GitHub y Postgres te va a cambiar cómo trabajas. El setup son 10 minutos y el retorno es inmediato.

Y si quieres ir más lejos, echa un vistazo a cómo funcionan los agentes autónomos con LangChain — MCP y agentes con memoria son el siguiente paso natural.