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

Descripción de la cápsula

Bienvenido a la guía de Claude Code y MCP. En este módulo vas a descubrir por qué Model Context Protocol cambia las reglas del juego para los developers que trabajan con AI. No es otra herramienta más — es un protocolo estándar que convierte a Claude Code de un asistente con capacidades fijas en una plataforma extensible donde cualquier API, database, o servicio se convierte en una herramienta nativa.

Piensa en tu experiencia hasta ahora con Claude Code. Ya sabes darle instrucciones precisas. Ya sabes configurar su memoria con CLAUDE.md. Ya sabes orquestar flujos de trabajo complejos donde toma decisiones autónomas. Pero hay un límite claro: Claude Code solo puede hacer lo que tiene integrado de fábrica. ¿Quieres que consulte tu database de producción? ¿Que busque en tu Notion? ¿Que haga deploy en tu infraestructura? ¿Que consulte las métricas de tu Sentry? Sin MCP, cada una de esas integraciones requiere que alguien — Anthropic, un tercero, o tú — escriba código custom específico para esa combinación. Con MCP, cualquier servicio se convierte en una extensión nativa con un solo protocolo estándar.

Llegas de las guías anteriores sabiendo usar Claude Code como herramienta de desarrollo. Sales de este módulo entendiendo que puedes extenderlo con integraciones propias. El momento clave será cuando veas un MCP server existente funcionando dentro de Claude Code y pienses: "Yo puedo construir uno de estos." Ese momento marca el salto de usuario avanzado a developer de plataforma — y es exactamente a donde te lleva esta guía. No estás aprendiendo una feature nueva de Claude Code; estás aprendiendo a convertir Claude Code en la herramienta exacta que tu proyecto necesita.

¿Dónde estamos?

Contexto en el path

Esta es la Guía #5 de 11 del Claude Code Agentic Development Path. Cada guía anterior te dio un building block esencial:

Guía 1: Intro to Claude Code           ← Fundamentos del CLI
Guía 2: Prompt Engineering             ← Instrucciones efectivas
Guía 3: Agentic Workflows             ← Flujos autónomos
Guía 4: CLAUDE.md & Memory Systems    ← Configuración y memoria
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Guía 5: Claude Code & MCP             ← ESTÁS AQUÍ: Extensibilidad
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Guías 6-11: Temas avanzados           ← Lo que viene después

Veamos qué te dejó cada guía anterior y por qué importa para MCP:

Guía 1: Intro to Claude Code — Aprendiste los fundamentos del CLI: cómo interactuar con Claude Code, cómo navegar su interfaz, cómo dar comandos básicos y obtener resultados útiles. Saliste sabiendo moverte con confianza en la terminal con un AI assistant. Esta base es esencial porque todo MCP pasa por el CLI — configuración de servers, verificación de conexiones, uso de herramientas, todo ocurre en tu terminal.
Guía 2: Prompt Engineering for Claude Code — Descubriste que la calidad de tus resultados depende directamente de la calidad de tus instrucciones. Aprendiste técnicas de prompting específicas para un entorno CLI agéntico — desde prompts directos hasta instrucciones multi-step con contexto complejo. Cuando uses MCP servers, la forma en que formulas tus peticiones determina si Claude Code utiliza las herramientas del server o intenta resolverlo por su cuenta. Un buen prompt como "Lee el archivo package.json del directorio del proyecto y dime las dependencias desactualizadas" activa el MCP server de filesystem; un prompt vago como "¿Qué dependencias tengo?" podría no hacerlo.
Guía 3: Agentic Workflows — Pasaste de dar instrucciones individuales a orquestar flujos de trabajo completos. Aprendiste a pensar en cadenas de acciones donde Claude Code toma decisiones, usa herramientas, y completa tareas multi-paso de forma autónoma. MCP amplifica este poder exponencialmente: en lugar de flujos limitados a herramientas integradas, ahora tus workflows pueden incluir consultas a tu database, búsquedas en tu Notion, y deploys a tu infraestructura — todo dentro del mismo flujo agéntico.
Guía 4: CLAUDE.md & Memory Systems — Configuraste Claude Code para que "recuerde" tus preferencias, convenciones del proyecto, y contexto persistente a través de CLAUDE.md y sistemas de memoria. Tu Claude Code dejó de ser genérico y se convirtió en un asistente personalizado para tu proyecto. MCP es la extensión natural de esta idea: si CLAUDE.md personaliza lo que Claude Code sabe, MCP personaliza lo que Claude Code puede hacer.

