Servir via Streamable HTTP

Cerca de 37 minutos min de leitura, com 6 exemplos em 9 seções.

Edição 2026.11.14 Exemplos aprovados em 19 de nov de 2026 70 de 70 exemplos passam O que mudou

Traduzido com IA. Verificado por pessoas em inglês. Como fazemos os livros

Traduzido do livro em inglês, edição 2026.11.14. Leia o original

Ao final deste capítulo, você será capaz de servir o servidor Model Context Protocol da loja via Streamable HTTP, ler o que cada requisição e cada resposta carregam, transmitir o progresso de uma chamada longa e cancelá-la, executar o servidor como réplicas atrás de um único endereço, sem sticky sessions, e recusar requisições que um navegador foi enganado para enviar. O que este capítulo afirma vale para a revisão 2026-07-28 da especificação e para a versão 2.3.0 do SDK Python, mcp.

Até este capítulo, cada host lançava shop-support, o servidor da loja, como subprocesso e conversava com ele via stdio, o que funciona para uma pessoa em uma máquina. A equipe de suporte da loja agora atende chamados vindos de muitos hosts. O servidor precisa alcançar a API da loja a partir de dentro da rede da loja. E a equipe quer uma tarefa lenta no servidor: recount_stock, que conta de novo cada produto nos dois armazéns e leva minutos na loja real. Um subprocesso por host não pode ser compartilhado, escalado nem monitorado a partir de um único lugar.

Para um servidor que muitos hosts compartilham, o Model Context Protocol (MCP) define um segundo transporte, Streamable HTTP. O servidor escuta em um único endpoint HTTP, e cada mensagem que um cliente envia é um POST próprio, como descreve o transporte Streamable HTTP da especificação. O restante do MCP permanece como está: as mensagens JSON-RPC, o _meta em cada requisição e as mesmas ferramentas.

Quatro pequenos módulos compartilhados em examples/lib/ trazem a configuração deste capítulo, para que cada exemplo mostre apenas a sua ideia:

  • lib.http_mcp inicia um exemplo de servidor como processo próprio em uma porta loopback livre, envia requisições escritas à mão, com os cabeçalhos que a revisão fixada exige, e carrega o objeto do servidor que um exemplo anterior define.
  • lib.wire, o impressor de rastros de Ler as mensagens no tráfego, ganha record_http, que envolve a aplicação HTTP de um servidor e registra cada troca: cabeçalhos, corpo, status e cada mensagem na resposta.
  • lib.recount guarda a recontagem da loja, seus SKUs e uma chamada de API por produto.
  • lib.shared_state mantém o estado em um único arquivo SQLite que vários processos de servidor abrem, para as réplicas em Executar réplicas sem sticky sessions.

A maioria dos exemplos serve a aplicação HTTP do servidor no próprio processo, por meio de lib.loopback, o auxiliar do capítulo 1 para uma aplicação em uma porta loopback livre, para que o gravador veja o lado do servidor. O primeiro exemplo e o de réplicas são as exceções, executando o servidor como processos separados, como faz uma implantação. Tudo escuta apenas em 127.0.0.1.

Esta parte ainda não foi traduzida, por isso está em inglês.

Move the server from stdio to HTTP

Última alteração na edição 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 Aprovado
"""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())
Saídapython 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.

Leia uma troca HTTP

Última alteração na edição 2026.11.11

O cliente em Mova o servidor de stdio para HTTP escondeu tudo isso, mas, quando uma chamada falha atrás de um proxy ou de um gateway, a troca é o que você lê, então vale a pena saber como uma troca correta se parece. Na revisão fixada, todo POST carrega cabeçalhos que copiam partes do seu corpo. MCP-Protocol-Version repete a versão, Mcp-Method repete o método JSON-RPC e Mcp-Name repete a ferramenta, o prompt ou o recurso de tools/call, prompts/get e resources/read. As cópias existem para que balanceadores de carga, gateways e ferramentas de monitoramento possam rotear e inspecionar uma requisição sem analisar o corpo, como explica a especificação do transporte Streamable HTTP.

O corpo continua sendo a fonte da verdade. Um servidor DEVE rejeitar uma requisição cujos cabeçalhos não coincidam com o corpo, com 400 Bad Request e o erro JSON-RPC -32020, HeaderMismatch. Essa regra é o que torna os cabeçalhos seguros para roteamento. Um gateway que envia Mcp-Name: check_stock para as réplicas de estoque pode confiar que o corpo também nomeia check_stock, porque, caso contrário, um servidor recusaria a requisição.

Registrar uma chamada get_order_status com o cliente do SDK mostra uma troca correta. Duas requisições que o cliente do SDK nunca envia, feitas por meio de lib.http_mcp.post, mostram o que o servidor recusa: um tools/call cujo Mcp-Name diz check_stock enquanto o corpo nomeia get_order_status, e um 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 Aprovado
"""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())
Saídapython 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

