Ir al contenido principal
Español— Elegir un idioma
Menú

Despliegue de un servidor MCP en producción

Lección 12 de 14 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Del prototipo al servidor de producción
  2. Opción 1: Hugging Face Spaces
  3. Opción 2: Docker
  4. Opciones 3 y 4: Despliegues gestionados
  5. Asegurar el despliegue
  6. Ver qué está ocurriendo
  7. Puntos clave

Actualización 2 de noviembre de 2026 — Le Chat pasa a llamarse Vibe. Desde el 28 de mayo de 2026, Le Chat se ha renombrado como Vibe (sigue disponible en chat.mistral.ai): un único agente para trabajo y código que conserva tus conversaciones, configuraciones y suscripciones. La experiencia heredada de Le Chat sigue accesible en el modo Chat; en el modo Work, los agentes son ahora habilidades (se invocan con @), las memorias forman la base de conocimientos y la investigación profunda es la habilidad Deep Research. Los planes se llaman ahora Mistral Free, Pro, Team y Enterprise. Esta lección utiliza el nombre Vibe; es posible que algunos menús descritos aquí hayan cambiado de nombre o ubicación.

Actualización 2 de noviembre de 2026 — MCP Python SDK v2. Este curso sigue ahora la versión 2 del SDK mcp (2.3.0 a fecha de 2 de octubre de 2026): MCPServer reemplaza a FastMCP, la configuración del transporte se traslada a run() o streamable_http_app(), y una aplicación expuesta bajo un nombre de host real debe declarar dicho nombre de host (transport_security). Esta es también la versión requerida por el SDK de Mistral: el extra mistralai[agents] requiere mcp>=2.2.0,<3.0. Fuentes: Novedades en v2 · Guía de migración · Despliegue y escalado.

Del prototipo al servidor de producción

Tu servidor funciona en local y ngrok lo expone al mundo solo para una demostración. El problema surge cuando otra persona necesita usarlo: cierras el terminal, la URL deja de funcionar y se rompen todos los conectores que configuraron tus compañeros. Llevarlo a producción significa, esencialmente, obtener una dirección estable, disponible 24/7 y servida sobre HTTPS. Cuatro opciones te permiten lograrlo, desde la más rápida hasta la que ofrece mayor control. Tu elección depende principalmente de la sensibilidad de tus datos y del grado de control que quieras tener sobre la infraestructura.

Opción 1: Hugging Face Spaces

Hugging Face Spaces ofrece máquinas virtuales gratuitas sin GPU, más que suficientes para un servidor MCP que reenvía llamadas a API. Esta es la vía más rápida para un despliegue real: tres archivos y un git push.

mon-mcp-space/
├── app.py              # FastAPI + servidor MCP
├── requirements.txt    # Dependencias
└── README.md           # Metadatos del Space

El archivo app.py sigue exactamente la estructura que has visto hasta ahora, salvo que los valores sensibles se leen del entorno; HF Secrets los inyecta allí:

# app.py
"""Servidor MCP desplegado en Hugging Face Spaces."""

import os
from contextlib import asynccontextmanager

from fastapi import FastAPI
from mcp.server.mcpserver import MCPServer
from mcp.server.transport_security import TransportSecuritySettings

mcp = MCPServer("My Production Server")

@mcp.tool()
def hello(name: str) -> str:
    """Saluda a una persona.

    Args:
        name: El nombre de pila de la persona

    Returns:
        Mensaje de saludo
    """
    return f"¡Hola {name} desde Hugging Face Spaces!"

@asynccontextmanager
async def lifespan(app: FastAPI):
    async with mcp.session_manager.run():
        yield

# Nombre de host del Space, con formato <usuario>-<space>.hf.space
SPACE_HOST = os.environ.get("MCP_PUBLIC_HOST", "localhost")
security = TransportSecuritySettings(allowed_hosts=[SPACE_HOST, f"{SPACE_HOST}:*"])

