Introducción: El problema de las capacidades limitadas

Imagina que Claude Code es como un asistente muy inteligente que vive en tu terminal. Por defecto, puede leer archivos, escribir código y ejecutar comandos bash. Estas son herramientas poderosas, pero hay un límite: solo puede interactuar directamente con tu sistema de archivos y tu shell.

¿Qué pasa cuando necesitas que Claude:

• Consulte datos de una base de datos PostgreSQL?
• Cree un issue en tu sistema de tickets de GitHub?
• Navegue por una página web y extraiga información?
• Envíe mensajes a Slack o correos electrónicos?
• Acceda a tu calendario de Google o tus notas en Notion?

Aquí es donde entra MCP — el puente que conecta Claude Code con el mundo exterior.

¿Qué es MCP?

MCP (Model Context Protocol) es un protocolo estándar y de código abierto desarrollado por Anthropic para conectar modelos de lenguaje grandes (LLMs) como Claude con herramientas externas, bases de datos, APIs y servicios.

Piensa en MCP como el "USB-C de las aplicaciones de IA" — un estándar universal que permite que cualquier herramienta se conecte con cualquier LLM que soporte el protocolo.

Definición formal

MCP es un protocolo basado en JSON-RPC 2.0 que permite a las aplicaciones de IA:

• Acceder a fuentes de datos (archivos, bases de datos, APIs)
• Usar herramientas (buscadores, calculadoras, automatizadores)
• Integrarse con flujos de trabajo (sistemas empresariales, servicios cloud)

Fecha de lanzamiento: Noviembre 2024 Gobernanza actual (2026): Agentic AI Foundation (AAIF) bajo la Linux Foundation, co-fundada por Anthropic, Block y OpenAI.

¿Cómo funciona MCP?

MCP funciona con una arquitectura cliente-servidor:

┌─────────────────┐          ┌──────────────┐          ┌─────────────────┐
│  Claude Code    │ ←──MCP──→│  MCP Server  │ ←─────→  │  Servicio       │
│  (Cliente)      │          │              │          │  Externo        │
│                 │          │              │          │  (GitHub, DB,   │
│  - Lee prompts  │          │  - Expone    │          │   Slack, etc.)  │
│  - Envía        │          │    tools     │          │                 │
│    requests     │          │  - Traduce   │          │                 │
│  - Recibe       │          │    datos     │          │                 │
│    resultados   │          │              │          │                 │
└─────────────────┘          └──────────────┘          └─────────────────┘

Componentes clave

1. Cliente MCP: Claude Code actúa como cliente que solicita capacidades
2. Servidor MCP: Software que expone herramientas y datos de un servicio específico
3. Protocolo: JSON-RPC 2.0 para la comunicación estandarizada

Flujo de comunicación

1. Claude Code se conecta a uno o más servidores MCP
2. Cada servidor MCP expone sus capacidades (tools, resources, prompts)
3. Cuando necesitas usar una herramienta, Claude envía una solicitud al servidor correspondiente
4. El servidor MCP ejecuta la acción en el servicio externo
5. El servidor devuelve los resultados a Claude Code
6. Claude procesa los resultados y continúa con tu tarea

Ejemplo práctico:

Usuario: "Crea un issue en GitHub para reportar el bug que encontramos"
 
Claude Code → MCP Server GitHub: create_issue(title="Bug X", body="...")
MCP Server → GitHub API: POST /repos/user/repo/issues
GitHub API → MCP Server: {id: 123, url: "..."}
MCP Server → Claude Code: Issue creado exitosamente
Claude Code → Usuario: "He creado el issue #123 en GitHub"

Casos de uso principales

MCP permite escenarios que serían imposibles o muy complejos solo con herramientas nativas:

1. Integración con sistemas de tickets

> "Implementa la feature descrita en JIRA issue ENG-4521 y crea un PR en GitHub"

Claude lee el issue de JIRA, implementa el código, crea el commit y abre el PR — todo automáticamente.

2. Consultas a bases de datos

> "Muéstrame los 10 usuarios más activos del último mes según nuestra DB de PostgreSQL"

Claude ejecuta la query SQL apropiada y presenta los resultados en formato legible.

3. Análisis de monitoreo

> "Revisa Sentry para ver si hay errores relacionados con el feature de login"

Claude accede a tus herramientas de monitoreo y analiza los logs.

4. Automatización de navegadores

> "Ve a nuestra página de pricing y verifica que todos los precios se muestren correctamente"

Con Playwright MCP, Claude puede controlar un navegador real.

5. Integración con herramientas de diseño

> "Actualiza nuestro componente de header basándote en el diseño nuevo de Figma"

Claude lee el diseño de Figma y genera el código correspondiente.

6. Workflows empresariales

> "Envía un mensaje en el canal #engineering de Slack con el resumen del PR que acabo de crear"

Integración con herramientas de comunicación del equipo.

Beneficios de MCP

1. Extensibilidad sin límites

No hay que esperar a que Anthropic agregue soporte para cada herramienta. La comunidad puede crear servidores MCP para cualquier servicio.

2. Estandarización

Un solo protocolo para múltiples servicios. Aprendes a configurar un servidor MCP y sabes configurar todos.

3. Separación de responsabilidades

• Claude Code: Se enfoca en entender tu intención y generar código
• MCP Server: Se encarga de los detalles de integración con cada servicio
• Servicio externo: Solo necesita una API estándar

4. Mantenimiento independiente

Si GitHub cambia su API, solo se actualiza el servidor MCP de GitHub. Claude Code no necesita cambios.

5. Reutilización entre LLMs

MCP es un estándar abierto. Cualquier LLM que implemente MCP puede usar los mismos servidores.

6. Seguridad y control

Los servidores MCP pueden configurarse con permisos específicos y autenticación OAuth 2.0.

MCP vs CLI directo: ¿Cuándo usar cada uno?

No siempre necesitas MCP. A veces, ejecutar un comando CLI directamente con Bash es más simple.

Ejemplo comparativo

CLI directo (mejor opción):

> "Ejecuta git status y muéstrame los archivos modificados"
# Claude simplemente ejecuta: git status

MCP (mejor opción):

> "Busca todos los PRs abiertos en GitHub que mencionen 'authentication'
   y resume el estado de cada uno"
# Con MCP: Claude consulta la API de GitHub múltiples veces,
# mantiene contexto entre llamadas, y procesa resultados complejos

Regla general

• CLI directo: Operaciones simples, stateless, de una sola ejecución
• MCP: Operaciones complejas, con estado, que requieren múltiples interacciones

El ecosistema MCP

MCP es de código abierto y tiene una comunidad activa creando servidores para todo tipo de servicios:

Servidores MCP populares (2026)

• Playwright: Automatización de navegadores
• GitHub: Issues, PRs, repositorios
• PostgreSQL: Consultas a bases de datos
• Slack: Mensajería y canales
• Filesystem: Acceso extendido a archivos
• Google Calendar: Gestión de eventos
• Notion: Notas y bases de datos
• Sentry: Monitoreo de errores
• Figma: Diseños y componentes

En el siguiente punto (6.2) exploraremos los MCPs más populares en detalle.

Recursos de la comunidad

• Sitio oficial: modelcontextprotocol.io
• GitHub: github.com/modelcontextprotocol
• Blog: blog.modelcontextprotocol.io
• Inspector Tool: Herramienta para testear servidores MCP

Conclusión

MCP transforma Claude Code de un asistente de código en un orquestador de ecosistemas completos. Ya no estás limitado a leer archivos y ejecutar comandos — ahora Claude puede interactuar con prácticamente cualquier herramienta o servicio que uses.

Lo importante a recordar:

• MCP es un protocolo estándar para conectar LLMs con herramientas externas
• Funciona con arquitectura cliente-servidor
• Claude Code actúa como cliente MCP
• Los servidores MCP exponen capacidades de servicios externos
• Es mejor que CLI directo para operaciones complejas con estado
• Hay un ecosistema creciente de servidores MCP disponibles

En los siguientes puntos del módulo aprenderás:

• 6.2: Los MCPs más populares y qué puedes hacer con cada uno
• 6.3: Cómo instalar y configurar servidores MCP
• 6.4: Cuándo usar MCP vs CLI directo (casos avanzados)
• 6.5: Filosofía recomendada para usar MCP efectivamente

Recursos adicionales

• Introducing the Model Context Protocol - Anthropic
• MCP Specification
• Connect Claude Code to tools via MCP
• Introduction to Model Context Protocol - Anthropic Course

6.2 MCPs populares

Introducción: El ecosistema MCP en 2026

Desde el lanzamiento de MCP en noviembre de 2024, el ecosistema ha crecido exponencialmente. En 2026 existen más de 7,900 servidores MCP disponibles, desde soluciones oficiales hasta herramientas comunitarias especializadas.

En este punto exploraremos los MCPs más populares y útiles para desarrolladores, organizados por categorías, con casos de uso específicos y ejemplos prácticos.

Nota importante: Este punto se enfoca en qué puede hacer cada MCP. En el punto 6.3 aprenderás cómo instalarlos y configurarlos.

Categorías de MCPs

🌐 Automatización de navegadores

Playwright

Servidor MCP para automatización de navegadores web usando Playwright.

Casos de uso principales:

• Testing automatizado de interfaces de usuario
• Web scraping estructurado y confiable
• Navegación automática por flujos web
• Captura de screenshots y videos
• Validación de diseños responsive

Ejemplos de prompts:

> "Navega a nuestra página de pricing y verifica que todos los planes
   muestren el precio correcto"
 
> "Accede al dashboard de producción, haz login con las credenciales de test,
   y captura un screenshot del estado actual"
 
> "Ejecuta un test E2E del flujo de compra completo y reporta cualquier error"

Consideraciones:

• Requiere Playwright instalado localmente
• Ideal para operaciones complejas que requieren estado del navegador
• Más eficiente que herramientas basadas en screenshots

Browserbase

Automatización de navegadores en la nube.

Casos de uso principales:

• Navegación web sin instalar Playwright localmente
• Extracción de datos a escala
• Llenado automático de formularios
• Automatización en ambientes sin GUI

Ejemplos de prompts:

> "Extrae todos los posts del blog de la competencia publicados este mes"
 
> "Completa el formulario de contacto en [url] con los datos del cliente"

Consideraciones:

• Basado en cloud, no requiere setup local
• Requiere cuenta en Browserbase
• Mejor para operaciones distribuidas

🔧 Integración con plataformas de desarrollo

GitHub (Oficial)

Servidor MCP oficial de GitHub para gestión completa de repositorios.

Casos de uso principales:

• Búsqueda avanzada de código en repositorios
• Gestión de issues y pull requests
• Code reviews automatizados
• Creación y gestión de branches
• Consulta de GitHub Actions

Ejemplos de prompts:

> "Busca todos los archivos en nuestro repo que usen la función
   deprecatedAPI y crea un issue para cada uno"
 
> "Revisa el PR #456 y comenta sobre problemas de seguridad potenciales"
 
> "Crea una rama feature/new-auth, implementa autenticación JWT,
   y abre un PR con descripción detallada"
 
> "Muéstrame todos los PRs abiertos que mencionan 'performance'
   y resume el estado de cada uno"

Características especiales:

• Modo solo lectura: Evita modificaciones accidentales
• Toolsets dinámicos: Habilita/deshabilita grupos de funcionalidades
• Búsqueda avanzada: Soporte completo de la sintaxis de GitHub Search
• Iconos Octicon: Visualización nativa en clientes que lo soporten

Configuración básica:

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

Consideraciones:

• Requiere GitHub Personal Access Token
• Soporta modo read-only para seguridad
• Actualizado activamente por GitHub (2026)

GitLab

Similar a GitHub MCP pero para GitLab.

Casos de uso principales:

• Gestión de merge requests
• CI/CD pipeline management
• Issues y milestones
• Wiki y documentación

Ejemplos de prompts:

> "Analiza los pipelines que fallaron esta semana y crea un reporte"
 
> "Actualiza el wiki del proyecto con la nueva arquitectura"

Linear

Gestión de proyectos e issues estilo ágil.

Casos de uso principales:

• Crear y actualizar issues de forma automática
• Sincronizar tareas entre código y Linear
• Reporting de sprints
• Gestión de ciclos y roadmaps

Ejemplos de prompts:

> "Crea un issue en Linear para cada TODO que encuentres en el código"
 
> "Muéstrame todas las tareas asignadas a mí en el sprint actual"

🗄️ Bases de datos

PostgreSQL

Servidor MCP para consultas y gestión de bases de datos PostgreSQL.

Casos de uso principales:

• Consultas SQL en lenguaje natural
• Análisis de datos y generación de reportes
• Gestión de schemas
• Debugging de queries
• Migraciones de datos

Ejemplos de prompts:

> "Muéstrame los 10 usuarios más activos del último mes"
 
> "Analiza la tabla orders y encuentra patrones de compra inusuales"
 
> "Genera un reporte de ventas por categoría de producto"
 
> "Optimiza esta query SQL: [pegar query lenta]"

Configuración básica:

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

Consideraciones:

• Soporta modo read-only (recomendado para producción)
• Pooling de conexiones incluido
• Ideal para análisis de datos ad-hoc

MongoDB

Servidor MCP para bases de datos NoSQL MongoDB.

Casos de uso principales:

• Consultas a colecciones en lenguaje natural
• Agregaciones complejas
• Análisis de documentos JSON
• Debugging de queries

Ejemplos de prompts:

> "Busca todos los usuarios que se registraron en los últimos 7 días
   y tienen más de 5 pedidos"
 
> "Analiza la colección de logs y encuentra errores recurrentes"

Configuración básica:

{
  "mcpServers": {
    "mongodb": {
      "command": "npx",
      "args": ["-y", "@nam088/mcp-database-server"],
      "env": {
        "DB_TYPE": "mongodb",
        "MONGODB_CONNECTION_STRING": "mongodb://localhost:27017/mydb"
      }
    }
  }
}

