Integraciones de Claude Code: Servidores MCP, IDE y CI/CD
Claude Code es poderoso por sí solo. Lee tus archivos, escribe código, ejecuta comandos. Pero ahora mismo, cada vez que necesitas que sepa algo fuera de tu proyecto — un esquema de base de datos, un issue de GitHub, un error de Sentry — estás copiando y pegando. Eres el intermediario.
¿Y si Claude pudiera simplemente... ir a buscar esa información por sí mismo?
Eso es lo que hacen los servidores MCP. Solo el 8% de los setups en nuestro análisis los configuran, pero los que lo hacen obtienen 7.5/10 en promedio. La razón es simple: los servidores MCP eliminan el impuesto del copiar y pegar que consume la mayor parte del tiempo de sesión.
Configuremos uno ahora mismo. Lo tendrás funcionando en menos de cinco minutos.
Tu primer servidor MCP: GitHub
MCP significa Model Context Protocol. Es un estándar abierto que permite a Claude comunicarse con servicios externos a través de una interfaz estructurada. Un servidor MCP es un pequeño programa que corre en segundo plano y le da a Claude acceso a herramientas — como buscar issues, consultar bases de datos o leer documentación.
Empecemos con el servidor MCP de GitHub porque la configuración es muy sencilla y el beneficio es inmediato.
Agrega esto a tu .claude/settings.json:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_tu_token_aqui"
}
}
}
}
Necesitarás un GitHub Personal Access Token. Ve a GitHub > Settings > Developer Settings > Personal access tokens > Generate new token. Dale el scope repo.
Reinicia Claude Code y prueba esto:
> Lista mis 5 pull requests más recientes
Claude no te pide pegar nada. Llama al servidor MCP de GitHub, obtiene tus PRs y los muestra. Ahora prueba:
> ¿Cuál es el estado del issue #42? Lee los comentarios también.
Claude obtiene el issue, lee la discusión y tiene el contexto completo. Cuando dices "trabaja en el issue #42", realmente sabe lo que dice el issue #42 — sin que copies la descripción en el chat.
Ese es todo el punto de MCP: Claude obtiene el contexto por sí mismo en lugar de que tú hagas de mensajero.
El servidor MCP de base de datos (el que lo cambia todo)
Si usas PostgreSQL, este es el servidor MCP que te hará preguntarte cómo trabajabas antes sin él.
Agrega a .claude/settings.json:
{
"mcpServers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"DATABASE_URL": "postgresql://dev:dev@localhost:5432/myapp_dev"
}
}
}
}
Lo que desbloquea:
- Claude lee tus esquemas de tablas reales antes de escribir consultas — se acabó adivinar nombres de columnas
- Puede ejecutar consultas SELECT para entender la forma de los datos
- La generación de migraciones se vuelve precisa porque Claude ve el esquema real actual
- Los errores de nombres de columnas se detectan antes de ejecutar el código
Importante: Usa un usuario de base de datos de solo lectura. Claude no necesita acceso de escritura para entender tu esquema:
CREATE USER claude_readonly WITH PASSWORD 'secure_password';
GRANT CONNECT ON DATABASE myapp_dev TO claude_readonly;
GRANT USAGE ON SCHEMA public TO claude_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO claude_readonly;
Pruébalo. Pregúntale a Claude: "Muéstrame el esquema de la tabla users." Consulta la base de datos directamente y te da las columnas exactas, tipos y restricciones. Se acabó el "Asumiré que el esquema se ve así."
Más servidores MCP que vale la pena configurar
Una vez que le agarras la onda, estos son los otros servidores que se ganan su lugar:
Slack — buscar en conversaciones del equipo
{
"mcpServers": {
"slack": {
"command": "npx",
"args": ["-y", "@anthropic/mcp-server-slack"],
"env": {
"SLACK_BOT_TOKEN": "xoxb-tu-token-bot"
}
}
}
}
¿Trabajando en una feature que se discutió en Slack la semana pasada? En lugar de que tú resumas la conversación, Claude la busca directamente.
Sentry — obtener reportes de errores
{
"mcpServers": {
"sentry": {
"command": "npx",
"args": ["-y", "@sentry/mcp-server"],
"env": {
"SENTRY_AUTH_TOKEN": "tu_token_sentry",
"SENTRY_ORG": "tu-org",
"SENTRY_PROJECT": "tu-proyecto"
}
}
}
}
¿Depurando un error de producción? Claude obtiene la stack trace exacta, cantidad de usuarios afectados y frecuencia del error desde Sentry. Se acabó hacer capturas de pantalla de reportes de errores y pegarlos en el chat.
Context7 — documentación en tiempo real
{
"mcpServers": {
"context7": {
"command": "npx",
"args": ["-y", "@context7/mcp-server"]
}
}
}
Este es sigilosamente útil. En lugar de confiar en datos de entrenamiento (que pueden estar desactualizados), Claude obtiene la documentación actual para la versión exacta de la biblioteca que usas. Especialmente útil para bibliotecas que evolucionan rápido como Next.js, React o Prisma donde la API cambia entre versiones.
Filesystem — acceder a archivos fuera de tu proyecto
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": [
"-y", "@modelcontextprotocol/server-filesystem",
"/Users/tu/proyectos/libs-compartidas",
"/Users/tu/proyectos/design-system"
]
}
}
}
¿Monorepo? ¿Necesitas que Claude referencie tu design system mientras edita una feature? El servidor filesystem le da acceso a directorios fuera del proyecto actual.
Integración con IDE: encontrar a Claude donde codeas
VS Code
La forma más rápida de empezar:
- Instala la extensión Claude Code del marketplace de VS Code
- Abre tu proyecto
- Presiona
Cmd+Shift+P(Mac) oCtrl+Shift+P(Windows/Linux) y escribe "Claude" - Selecciona "Claude Code: Open Panel"
La extensión de VS Code le da a Claude acceso a tus archivos abiertos, salida del terminal, errores de TypeScript, advertencias de ESLint — todo sin copiar y pegar.
JetBrains (IntelliJ, WebStorm, PyCharm)
Abre la terminal integrada en tu IDE JetBrains y ejecuta claude. Funciona en el panel de terminal con acceso completo a tu proyecto. El plugin de JetBrains (actualmente en beta) agrega sugerencias inline y un panel de chat dentro del IDE.
Terminal con tmux
Si vives en la terminal, este patrón funciona bien — Claude en un panel, tu editor en el otro:
tmux new-session -d -s dev
tmux split-window -h
tmux send-keys -t dev:0.1 'claude' Enter
tmux attach -t dev
Codeas a la izquierda, Claude corre a la derecha. Mismo directorio de proyecto, cero cambio de contexto.
CI/CD: Claude revisa cada PR automáticamente
Aquí es donde Claude Code pasa de herramienta personal a infraestructura de equipo.
Revisión automatizada de PR con GitHub Actions
Crea .github/workflows/claude-review.yml:
name: Claude Code Review
on:
pull_request:
types: [opened, synchronize]
jobs:
review:
runs-on: ubuntu-latest
permissions:
contents: read
pull-requests: write
steps:
- uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Claude Code Review
uses: anthropics/claude-code-action@v1
with:
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
prompt: |
Revisa este pull request. Verifica:
1. Problemas de seguridad (inyección SQL, XSS, secrets expuestos)
2. Problemas de rendimiento (consultas N+1, índices faltantes)
3. Manejo de errores faltante
4. Gaps en cobertura de tests
Publica tu revisión como comentario de PR con secciones CRÍTICA e INFORMATIVA.
Cada PR recibe una revisión exhaustiva antes de que un humano la mire. Los problemas mecánicos se capturan automáticamente, para que tus revisores humanos puedan enfocarse en arquitectura y decisiones de diseño.
Triage automatizado de issues
name: Issue Triage
on:
issues:
types: [opened]
jobs:
triage:
runs-on: ubuntu-latest
permissions:
issues: write
steps:
- uses: actions/checkout@v4
- name: Triage Issue
uses: anthropics/claude-code-action@v1
with:
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
prompt: |
Analiza este issue de GitHub. Basándote en el codebase:
1. Identifica qué archivos probablemente están afectados
2. Estima la complejidad (trivial / moderada / compleja)
3. Sugiere labels relevantes
4. Si es un bug, intenta identificar la causa raíz
Publica tu análisis como comentario.
Los nuevos issues se analizan automáticamente — archivos afectados identificados, complejidad estimada, labels sugeridos. Tu equipo pasa menos tiempo triando y más construyendo.
Modo headless para scripting
Claude Code puede correr de forma no interactiva para automatización personalizada:
# Ejecutar un prompt único y salir
claude -p "Ejecuta la suite de tests y reporta fallos" --output-format json
# Enviar entrada por pipe
echo "Explica la arquitectura de este proyecto" | claude -p --output-format text
# Usar en un script
RESULT=$(claude -p "Busca comentarios TODO en src/" --output-format json)
echo "$RESULT" | jq '.output'
Este es el bloque de construcción para pasos CI/CD personalizados, hooks de pre-commit y cualquier workflow donde quieras que Claude haga un trabajo específico y reporte el resultado.
Mantén tus tokens seguros
Los servidores MCP corren con tus credenciales. Tómatelo en serio.
Nunca hagas commit de tokens en settings.json. Usa referencias a variables de entorno en su lugar:
{
"mcpServers": {
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
}
}
}
}
Usa credenciales de solo lectura donde sea posible. Claude rara vez necesita acceso de escritura a tu base de datos o GitHub.
Limita el alcance a lo que necesitas. No conectes una base de datos de producción — usa dev o staging.
Revisa el código de los servidores MCP. Son paquetes npm que corren con tus credenciales. Verifica el código fuente, prefiere paquetes oficiales y fija versiones.
El setup completo
Aquí está el .claude/settings.json completo para un proyecto bien integrado — permisos, servidores MCP y hooks trabajando juntos:
{
"permissions": {
"allow": [
"Bash(npm run *)",
"Bash(git *)",
"Read",
"Glob",
"Grep"
],
"deny": [
"Bash(rm -rf *)",
"Bash(git push --force*)"
]
},
"mcpServers": {
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres"],
"env": {
"DATABASE_URL": "${DEV_DATABASE_URL}"
}
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
}
},
"context7": {
"command": "npx",
"args": ["-y", "@context7/mcp-server"]
}
},
"hooks": {
"PreToolUse": [
{
"matcher": "Bash",
"command": ".claude/hooks/pre-tool-guard.sh"
}
]
}
}
Acceso al esquema de base de datos, issues y PRs de GitHub, documentación en tiempo real, guards de seguridad y permisos sensatos. Eso es un entorno de desarrollo conectado, no un chatbot aislado.
Lo que sigue
Con integraciones en su lugar, Claude Code deja de ser una herramienta en la que pegas contexto y empieza a ser una herramienta que obtiene su propio contexto. Los próximos pasos:
- Patrones de workflow — subagents, orquestación de revisión de código y las estrategias de depuración de los power users
- Optimización de costos — los servidores MCP añaden uso de tokens, así que estas estrategias mantienen tu factura controlada
- Evaluar tu setup para ver cómo se comparan tus integraciones con las mejores configuraciones
Preguntas frecuentes
¿Cuántos servidores MCP puedo ejecutar a la vez?
No hay límite estricto, pero cada servidor es un proceso separado usando memoria y CPU. En la práctica, 3-5 es el punto óptimo. Más allá de eso, el tiempo de arranque aumenta y el contexto de Claude se llena de descripciones de herramientas. Empieza con los servidores que te ahorran más copiar y pegar — típicamente base de datos y GitHub.
¿Los servidores MCP funcionan con el plan Max, o solo API?
Ambos. Los servidores MCP corren localmente en tu máquina independientemente del modelo de facturación. La única diferencia de costo: las llamadas de herramientas MCP generan tokens adicionales (descripciones de herramientas, entradas, salidas), que importan más con precios de API por token que con el plan Max de tarifa plana.
¿Puedo escribir mi propio servidor MCP?
Sí, y es más directo de lo que esperarías. Un servidor MCP se comunica por stdio usando JSON-RPC. El paquete @modelcontextprotocol/sdk proporciona helpers en TypeScript:
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
const server = new Server({ name: "my-server", version: "1.0.0" });
server.setRequestHandler("tools/list", async () => ({
tools: [{ name: "my_tool", description: "Does something useful", inputSchema: { type: "object" } }]
}));
const transport = new StdioServerTransport();
await server.connect(transport);
También hay SDKs para Python, Go y Rust.
¿Es segura la integración con GitHub Actions?
La acción oficial anthropics/claude-code-action corre en un entorno CI sandboxed. Solo puede acceder a lo que otorgues vía permisos de GitHub Actions (contents: read, pull-requests: write). Almacena tu clave API de Anthropic como un secreto de GitHub, nunca hardcodeada. El principal riesgo es el costo — una action fuera de control en un repo activo puede generar cargos API significativos. Configura alertas de gasto y limita qué eventos activan la action.
¿Por qué usar MCP en lugar de decirle a Claude que ejecute comandos shell?
Los comandos shell funcionan, pero son frágiles. Con un servidor MCP de PostgreSQL, Claude llama query("SELECT * FROM users LIMIT 5") — no necesita descifrar tu cadena de conexión psql, manejar autenticación o parsear salida tabular. MCP le da a Claude acceso tipado y estructurado a tus herramientas. Menos errores, resultados más confiables, y puedes otorgar acceso de lectura a la base de datos sin otorgar acceso shell completo.