MCP y Remote Control: conexiones externas

Descripción

Hasta ahora, las integraciones que has visto conectan Claude Code con herramientas que ya conoces: Git para versionado, SDK para acceso programático, headless CLI para automatización en scripts. Pero hay una pregunta que no hemos respondido: ¿qué pasa cuando Claude Code necesita acceder a algo que no está en tu sistema de archivos? ¿Una base de datos? ¿Una API externa? ¿Un servicio de búsqueda web?

Para eso existe MCP (Model Context Protocol): un protocolo abierto que permite conectar Claude Code con fuentes de datos y herramientas externas. En lugar de que Claude Code solo pueda leer archivos y ejecutar comandos, MCP le da acceso a bases de datos, APIs, servicios web, y cualquier herramienta que tenga un MCP server.

Esta capsula también cubre Remote Control y acceso remoto: las formas de ejecutar Claude Code de forma remota, incluyendo scheduled agents y headless mode. Juntos, MCP y las capacidades remotas representan el extremo mas avanzado de las integraciones -- donde Claude Code deja de ser una herramienta local y se convierte en un nodo conectado a un ecosistema mas amplio.

MCP: Model Context Protocol

Qué es MCP

MCP (Model Context Protocol) es un protocolo abierto creado por Anthropic que estandariza cómo los agentes de IA se conectan con fuentes de datos y herramientas externas. Piensa en MCP como un "USB-C para agentes de IA" — una interfaz universal que permite conectar cualquier servicio.

El problema que resuelve

Sin MCP, cada integración es custom:

┌──────────────────────────────────────────────────────────────┐
│                 SIN MCP                                       │
│                                                              │
│  Claude Code ──── custom script ──── Base de datos           │
│  Claude Code ──── otro script ──── GitHub API                │
│  Claude Code ──── shell command ──── Web search              │
│  Claude Code ──── otro script ──── Slack                     │
│                                                              │
│  (cada integración es diferente, fragil, difícil de mantener)│
└──────────────────────────────────────────────────────────────┘

Con MCP, todo usa el mismo protocolo:

┌──────────────────────────────────────────────────────────────┐
│                 CON MCP                                       │
│                                                              │
│               ┌── MCP Server: PostgreSQL                     │
│               │                                              │
│  Claude Code ─┼── MCP Server: GitHub                         │
│   (MCP client)│                                              │
│               ├── MCP Server: Web Search                     │
│               │                                              │
│               └── MCP Server: Slack                          │
│                                                              │
│  (un protocolo, múltiples servidores, plug & play)           │
└──────────────────────────────────────────────────────────────┘

Conceptos clave de MCP

Cómo funciona

1. Instalas/configuras un MCP server
2. Lo registras en Claude Code (settings)
3. Claude Code detecta las herramientas del server
4. Cuando necesita datos externos, Claude usa las herramientas del server
5. El server ejecuta la operación y devuelve el resultado
6. Claude Code integra el resultado en su respuesta

MCP servers populares

⚠️ Paquetes MCP en evolución: Los nombres de paquetes del ecosistema MCP cambian frecuentemente. Verifica los nombres actuales en el MCP Server Registry antes de instalar.

Filesystem MCP Server

Acceso mejorado al sistema de archivos con búsqueda avanzada, operaciones batch, y watch de cambios.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/directory"]
    }
  }
}

Herramientas disponibles:

• read_file: leer contenido de archivos
• write_file: escribir archivos
• list_directory: listar contenido de directorio
• search_files: búsqueda avanzada por contenido
• get_file_info: metadata de archivos

GitHub MCP Server

Acceso a la API de GitHub: issues, PRs, repos, code search.

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

Herramientas disponibles:

• search_repositories: buscar repos
• get_issue: leer un issue
• create_issue: crear issues
• list_pull_requests: listar PRs
• get_pull_request_diff: leer diff de un PR
• create_pull_request_review: dejar un review

PostgreSQL MCP Server

Queries directas a una base de datos PostgreSQL.

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

Herramientas disponibles:

• query: ejecutar queries SQL (SELECT)
• list_tables: listar tablas
• describe_table: schema de una tabla

Brave Search MCP Server

Búsqueda web en tiempo real.

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "<your-api-key>"
      }
    }
  }
}

Herramientas disponibles:

• brave_web_search: buscar en la web
• brave_local_search: buscar negocios locales

Memory MCP Server