api = FastAPI(lifespan=lifespan)
api.mount("/mcp-endpoint", mcp.streamable_http_app(transport_security=security))

# Para variables sensibles, usa HF Secrets
API_KEY = os.environ.get("MY_API_KEY", "")

La peculiaridad de la plataforma reside en el README, cuya cabecera YAML dirige la construcción del Space. El campo app_port debe coincidir con el puerto en el que escucha realmente tu servidor; de lo contrario, el despliegue tendrá éxito pero permanecerá inaccesible:

---
title: My MCP Server
emoji: 🔧
colorFrom: blue
colorTo: green
sdk: docker
app_port: 7860
---
# Crea un Space en huggingface.co
# Sube el código
git push
# El Space se despliega automáticamente

Tu endpoint pasa a ser entonces https://your-username-mon-mcp-space.hf.space/mcp-endpoint/mcp, servido sobre HTTPS. Queda un paso de configuración: declara este nombre de host, your-username-mon-mcp-space.hf.space, en la variable MCP_PUBLIC_HOST dentro de la configuración del Space. Sin ello, el SDK rechazará todas las solicitudes con un error 421 Invalid Host header.

Opción 2: Docker

En cuanto el servidor toca datos internos, alojarlo en tu propia infraestructura se convierte en la norma, y Docker es el formato estándar. El Dockerfile requiere apenas unas pocas instrucciones, colocando la instalación de dependencias antes de copiar el código para aprovechar el almacenamiento en caché de capas durante las reconstrucciones:

FROM python:3.12-slim

WORKDIR /app

# Instalar dependencias
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar código
COPY . .

# Exponer puerto
EXPOSE 8000

# Iniciar servidor
CMD ["uvicorn", "server:api", "--host", "0.0.0.0", "--port", "8000"]
fastapi>=0.115.0
uvicorn>=0.30.0
mcp>=2.2,<3
httpx>=0.27.0   # solo si tus herramientas lo usan: el SDK v2 ya no lo instala

En el arranque, la opción --restart unless-stopped es lo que distingue un despliegue de producción de una prueba sencilla: sin ella, el primer fallo dejará tu servidor fuera de línea hasta que alguien se dé cuenta.

# Construir la imagen
docker build -t mon-mcp-server .

# Ejecutar el contenedor
docker run -d \
  --name mcp-server \
  -p 8000:8000 \
  -e MY_API_KEY="secret" \
  -e DATABASE_URL="postgresql://..." \
  --restart unless-stopped \
  mon-mcp-server

Docker Compose hace reproducible esta configuración y añade una comprobación de estado (health check), que el orquestador utiliza para detectar un servidor bloqueado: un proceso activo que ya no responde es un escenario que los reinicios automáticos simples no cubren:

# docker-compose.yml
version: "3.8"
services:
  mcp-server:
    build: .
    ports:
      - "8000:8000"
    environment:
      - MY_API_KEY=${MY_API_KEY}
      - DATABASE_URL=${DATABASE_URL}
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/"]
      interval: 30s
      retries: 3

Opciones 3 y 4: Despliegues gestionados

Prefect Horizon (anteriormente FastMCP Cloud), la plataforma del equipo detrás del framework independiente FastMCP, elimina el paso de la infraestructura: te registras en horizon.prefect.io con tu cuenta de GitHub, eliges el repositorio y el archivo del servidor, y la plataforma construye y publica una URL con autenticación integrada. Está orientada a servidores escritos con ese framework (pip install fastmcp, from fastmcp import FastMCP), que es distinto del SDK oficial utilizado en este curso; existe un nivel gratuito para proyectos personales.

Cloudflare Workers apunta a un perfil de uso diferente: serverless, con ejecución lo más cerca posible del usuario y, por tanto, latencia reducida. Una plantilla dedicada pone en marcha el proyecto:

# Usa la plantilla MCP de Cloudflare
npm create cloudflare@latest -- remote-mcp-server-authless --template=cloudflare/ai/demos/remote-mcp-authless

