Sirve mediante Streamable HTTP

Unos 32 minutos de lectura, con 6 ejemplos en 9 secciones.

Edición 2026.11.14 Ejemplos verificados el 19 de nov de 2026 70 de 70 ejemplos pasan Qué ha cambiado

Traducido con IA. Verificado por personas en inglés. Cómo hacemos los libros

Traducido del libro en inglés, edición 2026.11.14. Lee el original

Al terminar este capítulo podrás servir el servidor de Model Context Protocol de la tienda mediante Streamable HTTP, leer qué lleva cada petición y cada respuesta, transmitir el progreso de una llamada larga y cancelarla, ejecutar el servidor como réplicas detrás de una sola dirección sin sesiones fijas, y rechazar las peticiones que un navegador haya sido engañado para enviar. Lo que dice este capítulo se cumple en la revisión 2026-07-28 de la especificación y en la versión 2.3.0 del SDK de Python, mcp.

Hasta este capítulo, cada host lanzaba shop-support, el servidor de la tienda, como un subproceso y se comunicaba con él por stdio, lo que funciona para una persona en una sola máquina. El equipo de soporte de la tienda ahora atiende tickets desde muchos hosts. El servidor tiene que llegar a la API de la tienda desde dentro de la red de la tienda. Y el equipo quiere un trabajo lento en el servidor: recount_stock, que recuenta cada producto en ambos almacenes y tarda minutos en la tienda real. Un subproceso por host no puede compartirse, escalarse ni vigilarse desde un solo lugar.

Para un servidor que muchos hosts comparten, el Model Context Protocol (MCP) define un segundo transporte, Streamable HTTP. El servidor escucha en un solo endpoint HTTP, y cada mensaje que envía un cliente es un POST propio, tal como describe la especificación del transporte Streamable HTTP. El resto de MCP sigue igual: los mensajes JSON-RPC, el _meta en cada petición y las mismas herramientas.

Cuatro pequeños módulos compartidos en examples/lib/ contienen la preparación de este capítulo, de modo que cada ejemplo muestra solo su idea:

  • lib.http_mcp inicia un ejemplo de servidor como proceso propio en un puerto loopback libre, envía peticiones escritas a mano con las cabeceras que pide la revisión fijada, y carga el objeto del servidor que define un ejemplo anterior.
  • lib.wire, el impresor de trazas de Lee los mensajes en el cable, incorpora record_http, que envuelve la aplicación HTTP de un servidor y registra cada intercambio: cabeceras, cuerpo, estado y cada mensaje de la respuesta.
  • lib.recount contiene el recuento de la tienda, sus SKU y una llamada a la API por producto.
  • lib.shared_state mantiene el estado en un único archivo SQLite que abren varios procesos del servidor, para las réplicas de Ejecuta réplicas sin sesiones fijas.

La mayoría de los ejemplos sirven la aplicación HTTP del servidor en su propio proceso, a través de lib.loopback, el auxiliar del capítulo 1 para una aplicación en un puerto loopback libre, de modo que el grabador ve el lado del servidor. El primer ejemplo y el de las réplicas son las excepciones: ejecutan el servidor como procesos separados, como lo haría un despliegue. Todo se enlaza a 127.0.0.1.

Esta parte aún no está traducida, así que está en inglés.

Move the server from stdio to HTTP

Último cambio en la edición 2026.11.14

A server on stdio has exactly one client, the host that launched it. A server on Streamable HTTP has an address, and any client that can reach that address can use it. At the pinned revision that costs the server little, because the protocol keeps no state between requests. The changelog records that the revision removed the initialize handshake and the Mcp-Session-Id header, and that each request carries its own protocol version and client capabilities in _meta. A request over HTTP is therefore self-contained, like a call to the shop's own API: one POST in, one response out.

A server answers each request in one of two forms: a single JSON object (Content-Type: application/json), or a Server-Sent Events stream (text/event-stream) that belongs to that one request. The client must accept both, as the transport specification says. The stream exists so that the server can send notifications, such as progress, before the result, which Stream progress on a long call relies on.

In the Python SDK the change is one argument. MCPServer.run(transport="streamable-http") serves the server under uvicorn, by default on 127.0.0.1, port 8000, at the path /mcp (mcp/server/mcpserver/server.py). On the client side, Client takes a URL where it took StdioServerParameters, and connects with the SDK's Streamable HTTP client (mcp/client/client.py). The shop's server keeps chapter 3's five tools unchanged, and only the last lines of its file change. The port comes from http_mcp.port(), not 8000, so it never collides with anything else.

serve-on-loopback.py Python 3.12.15 · cryptography 50.0.2 · httpx2 2.16.2 · jsonschema 4.26.0 · mcp 2.3.0 · mcp-types 2.3.0 · pydantic 2.14.3 · starlette 1.10.0 · uvicorn 0.54.0 Superado
"""Serves chapter 3's five tools over Streamable HTTP in a process of its own, then calls one from a client that has onlythe endpoint's URL. The point rests on the protocol revision and O-1873 status lines: the client settles on the pinnedrevision and gets the order's status back."""import asyncioimport sysfrom urllib.parse import urlsplitfrom mcp import Clientfrom lib import http_mcp, loopback, shop_api, shop_toolsserver = shop_tools.create_server(version="0.6.0")      # chapter 3's tools, unchangedasync def main() -> None:    with loopback.serve(shop_api.create_app()) as api_url:        with http_mcp.launch(__file__, env=shop_api.server_env(api_url)) as url:   # runs this file again with --serve, as its own process            async with Client(url) as client:                                # no handshake: the client needs only the URL                print("endpoint host:", urlsplit(url).hostname)                print("endpoint path:", urlsplit(url).path)                print("protocol revision:", client.protocol_version)                print("server:", client.server_info.name, client.server_info.version)                print("tools:", len((await client.list_tools()).tools))                result = await client.call_tool("get_order_status", {"order_id": "O-1873"})                print("O-1873 status:", result.structured_content["status"])if "--serve" in sys.argv:    server.run(transport="streamable-http", port=http_mcp.port())   # 127.0.0.1, path /mcpelse:    asyncio.run(main())
Salidapython serve-on-loopback.py
endpoint host: 127.0.0.1
endpoint path: /mcp
protocol revision: 2026-07-28
server: shop-support 0.6.0
tools: 5
O-1873 status: delivered

The client reached the server at the SDK's defaults, 127.0.0.1 at /mcp.

It settled on revision 2026-07-28 and found 5 tools on shop-support 0.6.0. Order O-1873 came back delivered, as it does over stdio. The server process got the shop's API address and key in its environment, as the stdio servers did, and nothing else changed.

