Módulo 1: Qué es MCP y Por Qué Importa

El Ecosistema MCP Actual

Descripción de la cápsula

Ya sabes qué es MCP y por qué importa. Ahora vas a explorar quién lo usa, qué existe, y hacia dónde va. El ecosistema MCP no es una promesa futura — es una realidad en crecimiento activo. AI hosts como Claude Code, Cursor, y Windsurf ya soportan MCP. Hay cientos de MCP servers open source. Y la comunidad crece cada mes.

En esta cápsula vas a mapear el ecosistema completo: qué hosts soportan MCP, qué servers existentes puedes usar ya, y qué categorías de servers son las más populares. Al terminar, tendrás una visión clara de dónde estás entrando y qué oportunidades existen para construir tus propios servers.

AI Hosts que soportan MCP

Hosts con soporte oficial

Estos AI hosts implementan MCP Client y pueden conectarse con cualquier MCP Server:

Hosts con MCP Client:
├── Claude Code (Anthropic)
│   └── CLI de desarrollo con soporte nativo MCP
├── Claude Desktop (Anthropic)
│   └── App de escritorio con MCP support
├── Cursor (IDE)
│   └── Editor de código con AI integrado
├── Windsurf (Codeium)
│   └── IDE con AI agent
├── Zed (Editor)
│   └── Editor de código con MCP support
├── Continue.dev
│   └── Extension open source para VS Code/JetBrains
└── Sourcegraph Cody
    └── AI coding assistant

¿Qué significa "soporte MCP" para un host?

Cuando un host soporta MCP, significa que:

Tiene un MCP Client integrado — puede establecer conexiones con MCP Servers
Descubre capabilities automáticamente — al conectarse con un Server, sabe qué Resources, Tools, y Prompts están disponibles
Puede invocar Tools — el modelo puede decidir usar herramientas del Server
Puede leer Resources — puede acceder a datos expuestos por el Server
Puede usar Prompts — puede ejecutar templates predefinidos

Para ti como developer: Tu MCP Server funciona en todos estos hosts sin cambiar una línea de código. Construyes una vez, funciona en todas partes.

Diferencias entre hosts

Aunque todos estos hosts soportan MCP, hay diferencias en cómo lo implementan:

Claude Code:
├── Soporte completo (Resources, Tools, Prompts)
├── Configuración via CLI: claude mcp add ...
├── Scope: user, project, o local
└── Transport: stdio (principal), Streamable HTTP

Cursor:
├── Soporte para Tools (Resources parcial)
├── Configuración via settings JSON
└── Transport: stdio

Windsurf:
├── Soporte para Tools
├── Configuración via settings
└── Transport: stdio

Zed:
├── Soporte para Tools y Prompts
├── Configuración via settings
└── Transport: stdio

No te preocupes por estas diferencias ahora — en esta guía usamos Claude Code como host principal. Lo importante es que el protocolo subyacente es el mismo.

Categorías de MCP Servers

Servers de desarrollo y código

Desarrollo:
├── GitHub MCP Server
│   └── PRs, issues, repos, code search
├── GitLab MCP Server
│   └── Merge requests, pipelines, repos
├── Linear MCP Server
│   └── Issues, projects, cycles
├── Sentry MCP Server
│   └── Error tracking, issues, events
└── Filesystem MCP Server
    └── Leer/escribir archivos locales

Estos son los más relevantes para ti — conectan tus herramientas de desarrollo directamente con Claude Code.

Servers de bases de datos

Databases:
├── PostgreSQL MCP Server
│   └── Queries, schemas, migrations
├── SQLite MCP Server
│   └── Queries locales, schemas
├── MongoDB MCP Server
│   └── Documents, collections, queries
├── Redis MCP Server
│   └── Keys, values, pub/sub
└── Supabase MCP Server
    └── Auth, database, storage

Imagina preguntarle a Claude Code "¿cuántos usuarios activos tenemos esta semana?" y que ejecute la query directamente contra tu database.

Servers de productividad

Productividad:
├── Notion MCP Server
│   └── Pages, databases, search
├── Google Drive MCP Server
│   └── Files, folders, search
├── Slack MCP Server
│   └── Messages, channels, search
├── Google Calendar MCP Server
│   └── Events, calendars
└── Todoist MCP Server
    └── Tasks, projects