O cliente fez três POSTs para essa única chamada: server/discover, tools/call, tools/list. O primeiro pergunta ao servidor o que ele suporta, já que não há handshake. O último é o cliente do SDK buscando a lista de ferramentas após a chamada, para que possa verificar o resultado estruturado contra o esquema de saída da ferramenta (mcp/client/session.py, validate_tool_result). O POST de tools/call trazia:

  • MCP-Protocol-Version: 2026-07-28
  • Mcp-Method: tools/call
  • Mcp-Name: get_order_status
  • Accept: application/json, text/event-stream, porque o cliente deve aceitar qualquer uma das duas formas de resposta

O campo _meta do corpo continha as mesmas três chaves que ele contém via stdio: io.modelcontextprotocol/protocolVersion, io.modelcontextprotocol/clientInfo, io.modelcontextprotocol/clientCapabilities. A resposta voltou 200 como application/json, e não definiu nenhum cabeçalho de sessão (mcp-session-id: none).

A resposta era JSON simples porque a ferramenta não enviou nada antes do seu resultado. O SDK não se compromete com um fluxo de eventos até que o handler envie uma notificação ou se passem 15 segundos, então um handler que termina em silêncio dentro dessa janela recebe uma resposta JSON (mcp/server/_streamable_http_modern.py). Esse limite de 15 segundos é um detalhe de implementação desse módulo privado e pode mudar entre versões.

O servidor recusou a requisição incompatível antes de a ferramenta executar, com 400 e erro -32020 mcp-name header does not match the request body's 'name' parameter. O cliente do próprio SDK se recupera do -32020 buscando a lista de ferramentas de novo e reenviando uma vez, porque, na revisão fixada, uma ferramenta pode marcar parâmetros com x-mcp-header, que os clientes copiam para cabeçalhos Mcp-Param-{Name}, e uma listagem desatualizada gera esses cabeçalhos de forma errada (mcp/client/client.py, call_tool).

O GET também foi recusado: 405, com Allow: POST. Um servidor que suporta apenas a revisão fixada DEVE responder a GET e DELETE com 405 Method Not Allowed, porque essa revisão não tem um fluxo que o cliente abra com GET (a especificação do transporte). O aplicativo do SDK também atende as revisões de 2025 e envia um GET sem a versão fixada no cabeçalho MCP-Protocol-Version ao seu handler de 2025, que o atende e recusa apenas um GET marcado com a revisão fixada, como este foi (mcp/server/streamable_http_manager.py).

Regra prática: quando uma chamada HTTP falhar, leia a troca primeiro: os três cabeçalhos de roteamento, _meta no corpo, o status e o tipo de conteúdo. Faça o roteamento em um gateway com base em Mcp-Method e Mcp-Name, se precisar, e nunca reescreva um corpo sem reescrever seus cabeçalhos para que combinem, porque o servidor recusará o par com -32020. Em um servidor que suporta apenas a revisão fixada, um 405 significa que um cliente mais antigo está abrindo um fluxo GET; o aplicativo do SDK atende esses clientes.

Esta parte ainda não foi traduzida, por isso está em inglês.

Stream progress on a long call

