Model Context Protocol (MCP) con Claude: guía de implementación completa

El Model Context Protocol (MCP) es el nuevo estándar de Anthropic para conectar agentes Claude a tus herramientas, bases de datos y servicios empresariales. Lanzado oficialmente en junio de 2026 e integrado en Claude Sonnet 5, MCP permite a tus agentes de IA acceder directamente a tus datos sin pasar por integraciones falsas o bricolajes de API.

Si estás construyendo agentes de IA en 2026, MCP ya no es opcional, es la base. Aquí te mostramos cómo implementarlo.

¿Qué es realmente el model context protocol?

MCP no es una nueva API para llamar a Claude (ya tienes eso). Es un protocolo de interoperabilidad que define cómo una aplicación cliente (Claude, Cursor, Grok Build, o tu propia IA) se conecta a servidores MCP que exponen herramientas, recursos y datos.

Analogía: MCP es a Claude lo que los plugins son a un navegador. Excepto que es estándar, bidireccional y pensado para IA.

Componentes clave:

• Cliente MCP: Claude, tu agente de IA, o tu aplicación
• Servidor MCP: endpoint que expone herramientas y recursos
• Recursos: datos que el servidor pone a disposición (base de datos, archivos, API)
• Herramientas: funciones que el agente puede llamar para realizar una acción
• Prompts: plantillas reutilizables para guiar a Claude

Exactamente lo que hizo Simple Booking en junio de 2026, construyeron un servidor MCP que expone su sistema de reservas CRS, y ahora Claude puede consultar/modificar directamente las reservas hoteleras.

Arquitectura: cómo encaja todo

Antes de MCP, la arquitectura era caótica:

Claude (vía API)
    ↓ [prompt engineering manual]
    ↓ [tool_use call]
Aplicación -> [Parseas la respuesta] -> Integración personalizada
    ↓
Base de datos

Con MCP:

Claude (vía cliente MCP)
    ↓
Protocolo Cliente MCP (JSON-RPC estándar)
    ↓
Tu Servidor MCP
    ↓ [reconexión automática]
    ↓
Tus herramientas (funciones), recursos (datos), prompts

El agente Claude ahora puede:

• Interrogar tus recursos directamente: "¿Cuál es el número de pedidos pendientes?" -> Consulta MCP -> Tu base de datos
• Llamar tus herramientas atómicamente: "Crea una factura" -> Llamada herramienta MCP -> Tu lógica empresarial
• Reutilizar prompts optimizados: use_mcp_resource("contexto_facturacion") -> plantilla coherente en todos los agentes

Cómo implementar un servidor MCP mínimo

El protocolo MCP usa JSON-RPC 2.0 sobre stdio o HTTP. Aquí hay un servidor mínimo en Python que expone una base de datos PostgreSQL:

from MCP.server import Server
from MCP.types import Tool, Resource, TextContent
import asyncio
import psycopg2

app = Server("my-database-server")

# Declara un recurso: la lista de clientes
@app.resource("db://customers")
async def get_customers():
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute("SELECT id, name, email FROM customers LIMIT 100")
    rows = cur.fetchall()
    conn.close()
    
    return TextContent(
        type="text/plain",
        text="\n".join([f"ID: {r[0]}, Name: {r[1]}, Email: {r[2]}" for r in rows])
    )

# Declara una herramienta: crear un nuevo pedido
@app.tool("create_order")
async def create_order(customer_id: int, items: list, total: float):
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO orders (customer_id, items, total, status) VALUES (%s, %s, %s, %s)",
        (customer_id, str(items), total, "pending")
    )
    conn.commit()
    order_id = cur.lastrowid
    conn.close()
    
    return f"Order {order_id} created successfully"

if __name__ == "__main__":
    asyncio.run(app.run())

Son 30 líneas. Sin parseo manual, sin prompt engineering complicado. Claude ahora sabe que puede:

1. Llamar get_customers para ver los clientes
2. Llamar create_order(customer_id, items, total) para crear un pedido

