Servidores MCP: Conectando AI a Tus Herramientas y Datos

¿Qué es MCP?

El Protocolo de Contexto de Modelo (MCP) es un estándar abierto creado por Anthropic que define cómo las aplicaciones AI se comunican con herramientas y fuentes de datos externas. Pensalo como una capa de adaptador universal: en vez de que cada agente AI construya integraciones personalizadas para cada servicio, MCP provee una interfaz estandarizada que cualquier cliente AI puede usar para conectarse a cualquier servidor compatible con MCP. La especificación del protocolo es open-source y vendor-neutral, lo que significa que cualquier modelo AI o plataforma puede implementarla.

MCP sigue una arquitectura cliente-servidor. El cliente es la aplicación AI (Claude Code, Claude Desktop, o un agente personalizado construido con el Claude Agent SDK). El servidor es un proceso liviano que expone capacidades específicas -- herramientas (funciones ejecutables), recursos (referencias a datos) y prompts (templates reutilizables). Cuando un agente AI necesita interactuar con un servicio, descubre los servidores MCP disponibles, consulta sus capacidades y llama a sus herramientas a través del protocolo estandarizado. Un solo cliente puede conectarse a muchos servidores simultáneamente, y un solo servidor puede servir a múltiples clientes.

El protocolo soporta tres modos de transporte: Stdio (entrada/salida estándar para procesos locales -- más rápido y simple, ideal para servidores en la misma máquina), SSE (Server-Sent Events -- deprecado, reemplazado por Streamable HTTP; SSE requería pasar tokens de auth en query strings de URL, un anti-patrón de seguridad) y Streamable HTTP (el transporte más nuevo soportando streaming bidireccional completo vía un solo endpoint con auth basada en headers -- mejor para operaciones de larga duración y servidores remotos que necesitan enviar actualizaciones). Los servidores MCP se pueden escribir en cualquier lenguaje, con SDKs oficiales para Python y TypeScript.

Cómo Lo Uso

Mi stack MCP es el tejido conectivo entre Claude Code y cada servicio con el que trabajo diariamente. El servidor Atlassian Rovo es el más usado -- permite a Claude Code leer tickets JIRA, actualizar estados de issues, agregar comentarios, buscar en Confluence y crear páginas. Cuando estoy trabajando en un feature, Claude Code lee la historia JIRA, entiende los criterios de aceptación, implementa el código y actualiza el estado del ticket, todo sin salir del terminal.

Los servidores MCP de Firebase y Supabase manejan interacciones de base de datos para diferentes proyectos. Claude Code puede inspeccionar esquemas, escribir consultas, verificar integridad de datos e incluso sugerir optimizaciones de índices analizando patrones de consulta.

Los servidores MCP de GitHub y GitLab automatizan mi flujo de revisión de código. Cuando un PR está listo, Claude Code lee el diff a través del servidor MCP, analiza cambios contra convenciones del proyecto (de CLAUDE.md) y publica comentarios de revisión estructurados.

Ejecuto el servidor MCP de Slack para coordinación de equipo. Claude Code puede leer historial de canales relevantes, buscar decisiones pasadas y publicar actualizaciones de estado. Combinado con el MCP de Stripe para proyectos de pagos, tengo un conjunto de herramientas completo que cubre el ciclo de vida completo de desarrollo.

Primeros Pasos

Agregar un servidor MCP a Claude Code toma solo unas pocas líneas de configuración. Los servidores se definen en archivos de configuración o .mcp.json y se inician automáticamente cuando Claude Code arranca. Las variables de entorno usan la sintaxis ${VAR_NAME} para inyección segura de credenciales.

// .mcp.json - Project MCP configuration (committed to repo)
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    },
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}

Instala y prueba un servidor manualmente antes de agregarlo a tu configuración. Usa los comandos /mcp para gestionar servidores en tiempo de ejecución.

# Test a server locally
npx -y @modelcontextprotocol/server-github

# Add a server via Claude Code CLI
/mcp add github npx -y @modelcontextprotocol/server-github

# Check status of all connected servers
/mcp status

# Remove a server
/mcp remove github