The SDK's streamable_http_app() also takes a stateless_http flag, At 2.3.0, the app routes each request by its MCP-Protocol-Version header, and a request at the pinned revision goes to a handler that serves one exchange and never sets Mcp-Session-Id, whatever the flag says. The flag only changes how clients on a 2025 revision are served (mcp/server/streamable_http_manager.py). The older HTTP+SSE transport, with its separate event endpoint, has been deprecated since revision 2025-03-26. Its earliest removal is three months after the specification's feature-lifecycle proposal, SEP-2596, reaches Final (deprecated features). Move from HTTP+SSE to Streamable HTTP ports a server off it.

Working rule: Serve over Streamable HTTP with MCPServer.run(transport="streamable-http") and its loopback default while you develop, and give clients the endpoint's URL. Leave stateless_http alone unless you also serve clients on a 2025 revision, where it decides whether they get sessions. Keep stdio for servers that a host launches for one user, as Choose stdio or Streamable HTTP explains.

Lee un intercambio HTTP

Último cambio en la edición 2026.11.11

El cliente de Mueve el servidor de stdio a HTTP ocultaba todo esto, pero cuando una llamada falla detrás de un proxy o de una pasarela, lo que lees es el intercambio, así que conviene saber cómo es uno correcto. En la revisión fijada, cada POST lleva cabeceras que copian partes de su cuerpo. MCP-Protocol-Version repite la versión, Mcp-Method el método JSON-RPC y Mcp-Name la herramienta, el prompt o el recurso para tools/call, prompts/get y resources/read. Las copias existen para que los balanceadores de carga, las pasarelas y la monitorización puedan enrutar e inspeccionar una petición sin analizar su cuerpo, como explica la especificación del transporte Streamable HTTP.

El cuerpo sigue siendo la fuente de verdad. Un servidor DEBE rechazar una petición cuyas cabeceras no coincidan con su cuerpo, con 400 Bad Request y el error JSON-RPC -32020, HeaderMismatch. Esa regla es la que hace seguro enrutar por las cabeceras. Una pasarela que envía Mcp-Name: check_stock a las réplicas de inventario puede confiar en que el cuerpo también nombra check_stock, porque un servidor rechazaría la petición en caso contrario.

Grabar una llamada a get_order_status con el cliente del SDK muestra un intercambio correcto. Dos peticiones que el cliente del SDK nunca envía, a través de lib.http_mcp.post, muestran lo que el servidor rechaza: un tools/call cuyo Mcp-Name dice check_stock mientras su cuerpo nombra get_order_status, y un GET.

trace-an-http-exchange.py Python 3.12.15 · cryptography 50.0.2 · httpx2 2.16.2 · jsonschema 4.26.0 · mcp 2.3.0 · mcp-types 2.3.0 · pydantic 2.14.3 · starlette 1.10.0 · uvicorn 0.54.0 Superado
"""Records the HTTP exchanges behind one tool call, then sends two requests the SDK's client never would. The point restson the request headers and response status lines of the tool call, and on the mismatched and GET lines, which show whatthe server refuses."""import asyncioimport osimport httpx2from mcp import Clientfrom lib import http_mcp, loopback, shop_api, wireSHOWN = ("content-type", "accept", "mcp-protocol-version", "mcp-method", "mcp-name")async def main() -> None:    server = http_mcp.load_server("serve-on-loopback.py")        # chapter 3's five tools    app = wire.record_http(server.streamable_http_app(), log="http.jsonl")   # logs each exchange as the app saw it    with loopback.serve(shop_api.create_app()) as api_url, loopback.serve(app) as base_url:        os.environ.update(shop_api.server_env(api_url))           # the server runs in this process, so it reads the API address here        async with Client(base_url + "/mcp") as client:            await client.call_tool("get_order_status", {"order_id": "O-1873"})        exchanges = wire.read_http_trace("http.jsonl")        # the recorder keeps header names in lower case        print("POSTs:", ", ".join(e["request_headers"]["mcp-method"] for e in exchanges))        call = next(e for e in exchanges if e["request_headers"]["mcp-method"] == "tools/call")        for name in SHOWN:            print(f"request {name}:", call["request_headers"][name])        print("request _meta keys:", ", ".join(call["request"]["params"]["_meta"]))        print("response status:", call["status"])        print("response content-type:", call["response_headers"]["content-type"])        print("response mcp-session-id:", call["response_headers"].get("mcp-session-id", "none"))        # the body names get_order_status, so this Mcp-Name header disagrees with it        wrong = http_mcp.post(base_url + "/mcp", "tools/call", {"name": "get_order_status",                              "arguments": {"order_id": "O-1873"}}, headers={"Mcp-Name": "check_stock"})        print("mismatched Mcp-Name status:", wrong.status_code)        print("mismatched Mcp-Name error:", wrong.json()["error"]["code"], wrong.json()["error"]["message"])        # a GET marked with the pinned revision, which the app refuses rather than serving its 2025 stream        stream = httpx2.get(base_url + "/mcp", headers={"MCP-Protocol-Version": http_mcp.VERSION})        print("GET status:", stream.status_code)        print("GET allow:", stream.headers["allow"])asyncio.run(main())
Salidapython trace-an-http-exchange.py
POSTs: server/discover, tools/call, tools/list
request content-type: application/json
request accept: application/json, text/event-stream
request mcp-protocol-version: 2026-07-28
request mcp-method: tools/call
request mcp-name: get_order_status
request _meta keys: io.modelcontextprotocol/protocolVersion, io.modelcontextprotocol/clientInfo, io.modelcontextprotocol/clientCapabilities
response status: 200
response content-type: application/json
response mcp-session-id: none
mismatched Mcp-Name status: 400
mismatched Mcp-Name error: -32020 mcp-name header does not match the request body's 'name' parameter
GET status: 405
GET allow: POST

El cliente hizo tres POST para esa única llamada: server/discover, tools/call, tools/list. El primero pregunta al servidor qué soporta, ya que no hay handshake. El último es el cliente del SDK pidiendo la lista de herramientas después de la llamada, para poder comprobar el resultado estructurado frente al esquema de salida de la herramienta (mcp/client/session.py, validate_tool_result). El POST de tools/call llevaba:

  • MCP-Protocol-Version: 2026-07-28
  • Mcp-Method: tools/call
  • Mcp-Name: get_order_status
  • Accept: application/json, text/event-stream, porque el cliente debe aceptar cualquiera de las dos formas de respuesta

Su _meta en el cuerpo contenía las mismas tres claves que usa por stdio: io.modelcontextprotocol/protocolVersion, io.modelcontextprotocol/clientInfo, io.modelcontextprotocol/clientCapabilities. La respuesta llegó con 200 como application/json, y no estableció ninguna cabecera de sesión (mcp-session-id: none).

