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

Configurar un servidor SSE remoto

Lección 7 de 14 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. De local a remoto
  2. El servidor apenas cambia
  3. Obtener una URL pública con ngrok
  4. Conectar un cliente Python
  5. Múltiples servidores en un único host
  6. 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 en chat.mistral.ai): un único agente para trabajo y código que conserva tus conversaciones, ajustes y suscripciones. La experiencia heredada de Le Chat sigue disponible en el modo Chat; en el modo Work, los agentes son ahora habilidades (se invocan con @), las memorias actúan como base de conocimientos y la búsqueda profunda es la habilidad Deep Research. Los planes se llaman ahora Mistral Free, Pro, Team y Enterprise. Esta lección usa el nombre Vibe; algunos menús descritos aquí pueden haber cambiado de nombre o ubicación. Addendum 3 de noviembre: los resultados de run_async se leen desde result.output_as_text; el SDK mistralai 3.7.0 no tiene un atributo output.

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 mueve 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.

De local a remoto

Hasta ahora, tu servidor MCP ha residido en tu máquina, comunicándose mediante STDIO. Este modo es ideal para el desarrollo, pero aísla tu trabajo: nadie más puede usarlo y Vibe de Mistral nunca podrá lanzar un proceso en tu máquina local. Para cruzar esta frontera, debes exponer el servidor a través de HTTP.

El cambio es más ligero de lo que podrías pensar. Un servidor MCP remoto publica sus herramientas en una URL; el cliente (Vibe, un SDK o un IDE) se conecta a través de la red en lugar de generar un proceso. El código de tus herramientas permanece intacto.

El servidor apenas cambia

MCPServer admite el transporte HTTP transmitible (Streamable HTTP) de forma nativa. El archivo siguiente está escrito exactamente igual que un servidor local: mismos decoradores, mismos docstrings, mismas firmas tipadas.

# remote_server.py
"""Servidor MCP remoto con transporte HTTP."""

from mcp.server.mcpserver import MCPServer

# El servidor es el mismo que en local
app = MCPServer("Remote Demo Server")

@app.tool()
def analyze_text(text: str, language: str = "fr") -> str:
    """Analiza texto y devuelve estadísticas.

    Args:
        text: El texto a analizar
        language: Código de idioma (fr, en, es). Predeterminado: fr

    Returns:
        Estadísticas del texto: recuento de palabras, caracteres y oraciones
    """
    words = len(text.split())
    chars = len(text)
    sentences = text.count(".") + text.count("!") + text.count("?")
    return (
        f"Language: {language}\n"
        f"Words: {words}\n"
        f"Characters: {chars}\n"
        f"Sentences: {sentences}"
    )

@app.tool()
def summarize_key_points(text: str, max_points: int = 5) -> str:
    """Extrae puntos clave del texto (versión simplificada).

    Args:
        text: El texto de origen
        max_points: Número máximo de puntos a extraer (1-10)

    Returns:
        Lista de puntos clave identificados
    """
    sentences = [s.strip() for s in text.split(".") if len(s.strip()) > 20]
    points = sentences[:max_points]
    return "\n".join(f"- {p}" for p in points) if points else "No key points identified."

El único cambio es un bloque de lanzamiento añadido al final del archivo: transporte HTTP, puerto y la lista de nombres de host que el servidor acepta.

import os
from mcp.server.transport_security import TransportSecuritySettings

if __name__ == "__main__":
    # Nombre de host público, p. ej., el que te asigna ngrok (sin https://)
    public_host = os.environ.get("MCP_PUBLIC_HOST")
    hosts = ["localhost:*", "127.0.0.1:*"]
    if public_host:
        hosts += [public_host, f"{public_host}:*"]
    app.run(
        transport="streamable-http",
        port=8000,
        transport_security=TransportSecuritySettings(allowed_hosts=hosts),
    )
python remote_server.py

Tu servidor escucha ahora en http://localhost:8000/mcp. La lista allowed_hosts no es un detalle menor: por defecto, el SDK v2 solo acepta peticiones dirigidas a localhost o 127.0.0.1, una protección contra el DNS rebinding. Detrás de un túnel o un nombre de dominio real, cualquier otra petición recibe un error 421 Invalid Host header, que el cliente muestra como un error genérico de transporte; solo el registro del servidor revela la razón.

Obtener una URL pública con ngrok

Para probar tu servidor desde Vibe sin un despliegue completo, ngrok crea un túnel entre una URL pública y tu puerto local. Esta herramienta acorta el ciclo de desarrollo más que ninguna otra: modificas una herramienta, reinicias y el conector remoto ve la nueva versión de inmediato.

# Instala el agente ngrok desde https://ngrok.com/download y luego autentícate (una sola vez)
ngrok config add-authtoken YOUR_NGROK_TOKEN

# Expón el puerto 8000
ngrok http 8000

ngrok te asigna una dirección como https://abc123.ngrok-free.app. Reinicia el servidor declarando este nombre de host (MCP_PUBLIC_HOST=abc123.ngrok-free.app python remote_server.py). Tu punto final de MCP se convierte en este, simplemente añadiendo la ruta /mcp:

https://abc123.ngrok-free.app/mcp

Añade esta URL tal cual a Mistral Vibe como un conector personalizado. Recuerda que es temporal y expone tu máquina: no dejes un túnel abierto en un servidor que toque datos reales.

