Saltar al contenido
Lección 6 de 14

Servidores MCP — Integraciones Externas

9 min read

Qué Es MCP

El Model Context Protocol (MCP) es un estándar abierto que define cómo los modelos de IA se conectan a herramientas y fuentes de datos externas. En lugar de que Claude esté limitado a leer archivos y ejecutar comandos de shell, MCP le permite interactuar con sistemas en vivo -- obteniendo datos de pull requests de GitHub, consultando bases de datos, enviando mensajes de Slack, controlando un navegador web y mucho más.

MCP funciona a través de una arquitectura cliente-servidor. Claude Code actúa como el cliente, y cada integración se ejecuta como un servidor MCP separado. Cuando Claude necesita interactuar con GitHub, envía una solicitud al servidor MCP de GitHub. Cuando necesita consultar una base de datos, habla con el servidor MCP de base de datos. Cada servidor expone un conjunto de herramientas que Claude puede invocar igual que sus herramientas integradas.

El resultado es que Claude Code se convierte en un hub de integraciones. Puedes conectarlo a cada servicio en tu stack de desarrollo, y Claude los orquesta todos a través de lenguaje natural.

Por Qué Importa MCP

Sin MCP, obtener datos en vivo en Claude requiere trabajo manual. Ejecutas un comando, copias la salida, la pegas en Claude y repites. MCP elimina este ciclo por completo.

Considera un flujo de trabajo típico de revisión de código. Sin MCP, abres el PR en tu navegador, copias el diff, lo pegas en Claude, pides la revisión y luego publicas los comentarios de revisión manualmente. Con el servidor MCP de GitHub, puedes decir "revisa el PR 42 y publica tu feedback como comentarios de revisión" -- Claude obtiene los datos del PR, analiza el diff y publica comentarios directamente, todo en una sola interacción.

MCP también le da a Claude acceso a datos que no puede obtener del sistema de archivos. Contenidos de bases de datos, respuestas de API, conversaciones de Slack, contenido de páginas web -- todo esto vive fuera del directorio de tu proyecto pero es crítico para muchas tareas de desarrollo.

Agregando Servidores MCP

La forma más rápida de agregar un servidor MCP es a través del CLI:

# Agregar un servidor con nombre y comando de inicio
claude mcp add github -- npx -y @modelcontextprotocol/server-github

# Agregar un servidor con variables de entorno
claude mcp add database -- npx -y @modelcontextprotocol/server-postgres \
  --connection-string "$DATABASE_URL"

# Agregar un servidor para automatizacion de navegador
claude mcp add browser -- npx -y @anthropic-ai/mcp-server-playwright

Cada comando registra el servidor MCP para que Claude Code lo inicie automáticamente al comienzo de cada sesión. El servidor se ejecuta como un proceso en segundo plano y se comunica con Claude a través de entrada/salida estándar.

Para ver todos los servidores registrados:

claude mcp list

Para eliminar un servidor:

claude mcp remove github

Configuración: El Archivo .mcp.json

Para configuraciones MCP a nivel de proyecto que deben compartirse con tu equipo, usa el archivo .mcp.json en la raíz de tu proyecto:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "database": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION": "${DATABASE_URL}"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "./docs", "./config"]
    }
  }
}

Las variables de entorno usan la sintaxis ${VAR_NAME} y se resuelven desde tu entorno de shell al inicio. Esto significa que puedes hacer commit de .mcp.json al control de versiones sin exponer secretos -- cada desarrollador establece los valores reales en su propio entorno.

Servidores MCP Populares

El ecosistema MCP está creciendo rápidamente. Aquí están los servidores más útiles para desarrollo de software:

GitHub -- Acceso completo a repositorios, pull requests, issues, actions y búsqueda de código. Claude puede crear PRs, publicar comentarios de revisión, gestionar issues y activar workflows.

claude mcp add github -- npx -y @modelcontextprotocol/server-github

Filesystem -- Acceso controlado a directorios fuera de tu proyecto. Útil para leer documentación, archivos de configuración o recursos compartidos.

PostgreSQL / MySQL -- Consultas directas a base de datos. Claude puede inspeccionar esquemas, ejecutar consultas de lectura y ayudarte a escribir migraciones basadas en las estructuras reales de las tablas.

Slack -- Leer y enviar mensajes en canales de Slack. Claude puede buscar historial de conversaciones, publicar actualizaciones y responder preguntas del equipo.

Brave Search -- Capacidades de búsqueda web. Claude puede buscar en internet documentación, respuestas de Stack Overflow y referencias de librerías.

Playwright -- Automatización de navegador. Claude puede navegar páginas web, llenar formularios, tomar capturas de pantalla e interactuar con aplicaciones web.

Memory -- Un grafo de conocimiento que persiste entre sesiones. Claude puede almacenar y recuperar información estructurada entre conversaciones.

Configurando el MCP de GitHub

El servidor MCP de GitHub es la integración más comúnmente usada. Aquí está una configuración completa:

  1. Genera un token de acceso personal de GitHub con los scopes repo y read:org.

  2. Establece el token en tu entorno:

export GITHUB_TOKEN=ghp_tu_token_aqui
  1. Agrega el servidor:
claude mcp add github -- npx -y @modelcontextprotocol/server-github
  1. Inicia una sesión de Claude Code y prueba estas interacciones:
claude
> Lista los pull requests abiertos en este repositorio
> Revisa el PR #42 y resume los cambios
> Crea un issue titulado "Refactorizar modulo de auth" con una descripcion de lo que necesita cambiar
> Cuales son las verificaciones fallidas en el PR #38?

Claude ahora tiene acceso completo de lectura/escritura a tu repositorio de GitHub a través de lenguaje natural. Puede obtener diffs de PRs, leer comentarios de revisión, crear issues e incluso activar GitHub Actions.

Configurando un MCP de Base de Datos

Conectar Claude a tu base de datos desbloquea capacidades poderosas para análisis de esquemas, depuración de consultas y planificación de migraciones:

# Establece tu cadena de conexion
export DATABASE_URL="postgresql://user:password@localhost:5432/myapp"

# Agrega el servidor
claude mcp add postgres -- npx -y @modelcontextprotocol/server-postgres \
  --connection-string "$DATABASE_URL"

Ahora puedes hacerle preguntas a Claude sobre tus datos en vivo:

claude
> Muestrame el esquema de las tablas users y orders
> Escribe una consulta para encontrar usuarios que hicieron mas de 5 pedidos en el ultimo mes
> Que indices existen en la tabla orders? Falta alguno para las consultas comunes?

Ten cuidado con los servidores MCP de base de datos en entornos de producción. Considera usar un usuario de base de datos de solo lectura o conectarte a una réplica de staging en lugar de producción.

Soporte OAuth

Algunos servidores MCP soportan autenticación OAuth para servicios que lo requieren. Cuando agregas un servidor habilitado con OAuth, Claude Code te guiará a través del flujo de autenticación -- típicamente abriendo una ventana de navegador para que inicies sesión y autorices el acceso.

Esto es común para servidores que se integran con Google Workspace, Microsoft 365, productos de Atlassian y otros servicios empresariales que usan OAuth 2.0.

Creando Servidores MCP Personalizados

Si ningún servidor existente cubre tu caso de uso, puedes construir el tuyo propio. Los servidores MCP se comunican a través de uno de tres protocolos de transporte:

stdio -- Entrada/salida estándar. El servidor lee mensajes JSON-RPC desde stdin y escribe respuestas en stdout. Este es el transporte más simple y el que la mayoría de herramientas CLI usan.

SSE (Server-Sent Events) -- Streaming basado en HTTP. El servidor se ejecuta como un endpoint HTTP que transmite eventos al cliente. Bueno para servidores remotos.

HTTP -- Solicitud/respuesta HTTP estándar. Cada llamada a herramienta es una solicitud HTTP separada. El más simple de desplegar pero no soporta streaming.

Un servidor MCP mínimo en Node.js se ve así:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new McpServer({
  name: "my-custom-server",
  version: "1.0.0",
});

// Registrar una herramienta
server.tool(
  "get_weather",
  "Get the current weather for a city",
  { city: { type: "string", description: "City name" } },
  async ({ city }) => {
    // Tu logica aqui — obtener datos del clima, consultar una API, etc.
    return {
      content: [
        { type: "text", text: `Clima en ${city}: 22C, soleado` },
      ],
    };
  }
);

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

Regístralo con Claude Code:

claude mcp add weather -- node ./my-mcp-servers/weather-server.js

Ahora Claude puede llamar a get_weather tan naturalmente como cualquier otra herramienta.

Consideraciones de Seguridad

Los servidores MCP se ejecutan con tus permisos de usuario. Un servidor MCP de base de datos puede ejecutar cualquier consulta que tu cadena de conexión permita. Un servidor de filesystem puede leer cualquier directorio al que le des acceso. Un servidor de GitHub puede crear PRs y modificar issues usando tu token.

Antes de instalar cualquier servidor MCP de terceros, revisa su código fuente. Entiende qué permisos necesita y qué acciones puede tomar. Usa el principio de mínimo privilegio: otorga acceso de solo lectura cuando sea posible, restringe el acceso al filesystem a directorios específicos y usa tokens de API con alcance limitado en lugar de tokens de acceso completo.

Para entornos de equipo, define tu configuración MCP en .mcp.json y revísala en code review igual que cualquier otra configuración de infraestructura. Documenta qué servidores se usan, por qué son necesarios y qué permisos requieren.

Solución de Problemas

Cuando un servidor MCP no está funcionando, comienza con estos pasos de diagnóstico:

# Listar todos los servidores y su estado
claude mcp list

# Verificar logs del servidor (si el servidor soporta logging)
claude mcp logs github

Los problemas comunes incluyen variables de entorno faltantes (el token no está configurado), conflictos de versión (el servidor requiere una versión más nueva de Node.js) y conflictos de puerto (otro proceso está usando el mismo puerto para servidores SSE/HTTP).

Prueba este ejercicio: configura el servidor MCP de GitHub para uno de tus repositorios. Inicia una sesión de Claude Code y pide a Claude que liste tus PRs abiertos, resuma el más reciente y sugiera mejoras. Luego crea un servidor MCP personalizado simple que exponga una sola herramienta -- quizás una que retorne el estado de despliegue de tu proyecto o el endpoint de health check. Regístralo con Claude Code y verifica que Claude pueda invocarlo.