SQLite

Servidor MCP para bases de datos SQLite locales.

Casos de uso principales:

• Análisis de bases de datos locales
• Testing con datos locales
• Exploración de schemas
• Prototipos y desarrollo

Ejemplos de prompts:

> "Crea una tabla de usuarios con campos básicos y genera datos de prueba"
 
> "Analiza la base de datos local.db y muéstrame su estructura"

Consideraciones:

• Sin dependencias externas
• Perfecto para desarrollo local
• Soporta CRUD completo

💬 Comunicación y productividad

Slack

Servidor MCP para integración completa con Slack.

Casos de uso principales:

• Buscar mensajes y conversaciones
• Enviar mensajes a canales o DMs
• Resumir threads y conversaciones
• Análisis de sentimiento en canales
• Notificaciones automáticas

Ejemplos de prompts:

> "Busca en #engineering todas las menciones de 'deployment issue'
   en los últimos 3 días y resume los problemas"
 
> "Envía un mensaje al canal #general anunciando el release v2.0"
 
> "Resume el thread más largo del canal #product esta semana"
 
> "Analiza el sentimiento en #support y reporta si hay clientes frustrados"

Características especiales:

• Modo stealth: Sin permisos adicionales ni bots
• Modo OAuth: Autenticación segura
• Soporte DM/Group DM: Mensajes directos y grupales
• Smart history: Paginación inteligente de historial
• Transporte flexible: Stdio, SSE, HTTP

Configuración básica:

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-xxxxx",
        "SLACK_TEAM_ID": "T12345"
      }
    }
  }
}

Consideraciones:

• Requiere Slack Bot Token
• Varios servidores disponibles con distintas capacidades
• Respeta permisos de Slack workspace

Discord

Similar a Slack MCP pero para Discord.

Casos de uso principales:

• Gestión de servidores Discord
• Moderación automática
• Análisis de comunidades
• Bots personalizados

Gmail

Servidor MCP para gestión de correos electrónicos.

Casos de uso principales:

• Enviar correos automáticamente
• Buscar y filtrar emails
• Crear borradores de emails
• Gestión de labels y carpetas

Ejemplos de prompts:

> "Busca todos los emails de clientes que mencionan 'bug' esta semana"
 
> "Crea un borrador de email invitando a 10 usuarios beta a probar la nueva feature"
 
> "Resume los emails importantes no leídos"

Notion

Servidor MCP para integración con Notion.

Casos de uso principales:

• Crear y actualizar páginas automáticamente
• Consultar bases de datos de Notion
• Sincronizar documentación
• Gestión de wikis y knowledge bases

Ejemplos de prompts:

> "Crea una página en Notion documentando la nueva API que acabamos de implementar"
 
> "Busca en la wiki de Notion cómo configuramos el entorno de staging"
 
> "Actualiza la base de datos de features con el estado actual del proyecto"

Consideraciones:

• Requiere Notion API key
• Respeta estructura de workspaces

Google Calendar

Servidor MCP para gestión de calendario.

Casos de uso principales:

• Crear eventos automáticamente
• Consultar disponibilidad
• Gestión de recordatorios
• Análisis de tiempo

Ejemplos de prompts:

> "Agenda una reunión de 1 hora con el equipo para revisar el sprint"
 
> "Muéstrame mi calendario de la próxima semana"
 
> "Encuentra un hueco de 30 minutos para una demo esta semana"

📊 Monitoreo y observabilidad

Sentry

Servidor MCP para monitoreo de errores y excepciones.

Casos de uso principales:

• Consultar errores recientes
• Análisis de stack traces
• Identificar patrones de errores
• Priorización de bugs

Ejemplos de prompts:

> "Muéstrame los errores más frecuentes en producción en las últimas 24 horas"
 
> "Analiza el error SENTRY-123 y sugiere una solución"
 
> "¿Hay nuevos errores desde el último deployment?"

Consideraciones:

• Requiere cuenta Sentry y API token
• Acceso a proyectos específicos

Datadog

Servidor MCP para métricas y logs.

Casos de uso principales:

• Consultar métricas de rendimiento
• Análisis de logs
• Alertas y dashboards
• Troubleshooting

Ejemplos de prompts:

> "Muéstrame el uso de CPU de los últimos 3 días"
 
> "¿Hay alguna métrica anormal en producción ahora mismo?"

🎨 Diseño

Figma (Oficial)

Servidor MCP oficial de Figma para integración con diseños.

Casos de uso principales:

• Generar código desde frames de Figma
• Extraer variables y componentes de diseño
• Sincronizar sistemas de diseño con código
• Implementar diseños con precisión
• Integrar diagramas FigJam en desarrollo

Ejemplos de prompts:

> "Genera el componente React para el botón primario del sistema de diseño en Figma"
 
> "Implementa este frame de Figma: [url] usando Tailwind CSS"
 
> "Extrae todos los colores y tokens del archivo de diseño y créalos como
   variables CSS"
 
> "Compara el componente Header en el código con el diseño de Figma
   y lista las diferencias"

Formas de uso:

1. Servidor local: A través de la app de escritorio Figma (http://127.0.0.1:3845/mcp)
2. Servidor remoto: Directamente desde https://mcp.figma.com/mcp

Características especiales:

• Selección de frames: Selecciona frames en Figma Desktop y úsalos directamente
• Enlaces compartidos: Pasa URLs de Figma para extraer información
• Recursos Make: Acceso a componentes de código de archivos Make
• FigJam: Extracción de diagramas y flujos

Caso de uso real:

Un equipo usó Figma MCP + Jira MCP para convertir un diseño complejo en 6 epics y 20 user stories en 10 minutos.

Consideraciones:

• Requiere cuenta Figma
• Funciona con archivos públicos y privados (con permisos)
• Ideal para equipos con sistemas de diseño

🗂️ Sistema de archivos

Filesystem

Servidor MCP oficial para acceso extendido a archivos.

Casos de uso principales:

• Operaciones de archivos con controles de seguridad
• Acceso a directorios específicos
• Lectura/escritura con permisos granulares
• Búsqueda avanzada de archivos

Ejemplos de prompts:

> "Busca todos los archivos .env en el proyecto y verifica que estén en .gitignore"
 
> "Lista todos los archivos modificados en los últimos 2 días"

Consideraciones:

• Controles de acceso configurables
• Más seguro que acceso bash directo
• Limitado a rutas específicas

Everything Search (Windows)

Búsqueda ultra-rápida de archivos en Windows.

Casos de uso principales:

• Búsqueda instantánea de archivos
• Localizar recursos rápidamente
• Indexación completa del sistema

Ejemplos de prompts:

> "Encuentra todos los archivos PDF que contengan 'invoice' en el nombre"

☁️ APIs y servicios cloud

Stripe

Servidor MCP para integración con Stripe.

Casos de uso principales:

• Gestión de pagos y suscripciones
• Procesamiento de reembolsos
• Consulta de transacciones
• Análisis de revenue

Ejemplos de prompts:

> "Muéstrame todas las suscripciones activas del plan Pro"
 
> "Procesa un reembolso para el pago pi_xxxxx"
 
> "¿Cuál fue el revenue total del mes pasado?"

Consideraciones:

• Requiere API keys de Stripe
• Manejo cuidadoso de datos sensibles
• Modo read-only recomendado para seguridad

AWS Suite

Servidores MCP oficiales para servicios AWS.

Servicios soportados:

• DynamoDB: Consultas y gestión de tablas
• Aurora: Bases de datos relacionales
• Neptune: Grafos de datos
• S3: Almacenamiento de objetos
• Lambda: Funciones serverless
• CloudFormation: Validación de templates

Casos de uso principales:

• Gestión de infraestructura cloud
• Consultas a servicios AWS
• Troubleshooting de deployments
• Validación de configuraciones

Ejemplos de prompts:

> "Lista todos los buckets S3 y su tamaño total"
 
> "Valida este template de CloudFormation y reporta problemas de seguridad"
 
> "Consulta la tabla DynamoDB users-prod para el usuario con id=123"

Consideraciones:

• Requiere AWS credentials configuradas
• Respeta IAM policies
• Ideal si tu infraestructura está en AWS

Cloudflare

Servidor MCP para Cloudflare.

Casos de uso principales:

• Gestión de Workers
• KV storage operations
• R2 object storage
• D1 database queries

Ejemplos de prompts:

> "Despliega este Worker a producción"
 
> "Consulta la KV store auth-tokens para el usuario X"

🔍 Búsqueda y conocimiento

Brave Search

Búsqueda web general.

Casos de uso principales:

• Búsqueda de información actualizada
• Investigación web
• Fact-checking

Ejemplos de prompts:

> "Busca las mejores prácticas de React 19 publicadas en 2026"

Context7

Documentación técnica actualizada en tiempo real.

Casos de uso principales:

• Consultar versiones específicas de librerías
• Documentación siempre actualizada
• Referencias técnicas precisas

Ejemplos de prompts:

> "¿Cómo se usa el hook useFormStatus en React 19?"
 
> "Muéstrame la sintaxis de Zod para validar arrays anidados"

Consideraciones:

• Alternativa a confiar en datos de entrenamiento
• Especialmente útil para frameworks que cambian rápido

Firecrawl

Web scraping y búsqueda avanzada.

Casos de uso principales:

• Extracción estructurada de datos web
• Scraping a escala
• Monitoreo de sitios web

Ejemplos de prompts:

> "Extrae todos los precios de la página de la competencia"
 
> "Monitorea [url] y notifícame si hay cambios"

Exa

Motor de búsqueda optimizado para IA.

Casos de uso principales:

• Búsquedas semánticas
• Investigación profunda
• Búsqueda específica para agentes IA

GPT Researcher

Generación de reportes de investigación citados.

Casos de uso principales:

• Investigación técnica profunda
• Evaluaciones arquitectónicas
• Reportes con fuentes verificadas

Ejemplos de prompts:

> "Investiga las opciones de bases de datos vectoriales y crea un reporte
   comparando sus características, rendimiento y casos de uso"

🧪 Desarrollo y testing

E2B

Ejecución de código en sandboxes seguros.

Casos de uso principales:

• Ejecutar código no confiable de forma segura
• Testing de snippets
• Validación de código generado
• Entornos de desarrollo efímeros

Ejemplos de prompts:

> "Ejecuta este script Python en un sandbox y muéstrame el output"
 
> "Prueba esta función con diferentes inputs y reporta los resultados"

Consideraciones:

• Totalmente aislado y seguro
• Soporta múltiples lenguajes
• Ideal para generar y validar código

Chrome DevTools MCP

Inspección de navegadores en vivo.

Casos de uso principales:

• Debugging de aplicaciones web
• Inspección de performance
• Análisis de red

Ejemplos de prompts:

> "Inspecciona la página actual y reporta problemas de performance"
 
> "Analiza todas las llamadas de red y encuentra las más lentas"

📚 Datos y análisis

Kaggle

Acceso a datasets, modelos y competiciones de Kaggle.

Casos de uso principales:

• Descargar datasets para ML
• Análisis exploratorio de datos
• Benchmarking con notebooks públicos

Ejemplos de prompts:

> "Descarga el dataset de Titanic de Kaggle y haz un análisis exploratorio"
 
> "Busca competiciones de NLP activas"

Alpha Vantage

Datos financieros en tiempo real.

Casos de uso principales:

• Análisis de acciones
• Datos de criptomonedas
• Commodities y forex

Ejemplos de prompts:

> "Muéstrame el precio de cierre de AAPL en los últimos 30 días"
 
> "Analiza la correlación entre BTC y ETH este mes"

🎉 Otros MCPs especializados

Supabase

Plataforma de backend como servicio.

Casos de uso principales:

• Gestión de bases de datos
• Autenticación
• Edge functions
• Storage

Magic UI

Patrones de React/Tailwind de referencia.

Casos de uso principales:

• Generación de componentes UI
• Aplicación de patterns consistentes
• Aceleración de desarrollo frontend

Twilio

SMS y llamadas telefónicas.

Casos de uso principales:

• Envío de SMS
• Notificaciones telefónicas
• Verificación de usuarios

Tabla comparativa de MCPs populares

*Requiere connection string (credenciales incluidas)

Cómo elegir qué MCPs instalar

Paso 1: Evalúa tu workflow actual

Hazte estas preguntas:

• ¿Qué tareas manuales repito frecuentemente?
• ¿Qué servicios externos consulto a menudo?
• ¿Qué integraciones beneficiarían mi desarrollo diario?
• ¿Qué herramientas usa mi equipo?

Paso 2: Prioriza por frecuencia de uso

Categoriza los MCPs:

• Alta prioridad: Uso diario o varias veces por semana
• Media prioridad: Uso semanal o mensual
• Baja prioridad: Casos edge o experimentación

Paso 3: Empieza con lo básico

Para desarrollo web típico, considera:

1. GitHub (si usas GitHub)
2. PostgreSQL (si usas bases de datos relacionales)
3. Slack o Discord (si tu equipo las usa)
4. Figma (si trabajas con diseñadores)

Para desarrollo full-stack: Agrega: 5. Sentry o herramienta de monitoreo que uses 6. Stripe (si manejas pagos) 7. Playwright (para testing)

Paso 4: Evita sobrecarga de contexto

⚠️ Importante: No instales todos los MCPs disponibles

• Cada MCP consume espacio de contexto
• Demasiados MCPs pueden confundir al modelo
• En 2026, Claude Code tiene MCP Tool Search que carga tools dinámicamente si tienes muchos MCPs

Regla práctica: Comienza con 3-5 MCPs. Agrega más según necesidad real.

Paso 5: Considera seguridad

Para cada MCP pregúntate:

• ¿Qué permisos necesita?
• ¿Puede modificar datos críticos?
• ¿Debería usar modo read-only?
• ¿Las credenciales están seguras?

Dónde encontrar más MCPs

Directorios oficiales y de la comunidad

1. mcpservers.org - Colección curada de servidores MCP organizados por categorías
2. mcp.so - +17,000 servidores MCP de la comunidad
3. PulseMCP.com - +7,900 servidores actualizados diariamente
4. mcp-awesome.com - 1,200+ servidores verificados con guías
5. Glama.ai - Marketplace visual con previews
6. MCP Server Finder - Directorio searchable
7. GitHub: modelcontextprotocol/servers - Repositorio oficial

Listas awesome de GitHub

• wong2/awesome-mcp-servers
• appcypher/awesome-mcp-servers
• ever-works/awesome-mcp-servers

Buscadores especializados

Usa términos como:

• "MCP server for [tecnología]"
• "[servicio] MCP integration"
• "awesome mcp servers"

MCPs experimentales y de nicho

Además de los MCPs populares, existe un ecosistema de servidores especializados:

Por industria

• Salud: Integración con sistemas médicos (FHIR, HL7)
• Finanzas: Trading APIs, análisis financiero
• E-commerce: Shopify, WooCommerce, Magento
• Educación: LMS, sistemas académicos

Experimentales

• Blockchain: Web3, contratos inteligentes
• IoT: Integración con dispositivos
• Gaming: Steam, Unity, game engines
• 3D: Blender, CAD, impresión 3D

De nicho

• Herramientas específicas de empresas
• Integraciones legacy
• APIs propietarias

Consejo: Evalúa bien los MCPs experimentales antes de usarlos en producción. Revisa:

• Mantenimiento activo
• Documentación
• Issues en GitHub
• Seguridad del código

Conclusión

El ecosistema MCP en 2026 es rico y diverso. Con más de 7,900 servidores disponibles, hay opciones para prácticamente cualquier caso de uso.

Puntos clave:

• Los MCPs transforman Claude Code en un orquestador universal de herramientas
• Existen MCPs para desarrollo, bases de datos, comunicación, diseño, cloud y más
• No necesitas instalar todos los MCPs — elige los relevantes para tu workflow
• La comunidad contribuye constantemente con nuevos servidores
• MCP Tool Search (2026) permite manejar cientos de tools sin saturar el contexto

Próximos pasos: En el siguiente punto (6.3) aprenderás cómo instalar y configurar estos MCPs en Claude Code, con ejemplos prácticos y mejores prácticas.

Recursos adicionales

• Awesome MCP Servers - Directory
• MCP Official Examples
• The Best MCP Servers for Developers in 2026
• GitHub MCP Server Official Repo
• Figma MCP Server Guide
• Slack MCP Server Overview

6.3 Gestión de MCPs

Introducción

En el punto anterior conociste los MCPs más populares y qué puede hacer cada uno. Ahora es momento de aprender a instalarlos, configurarlos y gestionarlos en Claude Code.

Este punto es completamente práctico. Al final, serás capaz de:

• Instalar cualquier MCP con el método apropiado
• Configurar autenticación y permisos
• Gestionar MCPs instalados (listar, actualizar, remover)
• Optimizar performance con MCP Tool Search
• Resolver problemas comunes
• Compartir configuración de MCPs con tu equipo

Comandos principales de gestión

Antes de instalar, familiarízate con los comandos básicos:

# Listar todos los MCPs configurados
claude mcp list
 
# Ver detalles de un MCP específico
claude mcp get github
 
# Eliminar un MCP
claude mcp remove github
 
# Revisar estado en sesión interactiva
/mcp
 
# Resetear opciones de project scope
claude mcp reset-project-choices

Instalación de MCPs

Existen dos métodos principales para instalar MCPs: CLI Wizard (interactivo) y configuración manual.

Método 1: CLI Wizard (Recomendado para empezar)

El método más simple es usar el comando claude mcp add que te guía paso a paso.

Sintaxis básica:

claude mcp add [opciones] <nombre> -- <comando> [args...]

Orden importante: Todas las opciones (--transport, --env, --scope, --header) deben ir antes del nombre del servidor. Usa -- para separar opciones del comando.

Ventajas del CLI Wizard

✅ Interactivo y guiado ✅ Validación automática ✅ Menos propenso a errores ✅ Ideal para aprender

Desventajas

❌ Lento para múltiples MCPs ❌ No documenta la configuración ❌ Difícil de automatizar

Método 2: Configuración manual

Edita directamente el archivo de configuración JSON.

Ubicaciones:

• Local: ~/.claude.json (dentro de la ruta del proyecto)
• Project: .mcp.json (raíz del proyecto)
• User: ~/.claude.json (global)

Estructura básica:

{
  "mcpServers": {
    "nombre-del-mcp": {
      "type": "http",
      "url": "https://api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${API_TOKEN}"
      }
    },
    "otro-mcp": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@some/mcp-server"],
      "env": {
        "API_KEY": "${SECRET_KEY}"
      }
    }
  }
}

