Conexiones SSE en Fast MCP para streaming eficiente

Clase 8 de 22 • Curso de MCP con Microsoft Azure

Resumen

Al hablar de MCP, es fundamental comprender los tipos de conexiones disponibles, especialmente las conexiones Server Send Events (SSE). Estas permiten realizar streaming de aplicaciones mediante HTTP, logrando que la comunicación entre servidor y cliente sea más rápida, ligera y eficiente, optimizando así la experiencia del usuario.

¿Qué son las conexiones Server Send Events (SSE)?

Las conexiones SSE posibilitan que tu servidor envíe información al cliente constantemente a través de HTTP. Esto facilita un flujo de datos eficiente y optimizado, reduciendo el exceso de procesamiento y logrando una interacción ágil y continua.

¿Qué beneficios aporta utilizar SSE?

Usar SSE mejora notablemente la comunicación servidor–cliente en aspectos clave:

Transmisión rápida de información.
Menor carga en el procesamiento.
Mayor eficiencia en el manejo continuo de datos.

Esto evita la lentitud progresiva causada por contextos extensos y mejora la gestión dinámica de información mediante entregas parciales, similares al funcionamiento de plataformas como Netflix.

¿Cómo configurar una conexión SSE en Python con Fast MCP?

Para implementar una conexión SSE, realiza los siguientes pasos básicos:

Crea una carpeta para tu clase, por ejemplo, clase siete.
Genera un archivo Python llamado server.py.
Importa las siguientes librerías necesarias para trabajar con Fast MCP, Starlette Applications y Starlette Routing:

from starlette.applications import Starlette
from starlette.routing import Route
from fast_mcp import FastMCP

Define e inicia tu servidor usando Fast MCP, nombrándolo claramente para diferenciarlo:

app = FastMCP("SSE de Platzi")

Despliega tu aplicación mediante UVCORN, ejecutando el siguiente comando en la terminal:

uvicorn server:app

Conecta tu aplicación con SSE usando la URL específica: localhost:8000/SSE.

La conexión al inspector sigue siendo igual, solo cambiando el transporte de STDIO a SSE al especificar la URL señalada. Esta pequeña modificación hará más eficiente el intercambio de información sin cambios visibles en la interfaz del usuario.

¿Es notable la diferencia visual al usar SSE?

En términos visuales o funcionales, el usuario no nota cambios inmediatos al interactuar con la aplicación. Las diferencias residen en los aspectos técnicos internos: el rendimiento y la eficiencia en el procesamiento de datos al usar SSE hacen que esta opción destaque sobre las conexiones tradicionales STDIO.

Te invitamos a experimentar y dejar tus comentarios sobre qué diferencias observaste al implementar Server Send Events con Fast MCP.

David Herrera

student•

Es interesante, como tal SSE ya es un estándar de transporte deprecado, remplazado por HTTP Streamable. Lo podemos revisar en la documentación oficial: https://modelcontextprotocol.io/docs/concepts/transports#server-sent-events-sse-deprecated