La respuesta fue JSON simple porque la herramienta no envió nada antes de su resultado. El SDK no se compromete con un flujo de eventos hasta que el manejador envía una notificación o pasan 15 segundos, así que un manejador que termina en silencio dentro de esa ventana recibe una respuesta JSON (mcp/server/_streamable_http_modern.py). Ese límite de 15 segundos pertenece a un detalle de ese módulo privado y puede cambiar entre versiones.

El servidor rechazó la petición con cabeceras que no coinciden antes de que se ejecutara la herramienta, con 400 y el error -32020 mcp-name header does not match the request body's 'name' parameter. El propio cliente del SDK se recupera de -32020 volviendo a pedir la lista de herramientas y reenviando la petición una vez, porque en la revisión fijada una herramienta puede marcar parámetros con x-mcp-header, que los clientes copian en cabeceras Mcp-Param-{Name}, y un listado desactualizado hace que esas cabeceras sean incorrectas (mcp/client/client.py, call_tool).

El GET también fue rechazado: 405, con Allow: POST. Un servidor que solo soporta la revisión fijada DEBERÍA responder a GET y DELETE con 405 Method Not Allowed, porque esa revisión no tiene un flujo que el cliente abra con GET (la especificación del transporte). La aplicación del SDK también sirve las revisiones de 2025, y envía un GET sin la versión fijada en MCP-Protocol-Version a su manejador de 2025, que lo atiende y solo rechaza un GET marcado con la revisión fijada, como este (mcp/server/streamable_http_manager.py).

Regla práctica: Cuando falla una llamada HTTP, lee primero el intercambio: las tres cabeceras de enrutamiento, _meta en el cuerpo, el estado y el tipo de contenido. Enruta en una pasarela según Mcp-Method y Mcp-Name si lo necesitas, y nunca reescribas un cuerpo sin reescribir sus cabeceras para que coincidan, porque el servidor rechazará el par con -32020. En un servidor que solo soporta la revisión fijada, un 405 significa que un cliente más antiguo está abriendo un flujo GET; la aplicación del SDK sirve a esos clientes en su lugar.

Esta parte aún no está traducida, así que está en inglés.

Stream progress on a long call

Último cambio en la edición 2026.11.14

The exchange in Read one HTTP exchange returned in milliseconds. A call that takes minutes leaves the person at the host seeing nothing, and the host can't tell slow from stuck. Progress is MCP's answer to a long call: the server reports how far it has got while the call runs. A client that wants progress puts a progressToken in the request's _meta. The server MAY then send notifications/progress with that token, each carrying a progress value that MUST increase with every notification, and optionally a total and a message (progress). Over Streamable HTTP, these notifications travel only on the response stream of the request they belong to (Streamable HTTP transport).

In the SDK, a tool reports with await ctx.report_progress(progress, total=..., message=...). A client asks for reports on a call with call_tool(..., progress_callback=...), which also puts the token in _meta. When the caller didn't ask, report_progress does nothing (mcp/server/_streamable_http_modern.py, progress), so a tool can always call it.

The shop's API has an endpoint, POST /stock/{sku}/recount, which recounts one product in both warehouses and takes a few seconds per product in the real shop. recount_stock calls it for each of the shop's 64 SKUs and reports after each one. In the examples, lib.recount asks the API to take 0.02 seconds per product, so a full recount takes a few seconds. The same server runs twice: once with the SDK's default, which can stream, and once with json_response=True, which makes every response a single JSON object.

progress-on-stock-recount.py Python 3.12.15 · cryptography 50.0.2 · httpx2 2.16.2 · jsonschema 4.26.0 · mcp 2.3.0 · mcp-types 2.3.0 · pydantic 2.14.3 · starlette 1.10.0 · uvicorn 0.54.0 Superado
"""Runs recount_stock with progress reports, once with the SDK's streaming responses and once with JSON-only responses. Thepoint rests on the content-type and progress report lines: a JSON-only server drops every report, though the recount stillcounts the same units."""import asyncioimport osfrom mcp import Clientfrom mcp.server.mcpserver import Context, MCPServerfrom mcp.types import ToolAnnotationsfrom lib import loopback, recount, shop_api, wireserver = MCPServer("shop-support", version="0.6.0")@server.tool(title="Recount stock", annotations=ToolAnnotations(read_only_hint=False, idempotent_hint=True))async def recount_stock(ctx: Context) -> recount.Recount:    """Recount every product's stock in both warehouses. Slow: reports progress per product."""    units = 0    async with recount.api() as api:        for n, sku in enumerate(recount.SKUS, 1):                       # counts from 1, so the last report is the total            units += await recount.one(api, sku)                        # lib.recount has the API take 0.02 seconds per product unless told otherwise            await ctx.report_progress(n, total=len(recount.SKUS), message=f"recounted {sku}")    return recount.Recount(skus=len(recount.SKUS), units=units)async def run(mode: str, json_response: bool) -> None:    # json_response=True sends every response as one JSON object, with no stream for reports to travel on    app = wire.record_http(server.streamable_http_app(json_response=json_response), log=f"{mode}.jsonl")    reports = []    async def on_progress(progress: float, total: float | None, message: str | None) -> None:        reports.append((progress, total, message))    with loopback.serve(app) as base_url:        async with Client(base_url + "/mcp") as client:            result = await client.call_tool("recount_stock", progress_callback=on_progress)    call = next(e for e in wire.read_http_trace(f"{mode}.jsonl") if e["request"]["method"] == "tools/call")    print(f"{mode} content-type:", call["response_headers"]["content-type"].split(";")[0])    print(f"{mode} progress reports:", len(reports))    print(f"{mode} last report:", "{:g} of {:g}, {}".format(*reports[-1]) if reports else "none")    print(f"{mode} units counted:", result.structured_content["units"])async def main() -> None:    with loopback.serve(shop_api.create_app()) as api_url:        os.environ.update(shop_api.server_env(api_url))          # the servers run in this process        await run("sse", json_response=False)        await run("json", json_response=True)asyncio.run(main())
Salidapython progress-on-stock-recount.py
sse content-type: text/event-stream
sse progress reports: 64
sse last report: 64 of 64, recounted KG-1064
sse units counted: 6969
json content-type: application/json
json progress reports: 0
json last report: none
json units counted: 6969

With the default, the host saw the recount move. The response came back as text/event-stream, and the client received 64 reports, the last of them 64 of 64, recounted KG-1064. The first progress notification is what committed the response to an event stream, so nobody had to wait out the SDK's 15-second window. The recount counted 6969 units.

