5 servidores MCP que van a cambiar tu forma de trabajar

Usas IA para programar. Le haces preguntas, pegas logs de errores, quizás dejas que escriba una función o dos. Responde con lo que sabe — que es lo que aprendió durante su entrenamiento, congelado en el tiempo como un mamut en hielo. No puede revisar tu base de datos. No puede abrir tu GitHub. No puede googlear si esa librería que estás por instalar fue abandonada desde 2023. Tu IA vive en una caja. 😼

La caja es el problema. Una IA que no puede tocar tu infraestructura real es solo un patito de hule muy elocuente.

Eso cambió en noviembre de 2024 cuando Anthropic lanzó MCP (Model Context Protocol) — una forma estándar para que las herramientas de IA se conecten a servicios externos. Piensa en ello como puertos USB para tu IA: conectas un "servidor" (un pequeño programa en segundo plano) y de repente tu agente de IA puede consultar bases de datos, gestionar issues en GitHub, buscar en la web o controlar un navegador. A marzo de 2026, el registro oficial de servidores MCP lista miles de estos plugins. La mayoría son demos. Algunos están rotos. Cinco realmente importan para el trabajo diario.

Te voy a guiar por cada uno, con instrucciones de instalación que puedes copiar y pegar en menos de cinco minutos.

Antes de empezar: dónde viven las configs de MCP

Los servidores MCP funcionan con cualquier cliente compatible — Claude Code, Claude Desktop, Cursor, Windsurf, Cline. Voy a usar ejemplos de Claude Code, pero el formato de configuración es casi idéntico en todos lados.

Tu archivo de configuración vive aquí:

# Claude Code (nivel de proyecto)
.mcp.json

# Claude Code (global)
~/.claude.json

# Claude Desktop
~/Library/Application Support/Claude/claude_desktop_config.json  # macOS
~/.config/Claude/claude_desktop_config.json                       # Linux

Cada servidor sigue el mismo patrón:

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@package/server-name"],
      "env": {
        "API_KEY": "your-key-here"
      }
    }
  }
}

npx ejecuta un paquete de Node.js sin instalarlo globalmente. La bandera -y se salta la confirmación. Eso es toda la ceremonia necesaria. Ahora lo bueno.

1. PostgreSQL — habla con tu base de datos en español

Qué hace: Tu IA lee el esquema de tu base de datos (la estructura — tablas, columnas, tipos), ejecuta queries SQL (el lenguaje que hablan las bases de datos) y devuelve resultados reales. Se acabó copiar la salida de tu terminal y pegarla en el chat.

Por qué te importa: La mitad del desarrollo es "revisar la base de datos, entender los datos, escribir una query." Este servidor convierte eso en una conversación.

Config:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-postgres",
        "postgresql://user:pass@localhost:5432/mydb"
      ]
    }
  }
}

Dices: "Muéstrame todos los usuarios que se registraron esta semana pero nunca compraron nada." Claude ejecuta SQL real contra tu base de datos. Datos reales regresan. Dices: "Crea un índice para que eso vaya más rápido." Claude analiza el plan de ejecución y construye el índice correcto.

El servidor expone tres herramientas: query (ejecutar SQL de solo lectura), list_tables y describe_table.

Seguridad: Crea un usuario de base de datos de solo lectura. No le entregues tus credenciales de admin a ninguna herramienta automatizada:

CREATE USER mcp_readonly WITH PASSWORD 'secure_password';
GRANT CONNECT ON DATABASE mydb TO mcp_readonly;
GRANT USAGE ON SCHEMA public TO mcp_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO mcp_readonly;

Veredicto: Primer servidor que instalo en cada proyecto. Ahorra más de 30 minutos diarios de arqueología de copiar y pegar. 😸

2. GitHub — repos sin abrir el navegador

Qué hace: Integración completa con GitHub — issues, pull requests (PRs — cambios de código propuestos), búsqueda de código, operaciones con archivos. Todo a través de tu agente de IA.

Por qué te importa: Cambiar de contexto entre la terminal, el chat y GitHub mata la concentración. Este servidor te mantiene en un solo lugar.

Config:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Necesitas un token de acceso personal — consíguelo en github.com/settings/tokens. Scopes necesarios: repo, read:org, read:user.

Ahora puedes decir: "Crea un issue para el bug de timeout en el login con el stack trace que te acabo de mostrar." O: "Revisa el PR #47 y comenta sobre problemas de seguridad." Claude lee el diff, analiza el código, publica comentarios de review reales en GitHub.

Herramientas clave: create_issue, list_pull_requests, search_code, create_branch, get_file_contents. Más de una docena en total.

Jugada maestra: Combina esto con el servidor de Postgres. "Revisa los logs de errores en la base de datos, encuentra el código relevante en GitHub, crea un issue con ambos." Un prompt. Tres herramientas. Cero pestañas del navegador. 😹

Veredicto: Segundo servidor que instalo. La interfaz web de GitHub está bien para navegar. Para trabajar, esto es más rápido.

3. Filesystem — acceso controlado a archivos con barandillas

Qué hace: Le da a tu agente de IA acceso para leer, escribir, buscar y gestionar archivos — pero solo dentro de los directorios que tú permitas explícitamente. No puede meterse en tus llaves SSH ni en tus archivos .env.

Config:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/home/user/projects",
        "/home/user/documents"
      ]
    }
  }
}