Almacenamiento persistente de knowledge graph para contexto entre sesiones.

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

Herramientas disponibles:

• create_entities: crear nodos de conocimiento
• create_relations: crear relaciones entre nodos
• search_nodes: buscar en el knowledge graph
• read_graph: leer el grafo completo

Configuración de MCP en Claude Code

Dónde se configura

MCP servers se configuran en los settings de Claude Code. Hay varios niveles:

Ejemplo: configurar GitHub MCP

Paso 1: Obtener un Personal Access Token de GitHub con los permisos necesarios (repo, read:org).

Paso 2: Configurar en settings:

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

⚠️ Seguridad: Nunca pongas tokens en .claude/settings.json (archivo de equipo). Usa .claude/settings.local.json (archivo personal, debe estar en .gitignore) o variables de entorno.

Paso 3: Verificar en Claude Code:

Tú: ¿Qué herramientas MCP tienes disponibles?

Claude Code: Tengo acceso al MCP server de GitHub con las 
siguientes herramientas:
- search_repositories
- get_issue
- create_issue
- list_pull_requests
...

Ejemplo: configurar múltiples servers

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "POSTGRES_CONNECTION_STRING": "${DATABASE_URL}"
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "${BRAVE_API_KEY}"
      }
    }
  }
}

Verificar que un MCP server funciona

Después de configurar, inicia una nueva sesión de Claude Code y pregunta:

Tú: Lista las herramientas MCP que tienes disponibles y prueba 
    una query a la base de datos.

Si la configuración es correcta, Claude Code mostrará las herramientas del server y ejecutará la query.

MCP en acción: ejemplos prácticos

Ejemplo 1: debugging con base de datos

Tú: El usuario user@example.com reporta que no puede ver sus 
    pedidos. Consulta la base de datos para entender qué pasa.

Claude Code (usando MCP Postgres):
→ query: SELECT * FROM users WHERE email = 'user@example.com'
→ Resultado: user_id = 42, active = true

→ query: SELECT * FROM orders WHERE user_id = 42
→ Resultado: 3 orders, pero todos tienen status = 'draft'

Encontré el problema. El usuario tiene 3 pedidos, pero todos 
están en status 'draft'. La vista de pedidos probablemente 
filtra por status = 'completed' o 'shipped'. 

Los pedidos nunca pasaron de 'draft' — posiblemente un bug en 
el checkout flow que no actualiza el status después del pago.

Ejemplo 2: análisis de issue de GitHub

Tú: Revisa el issue #156 de nuestro repo y propón una solución.

Claude Code (usando MCP GitHub):
→ get_issue: owner/repo #156
→ Título: "API returns 500 on empty cart checkout"
→ Descripción: "When trying to checkout with an empty cart..."

He leído el issue #156. El problema es que el endpoint POST 
/checkout no valida si el carrito está vacío antes de procesar.

Solución propuesta:
1. Agregar validación en checkout_service.py
2. Devolver 400 con mensaje "Cart is empty" 
3. Agregar test para este caso

¿Quieres que lo implemente?

Ejemplo 3: investigación con búsqueda web

Tú: Necesito implementar rate limiting. ¿Cuál es la mejor 
    librería para FastAPI en 2026?

Claude Code (usando MCP Brave Search):
→ brave_web_search: "FastAPI rate limiting library 2026 best"
→ Resultados: slowapi, fastapi-limiter, custom middleware...

Basado en mi búsqueda, las opciones principales son:

1. **slowapi** (más popular): basado en limits, soporte para 
   Redis y in-memory. Bien mantenida.
2. **fastapi-limiter** (más simple): decoradores simples, 
   menos features pero más ligera.
3. **Custom middleware**: para casos complejos donde necesitas 
   control total.

Recomendación: slowapi si necesitas rate limiting distribuido 
(con Redis), fastapi-limiter si es un proyecto simple.

MCP: nota importante

Esta cápsula cubre la configuración básica de MCP en Claude Code. MCP es un tema amplio con muchas posibilidades:

• Crear tus propios MCP servers
• MCP servers para APIs internas de tu empresa
• Orquestación de múltiples MCP servers
• Seguridad y autenticación avanzada

La Guía #5 de esta serie (Claude Code & MCP) cubre MCP en profundidad: desde crear servers custom hasta arquitecturas multi-server para equipos. Si MCP te interesa, esta cápsula te da la base; la Guía #5 te da la maestría.

Remote Control y Acceso Remoto