Pero espera, hay una trampa. Expones directamente tu base de datos. ¿Y si Claude alucina un customer_id inválido? Necesitas agregar validación:

@app.tool("create_order")
async def create_order(customer_id: int, items: list, total: float):
    # Validación: ¿existe realmente el cliente?
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute("SELECT id FROM customers WHERE id = %s", (customer_id,))
    if not cur.fetchone():
        return f"Error: customer {customer_id} does not exist"
    
    # Continúa con la creación del pedido...

Limitación honesta: cuanto más expones funcionalidades vía MCP, más depender de Claude para tomar buenas decisiones. Un agente mal guiado aún puede causar daño. Necesitas:

• Rate limiting en herramientas peligrosas
• Logging y audit trails
• Prompts del sistema muy claros sobre restricciones empresariales
• Tests de caos para ver qué pasa si Claude llama a una herramienta con inputs extraños

Conectar claude sonnet 5 a tu servidor MCP

Una vez que tengas tu servidor MCP en su lugar, lo llamas vía el SDK de Claude. Claude Sonnet 5 (lanzado el 30 de junio de 2026) tiene soporte MCP nativo integrado.

from anthropic import Anthropic

client = Anthropic()

# Configura servidor MCP para esta sesión
mcp_config = {
    "servers": {
        "my_database": {
            "command": "python",
            "args": ["./mcp_server.py"],
            "env": {"DATABASE_URL": "postgresql://..."}
        }
    }
}

response = client.messages.create(
    model="claude-sonnet-5",  # Nuevo, salido 30 de junio de 2026
    max_tokens=2048,
    tools=[
        # Las herramientas MCP se descubren automáticamente de los servidores
    ],
    messages=[
        {
            "role": "user",
            "content": "Crea un pedido para el cliente #42: 2x producto A, 1x producto B. Total: 150€"
        }
    ]
)

# Claude ahora va a:
# 1. Parsear el mensaje del usuario
# 2. Verificar que tiene acceso a la herramienta "create_order" vía MCP
# 3. Llamar create_order(customer_id=42, items=[...], total=150)
# 4. Recibir la respuesta del servidor MCP
# 5. Continuar el diálogo

Claude Sonnet 5 también agrega agentic loops mejorados, puede llamar múltiples herramientas en secuencia sin volver a tu código cada vez. Útil para: "Obtén pedidos pendientes, crea facturas para cada uno, luego envía un email."

Casos de uso reales en producción

1. Integraciones hoteleras (Simple Booking, junio de 2026)

Simple Booking expone su sistema de reservas CRS vía MCP. Las agencias de viaje usan Claude para:

• "¿Qué suites están disponibles el 15 de agosto en el hotel de Lyon?" -> Claude consulta MCP -> respuesta en tiempo real
• "Reserva la suite 42 para los Dupont del 15 al 20 de agosto" -> Claude llama la herramienta de reserva

Antes de MCP, eran webhooks personalizados. Ahora: un servidor MCP estándar, y cualquier herramienta compatible con MCP puede usarlo sin reimplementar la integración.

2. Automatización de media buying (Nexxen, junio de 2026)

Nexxen expone sus parámetros de campaña, presupuestos y audiencias vía MCP. Las agencias construyen agentes Claude que:

• Analizan el rendimiento de campañas ("Nuestro CPM está bajando, ¿por qué?")
• Ajustan presupuestos automáticamente ("Asigna el 20% del presupuesto a la audiencia premium")
• Crean nuevas campañas basadas en briefs de texto

Antes: integración Zapier + scripts personalizados. Ahora: un servidor MCP, fin.

3. Tu caso de uso: gestión de contenido de e-commerce

Tienes una tienda Shopify o un sistema de productos personalizado. Construye un servidor MCP que exponga:

• Recurso: inventory/sku-123 -> número de existencias
• Recurso: products/all -> catálogo completo
• Herramienta: update_product_description(sku, new_desc) -> actualiza tu base
• Herramienta: create_bundle(products, discount) -> crea un bundle
• Prompt: contexto_refactorizacion_catalogo -> instrucciones para Claude al pedirle que retrabaje 100 fichas de producto