Última alteração na edição 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 Aprovado
"""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())
Saídapython 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.

Cancele uma chamada que o cliente não precisa mais

Última alteração na edição 2026.11.11

A recontagem em Transmita o progresso de uma chamada longa foi até o fim porque o cliente esperou por ela. Muitas vezes, porém, o host deixa de precisar da resposta no meio do caminho: a pessoa fecha o chamado, ou o prazo do próprio host expira. Uma chamada que continua rodando depois disso desperdiça a API da loja e mantém ocupado tudo o que a ferramenta segura.

No Streamable HTTP, um cliente cancela uma requisição fechando o stream de resposta dessa requisição. O padrão de cancelamento da especificação chama o stream fechado de "sinal de cancelamento", diz que o servidor DEVE tratar a desconexão do cliente como cancelamento da requisição e afirma que nenhuma mensagem notifications/cancelled é "obrigatória nem esperada". Isso difere do stdio, em que um cliente ainda envia notifications/cancelled, e das revisões de 2025, em que os clientes HTTP também o enviavam. O SDK implementa as duas metades. Seu cliente aborta o POST quando a tarefa que aguarda é cancelada ou quando seu read timeout expira, e não envia mais nada (mcp/client/streamable_http.py). Seu servidor observa a desconexão e cancela a tarefa que executa o handler (mcp/server/_streamable_http_modern.py, watch_disconnect).

Dentro de uma ferramenta async def, o cancelamento chega como a exceção de cancelamento do anyio no próximo await. A ferramenta pode registrar onde parou, mas deve relançar a exceção. Uma limpeza que precisa aguardar algo exige um escopo blindado, como anyio.move_on_after(5, shield=True), ou o cancelamento cancela a limpeza também. Uma ferramenta def comum roda em uma thread de trabalho e só para se chamar anyio.from_thread.check_cancelled(). Uma que nunca o chama roda até o fim, e seu resultado é descartado. O guia de cancelamento do SDK e mcp/server/_streamable_http_modern.py (watch_disconnect) descrevem os dois casos.

Para acompanhar esse caminho de ponta a ponta, o host cancela a chamada no quinto relatório de progresso, como faria quando a pessoa fecha o chamado. Cada produto leva 0.1 segundo aqui, então o servidor ainda está na recontagem do sexto produto quando o stream se fecha. recount_stock registra como cada execução terminou, e o registrador (recorder) anota o que passou pela rede.

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 Aprovado
"""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)
Saídapython 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

A ferramenta parou quando o stream se fechou. O servidor registrou a chamada cancelled with 5 of 64 recounted, e a ferramenta tinha pedido à API da loja 6 recontagens. O cancelamento chegou à ferramenta enquanto ela aguardava a sexta, então os produtos restantes nunca foram enviados à API.

Na rede houve dois POSTs, server/discover, tools/call, e por isso nenhuma mensagem de cancelamento atravessou a conexão. O stream da chamada da ferramenta foi closed by the client, e carregou 5 progress, 0 result. O cliente não recebe resultado de uma chamada cancelada, e o servidor não envia nenhum.

Duas coisas desfazem isso. Com json_response=True, o caminho JSON do SDK não tem observador de desconexão, então uma conexão fechada nunca chega ao handler, e o handler roda até o fim (mcp/server/_streamable_http_modern.py). E um stream que se rompe por qualquer outro motivo, como um proxy que o encerra por timeout, cancela a requisição do mesmo modo. Os streams não podem ser retomados na revisão fixada, então o cliente DEVE enviar a requisição novamente com um novo ID de requisição (registro de alterações). Uma ferramenta que um stream rompido pode interromper deve ser segura para executar duas vezes, e a recontagem é, porque contar de novo dá a mesma contagem. Para uma recontagem que precisa sobreviver à saída do cliente, Inicie uma tarefa em vez de esperar a move para uma tarefa.

Os timeouts funcionam em cima do cancelamento. O padrão de cancelamento diz que um remetente DEVERIA definir um timeout para cada requisição, PODE redefini-lo quando chega progresso e DEVERIA sempre impor um máximo. Client(read_timeout_seconds=...), e o mesmo argumento em call_tool, definem esse limite, e esgotar o tempo cancela a chamada ao fechar seu stream (mcp/client/streamable_http.py).

Regra prática: Cancele uma chamada sobre Streamable HTTP cancelando a tarefa que a aguarda, ou com um timeout, e deixe o SDK fechar o stream. Escreva ferramentas longas como async def, relance a exceção de cancelamento e coloque qualquer limpeza aguardada sob um escopo blindado. Torne segura para nova execução toda ferramenta que roda por muito tempo, porque um stream rompido perde a chamada e o cliente a envia de novo.

Esta parte ainda não foi traduzida, por isso está em inglês.

Run replicas without sticky sessions