# Restart Claude Code to pick up config changes
# Or use /mcp to hot-reload individual servers

Construye tu primer servidor MCP personalizado usando el SDK de TypeScript. Un servidor mínimo que expone una sola herramienta toma unas 30 líneas de código.

// my-server.ts - Custom MCP server (TypeScript)
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from
  "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server({
  name: "my-tools",
  version: "1.0.0"
}, {
  capabilities: { tools: {} }
});

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "greet",
    description: "Generate a greeting",
    inputSchema: {
      type: "object",
      properties: {
        name: { type: "string", description: "Name to greet" }
      },
      required: ["name"]
    }
  }]
}));

server.setRequestHandler("tools/call", async (req) => {
  if (req.params.name === "greet") {
    const name = req.params.arguments.name;
    return {
      content: [{ type: "text", text: `Hello, ${name}!` }]
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

Acá está el servidor equivalente usando el SDK de Python con la API de alto nivel FastMCP.

# my_server.py - Custom MCP server (Python)
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-tools")

@mcp.tool()
def greet(name: str) -> str:
    """Generate a greeting for the given name."""
    return f"Hello, {name}!"

@mcp.tool()
def calculate_age(birth_year: int) -> str:
    """Calculate age from birth year."""
    from datetime import datetime
    age = datetime.now().year - birth_year
    return f"Approximately {age} years old"

@mcp.resource("config://app")
def get_config() -> str:
    """Expose application config as a resource."""
    import json
    return json.dumps({
        "version": "1.0.0",
        "environment": "production"
    })

if __name__ == "__main__":
    mcp.run()

Técnicas Avanzadas

Orquestación Multi-Servidor

Conecta múltiples servidores MCP y deja que el agente AI componga llamadas de herramientas entre ellos. Un patrón común: leer un ticket JIRA, verificar la rama Git relacionada, consultar la base de datos y publicar un resumen en Slack -- todo dentro de un solo ciclo de razonamiento.

// Example: .mcp.json with multi-server stack
{
  "mcpServers": {
    "atlassian": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-atlassian-rovo"],
      "env": {
        "ATLASSIAN_TOKEN": "${ATLASSIAN_TOKEN}",
        "ATLASSIAN_SITE": "mycompany.atlassian.net"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": { "GITHUB_TOKEN": "${GITHUB_TOKEN}" }
    },
    "slack": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-slack"],
      "env": { "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}" }
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "${DATABASE_URL}" }
    }
  }
}

Servidores Remotos Basados en HTTP

Despliega servidores MCP en máquinas remotas para acceso a nivel de equipo. Usa transporte SSE o Streamable HTTP en vez de Stdio. Los servidores remotos soportan headers de autenticación, TLS y balanceo de carga. Ideal para acceso centralizado a bases de datos, gateways de API compartidos o herramientas de cómputo intensivo.

// Remote server configuration via Streamable HTTP
{
  "mcpServers": {
    "company-tools": {
      "type": "streamable-http",
      "url": "https://mcp.internal.company.com/tools",
      "headers": {
        "Authorization": "Bearer ${MCP_AUTH_TOKEN}"
      }
    },
    "analytics": {
      "type": "sse",
      "url": "https://analytics-mcp.company.com/sse",
      "headers": {
        "X-API-Key": "${ANALYTICS_KEY}"
      }
    }
  }
}

Construcción de Servidores con Estado

Los servidores MCP pueden mantener estado entre llamadas de herramientas. Usa esto para connection pooling, gestión de sesiones, caching y coordinación de transacciones.

Implementación de Flujo OAuth

Para servicios que requieren OAuth 2.0, implementa el flujo de autorización dentro de tu servidor MCP. Maneja el refresh de tokens transparentemente para mantener acceso ininterrumpido. Para despliegues empresariales, integra con proveedores de identidad como Okta o Azure AD.

Selección de Herramientas Consciente del Contexto (Carga Diferida)

Cuando corres 10+ servidores MCP simultáneamente, usa ToolSearch para diferir la carga de herramientas. Los servidores registran herramientas solo con nombres; los esquemas completos se obtienen cuando el agente realmente los necesita, manteniendo el contexto activo liviano.

Gobernanza Empresarial: Allowlists y Denylists

Las organizaciones pueden aplicar políticas de servidores MCP a través de configuraciones gestionadas. Los allowlists restringen a servidores aprobados. Los denylists bloquean servidores riesgosos. Se aplican a nivel empresarial. Los logs de auditoría capturan cada conexión e invocación de herramientas.

MCP Apps: UI Interactiva en Conversaciones AI

MCP Apps es la primera extensión oficial de MCP, lanzada como GA en enero 2026. Permite a las herramientas MCP devolver componentes de UI interactivos -- dashboards, formularios, visualizaciones, gráficos y workflows multi-paso -- que se renderizan directamente dentro de la conversación AI. En vez de que las herramientas devuelvan solo texto, ahora pueden apuntar a UIs web ricas e interactivas con las que los usuarios interactúan inline.

La arquitectura introduce un esquema URI ui:// para recursos de UI. Cuando una herramienta incluye un campo _meta.ui.resourceUri en su respuesta, el cliente host (Claude Code, Claude Desktop, VS Code, etc.) obtiene el recurso de UI referenciado y lo renderiza en un iframe sandboxeado. La UI y el host se comunican vía JSON-RPC 2.0 sobre la API postMessage, permitiendo a la app solicitar llamadas de herramientas, enviar mensajes, actualizar el contexto del modelo y recibir datos del host.

MCP Apps difiere de las herramientas MCP regulares de manera fundamental: las herramientas regulares devuelven datos estructurados (texto, JSON) que la AI interpreta y presenta como texto. MCP Apps devuelve punteros a UIs interactivas que el usuario puede manipular directamente -- clickeando botones, llenando formularios, rotando modelos 3D, moviendo mapas o editando hojas de cálculo. La AI sigue orquestando llamadas de herramientas, pero la experiencia de usuario se vuelve visual e interactiva en vez de puramente conversacional.

Casos de Uso

Cómo Funciona: Herramienta con Recurso de UI

// MCP server exposing a tool with an MCP App UI
server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "show_dashboard",
    description: "Display an interactive metrics dashboard",
    inputSchema: {
      type: "object",
      properties: {
        metric: { type: "string", description: "Metric to display" }
      }
    }
  }]
}));