With json_response=True, the host got nothing until the end. The response was application/json, and the client received 0 reports. The recount still ran and counted 6969 units, and nothing failed. The SDK's JSON path has nowhere to send a notification, so report_progress returns without sending, and neither side logs it (mcp/server/_streamable_http_modern.py). The specification allows that, because progress is optional for the server. The person at the host would have waited the whole recount with no sign of life.

Streaming also has to survive intermediaries, since a proxy that buffers responses holds progress back until the end. The transport specification says servers SHOULD send X-Accel-Buffering: no on event streams to stop that, and the SDK sends it, with Cache-Control: no-cache, no-transform (mcp/server/_streamable_http_modern.py, _SSE_HEADERS).

Working rule: Report progress from any tool that can run longer than a few seconds, with a total when you know it and a message a person can read. Keep the SDK's default response mode. Use json_response=True only for a server whose every tool is quick, and know that it drops every progress report and every cancellation without telling anyone.

Cancelar una llamada que el cliente ya no necesita

Último cambio en la edición 2026.11.11

El recuento de Transmitir el progreso de una llamada larga llegó hasta el final porque el cliente esperó a que terminara. Sin embargo, a menudo el anfitrión deja de necesitar la respuesta a mitad de camino: la persona cierra el ticket o vence el plazo propio del anfitrión. Una llamada que sigue ejecutándose después de eso desperdicia la API de la tienda y mantiene ocupado lo que la herramienta utiliza.

En Streamable HTTP, un cliente cancela una solicitud cerrando el flujo de respuesta de esa solicitud. El patrón de cancelación de la especificación llama a ese flujo cerrado "la señal de cancelación", indica que el servidor DEBE tratar la desconexión del cliente como una cancelación de esa solicitud, y señala que ningún mensaje notifications/cancelled es "requerido ni esperado". Eso difiere de stdio, donde el cliente todavía envía notifications/cancelled, y de las revisiones de 2025, donde los clientes HTTP también lo enviaban. El SDK implementa ambas mitades. Su cliente aborta el POST cuando se cancela la tarea que lo espera o cuando vence su tiempo de lectura, y no envía nada más (mcp/client/streamable_http.py). Su servidor vigila la desconexión y cancela la tarea que ejecuta el manejador (mcp/server/_streamable_http_modern.py, watch_disconnect).

Dentro de una herramienta async def, la cancelación llega como la excepción de cancelación de anyio en el siguiente await. La herramienta puede registrar dónde se detuvo, pero debe volver a lanzar la excepción. La limpieza que tenga que esperar algo necesita un ámbito protegido, como anyio.move_on_after(5, shield=True), o la cancelación también cancelará la limpieza. Una herramienta def normal se ejecuta en un hilo de trabajo y solo se detiene si llama a anyio.from_thread.check_cancelled(). Una que nunca lo llama se ejecuta hasta el final, y su resultado se descarta. La guía de cancelación del SDK y mcp/server/_streamable_http_modern.py (watch_disconnect) describen ambos casos.

Para seguir ese camino de principio a fin, el anfitrión cancela la llamada en el quinto informe de progreso, tal como lo haría un anfitrión cuando su usuario cierra el ticket. Aquí cada producto tarda 0.1 segundos, de modo que el servidor todavía está dentro del recuento del sexto producto cuando se cierra el flujo. recount_stock registra cómo terminó cada ejecución, y el registrador anota lo que cruzó la conexión.

cancel-the-stock-recount.py Python 3.12.15 · anyio 4.16.0 · cryptography 50.0.2 · httpx2 2.16.2 · mcp 2.3.0 · mcp-types 2.3.0 · pydantic 2.14.3 · starlette 1.10.0 · uvicorn 0.54.0 Superado
"""Cancels recount_stock after five progress reports by closing its response stream, and records where the server stopped.The `server saw` and `tools/call stream` lines are the ones the prose's point rests on: they show where the toolstopped and how the client ended the call."""import osimport anyiofrom mcp import Clientfrom mcp.server.mcpserver import Context, MCPServerfrom lib import loopback, recount, shop_api, wireserver = MCPServer("shop-support", version="0.6.0")runs: list = []                           # how a recount ended, and how many recounts it asked the API for@server.tool(title="Recount stock")async def recount_stock(ctx: Context) -> recount.Recount:    """Recount every product's stock in both warehouses. Slow: reports progress per product."""    done = units = 0    async with recount.api() as api:        try:            for asked, sku in enumerate(recount.SKUS, 1):      # counted before each request to the API                units += await recount.one(api, sku, seconds=0.1)       # 0.1 seconds per product keeps the server inside the sixth one                done += 1                await ctx.report_progress(done, total=len(recount.SKUS), message=f"recounted {sku}")        except anyio.get_cancelled_exc_class():            runs.extend([f"cancelled with {done} of {len(recount.SKUS)} recounted", asked])            raise                         # always re-raise; cleanup that awaits goes under a shielded scope    return recount.Recount(skus=done, units=units)async def main() -> None:    app = wire.record_http(server.streamable_http_app(), log="cancel.jsonl")    with loopback.serve(shop_api.create_app()) as api_url, loopback.serve(app) as base_url:        os.environ.update(shop_api.server_env(api_url))        async with Client(base_url + "/mcp") as client:            with anyio.CancelScope() as scope:                async def on_progress(progress, total, message):                    if progress >= 5:                                   # the threshold: the host cancels after the fifth report                        scope.cancel()    # the host no longer needs the answer                await client.call_tool("recount_stock", progress_callback=on_progress)            await anyio.sleep(0.5)        # give the server time to see the closed stream        print(f"server saw: {runs[0]}\nrecounts asked of the API: {runs[1]}")    exchanges = wire.read_http_trace("cancel.jsonl")    print("POSTs:", ", ".join(e["request"]["method"] for e in exchanges))    kinds = [m.get("method", "result") for m in exchanges[-1]["messages"]]   # a response has no method, so it counts as the result    print("tools/call stream:", "finished" if exchanges[-1]["complete"] else "closed by the client")    print("tools/call messages:", kinds.count("notifications/progress"), "progress,", kinds.count("result"), "result")anyio.run(main)
Salidapython cancel-the-stock-recount.py
server saw: cancelled with 5 of 64 recounted
recounts asked of the API: 6
POSTs: server/discover, tools/call
tools/call stream: closed by the client
tools/call messages: 5 progress, 0 result

La herramienta se detuvo cuando se cerró el flujo. El servidor vio la llamada cancelled with 5 of 64 recounted, y la herramienta había pedido a la API de la tienda 6 recuentos. La cancelación llegó a la herramienta mientras esperaba el sexto, así que los productos restantes nunca llegaron a la API.