Última alteração na edição 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 Aprovado
"""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())
Saídapython 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.

Rejeitar requisições de outras origens

Última alteração na edição 2026.11.11

As réplicas em Execute réplicas sem sticky sessions escutam em 127.0.0.1, o que parece privado. Não é. Qualquer página web aberta em um navegador na mesma máquina pode enviar requisições a uma porta de loopback. Com DNS rebinding, o domínio de um atacante pode ser feito para resolver para 127.0.0.1 depois que a página é carregada, de modo que o navegador trata o servidor local como parte do site do atacante. O tutorial da especificação sobre servidores locais diz que vincular a 127.0.0.1 "não é um limite de autenticação" (segurança de servidor local).

O navegador entrega ao servidor a sua defesa. Ele envia o Origin da página em cada requisição que faz em nome dela. O transporte Streamable HTTP da especificação diz que os servidores DEVEM validar o Origin em cada conexão recebida, DEVEM responder 403 quando ele estiver presente e for inválido, e DEVEM preferencialmente vincular a 127.0.0.1 quando executarem localmente (DEVERIAM). Verificar também o Host evita o caso de rebinding, em que o navegador informa o domínio do atacante.

O SDK ativa as duas verificações por padrão. Quando o host do app é um nome de loopback e você não passa transport_security, ele permite apenas valores Host 127.0.0.1:*, localhost:* e [::1]:*, e apenas valores Origin com os mesmos nomes sob http:// (mcp/server/mcpserver/server.py). Quatro requisições testam esse padrão: tools/list sem Origin, com a origem própria do servidor, com http://attacker.example, e com um Host de fernhill.example. Em seguida, ele constrói o mesmo app com host="0.0.0.0", a configuração comum em contêineres, e envia novamente as duas requisições estrangeiras. Esse app vincula a 127.0.0.1, já que apenas a configuração está em teste.

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 Aprovado
"""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()
Saídapython 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

O padrão de loopback recusou as duas requisições estrangeiras. Uma requisição sem Origin recebeu 200 tools listed, e a origem própria do servidor também: 200 tools listed. A origem estrangeira recebeu 403 Invalid Origin header, e o host estrangeiro recebeu 421 Invalid Host header, ambos como texto simples e não como JSON-RPC (mcp/server/transport_security.py). A especificação permite um corpo de qualquer um dos dois tipos com o 403.

Construído com host="0.0.0.0", o app deixou passar as duas: 200 tools listed e 200 tools listed. Um host que o SDK não reconhece como loopback apenas impede que ele ative o padrão, e, sem configurações passadas, a verificação fica desligada (mcp/server/transport_security.py). Isso fica aquém do DEVE da especificação, e nada nos logs informa isso.

A requisição sem Origin mostra o que essa defesa cobre. Navegadores enviam Origin, enquanto scripts, ferramentas de linha de comando e outros servidores não enviam, e o SDK deixa passar uma requisição sem ele. A validação de Origin protege um servidor contra páginas web. Ela não faz nada contra um programa que consegue alcançar a porta, e para isso existe a autorização (Autorize clientes com OAuth).

Regra prática: Mantenha o padrão de loopback do SDK na máquina do desenvolvedor. Ao implantar em qualquer outro endereço, passe transport_security=TransportSecuritySettings(allowed_hosts=[...], allowed_origins=[...]) com os nomes que seu servidor atende, como mcp.fernhill.example, e nunca dependa do padrão. Trate a validação de Origin como proteção apenas contra navegadores, e coloque a autorização na frente de todo servidor que seja alcançável por algo além do próprio host.

Escolha stdio ou Streamable HTTP

Última alteração na edição 2026.11.11

As seções anteriores levaram o servidor da loja para o Streamable HTTP. O trabalho que essa mudança exigiu, desde o cancelamento até as réplicas e as verificações de origem, é o preço da mudança. O stdio não tem nada disso. O transporte stdio na especificação faz com que o cliente inicie o servidor como um subprocesso e troque mensagens pela sua entrada e saída padrão. O host é dono do processo, então nada mais consegue alcançá-lo, o servidor herda apenas o que o host lhe passa, e ele existe enquanto o host precisar dele.

Os transportes diferem em quem executa o servidor e no que decorre disso:

stdio Streamable HTTP
Iniciado por o host, um por host você, uma vez para muitos hosts
Acessível por o seu próprio host qualquer coisa que alcance o endereço
Cancelar notifications/cancelled fechar o fluxo de resposta
Logs erro padrão os logs do seu servidor
Credenciais o ambiente do host tokens de acesso OAuth
Escala por um processo por host réplicas atrás de um balanceador de carga

Recomendamos o stdio para um servidor que atende um único usuário na máquina desse usuário, como um que lê arquivos locais ou usa as credenciais próprias do usuário, e para desenvolvimento. Recomendamos o Streamable HTTP quando vários hosts compartilham um servidor, quando o servidor precisa ficar ao lado de sistemas que os hosts não conseguem alcançar, como a API da loja dentro da rede dela, ou quando você precisa implantar, escalar e monitorar o servidor como um serviço. Nesse caso, planeje a autorização desde o início, porque um servidor em um endereço precisa saber quem está chamando (Encontrar o servidor de autorização a partir do recurso).