server.setRequestHandler("tools/call", async (req) => {
  if (req.params.name === "show_dashboard") {
    return {
      content: [{ type: "text", text: "Dashboard ready." }],
      _meta: {
        ui: { resourceUri: "ui://my-server/dashboard" }
      }
    };
  }
});

// The UI resource (served via ui:// scheme) contains
// bundled HTML/JS that renders in a sandboxed iframe.
// The app communicates with the host via JSON-RPC 2.0
// over postMessage for tool calls and context updates.

Todo el contenido de UI corre en iframes sandboxeados con permisos restringidos. El iframe no puede acceder a la ventana padre ni hacer requests de red arbitrarios. Toda la comunicación entre la UI y el host pasa por mensajes JSON-RPC logueables, asegurando seguridad y auditabilidad.

MCP Server Cards

Los MCP Server Cards son un estándar para exponer metadata estructurada del servidor vía una URL .well-known/mcp.json. Cuando un navegador, crawler o registro MCP visita un dominio, puede descubrir servidores MCP disponibles, sus capacidades, endpoints de transporte y requisitos de autenticación desde una sola URL well-known. Esto habilita descubrimiento automatizado de servidores, indexación de registros e integración de clientes MCP basada en navegador sin configuración manual.

Un Server Card incluye el nombre del servidor, descripción, versión, lista de herramientas con descripciones, modos de transporte soportados, requisitos de autenticación e información de contacto. Las organizaciones pueden publicar Server Cards para sus servidores MCP internos, haciéndolos descubribles por cualquier cliente compatible. Este es el equivalente MCP de las especificaciones OpenAPI para APIs REST.

Elicitación

La elicitación permite a los servidores MCP solicitar entrada estructurada del usuario a mitad de tarea vía diálogos interactivos. Cuando un servidor necesita información adicional para completar una llamada de herramienta -- una confirmación, una elección de un conjunto de opciones o entrada libre -- puede enviar una solicitud de elicitación de vuelta al cliente. El cliente renderiza la UI apropiada (un diálogo de confirmación, dropdown, campo de texto o formulario) y retorna la respuesta del usuario al servidor.