Lista múltiples directorios — el servidor restringe el acceso solo a esas rutas. El servidor bloquea intentos de path traversal (trucos como ../../etc/passwd).

Herramientas: read_file, write_file, create_directory, list_directory, move_file, search_files, read_multiple_files.

Quién lo necesita: Usuarios de Claude Desktop, principalmente. Claude Code ya tiene acceso al sistema de archivos integrado, así que este servidor es redundante ahí. Pero para Claude Desktop — donde la IA de otro modo no puede tocar tus archivos para nada — esto es esencial. El sandboxing de directorios (restringir acceso a carpetas específicas) es una función de seguridad genuinamente buena.

Veredicto: Sáltatelo si usas Claude Code. Instálalo de inmediato si usas Claude Desktop.

4. Brave Search — datos en tiempo real de la web

Qué hace: Búsqueda web a través de la API de Brave Search. Tu IA busca cosas en vivo en vez de adivinar con datos de entrenamiento.

Por qué te importa: "¿Cuál es el precio actual del Hetzner CAX11?" "¿Esta librería todavía se mantiene?" "¿Cuál es la última versión de Next.js?" Estas preguntas necesitan respuestas en vivo. Los datos de entrenamiento no saben qué pasó el martes pasado.

Config:

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_your_key_here"
      }
    }
  }
}

Consigue una API key gratis en brave.com/search/api. Tier gratuito: 2,000 queries al mes, 1 request por segundo. Para un desarrollador solo, es más que suficiente. El tier de pago empieza en $5/mes por 20,000 queries si te acabas el límite gratuito.

Dos herramientas: brave_web_search (búsqueda web general con paginación) y brave_local_search (búsqueda de negocios locales).

Uso inteligente: Valida las sugerencias de arquitectura de tu IA antes de comprometerte. "Busca problemas conocidos con Prisma 6.x y PostgreSQL 17" es una excelente verificación de cordura antes de que lleves tres días metido en una implementación.

Veredicto: Llena la brecha más grande de la IA para programar — la incapacidad de verificar qué es verdad ahora mismo. 😼

5. Puppeteer — automatización del navegador por conversación

Qué hace: Controla un navegador headless (un navegador Chromium que corre de manera invisible, sin ventana visible). Tu IA navega páginas, toma capturas de pantalla, hace clic en botones, llena formularios, extrae contenido de sitios renderizados con JavaScript.

Config:

{
  "mcpServers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Sin API keys. Sin configuración. Puppeteer descarga Chromium automáticamente.

Herramientas: puppeteer_navigate, puppeteer_screenshot, puppeteer_click, puppeteer_fill, puppeteer_evaluate (ejecutar JavaScript en la página).

Di: "Ve a localhost:3000, toma una captura de pantalla del login, dime si se renderiza correctamente." Luego: "Llena las credenciales de prueba y envía." Claude navega, llena campos, hace clic en enviar, captura el resultado.

Yo lo uso para pruebas de regresión visual — "Navega a cada ruta y toma una captura de pantalla" me da un snapshot visual que Claude puede comparar contra los layouts esperados. Sin configurar Playwright, sin framework de pruebas. Solo "ve y mira la página."

Ojo: Esto corre un navegador real. Cada instancia se come de 200 a 500MB de RAM. No lo dejes corriendo en una laptop con poca memoria. El servidor limpia automáticamente cuando cierras tu cliente MCP.

Veredicto: El servidor más divertido de esta lista. Automatizar el navegador con lenguaje natural es genuinamente satisfactorio. Esencial para trabajo de frontend y web scraping. 😸

La config completa — copia y pega esto

Los cinco servidores, un solo archivo:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://mcp_readonly:password@localhost:5432/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/home/user/projects"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_xxx"
      }
    },
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Reemplaza los valores de ejemplo con tus credenciales reales. Guárdalo como .mcp.json en la raíz de tu proyecto o ~/.claude.json para acceso global.

Encontrar más (y saber cuándo parar)

El registro oficial vive en github.com/modelcontextprotocol/servers. mcpservers.org lista servidores de la comunidad. Navega si tienes curiosidad.

Pero resiste la tentación de instalar 15 servidores "por si acaso." Cada uno es un proceso corriendo. Cada uno agrega tiempo de inicio. Cada uno es una superficie de ataque — un punto de entrada potencial para problemas de seguridad. El 80% de los desarrolladores necesitan dos o tres servidores, máximo.

Ahora eres peligroso

Empezaste con una IA que vivía en una caja de texto. Ahora tienes una que consulta tu base de datos, gestiona tu GitHub, busca en la web en vivo y maneja un navegador. El protocolo por debajo — JSON-RPC (un formato de mensajes simple) sobre stdio (entrada/salida estándar, cómo los programas se comunican entre sí) — es aburrido. Los protocolos aburridos que funcionan son exactamente lo que necesitábamos.

Estos cinco servidores cubren el 90% de lo que un desarrollador independiente necesita. Todo lo demás en el directorio MCP es herramientas de nicho para casos de uso específicos o demos que se van a romper en el momento en que realmente dependas de ellos. Empieza con Postgres y GitHub. Agrega Brave Search cuando necesites datos en vivo. Agrega Puppeteer cuando quieras sentir que vives en 2030.

La caja está abierta. Tu IA ahora tiene manos. Trata de que no tire nada importante. 😹