MCP: Streaming responses for tool calls (August 2026) (Pending)¶

Starting August 20, 2026, Snowflake’s managed MCP server returns tool call responses as Server-Sent Events (SSE) streams instead of single JSON payloads. This aligns Snowflake’s MCP implementation with the MCP specification (2025-11-25), which requires clients to support SSE as a transport. MCP clients that follow the official specification are already compliant and require no changes. Clients that parse the tools/call response as a single JSON body must be updated to consume an SSE stream.

Behavior change¶

Before the change:

When an MCP client sends a tools/call request to the Snowflake MCP endpoint, the server returns the result as a single JSON response:

Content-Type: application/json

{ "result": { ... } }

After the change:

When an MCP client sends a tools/call request to the Snowflake MCP endpoint, the server initializes a Server-Sent Events stream:

Content-Type: text/event-stream

data: { "result": { ... } }

data: [DONE]

Per the MCP specification, the client must include an Accept header that lists both application/json and text/event-stream as accepted content types:

Accept: application/json, text/event-stream

Impact¶

This change affects MCP clients that interact with the Snowflake managed MCP server and parse the tools/call response as a single JSON body. Specifically:

• Clients that don’t include text/event-stream in the Accept header may receive an error or an unexpected response format.
• Clients that read the full response body as JSON (for example, response.json() in Python or response.json() in JavaScript fetch) won’t receive a complete result because the response body is now a stream.
• Clients that follow the MCP specification (2025-11-25) and already handle SSE responses aren’t affected.

What you should do¶

If your MCP client parses the tools/call response as a single JSON body, update it before August 20, 2026:

1. Update the Accept header. Add text/event-stream to the Accept header on all requests to the Snowflake MCP endpoint:

   Accept: application/json, text/event-stream
   

2. Handle the SSE response. Update your response handler to consume an SSE stream instead of a single JSON body. The stream delivers one or more data: events and closes with a data: [DONE] event.

   Example using Python (httpx-sse):

   Copy code

   from httpx_sse import connect_sse
   import httpx
   
   mcp_server_url = (
       "https://<account_url>/api/v2/databases/<database>"
       "/schemas/<schema>/mcp-servers/<name>"
   )
   
   with httpx.Client() as client:
       with connect_sse(
           client,
           "POST",
           mcp_server_url,
           headers={
               "Authorization": f"Bearer {token}",
               "Content-Type": "application/json",
               "Accept": "application/json, text/event-stream",
           },
           json={
               "jsonrpc": "2.0",
               "id": 1,
               "method": "tools/call",
               "params": {...},
           },
       ) as event_source:
           for event in event_source.iter_sse():
               print(event.data)
   

   Example using Node.js (eventsource-parser):

   Copy code

   import { createParser } from "eventsource-parser";
   
   const mcpServerUrl =
     "https://<account_url>/api/v2/databases/<database>/schemas/<schema>/mcp-servers/<name>";
   
   const response = await fetch(mcpServerUrl, {
     method: "POST",
     headers: {
       Authorization: `Bearer ${token}`,
       "Content-Type": "application/json",
       Accept: "application/json, text/event-stream",
     },
     body: JSON.stringify({
       jsonrpc: "2.0",
       id: 1,
       method: "tools/call",
       params,
     }),
   });
   
   const parser = createParser((event) => {
     if (event.type === "event") console.log(JSON.parse(event.data));
   });
   
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
     parser.feed(decoder.decode(value));
   }
   

3. Review the MCP specification. Review the MCP transport specification to confirm your client is fully compliant with the 2025-11-25 version.

See also¶

• Snowflake-managed MCP server
• MCP transport specification (2025-11-25)
• Behavior change policy
• Unbundled behavior changes

Ref: 2405