En la red hubo dos POST, server/discover, tools/call, así que no cruzó ningún mensaje de cancelación. El flujo de la llamada a la herramienta fue closed by the client, y contenía 5 progress, 0 result. El cliente no recibe resultado de una llamada cancelada, y el servidor tampoco envía ninguno.

Dos cosas deshacen esto. Con json_response=True, la ruta JSON del SDK no tiene vigilante de desconexión, así que una conexión cerrada nunca llega al manejador, y el manejador se ejecuta hasta el final (mcp/server/_streamable_http_modern.py). Y un flujo que se rompe por cualquier otro motivo, como un proxy que lo corta por tiempo, cancela la solicitud de la misma manera. En la revisión fijada los flujos no pueden reanudarse, así que el cliente DEBE volver a enviar la solicitud con un nuevo ID de solicitud (registro de cambios). Una herramienta que un flujo roto puede interrumpir debe ser segura para ejecutarse dos veces, y el recuento lo es, porque contar de nuevo da el mismo resultado. Para un recuento que debe sobrevivir a la desaparición del cliente, Iniciar una tarea en lugar de esperar lo traslada a una tarea.

Los tiempos de espera se sitúan sobre la cancelación. El patrón de cancelación indica que un emisor DEBERÍA establecer un tiempo de espera para cada solicitud, PUEDE reiniciarlo cuando llegue progreso, y DEBERÍA aplicar siempre un máximo. Client(read_timeout_seconds=...), y el mismo argumento sobre call_tool, dan ese límite, y agotar el tiempo cancela la llamada cerrando su flujo (mcp/client/streamable_http.py).

Regla práctica: Cancela una llamada sobre Streamable HTTP cancelando la tarea que la espera, o con un tiempo de espera, y deja que el SDK cierre el flujo. Escribe las herramientas largas como async def, vuelve a lanzar la cancelación y pon cualquier limpieza que deba esperar bajo un ámbito protegido. Haz que toda herramienta de ejecución prolongada sea segura para reintentar, porque un flujo roto pierde la llamada y el cliente vuelve a enviarla.

Esta parte aún no está traducida, así que está en inglés.

Run replicas without sticky sessions

Último cambio en la edición 2026.11.14

Every example so far, including the cancelled recount in Cancel a call the client no longer needs, ran one server process. The support team needs more than one, so that a restart or a slow recount doesn't stop every host. A load balancer in front of two replicas sends each request wherever it likes. With 2025-era sessions, the load balancer had to use sticky sessions, which route every request carrying the same Mcp-Session-Id to the replica that held the session. The pinned revision has no sessions, so any replica can serve any request. A server that needs state across calls mints an explicit handle instead, and the client passes it back as an ordinary argument (changelog).

The protocol keeping no state doesn't mean the application keeps none. The shop's server holds three kinds of state that a second replica doesn't see:

  • The key that seals requestState. The refund confirmation from Return an input request instead of a result sends the client a sealed requestState and opens it on the retry. By default MCPServer seals with a key that each process makes when it starts, and the state also names the server's name as its audience (mcp/server/request_state.py).
  • The handles the tools mint. Chapter 3's quote store keeps each quote_id in the memory of the process that made it, as What goes wrong in production in chapter 3 warned.
  • The record of answered confirmations. confirmations.OnceOnly, from Keep round-trip state tamper-proof, remembers each answered requestState in one process's memory.

One refund, asked for on replica a and confirmed on replica b, touches all three kinds of state. Two replicas of chapter 5's refund server, each a process on its own port with one shop API behind both, run it. lib.http_mcp.load_server loads the server that refund-asks-to-confirm.py defines, and each replica runs it over HTTP. One client connects to each replica, and both read order O-1873. Then the client on replica a quotes a refund for order O-2289, whose amount is above the policy's limit, and replica a asks for confirmation. The retry with the support lead's yes goes to replica b, as a load balancer might send it. The sequence runs three times, fixing one kind of state each time:

  1. each replica makes its own key;
  2. both replicas read one key from SHOP_REQUEST_STATE_KEY, through confirmations.state_security();
  3. both also keep their quotes and their answered confirmations in one shared store, a SQLite file named by SHOP_STATE_STORE, and the client then sends the same answer a second time, to replica a.

The shared store is lib.shared_state. Its SharedMap and SharedSet keep entries in a SQLite file that every process on the machine opens, and each carries a lock on a file beside it, so that one replica's check-then-write can't interleave with another's. shop_tools.create_server(quotes=...) and confirmations.OnceOnly(seen=...) take any such container, and fall back to process memory without one, so chapters 3 and 5 run as before. Rows hold JSON, not pickles, and a quote's expiry is stored as a wall-clock time, because a monotonic deadline means nothing on another host. A SQLite file reaches only processes on one machine. A deployment puts the same two tables in a database its replicas share.