Ejemplo concreto: le dices a Claude "Lee todas las descripciones de producto y corrige faltas, mejora SEO, agrega dimensiones en cm". Claude:

1. Consulta products/all vía MCP
2. Analiza las 200 descripciones
3. Para cada producto, llama update_product_description(sku, new_desc)
4. Genera un reporte

Tiempo humano: 10 minutos de supervisión. Antes: un día completo para tu equipo.

Gestión de permisos y seguridad

Un riesgo mayor: si Claude tiene acceso a todas tus herramientas, podría llamar a una función peligrosa. Agrega controles:

1. Define el alcance de herramientas por caso de uso

# En lugar de exponer "delete_order" globalmente
@app.tool("delete_order", scopes=["admin_only"])
async def delete_order(order_id: int):
    # Requiere permiso especial
    pass

2. Rate limiting

from functools import wraps

def rate_limit(max_calls=10, period=60):
    def decorator(func):
        calls = []
        async def wrapper(*args, **kwargs):
            now = time.time()
            calls = [c for c in calls if c > now - period]
            if len(calls) >= max_calls:
                raise Exception("Rate limit exceeded")
            calls.append(now)
            return await func(*args, **kwargs)
        return wrapper
    return decorator

@app.tool("create_order")
@rate_limit(max_calls=50, period=3600)
async def create_order(...):
    pass

3. Logging exhaustivo

import logging

logger = logging.getLogger("mcp_audit")

@app.tool("delete_order")
async def delete_order(order_id: int):
    logger.warning(f"Claude called delete_order({order_id}) - action requires approval")
    # Opcional: pedir confirmación humana antes de eliminar
    return "Deletion queued for human approval"

Desplegar un servidor MCP en producción

Dos enfoques:

1. Stdio (para desarrollo rápido)

Tu servidor MCP se ejecuta como proceso hijo del cliente Claude. Simple, pero limitado para escalabilidad.

{
  "servers": {
    "my_server": {
      "command": "python",
      "args": ["./mcp_server.py"]
    }
  }
}

2. HTTP con autenticación (para producción)

{
  "servers": {
    "my_server": {
      "url": "HTTPS://MCP.mycompany.com",
      "auth": {
        "type": "bearer",
        "token": "sk_live_..."
      }
    }
  }
}

Tu servidor MCP escucha en un endpoint HTTPS seguro, con certificados SSL y rate limiting en la gateway.

Despliegue recomendado:

• Servidor MCP: Docker en ECS/K8s, detrás de un load balancer
• Base de datos: PostgreSQL o MongoDB, estrictamente en VPC privada
• Monitoreo: CloudWatch, logs JSON estructurados, alertas en errores
• Versionado: versioniza tus recursos y herramientas MCP (ej: /API/v1/resources)

{
  "servers": {
    "database": { "command": "python", "args": ["./db_mcp.py"] },
    "email": { "command": "node", "args": ["./email_mcp.js"] },
    "shopify": { "url": "HTTPS://MCP.shopify.com" }
  }
}

Conclusión

El Model Context Protocol resuelve un problema real: antes de 2026, cada integración de agente IA era una personalización one-shot. Ahora es estándar.

Tres puntos clave a recordar:

1. MCP es el nuevo estándar para agentes IA en 2026, reemplaza los bricolajes de API personalizados
2. Implementar un servidor MCP es simple, 50 líneas de código para exponer tus herramientas y datos
3. Claude Sonnet 5 tiene el mejor soporte MCP nativo, si construyes un agente hoy, es el modelo adecuado

¿Construyes un agente de IA para tu negocio? Comienza por exponer tus datos y herramientas críticas vía MCP. Luego conéctalas a Claude Sonnet 5. En una semana, automatizas lo que tomaba un día antes.

¿Necesitas ayuda para implementar MCP en tu empresa? Podemos auditar tu arquitectura actual y proponerte un plan de integración. Contáctanos.