MCP Power Tools — Extendiendo el Alcance de Claude

Referencias Oficiales: MCP · MCP Specification · Overview

Ruta del currículo

1. CLAUDE.md Mastery — memoria del repo y reglas
2. Effective Prompting — framing de tareas y restricciones
3. MCP Power Tools — herramientas y contexto vivo ← Estás aquí
4. Multi-Agent Workflows — delegar y paralelizar
5. Hooks Automation — guardrails automáticos en local
6. GitHub Actions Workflows — mover trabajo repetible a automatización de equipo

Documentación oficial usada en esta guía

• Cómo Claude Code se conecta a servidores MCP — MCP
• Configuración project-scope vs user-scope — MCP
• Por qué MCP encaja tan bien aquí — Overview

¿Qué es MCP?

Model Context Protocol (MCP) permite dar a Claude Code acceso a herramientas externas y fuentes de datos. Piénsalo como plugins para tu asistente AI.

Sin MCP, Claude puede leer archivos y ejecutar comandos de shell. Con MCP, Claude puede:

• Consultar bases de datos directamente
• Buscar en documentación interna de tu empresa
• Interactuar con APIs (Jira, Slack, GitHub)
• Acceder a herramientas especializadas (navegadores, herramientas de diseño)

Configurando Servidores MCP

Los servidores MCP se configuran en .mcp.json en la raíz del proyecto:

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

Servidores MCP Esenciales

El Patrón context7

Uno de los servidores MCP más útiles. En lugar de que Claude adivine firmas de API:

Tú: "Agrega paginación a esta página de Next.js"
Claude: *usa context7 para obtener docs actuales de Next.js*
Claude: *implementa con API actual, no patrones desactualizados*

MCP vs. Sandbox de Codex

Alcance de Proyecto vs Alcance de Usuario

La configuración MCP tiene dos alcances. Elegir el correcto evita que los secretos acaben en el repositorio y facilita la incorporación de nuevos miembros al equipo.

Alcance de Proyecto — .mcp.json

Úsalo cuando todo el equipo necesita los mismos servidores MCP. Este archivo se puede incluir en git para que todos compartan la misma configuración automáticamente.

// .mcp.json en la raíz del proyecto — compartido via git
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    }
  }
}

Referencia variables de entorno con ${VAR_NAME} en lugar de hardcodear valores. Cada desarrollador guarda sus secretos reales en su propio archivo .env.

Alcance de Usuario — ~/.claude/settings.json

Úsalo para herramientas personales o servidores que necesitan tus claves API privadas. Están disponibles en todos tus proyectos sin configuración adicional por repositorio.

// ~/.claude/settings.json — personal, disponible en todos tus proyectos
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@anthropic/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "tu-clave-personal"
      }
    }
  }
}

Más Servidores MCP Útiles

Más allá de los básicos, estos servidores valen la pena para el trabajo diario:

Por ejemplo, con Brave Search Claude puede buscar los últimos issues de una librería o parches de seguridad en lugar de depender de sus datos de entrenamiento. Con Puppeteer puedes automatizar pruebas de UI web directamente desde una conversación con Claude.

Crear Tu Propio Servidor MCP

No estás limitado a servidores de la comunidad. Si tu empresa tiene herramientas internas — una wiki, un dashboard de monitoreo, una API propia — puedes envolverlas en un servidor MCP personalizado.

El SDK de TypeScript (@modelcontextprotocol/sdk) hace esto muy accesible:

// Concepto: un servidor MCP que busca en tu wiki interna
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 
const server = new Server({ name: "wiki-interna", version: "1.0.0" });
 
server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "buscar_wiki") {
    const query = request.params.arguments.query;
    // Llamar a tu API interna
    const resultados = await wikiInternaApi.buscar(query);
    return { content: [{ type: "text", text: JSON.stringify(resultados) }] };
  }
});

Una vez conectado, "encuentra nuestro runbook de despliegue" se convierte en una búsqueda real — no en una suposición. Cada sistema interno que conectas multiplica la utilidad de Claude para tu contexto específico.

Depuración y Solución de Problemas

Verificar servidores conectados

claude mcp list

Muestra todos los servidores MCP activos y su estado.

Problemas comunes

El servidor no arranca:

• Verifica que npx esté en tu PATH (which npx)
• Confirma tu versión de Node.js — la mayoría de servidores MCP requieren v18 o posterior
• Verifica que las variables de entorno necesarias estén configuradas

El servidor es lento o hay timeouts:

{
  "mcpServers": {
    "servidor-lento": {
      "command": "npx",
      "args": ["-y", "algun-servidor-mcp"],
      "timeout": 30000
    }
  }
}