two-replicas-one-client.py Python 3.12.15 · cryptography 50.0.2 · httpx2 2.16.2 · jsonschema 4.26.0 · mcp 2.3.0 · mcp-types 2.3.0 · pydantic 2.14.3 · starlette 1.10.0 · uvicorn 0.54.0 Superado
"""Runs two replicas of chapter 5's refund server through three kinds of shared state, and replays one confirmation across them.The point rests on the retry and replay lines: each shared kind of state removes one way the second replica fails."""import asyncioimport reimport sysimport tempfilefrom mcp import Client, MCPErrorfrom lib import confirmations, http_mcp, loopback, shared_state, shop_apiSHARED_KEY = "chapter-6-test-key-not-a-secret-0123456789"             # at least 32 bytes; a deployment reads its ownYES = {"action": "accept", "content": {"release": True}}              # the support lead's answer, as on the wireasync def outcome(call) -> str:                                       # refund status, tool error or protocol error    try:        result = await call    except MCPError as error:        return f"error {error.error.code} {error.error.message}"    # keeps only the error's first sentence, which names the cause    text = result.content[0].text.split(". ")[0] if result.is_error else result.structured_content["status"]    return re.sub(r"Q-[0-9a-f]{10}", "Q-…", text)                    # quote IDs are randomasync def refund_across(label: str, env: dict) -> None:    with http_mcp.launch(__file__, env=env) as url_a, http_mcp.launch(__file__, env=env) as url_b:        async with Client(url_a, elicitation_callback=confirmations.say_yes) as on_a, \                Client(url_b, elicitation_callback=confirmations.say_yes) as on_b:            print(f"{label} reads on a and b:", ", ".join([(await c.call_tool("get_order_status", {                "order_id": "O-1873"})).structured_content["status"] for c in (on_a, on_b)]))            quoted = await on_a.call_tool("quote_refund", {"order_id": "O-2289"})       # above the policy's limit            args = {"quote_id": quoted.structured_content["quote_id"]}            # allow_input_required lets the server answer with an input request, not a result, when it needs confirmation            first = await on_a.session.call_tool("issue_refund", args, allow_input_required=True)   # asks on a            # the answer goes back with the request state the server sealed, which the retry must open            answer = dict(input_responses={"confirm": YES}, request_state=first.request_state)            print(f"{label} retry on b:", await outcome(on_b.session.call_tool("issue_refund", args, **answer)))            if shared_state.STORE_VARIABLE in env:                    # only the shared-store run sends the answer a second time                print(f"{label} replay on a:", await outcome(on_a.session.call_tool("issue_refund", args, **answer)))async def main() -> None:    with loopback.serve(shop_api.create_app()) as api_url, tempfile.TemporaryDirectory() as shared:        env = shop_api.server_env(api_url)                            # one shop API behind both replicas        keyed = {**env, confirmations.STATE_KEY_VARIABLE: SHARED_KEY}        await refund_across("own keys", env)                          # each process makes its own key        await refund_across("shared key", keyed)        await refund_across("shared store", {**keyed, shared_state.STORE_VARIABLE: f"{shared}/state.db"})if "--serve" in sys.argv:                                             # one replica: chapter 5's server, over HTTP    http_mcp.load_server("refund-asks-to-confirm.py").run(transport="streamable-http", port=http_mcp.port())else:    asyncio.run(main())
Salidapython two-replicas-one-client.py
own keys reads on a and b: delivered, delivered
own keys retry on b: error -32602 Invalid or expired requestState
shared key reads on a and b: delivered, delivered
shared key retry on b: Error executing tool issue_refund: There is no quote Q-…
shared store reads on a and b: delivered, delivered
shared store retry on b: requested
shared store replay on a: Error executing tool issue_refund: Refund R-0113 was already confirmed

With their own keys, both reads worked (delivered, delivered), but the retry failed: error -32602 Invalid or expired requestState. Replica b couldn't open a state that replica a sealed, so the SDK refused the retry before the tool ran.

With one shared key, replica b opened the state, and the call failed one step later, inside the tool: "Error executing tool issue_refund: There is no quote Q-…" The quote lived in replica a's memory. The shared key fixed the first kind of state and exposed the second.

With the shared store as well, the retry on replica b released the refund, and its status became requested. Replica b found replica a's quote in the shared store, and with it the refund the shop's API already held, so it released that refund without asking for a second one. The same answer sent again to replica a was refused: "Error executing tool issue_refund: Refund R-0113 was already confirmed" Replica a had never seen the first answer. Without the shared record, its own OnceOnly check would have passed, and it would have asked the shop's API to release the refund again. Only the API's 409 for a refund it no longer holds would have stopped it. The refund completed once, across two replicas, with no sticky sessions. The specification asks for opaque, expiring handles (tools). Where their state lives is the server's choice, but with replicas it must be somewhere every replica reaches.

A deployment that hasn't moved some state yet can use a stopgap from the routing headers in Read one HTTP exchange. It isn't stickiness: a gateway sends every request whose Mcp-Name names a tool that depends on that state to one replica, and spreads the rest. A subscriptions/listen stream is held by one replica, and the SDK ships only an in-memory bus, so events published on another replica never reach it (deploy and scale; mcp/server/subscriptions.py, InMemorySubscriptionBus).

Working rule: Run replicas with no sticky sessions, and give every replica the same server name and the same requestState keys, injected from your secret store. Before you add a second replica, list every piece of state your tools keep in memory, such as handles, once-only records and subscriptions, and move each into storage that every replica reaches. Until one is moved, route the tools that depend on it to a single replica by Mcp-Name.

Rechazar requests de otros orígenes

Último cambio en la edición 2026.11.11

Las réplicas de Ejecutar réplicas sin sesiones persistentes escuchan en 127.0.0.1, lo que parece privado. No lo es. Cualquier página web abierta en un navegador de la misma máquina puede enviar solicitudes a un puerto de loopback. Con DNS rebinding, el dominio de un atacante puede resolverse a 127.0.0.1 después de cargar la página, de modo que el navegador trata el servidor local como parte del sitio del atacante. El tutorial de la especificación sobre servidores locales dice que enlazar a 127.0.0.1 "no es un límite de autenticación" (seguridad del servidor local).

El navegador proporciona al servidor su defensa. Envía el Origin de la página con cada solicitud que hace en nombre de la página. El transporte Streamable HTTP de la especificación dice que los servidores DEBEN validar Origin en cada conexión entrante, DEBEN responder 403 cuando esté presente y sea inválido, y DEBERÍAN enlazar a 127.0.0.1 cuando se ejecuten localmente. Comprobar también Host detiene el caso de rebinding, en el que el navegador indica el dominio del atacante.

El SDK activa ambas comprobaciones por defecto. Cuando el host de la aplicación es un nombre de loopback y no pasas transport_security, solo permite valores Host 127.0.0.1:*, localhost:* y [::1]:*, y solo valores Origin con los mismos nombres bajo http:// (mcp/server/mcpserver/server.py). Cuatro requests prueban ese valor por defecto: tools/list sin Origin, con el origen propio del servidor, con http://attacker.example, y con un Host de fernhill.example. Después construye la misma aplicación con host="0.0.0.0", la configuración habitual de un contenedor, y envía de nuevo las dos solicitudes ajenas. Esa aplicación enlaza a 127.0.0.1, ya que solo se prueba la configuración.