Com muitos hosts, a API da loja não deve ser acessível a partir dos notebooks da equipe de suporte, então o servidor passa para o Streamable HTTP. O livro mantém o stdio para os exemplos que precisam de apenas um host e um servidor, porque um subprocesso é a forma mais curta de executar um.

Regra prática: Publique um servidor por stdio quando ele atuar para um usuário na máquina desse usuário. Publique-o por Streamable HTTP quando atender a vários hosts, proteger sistemas que os hosts não conseguem alcançar ou precisar escalar, e configure verificações de origem e autorização antes do seu primeiro usuário externo. O mesmo código de servidor pode atender aos dois casos, então escolha por implantação, não por servidor.

O que dá errado em produção

Última alteração na edição 2026.11.11

O servidor da loja funciona em loopback com um cliente por vez. Atrás de proxies reais, balanceadores de carga e clientes, ele quebra de formas que o loopback nunca mostra. Aqui está cada uma, com a aparência que ela tem.

Toda requisição recebe 421. A implantação manteve a lista de permissões de loopback do SDK, e as requisições chegam com o nome público do servidor em Host. O sinal é Invalid Host header em texto simples em cada chamada, e nada nos logs da ferramenta. Passe allowed_hosts com os nomes pelos quais o servidor responde (Rejeite requisições de outras origens).

As verificações ficam desligadas sem que ninguém decida isso. Um servidor iniciado com host="0.0.0.0", a configuração comum em contêineres, aceita qualquer Host e Origin (mcp/server/transport_security.py). Nada falha, então o único sinal é uma sonda como reject-a-foreign-origin retornar 200. Execute essa sonda em cada implantação e defina transport_security explicitamente.

O progresso chega tudo de uma vez. Um proxy que armazena a resposta em buffer retém cada notificação até o resultado. O SDK envia X-Accel-Buffering: no, o cabeçalho que a especificação indica para isso, mas proxies e CDNs que ignoram esse cabeçalho têm configurações próprias. Uma barra de progresso que pula de nada para concluído denuncia o problema. Teste o progresso pelo caminho real, não em loopback.

Chamadas longas morrem em um número redondo de segundos. Proxies e balanceadores de carga fecham conexões ociosas após um tempo fixo. Depois que um fluxo está aberto, o SDK envia um comentário : ping a cada 15 segundos sem outro evento, para mantê-lo ocupado (mcp/server/_streamable_http_modern.py). Um proxy com limite de ociosidade menor, ou com um limite total por requisição, ainda corta o fluxo, e o corte cancela a ferramenta. Procure cancelamentos agrupados em uma mesma duração. Aumente os limites do proxy para o caminho do MCP, ou mova o trabalho para uma tarefa (Inicie uma tarefa em vez de esperar).

Uma nova tentativa executa o trabalho duas vezes. Um fluxo interrompido não pode ser retomado, e o cliente envia a requisição novamente com um novo ID (registro de alterações). Uma ferramenta que não é segura para repetir executa seu efeito colateral duas vezes. O issue_refund da loja é seguro porque uma cotação é reembolsada uma única vez, e com o armazenamento compartilhado isso vale em todas as réplicas. Dê a cada ferramenta com efeito colateral um identificador ou uma chave que faça a segunda chamada retornar o resultado da primeira, e guarde esse registro onde todas as réplicas o vejam.

json_response=True silencia o progresso e o cancelamento. Isso é tentador atrás de um gateway que não gosta de fluxos de eventos, e o SDK não emite nenhum aviso (Transmita o progresso de uma chamada longa). Aparece como chamadas longas que nunca reportam progresso e continuam executando depois que os clientes saem.

Um gateway reescreve o corpo. Um gateway que edita corpos JSON, mas não cabeçalhos, faz as requisições falharem com -32020, HeaderMismatch. O cliente do SDK reenvia uma vez após buscar a lista de ferramentas, então você verá requisições tools/call duplicadas e um fluxo constante de -32020 nas respostas do servidor.