Con esas bases, estás en el punto exacto para dar el siguiente salto: dejar de usar Claude Code solo con sus herramientas integradas y empezar a extenderlo con herramientas propias.

¿Hacia dónde vamos?

Esta guía tiene 3 phases que te llevan del concepto a la producción:

Phase 1: Fundamentos MCP (Módulos 1-3)
  → Entender qué es MCP, cómo funciona internamente, qué primitivas tiene
  → Construir el modelo mental que guía todo lo demás
  → Usar MCP servers existentes y entender su anatomía

Phase 2: Construir MCP Servers (Módulos 4-6)
  → Implementar MCP servers en TypeScript (módulo 4)
  → Implementar MCP servers en Python (módulo 5)
  → Crear MCP Apps con interfaz de usuario interactiva (módulo 6)
  → De la teoría a escribir código real que funciona

Phase 3: Producción (Módulos 7-8)
  → Testing, debugging, y observabilidad (módulo 7)
  → Proyecto integrador production-ready (módulo 8)
  → Salir con un MCP server publicable en tu portfolio

Estás en el Módulo 1 de Phase 1 — el punto de partida donde construyes el modelo mental que guía todo lo demás. No vas a escribir código de MCP servers todavía, pero vas a entender por qué MCP existe, qué problema resuelve, y cómo se siente usarlo. Sin estas bases, implementar un server sería seguir instrucciones mecánicamente sin entender el diseño detrás.

¿Qué es MCP en 30 segundos?

Antes de entrar en detalle, aquí tienes la versión ultra-compacta para que tengas el mapa mental desde el inicio:

MCP (Model Context Protocol) es un protocolo abierto que estandariza cómo las aplicaciones de AI (como Claude Code, Cursor, o Windsurf) se conectan con herramientas y fuentes de datos externas. Es el equivalente de USB-C para el mundo AI: un estándar universal que reemplaza docenas de integraciones custom con un solo protocolo que funciona en todas partes.

En términos prácticos: tú escribes un programa (un "MCP Server") que expone capabilities — leer datos, ejecutar funciones, ofrecer templates. Cualquier AI host que soporte MCP puede descubrir y usar esas capabilities automáticamente, sin código adicional. Construyes una vez, funciona en todas partes.

Un ejemplo concreto en 15 segundos

Imagina este escenario:

Sin MCP:
  Tú: "¿Cuántos usuarios activos tenemos esta semana?"
  Claude Code: "No tengo acceso a tu database. Necesitarías
                consultar directamente con SQL..."