reject-a-foreign-origin.py Python 3.12.15 · cryptography 50.0.2 · httpx2 2.16.2 · mcp 2.3.0 · mcp-types 2.3.0 · pydantic 2.14.3 · starlette 1.10.0 · uvicorn 0.54.0 Superado
"""Sends tools/list to the shop's server with foreign Origin and Host headers, first with the SDK's loopback default and thenwith host="0.0.0.0". The point rests on the foreign Origin and foreign Host lines: the default answers 403 and 421, and the0.0.0.0 app answers 200 to both."""from urllib.parse import urlsplitfrom lib import http_mcp, loopbackserver = http_mcp.load_server("serve-on-loopback.py")             # chapter 3's five toolsFOREIGN = "http://attacker.example"                                # a page in the user's browser, on another sitedef probe(label: str, url: str, headers: dict[str, str]) -> None:    response = http_mcp.post(url, "tools/list", headers=headers)    print(f"{label}:", response.status_code, response.text if response.status_code != 200 else "tools listed")def main() -> None:    with loopback.serve(server.streamable_http_app()) as base_url:             # host defaults to 127.0.0.1        # the server's own origin: loopback and the port it listens on, as a page served from it would send        url, own = base_url + "/mcp", f"http://127.0.0.1:{urlsplit(base_url).port}"        probe("no Origin", url, {})        probe("own Origin", url, {"Origin": own})        probe("foreign Origin", url, {"Origin": FOREIGN})        probe("foreign Host", url, {"Host": "fernhill.example"})         # a Host the loopback allowlist does not name    with loopback.serve(server.streamable_http_app(host="0.0.0.0")) as base_url:   # still bound to 127.0.0.1        probe("0.0.0.0 app, foreign Origin", base_url + "/mcp", {"Origin": FOREIGN})        probe("0.0.0.0 app, foreign Host", base_url + "/mcp", {"Host": "fernhill.example"})main()
Salidapython reject-a-foreign-origin.py
no Origin: 200 tools listed
own Origin: 200 tools listed
foreign Origin: 403 Invalid Origin header
foreign Host: 421 Invalid Host header
0.0.0.0 app, foreign Origin: 200 tools listed
0.0.0.0 app, foreign Host: 200 tools listed

El valor por defecto de loopback rechazó ambas solicitudes ajenas. Una solicitud sin Origin recibió 200 tools listed, y también el origen propio del servidor: 200 tools listed. El origen ajeno recibió 403 Invalid Origin header, y el host ajeno recibió 421 Invalid Host header, ambos como texto plano y no como JSON-RPC (mcp/server/transport_security.py). La especificación permite un cuerpo de cualquiera de los dos tipos con el 403.

Construida con host="0.0.0.0", la aplicación dejó pasar ambas: 200 tools listed y 200 tools listed. Un host que el SDK no reconoce como loopback solo impide que active el valor por defecto, y sin configuración pasada la comprobación queda desactivada (mcp/server/transport_security.py). Eso no cumple el DEBE de la especificación, y nada en los registros lo indica.

La solicitud sin Origin muestra qué cubre esta defensa. Los navegadores envían Origin, mientras que los scripts, las herramientas de línea de comandos y otros servidores no, y el SDK deja pasar una solicitud sin él. La validación de origen protege a un servidor de las páginas web. No hace nada frente a un programa que pueda alcanzar el puerto, que es para lo que sirve la autorización (Autorizar clientes con OAuth).

Regla práctica: Mantén el valor por defecto de loopback del SDK en la máquina de desarrollo. Cuando despliegues en cualquier otra dirección, pasa transport_security=TransportSecuritySettings(allowed_hosts=[...], allowed_origins=[...]) con los nombres a los que responde tu servidor, como mcp.fernhill.example, y nunca confíes en el valor por defecto. Trata la validación de Origin como protección solo frente a navegadores, y pon la autorización delante de todo servidor al que pueda llegar algo distinto de su propio host.

Elige stdio o Streamable HTTP

Último cambio en la edición 2026.11.11

Las secciones anteriores llevaron el servidor de la tienda a Streamable HTTP. El trabajo que ese cambio requirió, desde la cancelación hasta las réplicas y las comprobaciones de origen, es el precio del cambio. stdio no tiene nada de eso. El transporte stdio de la especificación hace que el cliente lance el servidor como un subproceso e intercambie mensajes por su entrada y salida estándar. El host es dueño del proceso, así que nada más puede alcanzarlo, el servidor hereda solo lo que el host le pasa y vive mientras el host lo necesite.

Los transportes se diferencian en quién ejecuta el servidor, y en lo que se sigue de ello:

stdio Streamable HTTP
Iniciado por el host, uno por host tú, una vez para muchos hosts
Accesible por su propio host cualquiera que llegue a la dirección
Cancelar notifications/cancelled cerrar el flujo de respuesta
Registros error estándar los registros de tu servidor
Credenciales el entorno del host tokens de acceso OAuth
Escala por un proceso por host réplicas detrás de un balanceador de carga

Recomendamos stdio para un servidor que trabaja para un solo usuario en la máquina de ese usuario, como uno que lee archivos locales o usa las credenciales propias del usuario, y para desarrollo. Recomendamos Streamable HTTP cuando varios hosts comparten un servidor, cuando el servidor debe ejecutarse junto a sistemas que los hosts no pueden alcanzar, como la API de la tienda dentro de su red, o cuando necesitas desplegar, escalar y vigilar el servidor como un servicio. Entonces planifica la autorización desde el principio, porque un servidor en una dirección necesita saber quién lo llama (Encuentra el servidor de autorización a partir del recurso).

Con muchos hosts, la API de la tienda no debería ser accesible desde los portátiles del equipo de soporte, así que el servidor pasa a Streamable HTTP. El libro mantiene stdio para los ejemplos que necesitan solo un host y un servidor, porque un subproceso es la forma más corta de ejecutar uno.

Regla práctica: Publica un servidor por stdio cuando actúa para un solo usuario en la máquina de ese usuario. Publícalo por Streamable HTTP cuando sirve a varios hosts, protege sistemas que los hosts no pueden alcanzar o debe escalar, y dale comprobaciones de origen y autorización antes de su primer usuario externo. El mismo código de servidor puede servir a ambos, así que elige por despliegue, no por servidor.

Qué falla en producción

Último cambio en la edición 2026.11.11

El servidor de la tienda funciona en loopback con un cliente a la vez. Detrás de proxies, balanceadores de carga y clientes reales falla de maneras que loopback nunca muestra; aquí está cada una, con su aspecto.

Cada request recibe 421. El despliegue conservó la lista de permitidos de loopback del SDK, y las solicitudes llegan con el nombre público del servidor en Host. La señal es Invalid Host header en texto plano en cada llamada y nada en los registros de herramientas. Pasa allowed_hosts con los nombres a los que responde el servidor (Rechazar solicitudes de otros orígenes).

Las comprobaciones están desactivadas sin que nadie lo decida. Un servidor iniciado con host="0.0.0.0", la configuración habitual en contenedores, acepta cualquier Host y Origin (mcp/server/transport_security.py). Nada falla, así que la única señal es una prueba como reject-a-foreign-origin que obtiene 200. Ejecuta esa prueba en cada despliegue y configura transport_security de forma explícita.

El progreso llega de golpe. Un proxy que almacena la respuesta retiene cada notificación hasta el resultado. El SDK envía X-Accel-Buffering: no, el encabezado que la especificación indica para esto, pero los proxies y CDN que lo ignoran tienen sus propias configuraciones. Una barra de progreso que salta de nada a completo lo delata. Prueba el progreso por la ruta real, no en loopback.