Ventajas de configuración manual

✅ Rápido para múltiples MCPs ✅ Documentable (comentarios en commits) ✅ Fácil de copiar/compartir ✅ Control total

Desventajas

❌ Requiere conocer la sintaxis ❌ Propenso a errores de formato ❌ Sin validación automática

¿Cuándo usar cada método?

Tipos de transporte

MCP soporta tres tipos de transporte. Cada uno tiene casos de uso específicos.

HTTP (Recomendado)

Servidores remotos que se comunican vía HTTP.

Cuándo usar:

• Servicios cloud (GitHub, Slack, Notion)
• APIs remotas
• MCPs oficiales de empresas

Sintaxis:

claude mcp add --transport http <nombre> <url>

Ejemplo:

# Notion MCP
claude mcp add --transport http notion https://mcp.notion.com/mcp
 
# Con autenticación Bearer
claude mcp add --transport http api https://api.example.com/mcp \
  --header "Authorization: Bearer your-token"

Configuración manual:

{
  "mcpServers": {
    "notion": {
      "type": "http",
      "url": "https://mcp.notion.com/mcp"
    },
    "api-auth": {
      "type": "http",
      "url": "https://api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${API_TOKEN}"
      }
    }
  }
}

SSE (Server-Sent Events) — ⚠️ Deprecado

Transmisión de datos en tiempo real.

Nota 2026: SSE está siendo deprecado en favor de HTTP. Úsalo solo si el MCP específicamente lo requiere.

Sintaxis:

claude mcp add --transport sse <nombre> <url>

Ejemplo:

claude mcp add --transport sse dashboard https://api.company.com/sse \
  --header "X-API-Key: your-key"

⚠️ Limitación: SSE no está soportado en la extensión VS Code, solo en CLI.

Stdio (Standard Input/Output)

Procesos locales que se comunican vía stdin/stdout.

Cuándo usar:

• Servidores MCP instalados localmente con npm/npx
• Scripts personalizados
• Herramientas que requieren acceso directo al sistema
• Bases de datos locales

Sintaxis:

claude mcp add --transport stdio <nombre> -- <comando> [args...]

Ejemplos:

# PostgreSQL
claude mcp add --transport stdio postgres \
  -- npx -y @modelcontextprotocol/server-postgres
 
# Slack
claude mcp add --transport stdio slack \
  -- npx -y @modelcontextprotocol/server-slack
 
# Playwright
claude mcp add --transport stdio playwright \
  -- npx -y @executeautomation/playwright-mcp-server

Configuración manual:

{
  "mcpServers": {
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/db"
      }
    }
  }
}

⚠️ Windows: Usa el wrapper cmd /c:

claude mcp add --transport stdio my-server \
  -- cmd /c npx -y @some/package

Scopes de instalación

Los MCPs pueden instalarse en tres scopes diferentes que determinan dónde se guarda la configuración y quién puede acceder.

Tabla comparativa de scopes

Local Scope (Default)

Archivo: ~/.claude.json (dentro de la ruta del proyecto)

Características:

• Privado para ti
• Solo accesible en el directorio actual del proyecto
• Por defecto si no especificas scope

Cuándo usar:

• Credenciales sensibles (tokens personales)
• MCPs que solo tú necesitas
• Testing de MCPs experimentales

Sintaxis:

# Implícito (default)
claude mcp add --transport http stripe https://mcp.stripe.com
 
# Explícito
claude mcp add --transport http stripe --scope local https://mcp.stripe.com

Project Scope

Archivo: .mcp.json en la raíz del proyecto

Características:

• Compartido con todo el equipo
• Se versiona en git
• Todos usan la misma configuración

Cuándo usar:

• MCPs que el equipo necesita (GitHub, Jira)
• Configuración estándar del proyecto
• Onboarding de nuevos devs

Sintaxis:

claude mcp add --transport http github --scope project \
  https://api.githubcopilot.com/mcp/

⚠️ Importante para project scope:

• NUNCA incluir credenciales directamente
• Usar variables de entorno: ${GITHUB_TOKEN}
• Documentar en README qué variables se necesitan

Ejemplo de .mcp.json seguro:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DB_CONNECTION_STRING}"
      }
    }
  }
}

README.md correspondiente:

## Configuración de MCPs
 
Este proyecto usa los siguientes MCPs:
 
### GitHub MCP
Requiere: `GITHUB_TOKEN` con permisos de repo
 
### PostgreSQL MCP
Requiere: `DB_CONNECTION_STRING` en formato:
`postgresql://user:pass@host:5432/dbname`
 
### Setup
1. Copia `.env.example` a `.env`
2. Completa las variables requeridas
3. Ejecuta `source .env` antes de iniciar Claude Code

User Scope

Archivo: ~/.claude.json (global, fuera del proyecto)

Características:

• Disponible en todos tus proyectos
• Privado para ti
• No versionado

Cuándo usar:

• MCPs que usas en múltiples proyectos
• Herramientas personales (tu configuración de Notion, Calendar)
• Utilidades generales

Sintaxis:

claude mcp add --transport http hubspot --scope user \
  https://mcp.hubspot.com/anthropic

Precedencia de scopes

Cuando existe un MCP con el mismo nombre en múltiples scopes:

Local > Project > User
(mayor)          (menor)

Ejemplo:

Local:   github → https://api.githubcopilot.com (token personal)
Project: github → https://api.githubcopilot.com (token del equipo)
 
Resultado: Se usa el MCP local con tu token personal

Esto permite overrides personales sin afectar la configuración del equipo.

Autenticación y credenciales

Los MCPs requieren diferentes tipos de autenticación según el servicio.

OAuth 2.0

Servicios que lo usan: GitHub, Slack, Notion, Figma, Sentry, Google, etc.

Flujo de instalación:

1. Instalar el MCP
2. Usar /mcp dentro de Claude Code
3. Seguir el flujo en el navegador
4. Tokens se guardan y refrescan automáticamente

Ejemplo con GitHub:

# 1. Instalar
claude mcp add --transport http github https://api.githubcopilot.com/mcp/
 
# 2. Dentro de Claude Code interactivo
> /mcp
# Selecciona GitHub y sigue el flujo OAuth
 
# 3. Verificar
> "Lista los PRs abiertos en mi repo"

Troubleshooting OAuth:

Si el navegador no se abre automáticamente:

• Presiona c para copiar la URL al portapapeles
• Pégala manualmente en el navegador

Si la autenticación falla después de completar OAuth:

• Reinicia Claude Code
• Usa claude mcp remove github y reinstala
• Verifica que tu navegador acepte cookies

API Keys y Tokens

Servicios que lo usan: Stripe, Twilio, bases de datos, APIs custom

Método 1: Variables de entorno en comando

claude mcp add --transport stdio db \
  --env DATABASE_URL="postgresql://user:pass@localhost:5432/db" \
  -- npx -y @modelcontextprotocol/server-postgres

Método 2: Variables de entorno del sistema (Recomendado)

# En tu shell (bash/zsh)
export GITHUB_TOKEN="ghp_xxxxxxxxxxxx"
export STRIPE_KEY="sk_test_xxxxxxxxxx"
export DATABASE_URL="postgresql://user:pass@localhost:5432/db"
 
# Instalar con placeholders
claude mcp add --transport stdio postgres \
  --env DATABASE_URL="${DATABASE_URL}" \
  -- npx -y @modelcontextprotocol/server-postgres

Método 3: Archivo .env (Mejores prácticas)

Crea .env en la raíz del proyecto:

# .env
GITHUB_TOKEN=ghp_xxxxxxxxxxxx
STRIPE_KEY=sk_test_xxxxxxxxxx
DATABASE_URL=postgresql://user:pass@localhost:5432/db

Agrega a .gitignore:

.env
.env.*

Carga antes de ejecutar Claude:

# Opción 1: source manual
source .env && claude
 
# Opción 2: dotenv (instalar globalmente)
npm install -g dotenv-cli
dotenv claude
 
# Opción 3: direnv (automático)
# Instalar direnv, luego crea .envrc:
echo 'source .env' > .envrc
direnv allow
claude  # Variables cargadas automáticamente

Connection Strings

Para bases de datos: PostgreSQL, MongoDB, MySQL, etc.

Formato PostgreSQL:

postgresql://[user]:[password]@[host]:[port]/[database]

Formato MongoDB:

mongodb://[user]:[password]@[host]:[port]/[database]

Ejemplo seguro:

# .env
DB_READONLY="postgresql://readonly:readpass@prod-db.company.com:5432/analytics"
DB_READWRITE="postgresql://admin:adminpass@localhost:5432/dev"
 
# .mcp.json (project scope)
{
  "mcpServers": {
    "db-prod": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DB_READONLY}"
      }
    }
  }
}

⚠️ Seguridad:

• Usa usuarios read-only para producción
• Nunca commites connection strings
• Usa SSH tunnels para DBs remotas si es posible

Headers personalizados

Para APIs que requieren headers específicos.

Sintaxis CLI:

claude mcp add --transport http api https://api.example.com/mcp \
  --header "Authorization: Bearer ${API_TOKEN}" \
  --header "X-API-Version: 2024-01-01"

Configuración manual:

{
  "mcpServers": {
    "custom-api": {
      "type": "http",
      "url": "https://api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${API_TOKEN}",
        "X-API-Version": "2024-01-01",
        "X-Client-ID": "${CLIENT_ID}"
      }
    }
  }
}

Ejemplos prácticos de instalación

Ejemplo 1: GitHub (OAuth, HTTP)

# Instalación
claude mcp add --transport http github https://api.githubcopilot.com/mcp/
 
# Autenticación
# Dentro de Claude Code:
> /mcp
# Selecciona GitHub → Sigue flujo OAuth
 
# Verificación
> "Muéstrame los PRs abiertos en anthropics/claude-code"

Ejemplo 2: PostgreSQL (Connection string, Stdio)

# Setup de variables
export DATABASE_URL="postgresql://readonly:pass@localhost:5432/analytics"
 
# Instalación
claude mcp add --transport stdio postgres \
  --env DATABASE_URL="${DATABASE_URL}" \
  -- npx -y @modelcontextprotocol/server-postgres
 
# Verificación
> "Consulta la tabla users y muéstrame los últimos 5 registros"

Ejemplo 3: Slack (Bot token, Stdio)

# Obtén tokens de https://api.slack.com/apps
export SLACK_BOT_TOKEN="xoxb-xxxxxxxxxxxxx"
export SLACK_TEAM_ID="T12345678"
 
# Instalación
claude mcp add --transport stdio slack \
  --env SLACK_BOT_TOKEN="${SLACK_BOT_TOKEN}" \
  --env SLACK_TEAM_ID="${SLACK_TEAM_ID}" \
  -- npx -y @modelcontextprotocol/server-slack
 
# Verificación
> "Busca en el canal #engineering mensajes sobre 'deployment'"

Ejemplo 4: Figma (Remoto HTTP con OAuth)

# Instalación
claude mcp add --transport http figma https://mcp.figma.com/mcp
 
# Autenticación
> /mcp
# Sigue flujo OAuth de Figma
 
# Verificación
> "Genera el componente Button del sistema de diseño:
   https://figma.com/file/abc123..."

Alternativa (Local - requiere Figma Desktop):

# Figma Desktop debe estar corriendo
claude mcp add --transport http figma-local http://127.0.0.1:3845/mcp

Ejemplo 5: Playwright (Local Stdio)

# Instalación
claude mcp add --transport stdio playwright \
  -- npx -y @executeautomation/playwright-mcp-server
 
# Verificación
> "Navega a https://example.com y verifica que el título
   de la página contiene 'Example'"

Ejemplo 6: Stripe (API Key, HTTP)

# Setup
export STRIPE_KEY="sk_test_xxxxxxxxxxxxx"
 
# Instalación
claude mcp add --transport http stripe https://mcp.stripe.com \
  --header "Authorization: Bearer ${STRIPE_KEY}"
 
# Verificación
> "Muéstrame las suscripciones activas del plan Pro"

MCP Tool Search (Feature 2026)

¿Qué es?

MCP Tool Search es una característica que permite carga dinámica de herramientas cuando tienes muchos MCPs instalados.

El problema que resuelve

Antes de Tool Search:

• GitHub MCP: ~46,000 tokens (91 herramientas)
• Playwright: ~9,700 tokens (21 herramientas)
• AWS: ~9,100 tokens (7 herramientas)

Un usuario reportó 144,802 tokens consumidos solo en definiciones de herramientas MCP, dejando poco espacio para trabajo real.

Cómo funciona

Antes (sin Tool Search):

[Claude recibe TODAS las definiciones de tools al inicio]
- 91 tools de GitHub
- 21 tools de Playwright
- ...
Total: ~100K tokens consumidos

Ahora (con Tool Search):

[Claude recibe una herramienta de búsqueda]
Cuando necesita algo:
1. Busca: "create pull request" → encuentra 3-5 tools relevantes
2. Carga solo esas tools: ~3K tokens
3. Las usa y las descarga después

Cuándo se activa

Automático por defecto:

• < 10,000 tokens en tools: Carga normal
• > 10,000 tokens en tools: Tool Search se activa automáticamente

Configuración

# Default (automático con threshold 10%)
claude
 
# Threshold personalizado (5%)
ENABLE_TOOL_SEARCH=auto:5 claude
 
# Siempre activado
ENABLE_TOOL_SEARCH=true claude
 
# Desactivado
ENABLE_TOOL_SEARCH=false claude

Verificar estado

Dentro de Claude Code:

# Ver desglose de tokens
> /context
 
# Análisis detallado de MCPs
> /doctor

Resultados medibles

Reducción de tokens: 77K → 8.7K (85% de reducción)

Mejora de precisión:

• Claude Opus 4: 49% → 74%
• Claude Opus 4.5: 79.5% → 88.1%

Requisitos

⚠️ Modelos compatibles:

• ✅ Sonnet 4 y superiores
• ✅ Opus 4 y superiores
• ❌ Haiku (no soporta tool search)

Gestión de output de MCPs

Límites de tokens

Los MCPs pueden devolver respuestas muy grandes. Claude Code tiene límites configurables:

• Warning threshold: 10,000 tokens
• Límite por defecto: 25,000 tokens
• Configurable: Variable MAX_MCP_OUTPUT_TOKENS

Configurar límite

# Aumentar límite a 50K tokens
export MAX_MCP_OUTPUT_TOKENS=50000
claude
 
# Sin límite (no recomendado)
export MAX_MCP_OUTPUT_TOKENS=0
claude

Ejemplo de warning

> "Dame todos los commits del repo en los últimos 6 meses"
 
⚠️ Warning: MCP output exceeded 10,000 tokens
This may consume significant context space.

Solución: Refina tu prompt para pedir datos más específicos:

> "Dame los commits del último mes que toquen archivos en /src"

Troubleshooting común

Problema 1: MCP no aparece en claude mcp list

Síntomas: Instalaste un MCP pero no aparece listado.

Diagnóstico:

# Verifica sintaxis del archivo de configuración
cat ~/.claude.json  # o .mcp.json
 
# Busca errores de JSON

Soluciones:

• Verifica que el JSON es válido (comas, llaves, comillas)
• Asegúrate de usar el scope correcto
• Reinicia Claude Code después de editar manualmente

Ejemplo de error común:

// ❌ MAL: Coma extra
{
  "mcpServers": {
    "github": {...},   // <-- coma extra
  }
}
 
// ✅ BIEN
{
  "mcpServers": {
    "github": {...}
  }
}

Problema 2: Error de autenticación

Síntomas: "Authentication failed", "Unauthorized", "401"

Para OAuth (GitHub, Slack, Notion):

# 1. Re-autenticar
> /mcp
# Selecciona el servicio → Clear authentication → Autenticar de nuevo
 
# 2. Si no funciona, reinstalar
claude mcp remove github
claude mcp add --transport http github https://api.githubcopilot.com/mcp/
> /mcp  # Autenticar

Para API Keys:

# Verifica que la variable está definida
echo $GITHUB_TOKEN
echo $DATABASE_URL
 
# Si está vacía, exporta de nuevo
export GITHUB_TOKEN="ghp_xxxxx"
 
# Verifica permisos del token (GitHub)
# https://github.com/settings/tokens

⚠️ Problema conocido: OAuth exitoso pero reconexión falla

"Authentication successful, but server reconnection failed.
You may need to manually restart Claude Code."

Solución: Reinicia Claude Code completamente.

Problema 3: MCP lento o timeout

Síntomas: "Connection timeout", "MCP server not responding"

Soluciones:

# 1. Aumentar timeout global
export MCP_TIMEOUT=30000  # 30 segundos (default: 10s)
claude
 
# 2. Verificar conectividad
ping mcp.notion.com
 
# 3. Revisar logs del servidor (stdio)
# Los errores aparecen en la consola de Claude Code
 
# 4. Para npx, limpiar cache
npm cache clean --force

Problema 4: npx no encuentra el paquete

Síntomas: "command not found", "package not found"

Soluciones:

# 1. Instalar globalmente primero (testing)
npm install -g @modelcontextprotocol/server-github
which server-github  # Verificar ruta
 
# 2. Especificar versión exacta
claude mcp add --transport stdio github \
  -- npx -y @modelcontextprotocol/server-github@1.0.0
 
# 3. Usar yarn o pnpm en lugar de npx
claude mcp add --transport stdio github \
  -- yarn dlx @modelcontextprotocol/server-github
 
# 4. Limpiar cache de npm
npm cache clean --force

Problema 5: Windows - cmd /c no funciona

Síntomas: En Windows, npx no se ejecuta correctamente

Solución 1: Usar wrapper cmd /c

claude mcp add --transport stdio my-server \
  -- cmd /c npx -y @some/package

Solución 2: PowerShell

claude mcp add --transport stdio my-server `
  -- powershell -Command "npx -y @some/package"

Solución 3: Ruta absoluta

# Encuentra la ruta de npx
where npx
# C:\Program Files\nodejs\npx.cmd
 
# Úsala directamente
claude mcp add --transport stdio my-server \
  -- "C:\Program Files\nodejs\npx.cmd" -y @some/package

Problema 6: WSL2 - conexión rechazada

Síntomas: "Connection refused" en WSL2 con MCPs remotos

Causa: Firewall de Windows bloquea la conexión desde WSL2

Solución:

# 1. Permitir puerto en Windows Firewall
# Configuración → Firewall → Reglas de entrada → Nueva regla
 
# 2. Usar IP correcta de WSL2
ip addr show eth0  # Anota la IP
 
# 3. En la configuración del MCP, usa la IP de WSL2
# en lugar de localhost

Problema 7: Variables de entorno no se expanden

Síntomas: ${DATABASE_URL} aparece literal en vez de expandirse

Causa: Inconsistencia entre clientes MCP

Solución:

# En lugar de confiar en expansión de .mcp.json,
# exporta la variable ANTES de ejecutar Claude
 
export DATABASE_URL="postgresql://..."
claude

Workaround para project scope:

# Crea script de setup
# setup-env.sh
#!/bin/bash
source .env
claude
 
# Equipo ejecuta:
./setup-env.sh

Mejores prácticas

Seguridad

🔒 Nunca commites credenciales

# .gitignore
.env
.env.*
.claude.json       # Si contiene credenciales
*.local.json

🔒 Usa read-only para producción

# Base de datos de producción
# Usuario: readonly con permisos SELECT únicamente
DATABASE_URL="postgresql://readonly:pass@prod-db:5432/analytics"

🔒 Limita permisos de tokens

# GitHub token: Solo permisos necesarios
# ✅ repo:status, read:org
# ❌ delete_repo, admin:org

🔒 Usa environment variable placeholders

// ✅ BIEN (project scope)
{
  "mcpServers": {
    "github": {
      "headers": {
        "Authorization": "Bearer ${GITHUB_TOKEN}"
      }
    }
  }
}
 
// ❌ MAL
{
  "mcpServers": {
    "github": {
      "headers": {
        "Authorization": "Bearer ghp_realtoken123"
      }
    }
  }
}

Organización

📁 Nombres descriptivos

# ❌ MAL
claude mcp add --transport http api https://...
 
# ✅ BIEN
claude mcp add --transport http github-work https://...
claude mcp add --transport http github-personal https://...

📁 Agrupa por proyecto

# Project scope (.mcp.json)
- MCPs que el equipo necesita
- Configuración estándar
 
# Local scope
- Tus credenciales personales
- MCPs experimentales
 
# User scope
- Herramientas personales multi-proyecto

📁 Documenta configuración compleja

{
  "mcpServers": {
    // GitHub MCP para gestión de repos
    // Requiere: GITHUB_TOKEN con permisos repo:*
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${GITHUB_TOKEN}"
      }
    }
  }
}

Performance

⚡ No instales MCPs que no uses

# Revisa qué MCPs tienes
claude mcp list
 
# Elimina los que no usas
claude mcp remove unused-mcp

⚡ Usa Tool Search para muchos MCPs

# Si tienes 5+ MCPs con muchas tools
ENABLE_TOOL_SEARCH=auto:5 claude

⚡ Configura timeouts apropiados

# Para MCPs lentos (consultas pesadas a DB)
export MCP_TIMEOUT=30000  # 30 segundos
 
# Para MCPs rápidos (default está bien)
# 10 segundos

Mantenimiento

🔄 Actualiza MCPs regularmente

# Para MCPs vía npx, siempre usa -y para última versión
# npx -y obtiene la versión más reciente
 
# Si instalaste globalmente
npm update -g @modelcontextprotocol/server-github
 
# Verifica versiones
npm list -g --depth=0 | grep mcp

🔄 Prueba después de updates

# Después de actualizar un MCP
> /mcp
# Verifica que el MCP aparece y está conectado
 
# Prueba funcionalidad básica
> "Lista los repos" # GitHub MCP
> "Consulta la tabla users" # PostgreSQL MCP

🔄 Mantén backup de configuración

# Backup manual
cp ~/.claude.json ~/.claude.json.backup
cp .mcp.json .mcp.json.backup
 
# Mejor: versiona en git (sin credenciales)
git add .mcp.json
git commit -m "docs: actualizar configuración de MCPs"

MCPs en equipo

Compartir configuración

Escenario: Tu equipo necesita los mismos MCPs (GitHub, PostgreSQL, Slack)

Setup recomendado:

1. Crea .mcp.json en project scope:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "postgres": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "slack": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}",
        "SLACK_TEAM_ID": "${SLACK_TEAM_ID}"
      }
    }
  }
}

2. Crea .env.example:

# .env.example - Template para el equipo
GITHUB_TOKEN=ghp_your_token_here
DATABASE_URL=postgresql://user:pass@localhost:5432/dbname
SLACK_BOT_TOKEN=xoxb-your-token-here
SLACK_TEAM_ID=T12345678

3. Documenta en README.md:

## Configuración de MCPs
 
### Requisitos
- Node.js 18+
- Claude Code instalado
 
### Setup
1. Copia el template de variables:
   ```bash
   cp .env.example .env