Conectar un cliente Python

En el lado del cliente, la estructura del código sigue siendo la misma que en la lección de RunContext. Solo cambia la clase de conexión: MCPClientStreamableHTTP con StreamableHTTPServerParams reemplaza al par STDIO, y proporcionas una URL en lugar de un comando.

# remote_client.py
import asyncio
from mistralai.client import Mistral
from mistralai.extra.run.context import RunContext
from mistralai.extra.mcp.streamable_http import (
    MCPClientStreamableHTTP,
    StreamableHTTPServerParams,
)

async def main():
    client = Mistral(api_key="YOUR_API_KEY")

    agent = client.beta.agents.create(
        model="mistral-medium-latest",
        name="remote-assistant",
        instructions="Usas herramientas remotas para analizar texto.",
    )

    # Conectar al servidor remoto
    server_url = "https://abc123.ngrok-free.app/mcp"
    mcp_client = MCPClientStreamableHTTP(
        params=StreamableHTTPServerParams(
            url=server_url,
            timeout=100,  # Tiempo de espera en segundos
        )
    )

    async with RunContext(
        agent_id=agent.id,
        continue_on_fn_error=True,
    ) as run_ctx:
        await run_ctx.register_mcp_client(mcp_client=mcp_client)

        result = await client.beta.conversations.run_async(
            run_ctx=run_ctx,
            inputs="Analiza este texto: MCP es un protocolo abierto.",
        )
        print(result.output_as_text)

asyncio.run(main())

El parámetro timeout merece una reflexión. Con STDIO, las llamadas eran casi instantáneas; a través de la red, una herramienta que consulta una API de terceros o procesa un documento grande puede tardar varias decenas de segundos. Un tiempo de espera demasiado corto se manifiesta como errores intermitentes y difíciles de reproducir, usualmente en las peticiones más útiles.

Cuando el servidor espera cabeceras específicas (un token de API, una clave de enrutamiento, una restricción CORS), las pasas en headers:

mcp_client = MCPClientStreamableHTTP(
    params=StreamableHTTPServerParams(
        url="https://my-server.example.com/mcp",
        timeout=100,
        headers={
            "Authorization": "Bearer my_api_token",
            "X-Custom-Header": "value",
        },
    )
)

Múltiples servidores en un único host

La lección 3 recomendaba servidores enfocados en lugar de un catálogo comodín. Esta recomendación no te condena a alquilar una máquina por servidor: con FastAPI, puedes montar varios servidores MCP en rutas distintas del mismo host.

# server.py — Múltiples servidores MCP en un único host
from contextlib import asynccontextmanager

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

# Servidor MCP para análisis de texto
text_mcp = MCPServer("Text Analysis")

@text_mcp.tool()
def analyze(text: str) -> str:
    """Analiza texto."""
    return f"Words: {len(text.split())}"

# Servidor MCP para cálculos
math_mcp = MCPServer("Math Tools")

@math_mcp.tool()
def calculate(expression: str) -> str:
    """Evalúa una expresión matemática."""
    return str(eval(expression))  # ¡Advertencia: eval en producción!

# Cada servidor MCP produce una aplicación ASGI independiente,
# que debe conocer el nombre de host bajo el cual se sirve
security = TransportSecuritySettings(allowed_hosts=["mon-serveur.com", "mon-serveur.com:*"])
text_app = text_mcp.streamable_http_app(transport_security=security)
math_app = math_mcp.streamable_http_app(transport_security=security)

# Ciclo de vida combinado: cada servidor debe iniciar su gestor de sesiones
@asynccontextmanager
async def lifespan(app: FastAPI):
    async with text_mcp.session_manager.run(), math_mcp.session_manager.run():
        yield

api = FastAPI(lifespan=lifespan)
api.mount("/text", text_app)
api.mount("/math", math_app)

Obtienes dos puntos finales independientes, https://mon-serveur.com/text/mcp para herramientas de análisis de texto y https://mon-serveur.com/math/mcp para herramientas matemáticas, que añades por separado en Vibe. El punto crítico es el lifespan: cada servidor MCP tiene un gestor de sesiones que debe iniciarse explícitamente. Si montas las aplicaciones sin pasar este lifespan a FastAPI, el servidor responde, pero cada llamada a herramienta falla con un error de tarea no inicializada. Un usuario que solo necesita cálculo no saturará su contexto con herramientas de texto. El comentario sobre eval no es broma: en un punto final público, esta línea ejecuta cualquier código enviado por el llamador; es un ejemplo pedagógico, nunca un patrón de producción.

Un último reflejo: antes de añadir tu URL a un chat, pásala de nuevo por el Inspector. Un punto final remoto añade fuentes de fallo que lo local ignoraba (túnel cerrado, cabecera faltante, puerto ocupado) y es mejor descubrirlas fuera de una conversación.

Puntos clave

  • Un servidor MCP remoto expone sus herramientas vía HTTP en un punto final /mcp
  • ngrok te permite obtener una URL pública para desarrollo
  • MCPClientStreamableHTTP con StreamableHTTPServerParams conecta el cliente al servidor remoto (MCPClientSSE es ahora solo para puntos finales heredados /sse)
  • El parámetro timeout es importante para servidores lentos
  • Puedes montar múltiples servidores MCP en el mismo host de FastAPI, siempre que pases su lifespan
  • Prueba siempre con el Inspector antes de integrar en un chat