Servers de cloud e infraestructura

Cloud:
├── AWS MCP Server
│   └── S3, Lambda, EC2, CloudWatch
├── Docker MCP Server
│   └── Containers, images, compose
├── Kubernetes MCP Server
│   └── Pods, services, deployments
├── Vercel MCP Server
│   └── Deployments, projects, domains
└── Cloudflare MCP Server
    └── Workers, KV, R2

Servers de AI y datos

AI/Data:
├── Brave Search MCP Server
│   └── Web search, news search
├── Puppeteer MCP Server
│   └── Browser automation, screenshots
├── Fetch MCP Server
│   └── HTTP requests, web scraping
└── Memory MCP Server
    └── Persistent memory across sessions

Anatomía de un MCP Server existente

Para entender mejor el ecosistema, veamos cómo están construidos dos MCP Servers típicos.

Ejemplo 1: Filesystem MCP Server

El Filesystem MCP Server es uno de los servers oficiales de referencia de Anthropic. Es ideal como ejemplo porque es simple y concreto:

Qué expone:

Filesystem MCP Server:
│
├── Tools:
│   ├── read_file(path)        → Lee contenido de un archivo
│   ├── write_file(path, data) → Escribe contenido a un archivo
│   ├── list_directory(path)   → Lista archivos y carpetas
│   ├── create_directory(path) → Crea una carpeta
│   ├── move_file(src, dst)    → Mueve/renombra archivo
│   ├── search_files(pattern)  → Busca archivos por patrón
│   ├── get_file_info(path)    → Metadata de un archivo
│   └── read_multiple_files()  → Lee varios archivos a la vez
│
└── Resources: (ninguno en este caso)
└── Prompts: (ninguno en este caso)

Cómo se usa en Claude Code:

Tú: "Lee el archivo package.json y dime qué dependencias tengo"

Claude Code:
→ Usa tool read_file("package.json")
→ MCP Server lee el archivo del disco
→ Retorna el contenido
→ Claude Code analiza y responde:
  "Tienes 12 dependencias: react, next, typescript..."

Tú: "Busca todos los archivos .ts que contengan 'TODO'"

Claude Code:
→ Usa tool search_files("**/*.ts")
→ Luego read_multiple_files() en los resultados
→ Filtra por 'TODO'
→ Responde con la lista de TODOs

Características del Filesystem Server:

Solo expone Tools (sin Resources ni Prompts) — es un ejemplo de server simple
Trabaja con datos locales (no necesita API keys ni autenticación externa)
Requiere que el usuario configure qué directorios puede acceder (security boundary)

Ejemplo 2: GitHub MCP Server

El GitHub MCP Server es más complejo y muestra el poder completo de MCP:

Qué expone:

GitHub MCP Server:
│
├── Tools:
│   ├── create_issue(repo, title, body)     → Crea un issue
│   ├── list_issues(repo, state, labels)    → Lista issues
│   ├── create_pull_request(repo, ...)      → Crea un PR
│   ├── search_repositories(query)          → Busca repos
│   ├── get_file_contents(repo, path)       → Lee archivos del repo
│   ├── create_or_update_file(repo, ...)    → Modifica archivos
│   ├── push_files(repo, files, message)    → Push múltiples archivos
│   ├── search_code(query)                  → Busca código
│   ├── list_commits(repo)                  → Lista commits
│   └── create_branch(repo, branch)         → Crea branch
│
├── Resources: (depende de la implementación)
│   └── Algunos exponen repo contents como resources
│
└── Prompts: (depende de la implementación)

Cómo se usa en Claude Code:

Tú: "Crea un issue para el bug que encontramos en el login,
     con label 'bug' y prioridad alta"

Claude Code:
→ Usa tool create_issue(
    repo="mi-empresa/mi-app",
    title="Bug: Login fails with special characters in email",
    body="Steps to reproduce: ...",
    labels=["bug", "high-priority"]
  )
→ GitHub API crea el issue
→ Retorna: { "number": 234, "url": "..." }
→ Claude Code: "Creé el issue #234 en mi-empresa/mi-app."