2. Completa las variables en .env:

   • GITHUB_TOKEN: Crea un token aquí
     • Permisos necesarios: repo, read:org
   • DATABASE_URL: Connection string de PostgreSQL
     • Para dev local: postgresql://postgres:postgres@localhost:5432/mydb
   • SLACK_BOT_TOKEN y SLACK_TEAM_ID: Obtén aquí

3. Carga variables y ejecuta Claude:

   source .env && claude

MCPs configurados

• GitHub: Gestión de repos, PRs, issues
• PostgreSQL: Consultas a base de datos
• Slack: Mensajería y búsqueda en canales

Troubleshooting

• Si GitHub no autentica: /mcp → Selecciona GitHub → Sigue OAuth
• Si PostgreSQL no conecta: Verifica DATABASE_URL en .env

 
4. **Agrega a `.gitignore`**:

.env .claude.json

 
5. **Commitea la configuración**:
```bash
git add .mcp.json .env.example README.md .gitignore
git commit -m "feat: configurar MCPs del equipo"
git push

Onboarding de nuevos devs

Script de setup automatizado (setup-mcps.sh):

#!/bin/bash
set -e
 
echo "🚀 Setup de MCPs para el proyecto"
 
# 1. Verificar que existe .env
if [ ! -f .env ]; then
  echo "⚠️  .env no encontrado"
  echo "📝 Copiando template..."
  cp .env.example .env
  echo "✅ .env creado. Por favor completa las variables y vuelve a ejecutar."
  exit 1
fi
 
# 2. Cargar variables
source .env
 
# 3. Verificar variables requeridas
required_vars=("GITHUB_TOKEN" "DATABASE_URL" "SLACK_BOT_TOKEN" "SLACK_TEAM_ID")
for var in "${required_vars[@]}"; do
  if [ -z "${!var}" ]; then
    echo "❌ Variable $var no definida en .env"
    exit 1
  fi
done
 
echo "✅ Todas las variables configuradas"
 
# 4. Verificar Claude Code
if ! command -v claude &> /dev/null; then
  echo "❌ Claude Code no está instalado"
  echo "Instala desde: https://code.claude.com"
  exit 1
fi
 
echo "✅ Claude Code instalado"
 
# 5. Los MCPs se cargan automáticamente desde .mcp.json
echo "✅ MCPs configurados desde .mcp.json"
 
# 6. Instrucciones de autenticación OAuth
echo ""
echo "📋 Pasos finales:"
echo "1. Ejecuta: source .env && claude"
echo "2. Dentro de Claude, ejecuta: /mcp"
echo "3. Autentica GitHub siguiendo el flujo OAuth"
echo ""
echo "🎉 ¡Listo para usar MCPs!"

Uso por nuevos devs:

git clone https://github.com/company/proyecto
cd proyecto
chmod +x setup-mcps.sh
./setup-mcps.sh

Comandos de gestión avanzados

Importar desde Claude Desktop

Si ya usas MCPs en Claude Desktop, puedes importarlos:

# Importar a local scope (default)
claude mcp add-from-claude-desktop
 
# Importar a user scope
claude mcp add-from-claude-desktop --scope user

Agregar desde JSON directo

Para configuraciones complejas:

claude mcp add-json weather-api '{
  "type": "http",
  "url": "https://api.weather.com/mcp",
  "headers": {
    "Authorization": "Bearer token123"
  }
}'

Claude Code como servidor MCP

Puedes usar Claude Code como servidor MCP para otros clientes:

# Iniciar Claude Code en modo servidor
claude mcp serve
 
# Configurar en otro cliente (ej: Claude Desktop)
# claude_desktop_config.json
{
  "mcpServers": {
    "claude-code": {
      "type": "stdio",
      "command": "/usr/local/bin/claude",
      "args": ["mcp", "serve"],
      "env": {}
    }
  }
}

Conclusión

La gestión de MCPs es fundamental para aprovechar al máximo Claude Code. Con la práctica, instalar y configurar MCPs se vuelve rutinario.

Resumen de lo aprendido:

• ✅ Dos métodos de instalación: CLI wizard (rápido) y manual (control)
• ✅ Tres transportes: HTTP (remoto), SSE (deprecado), Stdio (local)
• ✅ Tres scopes: Local (personal), Project (equipo), User (multi-proyecto)
• ✅ Autenticación: OAuth, API Keys, Connection strings
• ✅ Tool Search: Optimización automática para muchos MCPs
• ✅ Troubleshooting: Soluciones a problemas comunes
• ✅ Mejores prácticas: Seguridad, organización, performance
• ✅ MCPs en equipo: Compartir configuración de forma segura

Próximos pasos: En los siguientes puntos del módulo aprenderás:

• 6.4: MCP vs CLI - Cuándo usar cada uno (análisis avanzado)
• 6.5: Filosofía recomendada para usar MCPs efectivamente
• 6.6: Configuración avanzada de MCP (managed MCPs, policies)

Recursos adicionales

• Connect Claude Code to tools via MCP - Docs
• Troubleshooting - Claude Code Docs
• What is MCP Tool Search?
• MCP Configuration Guide - FastMCP
• OAuth for MCP Servers

6.4 MCP vs CLI: ¿Cuándo usar cada uno?

Introducción

En el punto 6.1 introdujimos la distinción básica entre usar MCP y usar CLI directo con Claude Code. Establecimos que:

• CLI directo es mejor para operaciones simples, stateless y de una sola ejecución
• MCP es mejor para operaciones complejas, con estado y que requieren múltiples interacciones

Pero la realidad es más matizada. Esta decisión afecta directamente la performance, mantenibilidad y experiencia tanto tuya como de tu equipo. Una mala elección puede resultar en:

• 🐌 Latencias innecesarias
• 🧠 Consumo excesivo de contexto
• 🔧 Configuración compleja sin beneficios
• 🐛 Debugging difícil

En este punto profundizaremos con criterios técnicos, patrones, casos de uso reales y una guía práctica para tomar la decisión correcta.

Marco de decisión: Criterios clave

Para decidir entre MCP y CLI, evalúa estos seis criterios:

1. Estado (Statefulness)

El criterio más importante.

¿Qué es el estado?

Estado se refiere a información que debe persistir entre múltiples operaciones relacionadas.

Ejemplos stateless:

# Cada comando es independiente, no requiere estado previo
git status
npm install
ls -la
curl https://api.example.com/users

Ejemplos stateful:

# Requiere mantener sesión de navegador activa
1. Navegar a página de login
2. Llenar formulario (requiere DOM cargado)
3. Hacer clic en submit (mantiene cookies)
4. Navegar a dashboard (usa la sesión)
 
# Requiere conexión persistente a la base de datos
1. Conectar a PostgreSQL
2. Ejecutar transacción BEGIN
3. Múltiples INSERTs relacionados
4. COMMIT final
 
# Requiere OAuth con refresh de tokens
1. Autenticar en GitHub
2. Listar PRs de un repo
3. Comentar en PR específico
4. Crear issue relacionado

Regla de oro

2. Complejidad de la operación

Operaciones simples

Características:

• 1 comando
• Sin parsing complejo
• Resultado directo

Ejemplo (CLI ideal):

# Ver archivos modificados en git
git status --short
 
# Instalar dependencias
npm install
 
# Listar contenedores Docker
docker ps

Operaciones complejas

Características:

• Múltiples pasos interdependientes
• Parsing y transformación de datos
• Lógica condicional

Ejemplo (MCP ideal):

Prompt: "Analiza los PRs abiertos en el repo, identifica cuáles tienen
         conflictos, revisa los archivos afectados y genera un reporte
         con sugerencias de priorización"
 
Con GitHub MCP:
1. Listar PRs abiertos
2. Para cada PR, obtener conflictos
3. Para PRs con conflictos, analizar archivos
4. Evaluar impacto y prioridad
5. Generar reporte estructurado
 
Con CLI (gh):
- Requeriría múltiples comandos gh pr list, gh pr view, gh api...
- Parsing manual de JSONs
- Lógica compleja en bash/scripts
- Frágil y difícil de mantener

Umbral práctico

• 1-2 comandos relacionados → CLI directo
• 3+ comandos interdependientes → Considera MCP

3. Frecuencia de uso

¿Cuántas veces ejecutarás esta operación?

Una vez / raramente:

# CLI directo es perfecto
aws s3 ls s3://my-bucket --region us-east-1
docker system prune -a

Varias veces por día / múltiples proyectos:

# MCP justifica el setup inicial
- Consultar issues de JIRA diariamente → JIRA MCP
- Analizar logs de Sentry frecuentemente → Sentry MCP
- Consultar métricas de Datadog regularmente → Datadog MCP

Trade-off: Setup vs Beneficio

Costo de setup de MCP:
- Instalación: 5-10 minutos
- Configuración de credenciales: 5 minutos
- Aprendizaje inicial: 10-15 minutos
Total: ~30 minutos
 
Beneficio por uso:
- Ahorro de tiempo por operación: 2-5 minutos
- Break-even: 6-15 usos
 
Conclusión:
Si lo usarás >10 veces, MCP vale la pena
Si lo usarás <5 veces, CLI directo es mejor

4. Necesidad de contexto persistente

Sin contexto persistente

CLI es suficiente:

# Cada llamada es independiente
curl https://api.example.com/status
gh pr list --state open
kubectl get pods

Con contexto persistente

MCP es superior:

Ejemplo 1: Navegación web

Con curl (frágil):
- Cada request pierde cookies
- No puede ejecutar JavaScript
- No mantiene estado del DOM
 
Con Playwright MCP (robusto):
- Sesión persistente
- JavaScript ejecutado
- DOM completo disponible
- Screenshots del estado actual

Ejemplo 2: Base de datos con transacciones

Con psql (complicado):
- Cada comando abre nueva conexión
- Transacciones requieren archivos SQL
- Difícil mantener estado entre queries
 
Con PostgreSQL MCP (fluido):
- Una conexión persistente
- Transacciones naturales
- Contexto entre queries
- Análisis iterativo de datos

5. Autenticación y autorización

Autenticación simple

CLI funciona bien:

# Token estático en variable de entorno
export GITHUB_TOKEN="ghp_xxxxx"
gh pr list
 
# API key simple
curl -H "X-API-Key: $API_KEY" https://api.example.com/data

Autenticación compleja

MCP es necesario:

Ejemplo real: Slack

# CLI directo (problemático)
# Tokens de Slack expiran cada 12 horas
# Requiere re-autenticación manual
curl -H "Authorization: Bearer $TOKEN" https://slack.com/api/...
 
# Slack MCP (robusto)
# OAuth automático
# Refresh de tokens transparente
# Claude solo pregunta: "Busca mensajes en #engineering sobre 'deployment'"

6. Procesamiento de respuestas

Respuestas simples

CLI suficiente:

# Texto plano, fácil de leer
git log --oneline
 
# JSON simple
curl https://api.example.com/status | jq '.status'
 
# Lista de strings
docker images --format "{{.Repository}}"

Respuestas complejas

MCP mejor:

Ejemplo: Análisis de PRs en GitHub

# Con gh CLI (tedioso)
gh pr list --json number,title,author,updatedAt,mergeable
# Resultado: JSON que Claude debe parsear en cada llamada
# Para analizar archivos de cada PR: más llamadas a gh pr view
 
# Con GitHub MCP (fluido)
# Claude internamente:
# 1. Obtiene PRs estructurados
# 2. Analiza relaciones entre datos
# 3. Filtra y agrupa según criterios complejos
# 4. Presenta resultados directamente interpretados

Ventaja clave de MCP: Los servidores MCP devuelven datos pre-estructurados y tipados que el LLM puede razonar mejor, en lugar de parsear texto o JSON raw.

Casos de uso específicos

Ahora analicemos casos reales con comparativa detallada.

Caso 1: Git operations

CLI directo (Recomendado)

Por qué funciona bien:

• Comandos git son stateless por naturaleza
• Salidas simples y legibles
• Ampliamente conocidos y documentados
• Sin overhead de configuración

Ejemplos ideales:

git status
git log --oneline -10
git diff main..feature-branch
git blame src/utils.ts
git branch --list

Cuándo CLI no es suficiente:

• Análisis profundo de historia (ej: "encuentra todos los commits que tocaron autenticación")
• Generación de reportes complejos
• Análisis de patrones en múltiples repos

Cuándo considerar alternativas

Para análisis complejos:

Prompt: "Analiza los últimos 100 commits, identifica cuáles introdujeron
         cambios en archivos de seguridad, revisa si tienen tests asociados,
         y genera un reporte de cobertura de testing en features de seguridad"
 
Mejor enfoque: CLI + Procesamiento por Claude
- git log con formato custom
- Claude procesa la salida
- Sin necesidad de MCP específico

Conclusión: CLI directo gana en >95% de casos de Git.

Caso 2: GitHub operations

El debate: gh CLI vs GitHub MCP

Este caso es controversial. Analicemos objetivamente:

gh CLI (Herramienta madura)

Ventajas:

• ✅ Ampliamente usado y testeado
• ✅ Integración perfecta con CI/CD
• ✅ Consume menos contexto
• ✅ Debugging transparente
• ✅ Ya está en training data de Claude

Ejemplo:

# Listar PRs abiertos
gh pr list --state open
 
# Ver detalles de un PR
gh pr view 123
 
# Crear un PR
gh pr create --title "Fix bug" --body "Description"
 
# Aprobar un PR
gh pr review 123 --approve

Limitaciones:

• Requiere múltiples comandos para workflows complejos
• Parsing de JSON cuando se necesitan datos estructurados
• No mantiene contexto entre operaciones

GitHub MCP (Integración AI-native)

Ventajas:

• ✅ Operaciones con lenguaje natural
• ✅ Datos pre-estructurados para el LLM
• ✅ Workflows complejos en un solo prompt
• ✅ Relaciones entre entidades (PRs ↔ Issues ↔ Commits)

Ejemplo:

Prompt: "Busca todos los PRs abiertos que mencionan 'authentication',
         revisa cuáles tienen conflictos, para los que no tienen conflictos
         verifica si los tests pasan, y para los que pasan tests hazme
         un resumen de los cambios y sugiéreme cuál revisar primero"
 
Con gh CLI: Requerirías ~6-8 comandos + parsing + lógica
Con GitHub MCP: Un prompt → Claude orquesta todas las llamadas necesarias

Limitaciones:

• Consume más contexto (sin Tool Search)
• Debugging menos transparente
• Overhead de setup inicial

Comparativa directa

Recomendación final

Usa gh CLI cuando:

• Operaciones individuales (listar PRs, ver issues)
• Scripts y CI/CD
• Quieres control total
• Eres desarrollador experimentado

Usa GitHub MCP cuando:

• Workflows multi-paso complejos
• Análisis y reportes automatizados
• Tu equipo prefiere lenguaje natural
• Integración con otros MCPs (ej: Jira + GitHub)

Solución híbrida: Muchos equipos usan ambos:

• gh CLI para operaciones rápidas cotidianas
• GitHub MCP para análisis y workflows complejos

Caso 3: Navegación y automatización web

curl/wget (Limitado)

Casos válidos:

# APIs REST simples
curl https://api.example.com/users
 
# Descargar archivos
wget https://example.com/file.zip
 
# Health checks
curl -I https://myapp.com/health

Limitaciones críticas:

• ❌ No ejecuta JavaScript
• ❌ No mantiene estado del navegador
• ❌ No puede interactuar (clicks, forms)
• ❌ No renderiza páginas dinámicas (SPAs)

Playwright MCP (Automatización completa)

Casos ideales:

# Testing E2E
Prompt: "Navega a la página de login, inicia sesión con credenciales de test,
         ve al dashboard, verifica que se muestren los datos del usuario,
         y toma un screenshot"
 
# Web scraping de SPAs
Prompt: "Extrae todos los productos de esta tienda e-commerce,
         incluyendo precios, descripciones e imágenes"
 
# Automatización de formularios
Prompt: "Completa el formulario de contacto con estos datos:
         nombre, email, mensaje"
 
# Validación visual
Prompt: "Compara el diseño actual con el screenshot de referencia
         y reporta diferencias"

Ventajas sobre curl:

• ✅ Navegador real (Chromium/Firefox/WebKit)
• ✅ JavaScript ejecutado completamente
• ✅ Mantiene sesión y cookies
• ✅ Puede interactuar con elementos
• ✅ Screenshots y videos
• ✅ Manejo de diálogos y popups

Comparativa

Conclusión: Si necesitas un navegador real, Playwright MCP. Si solo necesitas hacer un HTTP request, curl.

Caso 4: Bases de datos

psql/mysql CLI (Acceso directo)

Casos válidos:

# Query ad-hoc rápida
psql -d mydb -c "SELECT COUNT(*) FROM users"
 
# Export de datos
pg_dump mydb > backup.sql
 
# Verificar conectividad
psql -d mydb -c "SELECT version()"

Ventajas:

• Respuesta inmediata
• Sin overhead
• Herramientas maduras

Limitaciones:

• Múltiples conexiones para múltiples queries
• Parsing manual de resultados
• Sin análisis inteligente

PostgreSQL/MongoDB MCP (Análisis inteligente)

Casos ideales:

# Exploración interactiva
Prompt: "Muéstrame las 10 tablas más grandes de la base de datos"
 
# Análisis de datos
Prompt: "Encuentra usuarios que se registraron en los últimos 30 días
         pero no han hecho ninguna compra, agrupa por país y muéstrame
         estadísticas"
 
# Optimización de queries
Prompt: "Esta query es lenta: [pegar query]. Analiza el plan de ejecución
         y sugiéreme optimizaciones"
 
# Schema introspection
Prompt: "Explícame la relación entre las tablas users, orders y products"

Ventajas sobre psql directo:

• ✅ Una conexión persistente
• ✅ Transacciones naturales
• ✅ Schema introspection automático
• ✅ Claude entiende relaciones entre tablas
• ✅ Queries iterativas más fluidas
• ✅ Análisis de performance metrics (pg_stat_statements)

Comparativa

Recomendación

Usa psql CLI cuando:

• Query única y rápida
• Scripts de migración
• Backup/restore
• Eres DBA experto y prefieres control directo

Usa PostgreSQL MCP cuando:

• Análisis exploratorio de datos
• Necesitas ayuda con SQL complejo
• Múltiples queries relacionadas
• Debugging de performance
• Onboarding de developers que no dominan SQL

Caso 5: Comunicación (Slack/Discord)

CLI/API directa (Limitado)

Slack CLI:

# Enviar mensaje
slack chat send --channel "#general" --text "Deploy completed"
 
# Listar canales
slack conversations list

Limitaciones:

• No hay contexto de conversaciones
• Búsqueda limitada
• Sin análisis de sentimiento
• Interacción básica

Slack MCP (Integración completa)

Casos avanzados:

# Búsqueda contextual
Prompt: "Busca en #engineering todas las menciones de 'deployment issue'
         en los últimos 3 días, resume los problemas reportados y
         verifica si se resolvieron"
 
# Análisis de sentimiento
Prompt: "Analiza el canal #support y dime si hay clientes frustrados
         que necesiten atención urgente"
 
# Automatización de respuestas
Prompt: "Cuando alguien mencione 'build failed' en #ci-alerts,
         envía un mensaje en #engineering con el link del log"
 
# Resumen de threads
Prompt: "Resume el thread más largo del canal #product esta semana"

Ventajas:

• Contexto completo de conversaciones
• Búsqueda semántica
• Análisis de threads
• Integración con otros MCPs (ej: crear issue en GitHub basado en mensaje de Slack)

Conclusión: Para mensajería simple, CLI. Para análisis y automatización, MCP.

Matriz de decisión rápida

Usa este flowchart para decidir rápidamente:

┌─────────────────────────────────────┐
│ ¿Necesitas mantener estado entre    │
│ operaciones? (sesión, conexión)     │
└──────────────┬──────────────────────┘
               │
       ┌───────┴────────┐
       │ SÍ             │ NO
       ▼                ▼
   ┌───────┐        ┌───────────────────────────┐
   │  MCP  │        │ ¿Requiere autenticación   │
   └───────┘        │ compleja? (OAuth, MFA)    │
                    └────────┬──────────────────┘
                             │
                     ┌───────┴────────┐
                     │ SÍ             │ NO
                     ▼                ▼
                 ┌───────┐        ┌──────────────────────┐
                 │  MCP  │        │ ¿Son >3 pasos        │
                 └───────┘        │ relacionados?        │
                                  └────────┬─────────────┘
                                           │
                                   ┌───────┴────────┐
                                   │ SÍ             │ NO
                                   ▼                ▼
                               ┌───────┐        ┌─────────────────────┐
                               │  MCP  │        │ ¿Necesitas parsing  │
                               └───────┘        │ complejo?           │
                                                └────────┬────────────┘
                                                         │
                                                 ┌───────┴────────┐
                                                 │ SÍ             │ NO
                                                 ▼                ▼
                                             ┌───────┐        ┌──────┐
                                             │  MCP  │        │ CLI  │
                                             └───────┘        └──────┘

Tabla resumen

Patrones comunes

Patrón 1: "CLI first, MCP when it hurts"

Descripción: Empieza siempre con CLI directo. Solo migra a MCP cuando encuentres friction repetidamente.

Señales de que necesitas MCP:

• 🔴 Repites los mismos 3+ comandos frecuentemente
• 🔴 Pasas >5 minutos parseando salidas
• 🔴 Escribes scripts bash frágiles
• 🔴 Pierdes sesiones/conexiones constantemente
• 🔴 La autenticación es un dolor de cabeza

Ejemplo:

# Semana 1: CLI funciona bien
git log --oneline | grep "auth"
git show abc123
git blame src/auth.ts
 
# Semana 2: Repites lo mismo muchas veces
# Mismo flujo de comandos 10+ veces
 
# Semana 3: Escribes un script
# Script bash con parsing frágil
 
# Semana 4: El script falla por cambios en formato
# Debugging del script toma horas
 
# Solución: GitHub MCP + prompt natural
"Analiza todos los commits relacionados con autenticación,
 identifica quién hizo más cambios y qué archivos se modificaron"

Patrón 2: "MCP para servicios, CLI para sistema"

Regla práctica:

Servicios externos (APIs cloud, SaaS) → MCP
  - GitHub → GitHub MCP
  - Slack → Slack MCP
  - PostgreSQL → PostgreSQL MCP
  - Stripe → Stripe MCP
 
Operaciones del sistema (local) → CLI
  - git → git CLI
  - npm/yarn → CLI directo
  - docker → docker CLI
  - filesystem → ls, find, grep

Razón: Los servicios externos se benefician de:

• Autenticación gestionada
• Estado persistente
• APIs complejas abstraídas
• Rate limiting manejado

Patrón 3: "Estado es la frontera"

Sin estado necesario:

# CLI es perfecto
git status               # Sin estado
npm run build           # Sin estado
docker ps               # Sin estado
curl api.com/status     # Sin estado

Con estado necesario:

# MCP es superior
Navegador web           # Mantiene DOM, cookies, sesión
Conexión DB             # Pool de conexiones, transacciones
OAuth services          # Tokens, refresh automático
WebSocket connections   # Conexión persistente

Test rápido: "¿Necesito recordar información de la operación anterior para la siguiente?"

• NO → CLI
• SÍ → MCP

Anti-patrones (qué NO hacer)

❌ Anti-patrón 1: "MCP para todo"

Problema: Instalar MCPs para operaciones que el CLI hace perfectamente.

Ejemplo malo:

// .mcp.json
{
  "mcpServers": {
    "git": {...},           // ❌ Innecesario
    "npm": {...},           // ❌ Innecesario
    "filesystem": {...},    // ❌ Innecesario (ya tienes bash)
    "curl": {...}           // ❌ Innecesario
  }
}

Por qué es malo:

• Sobrecarga de contexto (menos espacio para tu código)
• Setup complejo sin beneficio
• Debugging más difícil
• Mayor superficie de fallos

Solución correcta: Solo instala MCPs que agreguen valor real:

• GitHub MCP: Análisis complejos de repos ✅
• PostgreSQL MCP: Exploración de datos ✅
• Playwright MCP: Testing E2E ✅

❌ Anti-patrón 2: "CLI cuando necesitas estado"

Problema: Intentar mantener estado con scripts bash frágiles.

Ejemplo malo:

#!/bin/bash
# Intentar automatizar navegación web con curl
 
# 1. Get login page
curl https://app.com/login > login.html
 
# 2. Extract CSRF token (frágil!)
TOKEN=$(grep csrf login.html | sed 's/.*value="\(.*\)".*/\1/')
 
# 3. Intentar login (sin cookies!)
curl -X POST https://app.com/login \
  -d "username=user&password=pass&csrf=$TOKEN"
 
# 4. Acceder dashboard (sin sesión!)
curl https://app.com/dashboard
# ❌ Falla: No hay sesión activa

Por qué es malo:

• No ejecuta JavaScript
• No mantiene cookies/sesión
• Frágil ante cambios en HTML
• Difícil de debuggear

Solución correcta:

# Playwright MCP
Prompt: "Navega a app.com, haz login con credenciales de test,
         ve al dashboard y extrae los datos del usuario"
 
# Playwright mantiene:
- Estado del navegador
- Cookies y sesión
- JavaScript ejecutado
- DOM completo

❌ Anti-patrón 3: "Crear MCP personalizado para casos simples"

Problema: Invertir semanas desarrollando un MCP personalizado para algo que el CLI hace en minutos.

Ejemplo malo:

Situación: Necesito ejecutar un script interno de la empresa
           que valida configuraciones
 
Mal enfoque:
1. Crear MCP server personalizado (2-3 días de desarrollo)
2. Configurar autenticación
3. Dockerizar
4. Deploy
5. Configurar en Claude Code
 
Total: ~1 semana de trabajo

Por qué es malo:

• Overhead de desarrollo enorme
• Mantenimiento continuo necesario
• Complejidad innecesaria

Solución correcta:

# Simplemente ejecuta el script
./scripts/validate-config.sh
 
# O si quieres integración más fluida, usa un hook
# .claude/settings.json
{
  "hooks": {
    "beforeBashTool": "./scripts/validate-config.sh"
  }
}

Cuándo SÍ crear un MCP personalizado:

• Tu herramienta será usada por múltiples proyectos
• Requiere estado complejo
• Otros equipos pueden beneficiarse
• Es un servicio interno crítico usado diariamente

Consideraciones avanzadas

Performance

Latencia de startup

CLI directo:

Tiempo de inicio: ~10-50ms
- Bash/shell ya está en memoria
- Comandos nativos instantáneos

MCP:

Tiempo de inicio (primera vez): ~500-2000ms
- Establecer conexión
- Autenticación
- Inicialización del servidor
 
Tiempo de inicio (subsecuente): ~100-300ms
- Conexión reutilizada (si es stateful)

Implicaciones:

• Para 1 operación: CLI gana
• Para 10+ operaciones: MCP gana (conexión persistente)

Consumo de contexto

Sin Tool Search:

Ejemplo real:
- GitHub MCP: ~46,000 tokens (91 herramientas)
- Playwright MCP: ~9,700 tokens (21 herramientas)
- AWS MCPs: ~9,100 tokens (7 herramientas)
 
Total con 5 MCPs: ~100,000 tokens
Contexto disponible para trabajo: 100,000 tokens
→ 50% del contexto consumido por definiciones de tools

Con Tool Search (2026):

Contexto por MCP tools: ~1,000 tokens (herramienta de búsqueda)
Total con 5 MCPs: ~5,000 tokens
Contexto disponible: 195,000 tokens
→ Reducción del 95% en consumo de contexto

Recomendación:

• Si usas 5+ MCPs, habilita Tool Search: ENABLE_TOOL_SEARCH=auto:5 claude
• Revisa consumo con: /context

Portabilidad y reproducibilidad

CLI es más portable

Ventajas:

# Funciona en CI/CD sin configuración
npm ci
npm test
 
# Funciona en cualquier máquina con git
git clone repo
cd repo
npm install
 
# Scripts reproducibles
#!/bin/bash
set -e
npm run build
npm run test
docker build -t myapp .

MCP requiere setup:

// .mcp.json necesario
// Variables de entorno necesarias
// Credenciales necesarias
// No funciona out-of-the-box en CI

Cuándo cada uno es apropiado

Experiencia del equipo

Equipo experto en CLI

Perfil:

• Desarrolladores senior
• Cómodos con terminal
• Scripts bash/shell avanzados
• Conocen bien las herramientas

Recomendación:

• Mantener CLI como default
• Agregar MCPs solo para casos donde agreguen valor claro
• Ejemplo: Playwright para testing, GitHub MCP para análisis complejos

Equipo menos técnico o nuevo

Perfil:

• Junior developers
• Diseñadores que programan
• Product managers técnicos
• Menos experiencia con CLI

Recomendación:

• MCPs pueden bajar la barrera de entrada
• Interfaces naturales más amigables
• Ejemplo: PostgreSQL MCP permite queries sin dominar SQL

Costos

CLI: Generalmente gratis

git, npm, docker, curl, etc. → Sin costo
gh (GitHub CLI) → Gratis
psql → Gratis

MCPs: Pueden tener costos

MCPs remotos (HTTP):

• GitHub MCP vía Copilot → Incluido en licencia
• Stripe MCP → Sin costo adicional (usa tu cuenta)
• Browserbase → $50-200/mes según uso
• Context7 → $20/mes

MCPs locales (Stdio):

• Playwright → Gratis (usa tu CPU)
• PostgreSQL → Gratis (tu DB)

Costo de Claude Code:

• Consumo de contexto → Afecta pricing de API
• Más MCPs = más contexto = potencialmente más costo

Recomendación: Evalúa trade-off:

¿Ahorro de tiempo > Costo de MCP/contexto?
  SÍ → Usar MCP
  NO → Mantener CLI

Casos edge y situaciones especiales

Caso 1: Servicios híbridos (GitHub, Slack)

Situación: GitHub tiene excelente CLI (gh) Y excelente MCP.

¿Cuál usar?

Enfoque práctico: Ambos, según contexto

# CLI para operaciones rápidas y cotidianas
gh pr list
gh pr view 123
gh issue create
 
# MCP para análisis y workflows complejos
"Analiza todos los PRs del milestone Q1-2026, identifica los que están
 bloqueados, revisa qué issues los bloquean, y genera un reporte de
 priorización"

Coexistencia:

// .mcp.json
{
  "mcpServers": {
    "github": {...}  // Para workflows complejos
  }
}
 
// Y también usas gh CLI cuando es más directo
// Claude puede usar ambos según lo que sea más apropiado

Regla práctica:

• Operación única y directa → gh CLI
• Workflow multi-paso con lógica → GitHub MCP

Caso 2: Servicios sin MCP disponible

Situación: Tu empresa usa una herramienta interna o un SaaS de nicho sin MCP oficial.

¿Cuándo crear tu propio MCP?

Criterios para justificar desarrollo:

✅ SÍ, crea un MCP si:

• La herramienta se usa diariamente
• Múltiples personas en el equipo la necesitan
• Tiene una API estructurada
• Requiere estado complejo (OAuth, sesiones)
• El workflow es multi-paso repetitivo
• Otros equipos/proyectos podrían reutilizarlo

Costo estimado:

• MCP simple: 2-4 días
• MCP medio: 1-2 semanas
• MCP complejo (OAuth, state): 2-4 semanas

❌ NO, usa CLI si:

• Uso ocasional (< 1 vez por semana)
• Solo tú lo necesitas
• Ya tiene buen CLI
• Operaciones simples stateless
• Equipo pequeño, no justifica inversión

Alternativa: Wrapper con CLI

# Crea un script wrapper
#!/bin/bash
# internal-tool.sh
 
API_KEY=$INTERNAL_TOOL_KEY
curl -H "Authorization: Bearer $API_KEY" \
     https://internal-tool.company.com/api/$1
 
# Uso:
./internal-tool.sh users/list
./internal-tool.sh projects/123
 
# Claude puede usar este script directamente vía Bash tool

Caso 3: Restricciones corporativas

Situación: Tu empresa tiene políticas estrictas de seguridad.

Problemas comunes con MCPs

1. Firewall bloquea conexiones externas:

❌ GitHub MCP (HTTP) → Bloqueado
✅ gh CLI (HTTPS directo) → Permitido

Solución:

• Usa CLI para servicios externos
• MCPs solo para servicios internos

2. No se permiten procesos background:

❌ MCP servers (stdio con npx) → Bloqueado
✅ CLI directo → Permitido

Solución:

• CLI directo únicamente
• O solicitar excepción para MCP específico

3. Credenciales deben estar en vault corporativo:

❌ Variables de entorno en .env → No permitido
✅ Integración con Vault → Requerido

Solución:

# Fetch de Vault antes de ejecutar
vault kv get -field=token secret/github > /tmp/gh_token
export GITHUB_TOKEN=$(cat /tmp/gh_token)
claude

Guía de migración CLI → MCP

Si ya usas CLI y estás considerando MCP, sigue estos pasos:

Paso 1: Identificar puntos de dolor

Audita tu workflow actual:

# Revisa tu historial de comandos
history | grep -E "(gh|curl|psql|aws)" | sort | uniq -c | sort -nr
 
# Identifica patrones repetitivos
# ¿Ejecutas los mismos 3-5 comandos en secuencia frecuentemente?

Preguntas clave:

• ¿Qué tareas repites >5 veces por semana?
• ¿Qué operaciones requieren múltiples comandos?
• ¿Dónde pierdes más tiempo parseando salidas?
• ¿Qué autenticaciones son más dolorosas?

Paso 2: Evaluar MCPs disponibles

Busca MCPs que resuelvan tus puntos de dolor:

# Directorios de MCPs
# https://mcpservers.org
# https://mcp.so
# https://www.pulsemcp.com/servers

Criterios de selección:

• Mantenido activamente (commits recientes)
• Documentación clara
• Ejemplos de uso
• Issues resueltas rápidamente
• Usado por la comunidad (stars, downloads)

Paso 3: Migración incremental

No migres todo de golpe. Empieza pequeño:

Semana 1: Setup básico

# Instala 1 MCP que resuelva tu mayor punto de dolor
claude mcp add --transport http github https://api.githubcopilot.com/mcp/
 
# Familiarízate con su uso
# Compara con tu workflow CLI anterior

Semana 2-3: Uso diario

# Usa el MCP para tareas reales
# Mide si realmente ahorra tiempo
# Identifica limitaciones

Semana 4: Evaluación

¿Ahorra tiempo? → Mantener, agregar otro MCP
¿No agrega valor? → Remover, seguir con CLI

Paso 4: Métricas de éxito

Define métricas antes de migrar:

Decisión basada en datos:

• Si >70% de métricas mejoran → Adoptar MCP
• Si <50% mejoran → Mantener CLI

Checklist de decisión

Usa esta checklist para cada caso:

Evaluación rápida

Estado:

• ¿Necesito mantener sesión/conexión entre operaciones? → MCP
• ¿Cada operación es independiente? → CLI

Complejidad:

• ¿Son 1-2 comandos simples? → CLI
• ¿Son 3+ comandos interdependientes? → MCP

Autenticación:

• ¿Usa OAuth/MFA/SAML? → MCP
• ¿Es API key simple? → CLI está bien

Frecuencia:

• ¿Lo usaré >10 veces? → MCP justificado
• ¿Uso único/raro? → CLI directo

Contexto:

• ¿Necesito parsear/transformar datos complejos? → MCP
• ¿La salida es texto simple? → CLI está bien

Ecosistema:

• ¿Ya existe MCP maduro? → Considerar MCP
• ¿El CLI es robusto y conocido? → Mantener CLI

Equipo:

• ¿Mi equipo lo usará frecuentemente? → MCP
• ¿Solo yo lo necesito? → CLI

Setup:

• ¿El beneficio justifica 30 min de configuración? → MCP
• ¿Necesito resultado ya? → CLI

Ejemplos completos

Ejemplo 1: Análisis de PRs en GitHub

Contexto: Eres tech lead y necesitas revisar PRs para el sprint actual.

Solución con CLI (gh)

# 1. Listar PRs del milestone
gh pr list --milestone "Sprint Q1-2026" --json number,title,author > prs.json
 
# 2. Para cada PR, verificar conflictos
for pr in $(jq -r '.[].number' prs.json); do
  gh pr view $pr --json mergeable
done > mergeable.json
 
# 3. Filtrar PRs con conflictos
jq 'select(.mergeable == "CONFLICTING")' mergeable.json > conflicts.json
 
# 4. Para PRs con conflictos, ver archivos afectados
# ... más bash scripting ...
 
# 5. Parsear y generar reporte
# ... aún más bash scripting ...

Pros:

• ✅ Control total
• ✅ Scriptable
• ✅ Funciona en CI

Cons:

• ❌ Requiere múltiples comandos
• ❌ Parsing manual de JSON
• ❌ Lógica compleja en bash
• ❌ Frágil ante cambios en formato
• ❌ Difícil de mantener

Tiempo: ~15-20 minutos

Solución con GitHub MCP

Prompt a Claude:
"Analiza todos los PRs del milestone 'Sprint Q1-2026'.
 Para cada PR:
 - Verifica si tiene conflictos
 - Si tiene conflictos, lista los archivos afectados
 - Revisa la complejidad de los cambios
 Genera un reporte priorizando los PRs sin conflictos
 que estén listos para merge"

Pros:

• ✅ Un solo prompt natural
• ✅ Claude orquesta todo
• ✅ Análisis contextual incluido
• ✅ Reporte estructurado automático

Cons:

• ❌ Requiere MCP configurado
• ❌ Menos control granular
• ❌ Debugging menos transparente

Tiempo: ~30 segundos

Decisión final

Para este caso: GitHub MCP gana

Razón:

• Workflow complejo multi-paso
• Requiere análisis contextual
• Se repite frecuentemente (cada sprint)
• Ahorro de tiempo significativo (20 min → 30 seg)

Ejemplo 2: Testing de UI con navegador

Contexto: Necesitas verificar que el flujo de login funciona correctamente después de un cambio.

Solución con curl (Limitada)

# 1. Intentar obtener página de login
curl https://myapp.com/login > login.html
 
# 2. Intentar extraer CSRF token (frágil)
CSRF=$(grep -oP 'csrf-token.*?content="\K[^"]+' login.html)
 
# 3. Intentar hacer POST (sin JavaScript)
curl -X POST https://myapp.com/api/login \
  -H "Content-Type: application/json" \
  -H "X-CSRF-Token: $CSRF" \
  -d '{"username":"test","password":"test123"}' \
  -c cookies.txt
 
# 4. Verificar dashboard (sin sesión real)
curl -b cookies.txt https://myapp.com/dashboard

Pros:

• ✅ Simple
• ✅ Rápido

Cons:

• ❌ No ejecuta JavaScript
• ❌ No renderiza React/Vue/Angular
• ❌ No puede interactuar con elementos
• ❌ No mantiene sesión real de navegador
• ❌ CSRF tokens en SPAs no funcionan así
• ❌ No funciona para aplicaciones modernas

Resultado: ❌ Falla en 90% de apps modernas

Solución con Playwright MCP

Prompt a Claude:
"Navega a https://myapp.com/login en un navegador.
 Ingresa username: test, password: test123.
 Haz clic en el botón de login.
 Verifica que llegues al dashboard.
 Confirma que se muestre el nombre del usuario en el header.
 Toma un screenshot del dashboard para evidencia."

Pros:

• ✅ Navegador real (Chromium)
• ✅ JavaScript ejecutado
• ✅ Interacciones reales (click, type)
• ✅ Sesión y cookies gestionadas
• ✅ Screenshot automático
• ✅ Funciona con cualquier SPA

Cons:

• ❌ Más lento que curl
• ❌ Requiere Playwright instalado

Resultado: ✅ Funciona perfectamente

Decisión final

Para este caso: Playwright MCP es obligatorio

Razón:

• Apps modernas requieren JavaScript
• Necesitas interacciones reales
• curl simplemente no puede hacer esto
• No hay alternativa CLI viable

Ejemplo 3: Consultas a base de datos

Contexto: Análisis exploratorio de datos de usuarios.

Solución con psql CLI

# Query 1: Usuarios registrados este mes
psql -d analytics -c "
  SELECT COUNT(*) as total_users
  FROM users
  WHERE created_at >= '2026-01-01'
"
 
# Query 2: Usuarios sin compras
psql -d analytics -c "
  SELECT u.id, u.email, u.created_at
  FROM users u
  LEFT JOIN orders o ON u.id = o.user_id
  WHERE o.id IS NULL
  LIMIT 10
" -t -A > users_no_orders.txt
 
# Query 3: Analizar por país
psql -d analytics -c "
  SELECT country, COUNT(*) as count
  FROM users u
  LEFT JOIN orders o ON u.id = o.user_id
  WHERE o.id IS NULL
  GROUP BY country
  ORDER BY count DESC
"
 
# Query 4: Calcular estadísticas
# ... más queries ...

Pros:

• ✅ Control directo
• ✅ Respuesta inmediata
• ✅ Export a archivos

Cons:

• ❌ Cada query abre nueva conexión
• ❌ Análisis iterativo tedioso
• ❌ Requiere conocimiento SQL avanzado
• ❌ Difícil explorar relaciones entre tablas

Tiempo: ~30 minutos de queries iterativas

Solución con PostgreSQL MCP

Prompt a Claude:
"Analiza la tabla users de la base de datos.
 Muéstrame usuarios que se registraron en enero de 2026
 pero no han hecho ninguna compra.
 Agrupa por país y muéstrame:
 - Cantidad por país
 - Promedio de días desde registro
 - Patrones comunes
 Sugiere acciones para convertirlos en clientes"

Pros:

• ✅ Conexión persistente
• ✅ Claude genera SQL optimizado
• ✅ Análisis contextual automático
• ✅ Explora relaciones entre tablas
• ✅ Insights adicionales sugeridos
• ✅ No requieres ser experto SQL

Cons:

• ❌ Menos control granular
• ❌ Queries generadas pueden no ser óptimas
• ❌ Requiere confianza en el análisis de Claude

Tiempo: ~2 minutos

Decisión final

Depende del contexto:

Usa psql CLI si:

• Eres DBA experto
• Sabes exactamente qué query necesitas
• Quieres control total del SQL
• Una sola query simple

Usa PostgreSQL MCP si:

• Exploración de datos
• No estás seguro qué buscar
• Análisis iterativo
• Quieres insights sugeridos
• No eres experto SQL

Ejemplo 4: Monitoreo y alertas

Contexto: Investigar errores en producción.

Solución con CLI (Sentry CLI + jq)

# 1. Listar errores recientes
sentry-cli issues list --project myapp > issues.json
 
# 2. Filtrar errores de las últimas 24h
jq '.[] | select(.lastSeen > "'$(date -u -d '1 day ago' +%Y-%m-%dT%H:%M:%S)')'' issues.json > recent.json
 
# 3. Buscar errores relacionados con "auth"
jq '.[] | select(.title | contains("auth"))' recent.json
 
# 4. Ver detalles de un error específico
sentry-cli issues show ISSUE_ID
 
# 5. Analizar stack trace
# ... parsing manual ...

Pros:

• ✅ Directo
• ✅ Scriptable

Cons:

• ❌ Múltiples comandos
• ❌ Parsing de JSON manualmente
• ❌ Análisis de stack traces manual
• ❌ Difícil correlacionar con código

Tiempo: ~10 minutos

Solución con Sentry MCP

Prompt a Claude:
"Revisa Sentry para errores en las últimas 24 horas.
 Enfócate en errores relacionados con autenticación.
 Para cada error:
 - Muestra el stack trace
 - Identifica el archivo y línea de código
 - Sugiere posible causa
 - Indica si es un error conocido (ya reportado)
 Prioriza por frecuencia y impacto"

Pros:

• ✅ Análisis contextual automático
• ✅ Correlación con código
• ✅ Sugerencias de solución
• ✅ Priorización inteligente

Cons:

• ❌ Requiere MCP configurado
• ❌ Dependencia de calidad del análisis de Claude

Tiempo: ~1 minuto

Decisión final

Para este caso: Sentry MCP gana

Razón:

• Análisis de errores se beneficia de contexto
• Correlación con código es valiosa
• Priorización automática ahorra tiempo
• Se hace frecuentemente (diario)

Ejemplo 5: Integración con Slack

Contexto: Buscar menciones de un feature en canales de ingeniería.

Solución con Slack CLI

# 1. Buscar mensajes en un canal
slack conversations history \
  --channel C0123456789 \
  --oldest $(date -d '7 days ago' +%s) > messages.json
 
# 2. Filtrar mensajes que contengan "deployment"
jq '.messages[] | select(.text | contains("deployment"))' messages.json
 
# 3. Para cada mensaje, obtener contexto (replies)
# ... más comandos ...
 
# 4. Analizar y resumir manualmente

Pros:

• ✅ Simple para búsquedas básicas

Cons:

• ❌ No busca en threads automáticamente
• ❌ Búsqueda literal (no semántica)
• ❌ Parsing manual
• ❌ No analiza sentimiento
• ❌ Difícil resumir threads largos

Tiempo: ~15 minutos

Solución con Slack MCP

Prompt a Claude:
"Busca en #engineering todas las menciones de 'deployment issue'
 en los últimos 7 días. Para cada mención:
 - Incluye el contexto del thread completo
 - Resume el problema reportado
 - Indica si se resolvió (busca mensajes posteriores)
 - Detecta si hay urgencia/frustración
 Agrupa por tipo de problema y dame un resumen ejecutivo"

Pros:

• ✅ Búsqueda semántica
• ✅ Threads incluidos automáticamente
• ✅ Análisis de sentimiento
• ✅ Resumen estructurado
• ✅ Detección de patrones

Cons:

• ❌ Requiere bot token de Slack
• ❌ Setup inicial necesario

Tiempo: ~30 segundos

Decisión final

Para este caso: Slack MCP gana

Razón:

• Búsqueda semántica superior
• Análisis contextual valioso
• Threads son esenciales en Slack
• Resumen automático ahorra mucho tiempo

Conclusión

Decidir entre MCP y CLI no es una cuestión de "uno u otro", sino de elegir la herramienta correcta para cada tarea.

Reglas de oro

1. "Estado es la frontera"

   • Sin estado → CLI
   • Con estado → MCP

2. "CLI first, MCP when it hurts"

   • Empieza con CLI
   • Migra a MCP cuando el dolor justifique el setup

3. "MCP para servicios, CLI para sistema"

   • Servicios externos → MCP
   • Operaciones locales → CLI

4. "Simplicidad sobre sofisticación"

   • No uses MCP por usar MCP
   • CLI es perfectamente válido para muchos casos

5. "Mide el valor"

   • ¿Ahorra tiempo? ¿Reduce errores? ¿Mejora DX?
   • Si no hay valor medible, mantén CLI

Toma de decisión rápida

┌─────────────────────────────────────────┐
│ ¿El CLI hace el trabajo bien?           │
└──────────────┬──────────────────────────┘
               │
       ┌───────┴────────┐
       │ SÍ             │ NO
       ▼                ▼
   ┌────────┐      ┌──────────────┐
   │ USA    │      │ Evalúa MCP:  │
   │ CLI    │      │ - ¿Existe?   │
   └────────┘      │ - ¿Agrega    │
                   │   valor?     │
                   │ - ¿Justifica │
                   │   setup?     │
                   └──────┬───────┘
                          │
                  ┌───────┴────────┐
                  │ SÍ             │ NO
                  ▼                ▼
              ┌────────┐      ┌──────────┐
              │ USA    │      │ Mantén   │
              │ MCP    │      │ CLI +    │
              └────────┘      │ scripts  │
                              └──────────┘

Últimas recomendaciones

Para desarrolladores individuales:

• Empieza con CLI
• Agrega 1-2 MCPs para tus mayores puntos de dolor
• Evalúa después de 1 mes

Para equipos:

• Define estándares de cuándo usar qué
• Documenta MCPs necesarios en README
• MCPs en project scope, credenciales en local scope

Para empresas:

• Políticas claras de seguridad para MCPs
• Audita MCPs permitidos
• Considera crear MCPs internos para herramientas críticas

Próximos pasos

En el siguiente punto (6.5 Filosofía recomendada) profundizaremos en las mejores prácticas y patrones para usar MCPs efectivamente en tu workflow diario.

Recursos adicionales:

• Connect Claude Code to tools via MCP
• My Take on the MCP vs CLI Debate
• GitHub Operations: gh vs MCP Comparison
• Managing Stateful MCP Server Sessions

Fuentes

• Configuring MCP Tools in Claude Code - Scott Spence
• Connect Claude Code to tools via MCP - Docs
• Claude Code: Best practices for agentic coding
• Managing Stateful MCP Server Sessions
• The Problem With MCP: Stateful Servers
• GitHub Operations: Complete Comparison Guide
• My Take on the MCP vs CLI Debate
• Playwright MCP: Comprehensive Guide
• A Detailed Guide to Playwright MCP Server
• MCP with Postgres - Querying in plain English

6.5 Filosofía recomendada para usar MCP

Introducción

Hasta ahora hemos visto qué es MCP, cuáles son los servidores disponibles, cómo instalarlos y cuándo usar MCP vs CLI. Pero hay algo más importante: la mentalidad correcta para usar MCPs de manera efectiva.

MCP es una tecnología poderosa, pero como toda herramienta poderosa, puede usarse mal. Algunos equipos caen en la trampa de "MCP para todo", llenando su configuración con decenas de servidores que nunca usan. Otros van al extremo opuesto, evitando MCPs cuando realmente agregarían valor.

Este punto trata sobre la filosofía — los principios, patrones mentales y mejores prácticas que te ayudarán a usar MCPs de forma efectiva, sostenible y escalable.

Los 5 principios fundamentales

1. Minimalismo: menos es más

Principio: Instala solo los MCPs que realmente usas frecuentemente.

✅ Correcto: 3-5 MCPs bien seleccionados, usados diariamente
❌ Incorrecto: 15+ MCPs "por si acaso"

Por qué importa:

• Cada MCP añade overhead de contexto (aunque Tool Search lo mitiga)
• Más MCPs = más configuración que mantener
• Más MCPs = más superficie de fallos
• Más MCPs = debugging más complejo

Regla práctica: Si no has usado un MCP en las últimas 2 semanas, probablemente no lo necesites.

Ejemplo real:

// ❌ Configuración problemática
{
  "mcpServers": {
    "github": {...},
    "gitlab": {...},        // ¿Usas ambos?
    "postgres": {...},
    "mysql": {...},         // ¿Usas ambos?
    "mongodb": {...},       // ¿Usas ambos?
    "playwright": {...},
    "puppeteer": {...},     // Duplicado con Playwright
    "slack": {...},
    "discord": {...},       // ¿Usas ambos?
    "notion": {...},
    "google-drive": {...},
    "aws-s3": {...},
    "stripe": {...},
    "sendgrid": {...},
    "twilio": {...}
  }
}
// Total: 15 MCPs, probablemente solo usas 4-5 regularmente
 
// ✅ Configuración limpia
{
  "mcpServers": {
    "github": {...},       // Usado diariamente
    "postgres": {...},     // Usado diariamente
    "playwright": {...},   // Testing E2E regular
    "slack": {...}         // Comunicación frecuente
  }
}
// Total: 4 MCPs, todos usados activamente

Acción: Audita tus MCPs mensualmente. Elimina los que no has usado.

2. Progresividad: empieza pequeño, crece gradualmente

Principio: No instales todos los MCPs que puedan ser útiles de golpe. Empieza con uno y agrega según necesidad.

Estrategia de adopción recomendada:

Semana 1: Instalación de primer MCP
  └─ Identifica tu mayor punto de dolor
  └─ Instala 1 MCP que lo resuelva
  └─ Úsalo intensivamente
  └─ Mide si realmente ayuda
 
Semana 2-3: Periodo de evaluación
  └─ ¿Ahorra tiempo real?
  └─ ¿Es fácil de usar?
  └─ ¿Causa problemas/friction?
 
Semana 4: Decisión
  ├─ Si agrega valor → Mantener + considerar segundo MCP
  └─ Si no agrega valor → Remover, volver a CLI
 
Repetir el ciclo...

Ejemplo de adopción progresiva:

Mes 1: GitHub MCP
  - Motivo: Analizas PRs diariamente
  - Resultado: ✅ Ahorra 15 min/día
 
Mes 2: PostgreSQL MCP
  - Motivo: Análisis de datos frecuente
  - Resultado: ✅ Ahorra 20 min/día
 
Mes 3: Playwright MCP (intento)
  - Motivo: Testing ocasional
  - Resultado: ❌ Solo lo usas 1 vez/semana
  - Acción: Removido
 
Mes 4: Slack MCP
  - Motivo: Búsqueda en canales diaria
  - Resultado: ✅ Ahorra 10 min/día
 
Final: 3 MCPs estables, alto valor, bajo mantenimiento

Error común a evitar: Instalar 10 MCPs el primer día "para probar" → confusión, overhead, abandono.

3. Estado como guía: el mejor indicador

Principio: Deja que la necesidad de estado dicte tu elección, no las tendencias o la novedad.

Pregunta clave antes de instalar un MCP: "¿Necesito mantener estado/contexto entre múltiples operaciones?"

Sin estado necesario     →  CLI directo
Con estado necesario     →  MCP ideal

Ejemplos claros:

Test rápido: "Si hago esta operación, ¿la siguiente depende del resultado de la anterior?"

• NO → CLI es suficiente
• SÍ → Considera MCP

4. Valor sobre tecnología: no uses MCP por usar MCP

Principio: MCP es un medio, no un fin. Solo úsalo si agrega valor medible.

Métricas de valor:

• ⏱️ Tiempo ahorrado: ¿Reduce el tiempo de la tarea significativamente?
• 🎯 Precisión: ¿Reduce errores comparado con CLI?
• 🧠 Carga cognitiva: ¿Hace la tarea más simple o más compleja?
• 🔄 Frecuencia: ¿Se repite lo suficiente para justificar el setup?

Framework de decisión:

Valor de MCP = (Ahorro por uso × Frecuencia) - Costo de setup
 
Donde:
  Ahorro por uso = Tiempo CLI - Tiempo MCP
  Frecuencia = Usos por semana
  Costo de setup = ~30 minutos (instalación + configuración)
 
Ejemplo 1: GitHub MCP
  Ahorro por uso: 15 min
  Frecuencia: 10 veces/semana
  Valor = (15 min × 10) - 30 min = 150 min - 30 min = 120 min/semana
  → ✅ MUY ALTO VALOR
 
Ejemplo 2: Stripe MCP (hipotético)
  Ahorro por uso: 5 min
  Frecuencia: 1 vez/mes
  Valor = (5 min × 0.25) - 30 min = 1.25 min - 30 min = -28.75 min
  → ❌ VALOR NEGATIVO, no justificado