Estado actual

Remote Control es una capacidad en evolucion de Claude Code. Las formas actuales de acceder a Claude Code de forma remota incluyen:

Scheduled Agents (Remote Triggers)

Claude Code permite crear agentes programados que se ejecutan en schedules cron:

# Listar triggers programados
# Se configuran desde la interfaz o CLI

# Los triggers ejecutan Claude Code en la nube
# sin necesidad de tener tu maquina encendida

Casos de uso:

• Revisiones de código automaticas en PRs
• Reportes periodicos sobre el estado del codebase
• Mantenimiento automatizado (dependencias, limpieza)

Headless Mode como "Remote Control"

El headless mode (-p flag) permite ejecutar Claude Code programaticamente, lo que habilita control remoto a traves de scripts y APIs:

# Ejecutar desde un servidor remoto
claude -p "analiza los ultimos 5 PRs y genera un resumen"

# Integrar en un webhook
curl -X POST your-server/api/claude \
  -d '{"prompt": "revisa el ultimo commit"}'

Notas importantes

• Las capacidades remotas estan en evolucion activa
• Verifica la documentación oficial para el estado actual: https://code.claude.com/docs/en
• Algunas features pueden requerir planes especificos (Team/Enterprise)

Computer Use en Claude Code (marzo-abril 2026)

Hasta 2026, Computer Use vivía solo en Claude Cowork. Ahora también está en Claude Code:

Computer Use en Claude Code Desktop (marzo 2026)

Claude Code Desktop puede controlar tu escritorio real: abrir apps nativas, hacer clic en UI, verificar cambios visuales. Está off por default y pide confirmación antes de cada acción.

Mejor para:

• Apps sin API (herramientas propietarias legacy)
• Verificar cambios end-to-end que solo un GUI puede validar (ej: flujos de onboarding de iOS Simulator)
• Drive hardware control panels
• Cualquier cosa que solo existe como GUI

Activarlo:

Settings → Computer use → Enable
Grant OS permissions (screen capture, input control)

Ejemplo de uso:

> Abre el iOS simulator, tap through el onboarding flow, y toma screenshot de cada paso

Computer Use en Claude Code CLI (abril 2026, research preview)

También disponible desde el CLI — Claude puede abrir apps nativas, hacer clic en UI, y verificar cambios desde tu terminal. Ideal para cerrar el loop en cosas que solo un GUI puede verificar.

Cuándo usarlo: Cuando ni un Connector ni una API resuelven tu caso. Como último recurso.

Cuándo NO: Tareas que tienen alternativa via API, commands, o MCP — siempre prefiere esas.

Ultraplan (abril 2026, early preview)

Ultraplan es una nueva forma de planear trabajo con Claude Code:

CLI local  ──▶  Planning en la nube  ──▶  Web editor
                        │                      │
                        ▼                      ▼
                 Ejecutar remoto       Pull de vuelta al local

Flujo típico:

1. Desde el CLI: draft un plan con Claude
2. El plan se sube a la nube, auto-crea un cloud environment
3. Revisas y comentas en un web editor
4. Ejecutas el plan remotamente (la nube hace el trabajo) o lo traes de vuelta local

Por qué importa: separa el "planear" del "ejecutar". Puedes planear en 5 min desde el CLI, revisar con un teammate en web, y ejecutar horas después sin tener que mantener tu máquina prendida.

Monitor tool (abril 2026)

El Monitor tool streamea events en background hacia la conversación. Claude puede "tail" logs de un proceso y reaccionar en vivo.

Ejemplo:

> Corre el dev server con npm run dev y monitoréalo. Si aparece un error, fix it.

Claude inicia el dev server en background, monitor tool le va streameando stdout/stderr, y cuando aparece un error en logs, Claude lo captura y actúa.

Casos de uso:

• Dev servers con hot reload
• Build processes largos
• Procesos de CI local
• Test watchers

Transcript Search (marzo 2026)

Buscar en la conversación larga con Claude Code — finalmente.

Cómo usar:

Ctrl+O    # abre transcript mode
/migrate  # busca "migrate" en todo el transcript
n         # siguiente match
N         # match anterior

Útil cuando recuerdas que Claude corrió un comando 200 mensajes atrás pero no recuerdas exactamente cuál.

PR Auto-fix (marzo-abril 2026)

Dos formas de activar PR auto-fix:

PR Auto-fix en Claude Code Web (marzo 2026)