Ambas opciones te ahorran gestionar certificados y reinicios, a cambio de dependencia de la plataforma y restricciones de ejecución: un Worker serverless, por ejemplo, no encaja bien con un servidor con estado.

Asegurar el despliegue

HTTPS no es negociable: Vibe rechaza endpoints en texto plano, y un token que viaja sobre HTTP es un token comprometido. Tres caminos llevan hasta allí dependiendo de tu alojamiento. Un proxy inverso como Nginx o Caddy colocado delante de tu servidor, con un certificado de Let’s Encrypt, cubre el caso del servidor dedicado. Las plataformas nativas de la nube (Hugging Face, Cloudflare y la mayoría de proveedores PaaS) proporcionan HTTPS automáticamente. Un túnel, como Cloudflare Tunnel, expone un servidor que permanece en tu red interna sin abrir puertos.

Ningún secreto debe aparecer en el código. Observa la distinción entre las dos sintaxis siguientes: os.environ["MCP_API_TOKEN"] hace fallar el arranque si falta la variable, lo cual es exactamente el comportamiento deseado para un secreto obligatorio, mientras que os.environ.get() tolera la ausencia para valores opcionales.

import os

# Configuración mediante variables de entorno
API_TOKEN = os.environ["MCP_API_TOKEN"]       # Obligatorio
DATABASE_URL = os.environ.get("DATABASE_URL")  # Opcional
DEBUG = os.environ.get("DEBUG", "false") == "true"

Un servidor público sin limitación de tasa acabará saturándose, voluntariamente o no. Un limitador basado en IP suele bastar en la mayoría de los casos:

from fastapi import FastAPI, Request
from slowapi import Limiter, _rate_limit_exceeded_handler

limiter = Limiter(key_func=lambda request: request.client.host)
api = FastAPI()
api.state.limiter = limiter

@api.middleware("http")
async def rate_limit(request: Request, call_next):
    # 100 solicitudes por minuto por IP
    ...

Ver qué está ocurriendo

En producción ya no tienes el terminal delante, y una herramienta que falla una de cada diez veces solo puede diagnosticarse con trazas. Como mínimo, instrumenta la entrada, la salida y la duración de cada llamada:

import logging
import time

logger = logging.getLogger("mcp-server")

@mcp.tool()
async def my_tool(param: str) -> str:
    """Mi herramienta con registro."""
    start = time.time()
    logger.info(f"Herramienta llamada con param={param}")

    try:
        result = await process(param)
        duration = time.time() - start
        logger.info(f"Herramienta finalizada en {duration:.2f}s")
        return result
    except Exception as e:
        logger.error(f"Error en la herramienta: {e}")
        raise

Medir la duración no es un lujo: una herramienta que tarda doce segundos en responder provoca tiempos de espera agotados (timeouts) en el cliente y da la impresión de un servidor roto cuando en realidad funciona. Antes de anunciar tu servidor, revisa los siguientes seis puntos de configuración.

  • HTTPS activo y certificado válido
  • Variables de entorno para todos los secretos
  • Registro estructurado habilitado
  • Endpoint de comprobación de estado (/ o /health)
  • Reinicio automático ante fallos
  • Limitación de tasa configurada

Quedan dos comprobaciones, las que la gente suele omitir con más frecuencia pero que revelan los problemas reales: una prueba con MCP Inspector lanzado desde fuera, y luego una prueba desde Mistral Vibe. Un servidor que responde perfectamente desde tu máquina puede quedar bloqueado por un firewall o una configuración CORS en cuanto se le llama desde otro lugar.

Puntos clave

  • Hugging Face Spaces: lo más rápido, gratuito, ideal para empezar
  • Docker: control total, adecuado para servidores dedicados y nube
  • Prefect Horizon (ex-FastMCP Cloud): despliegue desde GitHub, para servidores escritos con el framework FastMCP
  • Cloudflare Workers: serverless, baja latencia, escalable
  • Asegura con HTTPS, variables de entorno y limitación de tasa
  • Añade monitorización y registros para la depuración en producción