Diferencias con Filesystem Server:

Requiere autenticación (GitHub Personal Access Token)
Se comunica con un servicio remoto (GitHub API) no con el filesystem local
Tiene más tools y capabilities
Puede exponer Resources (repo contents como datos browseable)

Esto es MCP en práctica — el AI host usa tools del Server como si fueran capacidades nativas, sin importar si el server trabaja con archivos locales o APIs remotas.

MCP Servers que TÚ podrías construir

Una de las partes más emocionantes del ecosistema MCP es que está lleno de oportunidades. Estos son ejemplos de servers que podrías construir — algunos ya existen como versiones básicas, otros son oportunidades abiertas:

Ideas para servers de productividad personal

📊 Toggl/Clockify MCP Server
   → track_time(project, description, duration)
   → get_weekly_report()
   → "¿Cuántas horas trabajé esta semana en el proyecto X?"

📧 Gmail MCP Server  
   → search_emails(query, date_range)
   → draft_email(to, subject, body)
   → "Busca los emails de Juan sobre el deployment de la semana pasada"

📝 Obsidian MCP Server
   → search_notes(query)
   → create_note(title, content, tags)
   → "Crea una nota con el resumen de lo que aprendí hoy"

Ideas para servers de desarrollo

🐳 Docker Compose MCP Server
   → list_services()
   → restart_service(name)
   → get_logs(service, lines)
   → "Muéstrame los últimos 50 logs del servicio api"

📈 Grafana/Datadog MCP Server
   → get_dashboard(name)
   → query_metrics(metric, time_range)
   → "¿Cómo está el response time del endpoint /api/users?"

🔧 Internal API MCP Server
   → deploy(service, environment)
   → rollback(service)
   → get_health(service)
   → "Haz deploy del último commit de auth-service a staging"

Ideas para servers creativos

🎵 Spotify MCP Server
   → currently_playing()
   → search_tracks(query)
   → create_playlist(name, tracks)
   → "Crea una playlist de focus con música instrumental"

📐 Figma MCP Server
   → get_components(file_id)
   → export_assets(component_ids, format)
   → "Exporta todos los iconos del diseño en SVG"

El punto clave: Si usas un servicio que no tiene MCP server (o cuyo server existente no cubre tu caso de uso), tienes la oportunidad de construirlo. En los módulos 4-5 aprenderás exactamente cómo. Tu proyecto final del módulo 8 podría ser uno de estos.

Quién construye MCP Servers

Anthropic (servers oficiales)

Anthropic mantiene un set de reference servers que sirven como ejemplo y para uso directo:

Filesystem (acceso al sistema de archivos)
GitHub (integración con GitHub)
GitLab (integración con GitLab)
Google Drive (acceso a documentos)
PostgreSQL (queries a database)
Slack (integración con Slack)
Memory (memoria persistente)
Fetch (HTTP requests)
Puppeteer (browser automation)
Brave Search (búsqueda web)

Estos servers están en el repo oficial: github.com/modelcontextprotocol/servers

Comunidad open source

La mayoría de MCP servers son creados por la comunidad:

Contribuciones por tipo:
├── Developers individuales (60%)
│   └── Servers para servicios que usan en su trabajo
├── Empresas (25%)
│   └── Servers para sus propios productos
└── Anthropic (15%)
    └── Reference servers y ejemplos

Oportunidad para ti: Si usas un servicio que no tiene MCP Server, puedes construirlo. La comunidad valora contribuciones y muchos developers han ganado visibilidad construyendo MCP servers útiles.

Crecimiento del ecosistema

Adopción creciente

Timeline del ecosistema MCP:

Nov 2024: Anthropic anuncia MCP
         → Spec v1.0, SDKs iniciales en TypeScript y Python
         → ~10 reference servers oficiales
         → El concepto es nuevo, pocos lo conocen

Dic 2024: Primeros adopters
         → Cursor agrega soporte MCP (signal fuerte)
         → Primeros community servers empiezan a aparecer
         → Developers curiosos empiezan a experimentar

