HTTP Streaming

​

Learning objectives

• Explain the difference between classic HTTP streaming and MCP streaming notifications
• Implement a server that sends progress notifications using Streamable HTTP
• Write a client that handles incoming notifications in real time
• Understand the security considerations for HTTP-based MCP servers

​

Transport comparison

​

Classic streaming vs. MCP streaming

​

What is an MCP notification?

{
  "jsonrpc": "2.0",
  "method": "notifications/message",
  "params": {
    "level": "info",
    "data": "Processing document 3/10"
  }
}

​

Notification levels

​

Implementing notifications

​

Server side: sending notifications

from mcp.server.fastmcp import FastMCP, Context
from mcp.types import TextContent

mcp = FastMCP("streaming-server")

@mcp.tool(description="A tool that sends progress notifications")
async def process_files(message: str, ctx: Context) -> TextContent:
    for i in range(1, 11):
        await ctx.info(f"Processing document {i}/10")
    await ctx.info("Processing complete!")
    return TextContent(type="text", text=f"Done: {message}")

# Use streamable-http transport
mcp.run(transport="streamable-http")

[Tool("A tool that sends progress notifications")]
public async Task<TextContent> ProcessFiles(string message, ToolContext ctx)
{
    await ctx.Info("Processing file 1/3...");
    await ctx.Info("Processing file 2/3...");
    await ctx.Info("Processing file 3/3...");
    return new TextContent { Type = "text", Text = $"Done: {message}" };
}

var builder = McpBuilder.Create();
await builder
    .UseStreamableHttp()
    .Build()
    .RunAsync();

​

Client side: receiving notifications

async def message_handler(message):
    if isinstance(message, types.ServerNotification):
        print("NOTIFICATION:", message)
    else:
        print("SERVER MESSAGE:", message)

async with ClientSession(
    read_stream,
    write_stream,
    logging_callback=logging_collector,
    message_handler=message_handler,
) as session:
    await session.initialize()
    result = await session.call_tool("process_files", {"message": "batch-1"})

void MessageHandler(IJsonRpcMessage message)
{
    if (message is ServerNotification notification)
        Console.WriteLine($"NOTIFICATION: {notification}");
    else
        Console.WriteLine($"SERVER MESSAGE: {message}");
}

var clientOptions = new ClientSessionOptions
{
    MessageHandler = MessageHandler,
    LoggingCallback = (level, msg) => Console.WriteLine($"[{level}] {msg}")
};

using var client = new ClientSession(readStream, writeStream, clientOptions);
await client.InitializeAsync();

​

A simple HTTP streaming example

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import time

app = FastAPI()

async def event_stream():
    for i in range(1, 6):
        yield f"data: Message {i}\n\n"
        time.sleep(1)

@app.get("/stream")
def stream():
    return StreamingResponse(event_stream(), media_type="text/event-stream")

​

Security considerations

​

Migrating from SSE to Streamable HTTP

1. Update server code to use transport="streamable-http" in mcp.run().
2. Update client code to use streamablehttp_client instead of the SSE client.
3. Implement a message_handler in the client to process notifications.
4. Test with existing tools and workflows.
5. Optionally run both SSE and Streamable HTTP in parallel on different endpoints during the transition.

​

Assignment

1. Implement a server tool that processes a list and calls ctx.info() for each item.
2. Run the server with transport="streamable-http".
3. Write a client with a message_handler that prints notifications.
4. Observe the real-time output.

​

Key takeaways

• Streamable HTTP is the recommended transport for remote MCP servers (MCP spec 2025-11-25).
• MCP streaming uses a notification system — the final result is still a single response, but progress is sent as separate messages.
• Always validate the Origin header and use HTTPS in production deployments.
• Migrating from the deprecated SSE transport to Streamable HTTP requires only minor changes to both server and client.