Con MCP (y un database server configurado):
  Tú: "¿Cuántos usuarios activos tenemos esta semana?"
  Claude Code: → Usa tool query_database("SELECT COUNT(*) FROM users
                  WHERE last_active > NOW() - INTERVAL '7 days'")
               → "Tienen 1,247 usuarios activos esta semana,
                  un 12% más que la semana pasada."

La diferencia es que con MCP, Claude Code tiene acceso directo a tu database a través de un programa estandarizado. No es magia — es un protocolo que define cómo descubrir y usar herramientas externas.

¿Por qué esto te importa a ti, hoy? Porque significa que puedes conectar Claude Code con exactamente los servicios que tu equipo necesita — tu database, tu issue tracker, tu sistema de deployment — sin esperar a que Anthropic construya una integración oficial. Tú controlas las extensiones.

Por qué aprender MCP ahora

El timing importa. MCP fue anunciado por Anthropic en noviembre de 2024, y en poco más de un año se convirtió en el estándar de facto para integrar AI con servicios externos. Hay razones concretas por las que este es el momento exacto para aprenderlo:

El ecosistema está en el punto óptimo. Ya hay suficientes AI hosts con soporte MCP (Claude Code, Cursor, Windsurf, Zed, Continue.dev) y suficientes servers existentes (500+) para que sea útil hoy. Pero el ecosistema todavía es joven, lo que significa que hay oportunidades enormes para contribuir. Si construyes un MCP server para un servicio popular que aún no lo tiene, puedes ser el primero — y la comunidad lo va a notar.

La demanda de developers con experiencia MCP crece. Las empresas están adoptando MCP internamente para conectar sus AI tools con sistemas propietarios. Un developer que sabe construir MCP servers tiene una skill diferenciadora clara en el mercado. No es lo mismo decir "uso Claude Code" que "extiendo Claude Code con integraciones custom para mi equipo."

El protocolo está maduro pero sigue evolucionando. La spec es estable para desarrollo (no vas a construir sobre arena movediza), pero todavía hay features nuevas y mejoras en cada release. Aprender ahora te pone en posición de crecer con el ecosistema en lugar de tratar de alcanzarlo después.

El patrón se repite. Los developers que aprendieron React temprano, que adoptaron Docker antes de que fuera mainstream, que invirtieron en TypeScript cuando era "experimental" — todos tienen algo en común: vieron un estándar emergente y invirtieron antes de que se volviera obligatorio. MCP tiene todas las señales de ser ese tipo de tecnología.

Evidencia concreta del momentum:

Adopción de MCP por AI hosts:
├── Nov 2024: Claude Code y Claude Desktop (Anthropic)
├── Dic 2024: Cursor agrega soporte MCP
├── Ene 2025: Windsurf y Continue.dev lo adoptan
├── Feb 2025: Zed y Sourcegraph Cody lo integran
├── 2025-2026: Cada nuevo AI host que aparece ya viene con soporte MCP
│
Ecosistema de servers:
├── Nov 2024: ~10 reference servers de Anthropic
├── Mar 2025: 100+ community servers
├── Jun 2025: 500+ servers en directorios
├── 2026: Miles de servers disponibles, empresas con MCP interno

No estás subiendo a un tren que ya pasó. Estás subiendo en el momento exacto donde la inversión de aprendizaje tiene el mayor retorno.

Objetivo del módulo

Al completar este módulo, serás capaz de:

✅ Explicar qué es MCP en una oración clara a un colega developer
✅ Explicar MCP a alguien no-técnico usando la analogía USB-C
✅ Articular el problema M×N de integraciones AI con un ejemplo concreto y calcular el ahorro
✅ Distinguir entre MCP Host, Client, y Server con un ejemplo de cada uno
✅ Nombrar al menos 3 AI hosts que soportan MCP y 5 MCP servers existentes
✅ Evaluar un MCP server existente con criterios de calidad
✅ Haber configurado y usado un MCP server existente en Claude Code
✅ Haber completado el mini-proyecto de mapeo M×N vs M+N con integraciones reales

Roadmap del módulo

Cápsula	Tema	Qué aprenderás
02	El problema M×N de integraciones	Por qué cada AI host × cada servicio = explosión de integraciones
03	MCP: El USB-C del AI	Cómo MCP reduce M×N a M+N con un protocolo estándar
04	El ecosistema MCP actual	Quién usa MCP hoy: Claude Code, Cursor, Windsurf y más
05	Primer contacto con MCP	Hands-on: usar un MCP server existente en Claude Code

Flujo de aprendizaje: la progresión deliberada

La estructura de este módulo sigue una progresión que es deliberada: problema → solución → ecosistema → práctica. Cada cápsula construye sobre la anterior, y el orden importa.

Cápsula 02 — El problema M×N de integraciones

Empiezas entendiendo por qué necesitamos MCP. Sin sentir el dolor del problema, es imposible valorar la elegancia de la solución. Vas a ver cómo el modelo actual de integraciones AI es insostenible: cada AI host necesita integraciones custom con cada servicio, creando una explosión combinatoria donde los números crecen multiplicativamente. Con 5 hosts y 10 servicios necesitas 50 integraciones diferentes, cada una con su propia API, autenticación, y mantenimiento. Agrega un host más y son 10 integraciones nuevas de golpe.

Vas a analizar el problema desde tres perspectivas — la del proveedor de AI hosts, la del proveedor de servicios, y la tuya como developer — y verás que este mismo patrón ya ocurrió antes en la industria con conectores de hardware, APIs, y formatos de datos.

Cápsula 03 — MCP: El USB-C del AI

Con el problema claro, la solución se vuelve natural. MCP es un protocolo estándar que reduce M×N a M+N. Vas a entender la analogía USB-C en profundidad — no como metáfora superficial, sino como el mismo patrón de estandarización aplicado a un dominio diferente. Conocerás los 3 roles fundamentales: Host, Client, y Server. Verás cómo MCP se compara con alternativas. Y diseñarás conceptualmente tu primer MCP server.

Cápsula 04 — El ecosistema MCP actual

Saber que MCP existe no es suficiente — necesitas ver que ya se está usando. Vas a explorar qué AI hosts soportan MCP, qué categorías de servers existen, quién los construye, y cómo está creciendo la adopción. También vas a aprender a evaluar servers antes de usarlos e identificar oportunidades para construir los tuyos.

Cápsula 05 — Primer contacto práctico

Finalmente, pones las manos en la terminal. Vas a configurar el Filesystem MCP Server oficial en Claude Code, usarlo para resolver tareas reales, configurar un segundo server, y completar el mini-proyecto del módulo. MCP deja de ser concepto y se convierte en algo que funciona en tu máquina.

¿Por qué este orden? No puedes valorar la solución sin entender el problema. No puedes evaluar el ecosistema sin saber qué es MCP. Y no puedes anclar el conocimiento conceptual sin la experiencia práctica. Esa es la lógica.

Tiempo estimado

El módulo completo (4 cápsulas + mini-proyecto) está diseñado para completarse en 3-4 horas de estudio enfocado:

Cápsula 02 (problema M×N):    ~45 min (lectura + ejercicios)
Cápsula 03 (MCP = USB-C):     ~50 min (lectura + ejercicios)
Cápsula 04 (ecosistema):      ~45 min (lectura + exploración + ejercicios)
Cápsula 05 (primer contacto): ~60 min (setup + práctica + mini-proyecto)

Puedes hacerlo en una sentada o distribuirlo en varios días. Lo importante es completar las 4 cápsulas antes de pasar al módulo 2, porque cada una construye sobre la anterior.

Conexión con el proyecto

Mini-proyecto de este módulo

Vas a mapear 3 integraciones de tu día a día al modelo M×N vs M+N. Esto parece simple, pero te fuerza a pensar en integraciones como un problema de escalabilidad — exactamente el mindset que necesitas para el resto de la guía.

El entregable es un documento markdown donde:

Identificas 3 servicios que quisieras conectar con tus AI hosts
Calculas el costo de integraciones custom (M×N) vs protocolo estándar (M+N)
Investigas si ya existen MCP servers para esos servicios
Reflexionas sobre cuál de esas integraciones sería tu proyecto final

No es un ejercicio teórico — la integración que elijas aquí puede convertirse literalmente en tu proyecto del Módulo 8. Muchos developers descubren su proyecto final en este primer ejercicio de reflexión cuando se preguntan "¿qué integración me ahorraría más tiempo en mi día a día?"

Conexión con el proyecto integrador (Módulo 8)

En el proyecto final construirás un MCP server production-ready conectado a una database o API real. Ese server será funcional, testeado, documentado, y publicable en tu portfolio. Lo que aprendes aquí — el modelo mental de cómo funcionan las integraciones MCP, qué problema resuelven, y cómo se ve uno en acción — es la base conceptual para diseñar tu propio server con propósito.

Cada módulo te acerca al proyecto final:

Módulo 1: Entiendes el problema y ves MCP en acción        ← ESTÁS AQUÍ
Módulo 2: Entiendes la arquitectura interna (Host-Client-Server)
Módulo 3: Dominas las primitivas (Resources, Tools, Prompts)
Módulo 4: Construyes tu primer server en TypeScript
Módulo 5: Construyes un server en Python
Módulo 6: Creas una MCP App con interfaz interactiva
Módulo 7: Testing, debugging, y observabilidad
Módulo 8: Integras todo en un proyecto production-ready

Cuando llegues al Módulo 8, todo lo que aprendiste aquí será tu brújula de diseño: ¿qué problema estoy resolviendo? ¿a qué categoría pertenece mi server? ¿qué capabilities necesita exponer?

Tipos de proyectos que podrías construir

Para darte una idea de hacia dónde va todo esto, aquí hay ejemplos de proyectos integradores que otros developers han construido o podrían construir:

Un MCP server que conecta con Notion para que Claude Code pueda buscar y actualizar documentación del equipo
Un MCP server para PostgreSQL personalizado con queries específicas del negocio
Un MCP server que expone métricas de Datadog o Grafana para debugging asistido por AI
Un MCP server para un API interna que permite deploys y rollbacks desde Claude Code
Un MCP server que conecta con Jira/Linear para crear y actualizar tickets desde el terminal

Tu proyecto puede ser cualquiera de estos o algo completamente diferente. Lo importante es que resuelva un problema real de tu workflow.

Prerequisitos

Para este módulo necesitas:

✅ Claude Code instalado y funcionando (guía 1)
✅ Comodidad con CLI/terminal — saber navegar, ejecutar comandos, leer output (guía 1)
✅ Saber dar instrucciones efectivas a Claude Code (guía 2)
✅ Saber configurar Claude Code con CLAUDE.md (guía 4)
✅ Curiosidad sobre cómo extender herramientas AI
✅ Una carpeta con archivos de proyecto en tu máquina (para la cápsula 05)

No necesitas: Experiencia con protocolos de red, TypeScript/Python avanzado, JSON-RPC, WebSockets, o conocimiento previo de MCP. Todo se construye desde cero en esta guía.

¿Y si me falta algún prerequisito?

Si no completaste alguna guía anterior, aquí va la honestidad: puedes seguir este módulo conceptualmente sin problemas (cápsulas 02-04), pero la cápsula 05 (hands-on) requiere que Claude Code esté instalado y que sepas usarlo desde la terminal. Si llegas a ese punto sin las bases, te recomiendo pausar y completar al menos la guía 1 antes de continuar.

Setup técnico

Para la cápsula 05 (primer contacto práctico), vas a necesitar herramientas adicionales. Te recomiendo verificarlas ahora para que no pierdas tiempo cuando llegues a la práctica.

Node.js y npm

Los MCP servers oficiales de referencia están escritos en TypeScript y se ejecutan con npx. Necesitas Node.js instalado en tu sistema:

# Verificar Node.js (necesitas v18 o superior)
node --version

# Verificar npm (viene con Node.js)
npm --version

# Verificar npx (viene con npm 5.2+)
npx --version

Si no tienes Node.js instalado:

# macOS con Homebrew (recomendado)
brew install node

# Linux (Ubuntu/Debian)
curl -fsSL https://deb.nodesource.com/setup_lts.x | sudo -E bash -
sudo apt-get install -y nodejs

# O descarga el instalador desde https://nodejs.org
# Elige la versión LTS (Long Term Support)

Después de instalar, verifica que todo funcione:

# Deberías ver versiones para los tres
node --version && npm --version && npx --version

Claude Code actualizado

Asegúrate de tener la versión más reciente de Claude Code, que incluye soporte completo para MCP:

# Ver tu versión actual
claude --version

# Actualizar si es necesario
npm update -g @anthropic-ai/claude-code

Directorio de prueba

Para la cápsula 05, necesitarás un directorio con algunos archivos para que el Filesystem MCP Server tenga contenido con el cual trabajar. Puedes usar cualquier carpeta de proyecto existente, o crear una de prueba:

# Crear un directorio de prueba con archivos de ejemplo
mkdir -p ~/mcp-playground/src
mkdir -p ~/mcp-playground/docs

echo "# Mi primer contacto con MCP" > ~/mcp-playground/README.md
echo "console.log('hello MCP')" > ~/mcp-playground/src/index.js
echo "def main(): pass" > ~/mcp-playground/src/app.py
echo "TODO: aprender MCP" > ~/mcp-playground/docs/notes.txt
echo '{"name": "mcp-playground", "version": "1.0.0"}' > ~/mcp-playground/package.json

No te preocupes si no haces esto ahora — la cápsula 05 tiene instrucciones paso a paso. Pero tener Node.js instalado sí te ahorrará tiempo cuando llegues allá.

Resumen de setup

✅ Requerido ahora:
├── Claude Code instalado y funcionando
└── Terminal/CLI básico

✅ Requerido para cápsula 05:
├── Node.js v18+ instalado
├── npm y npx disponibles
└── Un directorio con archivos de proyecto

⬜ No requerido en este módulo:
├── TypeScript/Python SDK
├── Cuentas en servicios externos (GitHub API, etc.)
└── Docker o herramientas de deployment

Lo que NO cubre este módulo

Es igual de importante saber qué no vas a ver aquí, para calibrar expectativas correctamente:

❌ Implementación de MCP servers — No vas a escribir código de servers en este módulo. Eso viene en módulos 4-6, donde construirás servers completos en TypeScript y Python con capabilities reales.
❌ Arquitectura interna del protocolo — No vas a ver el formato de mensajes JSON-RPC, el lifecycle de conexión, ni los detalles del handshake inicial. El módulo 2 está completamente dedicado a la arquitectura Host-Client-Server.
❌ Las 3 primitivas en detalle — Vas a escuchar "Resources, Tools, y Prompts" mencionados como tipos de capabilities, pero no vas a profundizar en cómo diseñarlos, cuándo usar cada uno, o cómo implementarlos. El módulo 3 está dedicado completamente a las primitivas.
❌ TypeScript o Python SDK — No vas a usar los SDKs oficiales de MCP. El SDK de TypeScript se cubre en módulo 4 y el de Python en módulo 5.
❌ Testing o debugging de MCP servers — Herramientas como MCP Inspector y técnicas de testing se cubren en módulo 7. Aquí solo usas servers, no los depuras.
❌ Seguridad y permisos avanzados — MCP tiene un modelo de seguridad con permisos granulares. Lo verás cuando construyas servers, no ahora.
❌ MCP en producción — Deployment, monitoring, escalabilidad, y operaciones de MCP servers en entornos productivos se cubren en módulos 7-8.
❌ Transports avanzados — stdio, HTTP/SSE, y Streamable HTTP son los mecanismos de comunicación de MCP. Los conocerás en módulo 2, no aquí.

Este módulo es motivacional y conceptual. Estás construyendo el "por qué" antes del "cómo." La implementación viene después, y será mucho más efectiva porque llegas con el modelo mental correcto y la motivación de haber visto MCP en acción.

Cómo aprovechar este módulo al máximo

Algunos tips para sacar el mayor valor de estas 4 cápsulas:

Haz los ejercicios, no solo los leas. Los ejercicios están diseñados para que proceses activamente los conceptos. Calcular M×N vs M+N con tus propios servicios es fundamentalmente diferente a leer el cálculo de otro.
Toma notas de qué integraciones te interesan. Desde la cápsula 02, empezarás a pensar en servicios que quisieras conectar con Claude Code. Anota esas ideas — son semillas para tu proyecto final.
No te saltes la cápsula 05. Es tentador quedarse en la teoría, pero el primer contacto práctico ancla todo. La diferencia entre "entiendo MCP conceptualmente" y "vi MCP funcionando en mi terminal" es enorme.
Lee las secciones de troubleshooting aunque no tengas problemas. Contienen insights sobre errores conceptuales comunes que te ahorrarán confusión más adelante.
Conecta con tu trabajo real. En cada sección, piensa: "¿Cómo aplicaría esto en mi proyecto actual?" Esa conexión personal es lo que convierte conocimiento en skill.
No subestimes la analogía USB-C. Puede parecer simplista al inicio, pero la analogía es sorprendentemente precisa y útil. Cuando alguien te pregunte "¿Qué es MCP?", poder responder con una analogía clara y correcta vale más que una definición técnica perfecta.
Presta atención al ecosistema. La cápsula 04 sobre el ecosistema puede parecer "informativa" pero es donde encontrarás inspiración para tu proyecto final. Los servers que ya existen te muestran qué es posible; los que no existen te muestran qué puedes construir tú.

Evidencia de éxito

Al terminar este módulo, sabrás que tuviste éxito si:

✅ Puedes explicar MCP a un colega developer en 30 segundos sin dudar
✅ Puedes explicar MCP a alguien no-técnico usando la analogía USB-C de forma convincente
✅ Puedes dibujar el modelo M×N vs M+N en una pizarra con un ejemplo concreto
✅ Puedes calcular el ahorro de integraciones para cualquier combinación de hosts y servicios
✅ Puedes nombrar 3+ AI hosts que soportan MCP y explicar qué significa "soporte MCP"
✅ Puedes nombrar 5+ MCP servers existentes y en qué categoría caen
✅ Puedes distinguir entre Host, Client, y Server con un ejemplo real de cada uno
✅ Has configurado y usado el Filesystem MCP Server en Claude Code
✅ Has configurado un segundo MCP server y visto la composabilidad en acción
✅ Has completado el mini-proyecto M×N vs M+N con integraciones de tu propio trabajo
✅ Puedes argumentar por qué MCP es preferible a integraciones custom en la mayoría de escenarios
✅ Tienes una idea clara de qué integración podrías construir como proyecto final
✅ Sientes que construir tu propio MCP server es alcanzable — no intimidante, sino emocionante

Si puedes marcar la mayoría de estos puntos, estás listo para el Módulo 2.

El punto más importante no es el conocimiento técnico — es la confianza. Si terminas el módulo pensando "construir un MCP server es algo que yo puedo hacer, no algo solo para expertos", entonces el módulo cumplió su objetivo principal.

Resumen

Este módulo cubre el por qué de MCP — el problema que resuelve y por qué importa para ti como developer
MCP en 30 segundos: un protocolo abierto que estandariza cómo AI hosts se conectan con servicios externos, como USB-C para el AI
Progresión deliberada: problema M×N → solución MCP → ecosistema actual → primer contacto práctico
Al terminar tendrás un modelo mental claro de MCP y habrás usado un MCP server real en tu terminal
No escribirás código de MCP servers todavía — la implementación viene en módulos 4-6
El mini-proyecto te conecta con el proyecto final: la integración que elijas aquí puede ser tu proyecto del Módulo 8
Setup técnico necesario: Node.js (v18+), npm, npx, y Claude Code actualizado
Todo lo que aprendes aquí es la base conceptual para el resto de la guía — los 7 módulos que siguen construyen sobre esto

Recursos adicionales

Model Context Protocol — Especificación Oficial - La fuente autoritativa sobre MCP
Introducing the Model Context Protocol (Anthropic Blog) - Anuncio oficial y contexto de diseño
MCP TypeScript SDK - SDK oficial (lo usarás en módulo 4)
MCP Python SDK - SDK oficial (lo usarás en módulo 5)
Awesome MCP Servers - Directorio de MCP servers open source
Claude Code MCP Documentation - Configuración de MCP en Claude Code
MCP GitHub Organization - Repos oficiales: spec, SDKs, servers de referencia

Siguiente cápsula: El problema M×N de integraciones — por qué cada AI host necesita integraciones custom con cada servicio, y por qué eso no escala. Prepárate para sentir el dolor del problema antes de conocer la solución.

Siguiente →El Problema M×N de Integraciones AI