Ene-Mar 2025: Crecimiento rápido
         → 100+ community servers publicados
         → Windsurf, Zed, Continue.dev agregan soporte
         → SDKs maduran (TypeScript, Python)
         → Primeros tutoriales y guías aparecen
         → El término "MCP server" empieza a aparecer en job postings

Abr-Dic 2025: Ecosistema establecido
         → 500+ servers en directorios
         → MCP Apps con UI interactivo (nueva primitiva)
         → Empresas adoptan MCP internamente
         → Spec evoluciona con feedback de la comunidad
         → Herramientas de debugging y testing maduran

2026: Madurez
         → MCP es estándar de facto para integraciones AI
         → La mayoría de AI hosts lo soportan nativamente
         → Miles de servers disponibles
         → Empresas publican MCP servers oficiales para sus productos
         → Certificaciones y mejores prácticas establecidas

Métricas del ecosistema

Indicadores clave (estimados para 2026):
├── AI Hosts con soporte MCP:  10+
├── MCP Servers publicados:    1,000+
├── Categorías de servers:     15+
├── SDK lenguajes oficiales:   TypeScript, Python
├── SDK lenguajes community:   Go, Rust, Java, C#, Ruby
├── Estrellas en GitHub (spec): 30,000+
├── Contributors a repos oficiales: 500+
└── Empresas con MCP interno:  Cientos

Por qué la adopción se acelera

Network effects: Más hosts con MCP → más incentivo para crear servers → más servers → más incentivo para hosts de adoptar MCP. Es un ciclo virtuoso.
Open source: Cualquiera puede contribuir, no hay gatekeeping ni proceso de aprobación centralizado.
Low barrier: Crear un MCP server básico toma horas, no semanas. Un server funcional puede tener 30-50 líneas de código.
Real value: Los servers resuelven problemas reales de productividad — no son demos. Un developer que conecta su database con Claude Code ahorra tiempo medible cada día.
Composabilidad: Cada nuevo server agrega valor no solo individualmente sino en combinación con otros servers. Un server de GitHub + un server de Slack = capacidad de notificar al equipo sobre PRs automáticamente.

Cómo encontrar MCP Servers

Directorios principales

Official MCP Servers repo: github.com/modelcontextprotocol/servers
- Reference servers mantenidos por Anthropic
- Calidad garantizada, buen punto de partida
Awesome MCP Servers: github.com/punkpeye/awesome-mcp-servers
- Directorio community curado
- Categorizado por tipo
- Incluye estrellas y mantenimiento
MCP Hub: Directorio online con búsqueda
- Filtros por categoría, lenguaje, popularidad
NPM / PyPI:
- Busca packages con prefijo @modelcontextprotocol/ o mcp-server-

Criterios para elegir un MCP Server

Antes de usar un Server de la comunidad, evalúa con estos criterios:

✅ Señales fuertes:
├── Mantenido activamente (commits en últimas 4 semanas)
├── README completo con instrucciones de instalación
├── Tests incluidos (unit y/o integration)
├── Issues respondidos en <1 semana
├── >50 estrellas en GitHub
├── Versión estable (v1.0+)
├── Changelog o release notes
└── Licencia open source clara (MIT, Apache 2.0)

⚠️ Señales de precaución:
├── Sin commits en 3+ meses
├── README incompleto o desactualizado
├── Sin tests
├── Issues sin responder (>5 abiertos sin respuesta)
├── Solo proof-of-concept (README dice "WIP" o "experimental")
├── Sin licencia definida
└── Dependencias desactualizadas con vulnerabilidades

🚫 Red flags:
├── Pide credenciales de forma insegura (hardcoded en código)
├── Acceso demasiado amplio sin justificación
├── Sin código fuente visible (binario cerrado)
└── Documentación inexistente

Checklist rápido de evaluación

Cuando encuentres un MCP server que te interese, hazte estas preguntas en este orden:

¿Resuelve mi problema? — El server tiene los tools/resources que necesito
¿Es seguro? — Puedo revisar el código fuente y entender qué hace
¿Está mantenido? — Tiene actividad reciente y responde a issues
¿Está documentado? — Puedo instalarlo siguiendo el README
¿Tiene tests? — Tiene algún nivel de testing automatizado