Las llamadas largas mueren en un número redondo de segundos. Los proxies y balanceadores de carga cierran las conexiones inactivas tras un tiempo fijo. Una vez abierto un flujo, el SDK envía un comentario : ping cada 15 segundos sin otro evento, para que no quede inactivo (mcp/server/_streamable_http_modern.py). Un proxy con un límite de inactividad más corto, o un límite total por solicitud, sigue cortando el flujo, y el corte cancela la herramienta. Busca cancelaciones agrupadas en una misma duración. Aumenta los límites del proxy para la ruta de MCP, o pasa el trabajo a una tarea (Iniciar una tarea en lugar de esperar).

Un reintento ejecuta el trabajo dos veces. Un flujo interrumpido no se puede reanudar, y el cliente vuelve a enviar la solicitud con un nuevo ID (changelog). Una herramienta que no es segura de repetir realiza su efecto secundario dos veces. El issue_refund de la tienda es seguro porque un presupuesto se reembolsa una sola vez, y con el almacén compartido eso se cumple en cada réplica. Da a cada herramienta con efecto secundario un identificador o una clave que haga que la segunda llamada devuelva el resultado de la primera, y guarda ese registro donde lo vea cada réplica.

json_response=True silencia el progreso y la cancelación. Es tentador detrás de una pasarela que no soporta flujos de eventos, y el SDK no da ninguna advertencia (Transmitir el progreso de una llamada larga). Se manifiesta como llamadas largas que nunca informan y siguen ejecutándose después de que los clientes se han ido.

Una pasarela reescribe el cuerpo. Una pasarela que edita cuerpos JSON pero no encabezados hace fallar las solicitudes con -32020, HeaderMismatch. El cliente del SDK reenvía una vez tras obtener la lista de herramientas, así que verás solicitudes tools/call duplicadas y un goteo constante de -32020 en las respuestas del servidor.

Los clientes de la revisión 2025 necesitan sesiones. La misma aplicación atiende a clientes de la era 2025 mediante el protocolo de inicio antiguo, y por defecto guarda sus sesiones en la memoria de un solo proceso, lo que exige enrutamiento persistente (mcp/server/streamable_http_manager.py). Vigila 404 con "Session not found" solo en esos clientes, cuando una solicitud llega a otra réplica (mcp/server/streamable_http_manager.py). Configura stateless_http=True si los atiendes detrás de un balanceador de carga, y ten en cuenta lo que cuesta: esos clientes pierden la cancelación, así que sus manejadores se ejecutan hasta el final sin importar lo que haga el cliente (cancelación), y pierden las solicitudes del servidor al cliente como el muestreo y la elicitación (desplegar y escalar). Atender a clientes antiguos y nuevos durante la ventana analiza la compensación.

Las solicitudes grandes fallan con 413. El SDK limita el cuerpo de una solicitud a 4 MiB por defecto (mcp/server/transport_security.py). Una herramienta que recibe un documento como argumento lo alcanza primero. Aumenta max_request_body_size para ese servidor, o pasa una referencia al documento en lugar de sus bytes.

Regla práctica: Antes de que el servidor de la tienda reciba tráfico en una dirección, prueba cuatro cosas por la ruta real del proxy: un Origin ajeno recibe 403, el progreso llega mientras la llamada se ejecuta, una llamada más larga que el límite de inactividad del proxy sobrevive, y cerrar el flujo de una llamada detiene la herramienta. Luego vigila 421, 403 y -32020 por cliente, y las cancelaciones por duración.

Decisiones que tomó este capítulo

Último cambio en la edición 2026.11.11
  • El servidor de la tienda pasa a Streamable HTTP para los hosts del equipo de soporte, con las herramientas del capítulo 3 sin cambios. stdio se mantiene para los ejemplos con un solo host y un solo servidor.
  • MCPServer.run(transport="streamable-http") con los valores por defecto del SDK: loopback, la ruta /mcp, y el modo de respuesta por defecto, que es en flujo. stateless_http se deja sin definir hasta que los clientes de la era 2025 necesiten atenderse detrás de un balanceador de carga; y entonces les cuesta la cancelación.
  • json_response=True nunca se usa, porque elimina el progreso y la cancelación.
  • recount_stock informa el progreso después de cada producto, con un total y un mensaje, y es seguro ejecutarlo dos veces.
  • La cancelación es un flujo cerrado. Las herramientas largas son async def, vuelven a lanzar la cancelación y protegen con shield cualquier limpieza que se aguarde con await.
  • Las réplicas comparten su nombre de servidor y sus claves requestState a través de SHOP_REQUEST_STATE_KEY, y sus cotizaciones y confirmaciones respondidas a través de un almacén compartido, SHOP_STATE_STORE. Cada request, incluidas las devoluciones, se ejecuta en cualquier réplica. El almacén de los ejemplos es un archivo SQLite de filas JSON con caducidad según el reloj de pared; un despliegue usa una base de datos que comparten sus réplicas.
  • Las comprobaciones de Origin y Host siguen activas. En cualquier dirección que no sea loopback, transport_security enumera explícitamente los nombres del servidor. La autorización, no Origin, es lo que deja fuera a los llamantes que no son navegadores.
  • Las pasarelas pueden enrutar según Mcp-Method y Mcp-Name, porque el servidor rechaza un request cuyas cabeceras no coinciden con su cuerpo. Ninguna pasarela reescribe un cuerpo.
  • Las trazas HTTP provienen de lib.wire.record_http, y los requests escritos a mano de lib.http_mcp.post, solo para mostrar errores que el cliente del SDK nunca provocaría.
  • Los ejemplos ejecutan las réplicas como procesos separados, de modo que cada una tiene su propia memoria y su propia clave, como en un despliegue.

Este capítulo, en esta edición

Edición 2026.11.14Ejemplos verificados el 19 de nov de 2026Superan la prueba 6 de 6 ejemplos ejemplos de este capítulo

Traducido del libro en inglés, edición 2026.11.14.

Cita esta sección

Formato

Cada formato cita el libro en inglés, que esta traducción sigue.

Cada formato nombra esta edición. Su enlace abre la edición actual, donde el encabezado de cada sección indica cuándo cambió su texto por última vez. Las fechas de acceso y de recuperación son el día en que lo abres.

En esta página

Capítulo 6 de 12: Sirve mediante Streamable HTTP

  1. Move the server from stdio to HTTP
  2. Lee un intercambio HTTP
  3. Stream progress on a long call
  4. Cancelar una llamada que el cliente ya no necesita
  5. Run replicas without sticky sessions
  6. Rechazar requests de otros orígenes
  7. Elige stdio o Streamable HTTP
  8. Qué falla en producción
  9. Decisiones que tomó este capítulo

Volver arribaTodos los capítulos