Clientes da revisão de 2025 precisam de sessões. O mesmo aplicativo atende clientes da era 2025 pelo handshake antigo e, por padrão, mantém as sessões deles na memória de um único processo, o que exige roteamento fixo (mcp/server/streamable_http_manager.py). Observe 404 com "Session not found" apenas desses clientes, depois que uma requisição cai em outra réplica (mcp/server/streamable_http_manager.py). Defina stateless_http=True se você os atender atrás de um balanceador de carga, e saiba o custo: esses clientes perdem o cancelamento, então seus handlers executam até o fim, independentemente do que o cliente fizer (cancelamento), e perdem as requisições do servidor para o cliente, como sampling e elicitation (implantação e escala). Atenda clientes antigos e novos durante a transição analisa a troca.

Requisições grandes falham com 413. O SDK limita o corpo de uma requisição a 4 MiB por padrão (mcp/server/transport_security.py). Uma ferramenta que recebe um documento como argumento esbarra nesse limite primeiro. Aumente max_request_body_size para esse servidor, ou passe uma referência ao documento em vez dos seus bytes.

Regra prática: Antes que o servidor da loja receba tráfego em um endereço, teste quatro coisas pelo caminho real do proxy: um Origin de outro domínio recebe 403, o progresso chega enquanto a chamada executa, uma chamada mais longa que o limite de ociosidade do proxy sobrevive, e fechar o fluxo de uma chamada interrompe a ferramenta. Depois, monitore 421, 403 e -32020 por cliente, e os cancelamentos por duração.

Decisões tomadas neste capítulo

Última alteração na edição 2026.11.11
  • O servidor da loja passa a usar Streamable HTTP para os hosts da equipe de suporte, com as ferramentas do capítulo 3 sem alterações. O stdio continua nos exemplos com um host e um servidor.
  • MCPServer.run(transport="streamable-http") com os padrões do SDK: loopback, caminho /mcp e o modo de resposta padrão, que transmite em fluxo. stateless_http permanece não definido até que clientes da era de 2025 precisem ser atendidos atrás de um balanceador de carga, e então isso lhes custa o cancelamento.
  • json_response=True nunca é usado, porque ele descarta o progresso e o cancelamento.
  • recount_stock informa o progresso após cada produto, com um total e uma mensagem, e é seguro executá-lo duas vezes.
  • O cancelamento é um fluxo fechado. Ferramentas longas são async def, relançam o cancelamento e protegem com blindagem (shield) qualquer limpeza aguardada.
  • As réplicas compartilham o nome do servidor e as chaves requestState por meio de SHOP_REQUEST_STATE_KEY, e suas cotações e confirmações respondidas por meio de um único armazenamento compartilhado, SHOP_STATE_STORE. Toda requisição, inclusive reembolsos, pode ser executada em qualquer réplica. O armazenamento dos exemplos é um arquivo SQLite com linhas JSON e expiração por relógio de parede; uma implantação usa um banco de dados que as réplicas compartilham.
  • As verificações de Origin e Host continuam ativas. Em qualquer endereço que não seja loopback, transport_security lista explicitamente os nomes do servidor. A autorização, e não o Origin, impede o acesso de chamadores que não são navegadores.
  • Gateways podem rotear com base em Mcp-Method e Mcp-Name, pois o servidor rejeita uma requisição cujos cabeçalhos divergem do seu corpo. Nenhum gateway reescreve um corpo.
  • Os rastreamentos HTTP vêm de lib.wire.record_http, e as requisições escritas à mão, de lib.http_mcp.post, apenas para mostrar erros que o cliente do SDK nunca causaria.
  • Os exemplos executam as réplicas como processos separados, para que cada uma tenha sua própria memória e sua própria chave, como em uma implantação.

Este capítulo, nesta edição

Edição 2026.11.14Exemplos aprovados em 19 de nov de 20266 de 6 exemplos exemplos deste capítulo passam

Traduzido do livro em inglês, edição 2026.11.14.

Citar esta seção

Formato

Cada formato cita o livro em inglês, que esta tradução acompanha.

Todos os formatos citam esta edição. Seu link abre a edição atual, em que o título de cada seção indica quando seu texto foi alterado pela última vez. As datas de acesso e de recuperação são o dia em que você abre esta página.

Nesta página

Capítulo 6 de 12: Servir via Streamable HTTP

  1. Move the server from stdio to HTTP
  2. Leia uma troca HTTP
  3. Stream progress on a long call
  4. Cancele uma chamada que o cliente não precisa mais
  5. Run replicas without sticky sessions
  6. Rejeitar requisições de outras origens
  7. Escolha stdio ou Streamable HTTP
  8. O que dá errado em produção
  9. Decisões tomadas neste capítulo

Voltar ao topoTodos os capítulos