Si las respuestas son sí a las 5, úsalo. Si falla en 1-2, evalúa el riesgo. Si falla en 3+, busca una alternativa o construye el tuyo.

Comparación: MCP Server oficial vs community

Aspecto	Servers Oficiales	Community Servers
Mantenimiento	Anthropic team	Voluntarios/empresas
Calidad	Alta, testeados	Variable
Cobertura	~15 servicios core	500+ servicios
Documentación	Completa	Variable
Velocidad de update	Moderada	Puede ser rápida o lenta
Customización	Limitada (general purpose)	Específica para casos de uso
Soporte	Issues respondidos	Depende del maintainer
Security review	Sí	No garantizada

Recomendación: Empieza con servers oficiales para aprender. Usa community servers cuando necesites servicios específicos. Construye los tuyos cuando ninguno existente se ajuste a tus necesidades exactas.

Troubleshooting

"Hay tantos servers, ¿por dónde empiezo?"

Empieza con 1-2 servers oficiales que resuelvan un problema real para ti:

Si trabajas con código: GitHub MCP Server o Filesystem
Si usas databases: PostgreSQL o SQLite
Si investigas: Brave Search o Fetch

En la siguiente cápsula (05) configurarás tu primer MCP Server en Claude Code.

"¿Los MCP Servers tienen acceso a todo mi sistema?"

No automáticamente. Los servers tienen el acceso que tú les configures. El Filesystem server, por ejemplo, solo accede a los directorios que tú especifiques en la configuración. Claude Code pide confirmación antes de ejecutar operaciones sensibles. Nunca un server obtiene acceso root a tu sistema de forma silenciosa.

"¿Puedo usar MCP Servers de la comunidad en producción?"

Con precaución. Evalúa la calidad con los criterios de arriba, lee el código fuente, y testea antes de usar en producción. Para uso en desarrollo personal, la mayoría de community servers funcionan bien. Para producción, considera hacer un fork y mantener tu propia versión con las customizaciones que necesites.

"¿Un MCP server puede romper algo en mi sistema?"

Depende del server. Un server de lectura (como Brave Search) no puede modificar nada. Un server de escritura (como Filesystem con write access) sí puede crear o modificar archivos. Por eso es importante:

Revisar qué capabilities expone el server antes de configurarlo
Limitar el acceso (directorios específicos, read-only cuando sea posible)
Claude Code pide confirmación antes de operaciones de escritura

"¿Hay MCP servers que cuesten dinero?"

Los servers son programas open source gratuitos. Pero los servicios que conectan pueden tener costos. Un MCP server de AWS es gratuito, pero los recursos de AWS que usas a través de él sí cuestan. Un MCP server de Brave Search es gratuito, pero la Brave Search API tiene límites de uso gratuito y planes de pago para uso intensivo.

Ejercicios

Ejercicio 1: Explorar el directorio oficial (Fácil)

Ve al repo oficial de MCP Servers (github.com/modelcontextprotocol/servers) y:

Lista 5 servers que encontraste
Identifica qué tipo de capabilities expone cada uno (Resources, Tools, Prompts)
¿Cuál sería más útil para tu trabajo diario?

Ver solución ejemplo

5 servers del repo oficial:

Filesystem — Tools: read_file, write_file, list_directory, search_files
GitHub — Tools: create_issue, search_repos, create_pull_request; Resources: repo contents
PostgreSQL — Tools: query; Resources: schema information
Brave Search — Tools: brave_web_search, brave_local_search
Memory — Tools: store_memory, retrieve_memory; Resources: stored memories

Más útil para mí: Depende de tu workflow. Un developer backend probablemente diría PostgreSQL o GitHub. Un researcher diría Brave Search.

Ejercicio 2: Mapear tu stack a MCP Servers (Medio)

Lista las 5 herramientas/servicios que más usas en tu trabajo diario. Para cada una, busca si existe un MCP Server (oficial o community). Crea una tabla:

Servicio	¿Existe MCP Server?	¿Oficial o Community?	Link

Ver solución ejemplo