Esto habilita workflows multi-paso donde el servidor dirige la interacción: una herramienta de deployment puede preguntar "¿Desplegar a staging o producción?", una herramienta de base de datos puede solicitar confirmación antes de operaciones destructivas, y una herramienta de llenado de formularios puede recolectar datos estructurados campo por campo. La elicitación hace que los servidores MCP sean interactivos en vez de puramente request-response, habilitando automatización human-in-the-loop más rica.

Especificación MCP v2.1 y Hoja de Ruta 2026

La especificación MCP v2.1 (marzo 2026) introduce indicadores de recurso compatibles con RFC 8707 para prevenir ataques de redención errónea de tokens -- una mejora crítica de seguridad para servidores autenticados con OAuth. Esto exige que los servidores de autorización validen para qué recurso específico se emitió un token, previniendo que tokens emitidos para un servidor MCP se usen en otro.

La hoja de ruta 2026 se organiza en cuatro áreas prioritarias impulsadas por Working Groups y Spec Enhancement Proposals (SEPs): (1) Evolución de Transporte -- evolucionar Streamable HTTP para correr sin estado en múltiples instancias de servidor detrás de load balancers; (2) Comunicación entre Agentes -- cerrar brechas de ciclo de vida en el primitivo Tasks (semánticas de reintento, políticas de expiración); (3) Maduración de Gobernanza -- Working Groups e Interest Groups como vehículo principal para desarrollo del protocolo; (4) Preparación Enterprise -- audit trails, auth integrada con SSO, comportamiento de gateway y portabilidad de configuración.

Los Server Cards ahora son parte de la especificación v2.1, estandarizados como URL .well-known para descubrimiento automatizado. Benchmarks de producción muestran servidores MCP manejando más de 10,000 conexiones concurrentes con tiempos de respuesta sub-50ms bajo cargas típicas.

La estructura de gobernanza sigue madurando con nombramientos clave de liderazgo. El 8 de abril de 2026, Den Delimarsky (Anthropic) se unió como Lead Maintainer y Clare Liguori (AWS) como Core Maintainer, complementando a Peter Alexander (Anthropic) quien se unió como maintainer en enero 2026. Este equipo de maintainers multi-organización asegura que el protocolo evolucione con input tanto de los creadores originales como de los principales adoptantes, reforzando el modelo de gobernanza vendor-neutral de MCP.

Las prioridades de la hoja de ruta 2026 se están refinando a través de Working Groups activos: escalabilidad de transporte (correr Streamable HTTP sin estado detrás de load balancers con afinidad de sesión), comunicación y composabilidad de agentes (permitir que servidores MCP llamen a otros servidores MCP, creando cadenas de herramientas componibles), formalización de gobernanza (Working Groups e Interest Groups como vehículo canónico para cambios en la spec), y preparación enterprise (logging de auditoría, OAuth integrado con SSO y portabilidad de configuración entre ambientes).

El release candidate de la próxima especificación, MCP 2026-07-28, se publicó el 21 de mayo de 2026, y la especificación final se lanza el 28 de julio de 2026. Es la revisión más grande desde el lanzamiento: un núcleo de protocolo sin estado elimina por completo el handshake de inicialización y el header de sesión, de modo que los servidores remotos corren detrás de balanceadores de carga round-robin simples y los clientes pueden cachear las respuestas de tools/list. Las extensiones se vuelven de primera clase -- MCP Apps (UIs renderizadas por el servidor) y Tasks (trabajo de larga duración) se publican como extensiones oficiales -- junto con endurecimiento de la autorización alineado con OAuth y OpenID Connect, soporte completo de JSON Schema 2020-12 para herramientas, y una política formal de deprecación (roots, sampling y logging quedan deprecados). El proceso de revisión comunitaria se lleva a cabo en el repositorio abierto de GitHub, donde cualquier implementador puede enviar feedback sobre las Spec Enhancement Proposals (SEPs) antes de su ratificación.