Naturalmente el cambio sería así:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP(
    name="Calculator",
    host="0.0.0.0",
    port=8050, 
)

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers together"""
    return a + b

@mcp.resource("greeting://{name}{last_name}")
def get_greeting(name: str, last_name: str) -> str:
    """Return a greeting message for the given name"""
    return f"Hello, {name} {last_name}!"

# Run the server
if __name__ == "__main__":
    mcp.run(transport="streamable-http")

David Herrera

student•

De igual manera el resultado es exactamente el mismo, solo para complementar la clase, saludos. 👌

sebastián García

student•

Yo lo he venido haciendo asi y funciona de maravilla

Carlos Enrique Ramírez Flores

student•

Probando con postman

Favio Náquira

student•

¿Cómo instaló uvicorn? Este curso lo siento caótico, asume mil cosas y ni siquiera las aclaran en el resumen de la clase, que es lo que solían hacer para complementar todo, pareciera corrieron contra el tiempo para publicar esto...

Gerardo Matias Ferreira

student•

Uvicorn fue instalado en el momento que hiciste pip install "mcp[cli]". Es decir, se instaló MCP con sus dependencias.

Favio Náquira

student•

No se instala allí, lo corro y da error de que no encuentra el paquete, tuve que ir a google y buscar que era siquiera porque ni se explica. Ya instalado globalmente sirve para todo pero eso es algo que no se muestra ni se explica en la clase.

Cristian Pisco Intriago

student•

Esta es otra alternativa de usar Streamable HTTP.

from mcp.server.fastmcp import FastMCP
import uvicorn
import argparse

# Create an MCP server
mcp = FastMCP("Demo")

# Add an addition tool
@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

@mcp.tool(description="A simple echo tool")
def echo(message: str) -> str:
    return f"Echo: {message}"

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Run MCP Streamable HTTP based server")
    parser.add_argument("--port", type=int, default=8123, help="Localhost port to listen on")
    args = parser.parse_args()
    
    uvicorn.run(mcp.streamable_http_app, host="0.0.0.0", port=args.port)

Cristian Pisco Intriago

student•

Para correr el servidor.

python server.py --port=8888

Cristian Pisco Intriago

student•

Cuando tengan el inspector, seleccionan en Transport Type => Streamable HTTP.

en URL => http://localhost:8888/mcp

Le dan en Connect

andres reyes

student•

Entendiendo un poco sobre tools y resources:

Tool -> una acción que necesita el model AI ejecutar Resources _> data que se le da al modelo para tener mas contexto

Kevin Guzman

student•

Lo que dice el profe no es del todo cierto, de hecho en la documentación principal, dicen que la conexión más estable, sin delay y para cargas muy grandes es STDIN

Kevin Fiorentino

student•

Entiendo que STDIO es mejor para servidores MCP en tu computadora local. Lo que se hace en esta clase básicamente es exponer el servidor MCP por HTTP para conectarte de forma remota en otro computador. Claramente no se puede usar STDIO de forma remota.

William Schnaider Torres Bermon

student•

SSE (Server Sent Events) is a standard for server-to-client streaming, allowing servers to push real-time updates to clients over HTTP. This is particularly useful for applications that require live updates, such as chat applications, notifications, or real-time data feeds. Also, your server can be used by multiple clients at the same time as it lives on a server that can be run somewhere in the cloud for example.

from starlette.applications import Starlette
from starlette.routing import Mount, Host
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("My App")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

# Mount the SSE server to the existing ASGI server
app = Starlette(
    routes=[
        Mount('/', app=mcp.sse_app()),
    ]
)

In the preceding code we:

Imported the libraries we're going to need with Starlette (an ASGI framework) being pulled in.
Create an instance of an ASGI server (using Starletter specifically) and mount the default route /

What happens behind the scenes is that the routes /sse and /messages are setup to handle connections and messages respectively. The rest of the app, like adding features like tools, happens like with stdio servers.

Jair Israel Avilés Eusebio

student•

Tip. Si estas implementando Streamable HTTP. como mecanismo de transport con el siguiente comando puedes correr el servidor de forma local.

uv run server.py&#x20;

En mi caso estoy implementando el codigo de David Herrera y tengo el siguiente output:

$ uv run server.py&#x20;

INFO:     Started server process \[9514]

INFO:     Waiting for application startup.

\[08/15/25 18:47:28] INFO     StreamableHTTP session manager started                                                           streamable\_http\_manager.py:110

INFO:     Application startup complete.

INFO:     Uvicorn running on [http://0.0.0.0:8050](http://0.0.0.0:8050) (Press CTRL+C to quit)

\[08/15/25 18:48:39] INFO     Created new transport with session ID: 7e193a2535914431a901b5ee5a07bfec          streamable\_http\_manager.py:233

INFO:     127.0.0.1:59257 - "POST /mcp HTTP/1.1" 200 OK

INFO:     127.0.0.1:59257 - "POST /mcp HTTP/1.1" 202 Accepted

INFO:     127.0.0.1:59258 - "GET /mcp HTTP/1.1" 200 OK

INFO:     127.0.0.1:59257 - "POST /mcp HTTP/1.1" 200 OK

\[08/15/25 18:48:41] INFO     Processing request of type ListToolsRequest                                                       server.py:624

INFO:     127.0.0.1:59265 - "POST /mcp HTTP/1.1" 200 OK

\[08/15/25 18:48:46] INFO     Processing request of type CallToolRequest                                                        server.py:624