Servicio	¿Existe?	Tipo	Notas
GitHub	✅ Sí	Oficial	Reference server de Anthropic
PostgreSQL	✅ Sí	Oficial	Reference server de Anthropic
Notion	✅ Sí	Community	Varios options en awesome-mcp-servers
Vercel	⚠️ Parcial	Community	Existen pero limitados
Figma	❌ No	—	Oportunidad de crear uno

Insight: Si un servicio que usas no tiene MCP Server, eso es una oportunidad para construirlo tú al final de esta guía.

Ejercicio 3: Evaluar un MCP Server (Medio)

Elige un MCP Server community de Awesome MCP Servers y evalúalo con los criterios de calidad:

¿Tiene commits recientes?
¿Tiene README con instrucciones?
¿Tiene tests?
¿Tiene issues respondidos?
¿Cuántas estrellas tiene?

¿Lo usarías en tu setup?

Ver solución ejemplo

Server evaluado: Notion MCP Server (ejemplo hipotético)

Commits recientes: ✅ Último commit hace 2 semanas
README: ✅ Instrucciones de instalación y configuración claras
Tests: ⚠️ Tests básicos pero no comprehensivos
Issues: ✅ Maintainer responde en <48 hrs
Estrellas: ✅ 230 estrellas

Veredicto: Sí lo usaría para desarrollo personal. Para producción, revisaría el código más a fondo y agregaría mis propios tests.

Ejercicio 4: Identificar oportunidades (Difícil)

Piensa en 3 servicios o APIs que uses regularmente y que NO tienen MCP Server. Para cada uno, describe brevemente qué capabilities expondría un MCP Server:

Ver solución ejemplo

1. Spotify (no tiene MCP Server completo)

Tools: search_tracks(query), get_playlist(id), currently_playing()
Resources: spotify://playlists — lista de playlists del usuario
Uso: "Ponme música de focus" o "¿qué estoy escuchando?"

2. Stripe (no tiene MCP Server completo)

Tools: get_balance(), list_payments(date_range), search_customers(query)
Resources: stripe://dashboard — métricas clave del dashboard
Uso: "¿Cuántos pagos fallaron esta semana?"

3. Internal API del trabajo

Tools: deploy(environment), get_metrics(service), list_incidents()
Resources: internal://services — lista de microservicios
Uso: "Deploy el último commit a staging" o "¿Hay incidentes activos?"

Punto clave: Si identificaste servicios sin MCP Server, tienes la oportunidad de construirlos al final de esta guía. Tu proyecto integrador podría ser exactamente esto.

Resumen

En esta cápsula aprendiste:

Hosts con MCP: Claude Code, Cursor, Windsurf, Zed, Continue.dev, y más — todos con MCP Client integrado
Categorías de servers: Desarrollo (GitHub, GitLab), databases (PostgreSQL, MongoDB), productividad (Notion, Slack), cloud (AWS, Docker), y AI/datos
Anatomía de servers: Viste cómo están construidos el Filesystem server (simple, local) y el GitHub server (complejo, remoto)
Servers que podrías construir: Ideas concretas para productividad personal, desarrollo, y proyectos creativos
Servers oficiales vs community: Oficiales son ~15 y de alta calidad; community son 500+ y de calidad variable
Criterios de evaluación: Cómo evaluar un server antes de usarlo (mantenimiento, docs, tests, seguridad)
El ecosistema crece rápido: Network effects, open source, y bajo barrier to entry impulsan la adopción
Dónde encontrar servers: Repo oficial, Awesome MCP Servers, NPM/PyPI
Oportunidad: Servicios sin MCP Server son oportunidades para construir y contribuir

Próxima cápsula: Primer contacto con MCP — vas a configurar y usar un MCP Server existente en Claude Code. De la teoría a la práctica.

Recursos adicionales

Official MCP Servers Repository - Servers de referencia de Anthropic
Awesome MCP Servers - Directorio community curado
MCP Specification - Especificación técnica del protocolo
Claude Code MCP Documentation - Cómo configurar MCP en Claude Code
Cursor MCP Documentation - MCP en Cursor
MCP TypeScript SDK - Para construir tus propios servers

← AnteriorMCP: El USB-C del AI Siguiente →Primer Contacto: Usar un MCP Server en Claude Code