Ver los logs de comunicación MCP:

claude --mcp-debug

Esto muestra el log completo de solicitudes y respuestas entre Claude y cada servidor MCP — la forma más rápida de diagnosticar problemas de conexión.

Las Tres Primitivas de MCP: Tools, Resources, Prompts

Si piensas que MCP es solo "funciones que Claude puede llamar," solo estás usando un tercio de su potencial. MCP tiene tres primitivas fundamentales:

1. Tools — Funciones que Claude puede ejecutar (ej: consultar base de datos, crear issue)
2. Resources — Fuentes de datos que Claude puede leer (ej: esquemas de BD, archivos de configuración, documentación)
3. Prompts — Plantillas de prompts predefinidas que el servidor ofrece (ej: "analyze-schema", "review-code")

La mayoría solo usa Tools. Resources y Prompts permiten una integración mucho más profunda.

Ejemplo de Resources: Un servidor MCP de Postgres puede exponer los esquemas de tablas como recursos, para que Claude siempre tenga información actualizada del esquema sin necesidad de ejecutar una consulta cada vez.

Ejemplo de Prompts: Un servidor MCP de revisión de código puede ofrecer una plantilla "security-review" que incluye automáticamente todas las verificaciones de seguridad necesarias.

Servidores MCP Populares de la Comunidad

Más allá de los servidores listados anteriormente, estos servidores de la comunidad son ampliamente usados en flujos de trabajo reales:

Consulta https://github.com/modelcontextprotocol/servers para ver el catálogo completo de la comunidad.

Al elegir servidores, prefiere los oficiales (@modelcontextprotocol o @anthropic) por seguridad.

Crear Servidores MCP con Python

El SDK de Python es una alternativa a TypeScript — y a menudo más simple para flujos de trabajo con muchos datos.

pip install mcp

Ejemplo: envolver una API interna.

from mcp.server import Server
from mcp.types import Tool, TextContent
import mcp.server.stdio
 
app = Server("internal-api")
 
@app.list_tools()
async def list_tools():
    return [
        Tool(
            name="search_docs",
            description="Search internal documentation",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Search query"}
                },
                "required": ["query"]
            }
        )
    ]
 
@app.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "search_docs":
        results = await internal_api.search(arguments["query"])
        return [TextContent(type="text", text=str(results))]
 
async def main():
    async with mcp.server.stdio.stdio_server() as (read, write):
        await app.run(read, write, app.create_initialization_options())

Regístralo en .mcp.json:

{
  "mcpServers": {
    "internal-api": {
      "command": "python",
      "args": ["-m", "my_mcp_server"]
    }
  }
}

Si te sientes cómodo con Python, puedes envolver una API interna en unos 30 minutos.

Estrategia de Composición de Servidores MCP

No agregues todos los servidores que encuentres — cada uno añade overhead de contexto. Elige una combinación que se ajuste a tu flujo de trabajo.

Desarrollo Full-Stack:

{
  "mcpServers": {
    "postgres": { "...": "DB queries and schema" },
    "github": { "...": "PR and issue management" },
    "context7": { "...": "Live library docs" }
  }
}

Ingeniería de Datos:

{
  "mcpServers": {
    "postgres": { "...": "Data warehouse queries" },
    "filesystem": { "...": "Multi-repo access" },
    "memory": { "...": "Cross-session context" }
  }
}

DevOps/SRE:

{
  "mcpServers": {
    "sentry": { "...": "Error monitoring" },
    "docker": { "...": "Container management" },
    "github": { "...": "Deployment workflows" }
  }
}

Regla general: 2-4 servidores es lo ideal. Más de 5 puede ralentizar el inicio y consumir contexto.

Consejos Pro

No sobre-conectes

Cada servidor MCP agrega overhead de contexto. Comienza con 2-3 esenciales y añade más según sea necesario.

Combina con CLAUDE.md — el panorama completo

Instalar servidores MCP es solo la mitad del trabajo. Sin instrucciones explícitas, Claude tiene que adivinar cuándo usar cada herramienta. Una política clara en CLAUDE.md hace que el comportamiento sea consistente:

## Reglas de Uso de Herramientas MCP
- Preguntas sobre esquemas de BD → consulta postgres MCP primero, nunca adivines
- Librerías externas → revisa context7 para docs actuales antes de implementar
- Crear/actualizar issues → usa GitHub MCP, sin llamadas manuales a la API
- Necesitas info de la web → usa brave-search MCP
- Documentación interna → busca en internal-wiki MCP

Con estas reglas, Claude consulta la base de datos cuando se le pregunta sobre la estructura de una tabla, en lugar de inventarse un esquema.