Al crear un PR desde Claude Code web, hay un toggle "Auto fix" en el panel de CI. Activalo y Claude:

1. Observa el CI
2. Fixea failures (lint errors, typing issues, test fallidos)
3. Handlea nits del code review
4. Pushea hasta que el PR está verde

Para quién: equipos que no quieren babysitear PRs a través de 6 rondas de lint errors.

/autofix-pr desde el terminal (abril 2026)

Mismo feature pero desde el CLI:

> /autofix-pr

Activa PR auto-fix desde terminal sin abrir el web. Claude empieza a observar el PR y corrige CI failures solo.

/team-onboarding (abril 2026)

Empaqueta tu setup (CLAUDE.md, skills, hooks, settings) en una guía replayable para que un nuevo miembro del equipo llegue a tu mismo setup rápido:

> /team-onboarding

Genera un documento (con comandos y steps) que, al seguirlo, reproduce tu setup en otra máquina. Útil para:

• Onboarding de new hires
• Setup de ambientes dev consistentes en el equipo
• Documentar tu configuración de Claude Code

PowerShell Tool (Windows, marzo 2026)

Native PowerShell tool para Windows — antes Claude solo podía correr Bash (via Git Bash o WSL). Ahora puede correr cmdlets nativos, pipe objects, y trabajar con Windows paths sin traducir.

Activarlo:

{
  "env": {
    "CLAUDE_CODE_USE_POWERSHELL_TOOL": "1"
  }
}

Comparaciones y decisiones

MCP vs scripts custom vs SDK

Cuándo usar cada uno

¿Necesitas conectar con un servicio estándar (DB, API, search)?
├── Sí → ¿Existe un MCP server para ese servicio?
│   ├── Sí → Usa MCP
│   └── No → Script custom o crea tu propio MCP server
└── No → ¿Es lógica de automatización?
    ├── Simple → Headless CLI (-p)
    └── Compleja → SDK

MCP vs herramientas built-in de Claude Code

Claude Code ya tiene herramientas para leer archivos, ejecutar comandos, y buscar código. ¿Por qué necesitas MCP?

MCP no reemplaza las herramientas built-in — las complementa con acceso a recursos que no están en tu sistema de archivos local.

Patterns comunes

Pattern: MCP server por entorno

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

Usa settings.local.json para configurar el server apuntando a tu base de datos de desarrollo. El equipo puede tener cada uno su propia configuración.

⚠️ Nunca configures un MCP server apuntando a producción sin restricciones. Usa cuentas read-only para bases de datos de producción.

Pattern: MCP + CLAUDE.md

Documenta los MCP servers disponibles en tu CLAUDE.md:

# MCP Servers disponibles

## PostgreSQL (db-dev)
- Base de datos de desarrollo
- Tablas principales: users, orders, products
- Solo queries SELECT (read-only)
- Usar para debugging y análisis de datos

## GitHub (github)
- Repo: company/main-api
- Acceso: issues, PRs, code search
- Usar para revisar PRs y gestionar issues

Pattern: verificar MCP al iniciar sesión

# En CLAUDE.md - sección de inicio de sesión

Al iniciar una sesión:
1. Verifica que los MCP servers están disponibles
2. Si el server de PostgreSQL no responde, avisa al usuario
3. Lista las herramientas MCP disponibles si el usuario las necesita

Pitfalls y edge cases

Pitfall 1: tokens en settings.json compartido

{
  "mcpServers": {
    "github": {
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_MySecretToken123"
      }
    }
  }
}

Si esto está en .claude/settings.json, el token se commitea al repo. Cualquiera con acceso al repo tiene tu token.

Solución: Usa .claude/settings.local.json (en .gitignore) o variables de entorno:

{
  "mcpServers": {
    "github": {
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

Pitfall 2: MCP server que modifica datos

Un MCP server de base de datos puede ejecutar DELETE FROM users. Sin restricciones, Claude Code podría ejecutar queries destructivas.

Solución:

• Usa cuentas de base de datos con permisos read-only
• Configura el MCP server para aceptar solo SELECT queries
• Usa una base de datos de desarrollo, nunca producción directa

Pitfall 3: demasiados MCP servers

Cada MCP server agrega herramientas al contexto de Claude Code. Si tienes 10 servers con 5 herramientas cada uno, son 50 herramientas compitiendo por la atención de Claude.

Solución: Configura solo los servers que necesitas para el proyecto actual. Usa configuración por proyecto (.claude/settings.json) en lugar de global.

Pitfall 4: MCP server caído

Si un MCP server no está disponible cuando Claude Code intenta usarlo, recibirás un error. Claude Code no siempre maneja estos errores de forma elegante.

Solución: Verifica que los servers están corriendo antes de la sesión. Agrega verificación en CLAUDE.md:

Antes de usar herramientas MCP, verifica que el server responde.
Si un MCP server no está disponible, continúa sin él y avísame.

Pitfall 5: Ejecución remota sin supervision

Cuando ejecutas Claude Code de forma remota (headless mode o scheduled agents), no hay nadie para aprobar permisos interactivamente.

Solución: Configura permisos mas amplios en allowedTools para sesiones remotas. Usa el flag --allowedTools con headless mode para pre-aprobar las herramientas necesarias. Solo las acciones de alto riesgo deberian requerir aprobacion manual.

Ejemplo completo integrado

Un workflow que combina MCP, Git, y headless mode:

Escenario: debugging de un bug reportado en GitHub
────────────────────────────────────────────────────

Tú: El issue #203 reporta que los usuarios no pueden 
    actualizar su email. Investiga y resuelve.

Claude Code:
───────────

# 1. Leer el issue (MCP GitHub)
→ get_issue: company/api #203
→ "Users get 500 error when updating email via PATCH /users/me"
→ Steps to reproduce: ...
→ Error log: "UniqueConstraintError on users.email"

# 2. Investigar en la base de datos (MCP PostgreSQL)
→ query: SELECT email, COUNT(*) FROM users GROUP BY email HAVING COUNT(*) > 1
→ Resultado: 0 duplicados en la base de datos

→ query: SHOW CREATE TABLE users (o equivalente)
→ Resultado: UNIQUE constraint en email, pero el código no verifica 
  antes de hacer UPDATE

# 3. Leer el código (herramientas built-in)
→ Read: src/routes/users.py
→ El endpoint PATCH /users/me hace UPDATE sin verificar si el 
  nuevo email ya existe en la tabla

# 4. Implementar fix (herramientas built-in)
→ Write: src/routes/users.py
→ Agrega verificación: si el email ya existe, return 409 Conflict

→ Write: tests/test_users.py
→ Agrega test para el caso de email duplicado

# 5. Commit y referencia al issue (Git)
→ git add src/routes/users.py tests/test_users.py
→ git commit -m "fix(users): handle duplicate email on update

Check if email already exists before UPDATE. Returns 409
Conflict with clear error message instead of 500.

Fixes #203"

→ gh pr create --title "fix: handle duplicate email on update" \
    --body "Fixes #203. Adds email uniqueness check before UPDATE."

Este workflow usa tres integraciones en una sola sesión: MCP GitHub (para leer el issue), MCP PostgreSQL (para investigar la base de datos), y Git (para commit y PR).

Este módulo como puente

Lo que cubrimos vs lo que viene

Si MCP te interesó, la Guía #5 es tu siguiente paso después de completar esta guía.

Ejercicios prácticos

Ejercicio 1: Básico — Configurar MCP filesystem

Configura el MCP server de filesystem para dar a Claude Code acceso a un directorio específico.

Requisitos:

• Instala @modelcontextprotocol/server-filesystem via npx
• Configura en .claude/settings.local.json
• Verifica que Claude Code puede listar archivos usando el MCP server
• Limita el acceso a un directorio específico

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/your/project/docs"
      ]
    }
  }
}

Tú: ¿Qué herramientas MCP tienes disponibles? 
    Lista los archivos en el directorio docs usando MCP.

Ejercicio 2: Intermedio — Configurar GitHub MCP

Configura el MCP server de GitHub y úsalo para revisar issues de un repositorio.

Requisitos:

• Crea un Personal Access Token en GitHub (Settings → Developer settings → Tokens)
• Configura el MCP server en .claude/settings.local.json
• Pide a Claude Code que liste los issues abiertos de un repo público
• Pide que analice un issue específico

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

Tú: Lista los últimos 5 issues abiertos del repo facebook/react.

Tú: Lee el issue más reciente y propón una posible solución.

Ejercicio 3: Intermedio — MCP + investigación de bug

Simula un debugging workflow usando MCP GitHub para leer un issue y Claude Code para buscar el bug en el código.

Requisitos:

• Usa el MCP de GitHub para leer un issue de tu repositorio (o uno público)
• Claude Code analiza el código relevante usando herramientas built-in
• Genera un reporte con: issue description, root cause analysis, proposed fix

Tú: Lee el issue #[número] de [owner/repo] y analiza el código 
    de este proyecto para encontrar la causa raíz. Genera un 
    reporte con: descripción del issue, análisis de causa raíz, 
    y fix propuesto.

Ejercicio 4: Avanzado — Múltiples MCP servers

Configura al menos dos MCP servers y úsalos en una sola sesión de Claude Code.

Requisitos:

• Configura GitHub MCP y filesystem MCP (o cualquier combinación)
• En una sola sesión, pide a Claude Code que use ambos servers
• Ejemplo: "Lee el issue #X de GitHub y busca si hay documentación relevante en docs/"

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

Tú: Lee el issue #42 de [owner/repo] usando GitHub MCP. 
    Luego busca en el directorio docs/ si hay documentación 
    relacionada con el tema del issue. Si no hay, sugiere 
    qué documentación crear.

Ejercicio 5: Challenge — Documentar tu setup de integraciones

Crea una sección completa en tu CLAUDE.md que documente todas las integraciones del módulo.

Requisitos:

• Sección de Git conventions (conventional commits, branch naming)
• Sección de MCP servers disponibles (con descripción de cada uno)
• Sección de automatización (scripts de headless mode disponibles)
• Sección de permisos relacionados con integraciones (qué Git commands están permitidos)

# Integraciones

## Git Conventions
- Conventional commits: type(scope): description
- Branch naming: feature/*, fix/*, docs/*
- Merge strategy: squash merge en main
- NUNCA force push. NUNCA push directo a main.

## MCP Servers
### GitHub (github)
- Repo: owner/repo
- Acceso: issues, PRs, code search
- Usar para: revisar issues, crear PRs

### Filesystem (docs)
- Directorio: ./docs
- Acceso: read/write
- Usar para: buscar y actualizar documentación

## Scripts de automatización
- ./scripts/review.sh: code review de cambios
- ./scripts/pr-description.sh: generar descripción de PR
- ./scripts/daily-changelog.sh: changelog diario

## Permisos de Git
Permitidos: git status, git diff, git add, git commit, git log
Requieren aprobación: git push, git merge
Prohibidos: git push --force, git reset --hard

Resumen

Lo que aprendiste en esta cápsula:

• MCP (Model Context Protocol) es un protocolo abierto para conectar Claude Code con herramientas y datos externos
• MCP usa un modelo client-server: Claude Code es el client, los MCP servers exponen herramientas
• Servers populares: filesystem, GitHub, PostgreSQL, Brave Search, Memory
• La configuración va en settings.json o settings.local.json (tokens en local, nunca en el compartido)
• Remote Control incluye scheduled agents (triggers remotos) y headless mode para ejecución programatica remota
• MCP complementa las herramientas built-in — no las reemplaza
• Seguridad: usar cuentas read-only para DBs, tokens en settings.local.json, limitar MCP servers a los necesarios
• Esta guía cubre MCP básico — la Guía #5 cubre MCP en profundidad (crear servers, arquitectura, seguridad avanzada)

Resumen del módulo completo

Has completado el Módulo 7: Integraciones. Esto es lo que ahora sabes hacer:

Tu Claude Code ya no es una isla. Está conectado con Git para versionado, accesible programáticamente via SDK, automatizable con headless CLI, y extensible con MCP para datos externos. Es un componente integrado en tu stack de desarrollo.

Siguiente módulo: 08 - Proyecto integrador — construirás tu primera aplicación CLI completa con Claude Code, aplicando todo lo aprendido: CLAUDE.md, skills, hooks, subagents, Git workflows, y (opcionalmente) SDK o headless mode.

Recursos adicionales

Documentación oficial

• MCP Overview — Sitio oficial del Model Context Protocol
• MCP Servers — Repositorio de MCP servers oficiales
• Claude Code MCP Setup — Configuración de MCP en Claude Code
• Remote Control — Documentación de Remote Control

MCP servers de la comunidad

• MCP Server Registry — Lista de servers de la comunidad
• Creating MCP Servers — Guía para crear tu propio server

Complementarios

• Settings — Configuración de Claude Code incluyendo MCP
• Best Practices — Buenas prácticas de seguridad con MCP
• SDK Documentation — Usar el SDK con createSdkMcpServer()