How do I stream the results from an mcp tool call

[aparnarajan-pf]

Pre-submission Checklist

• I have checked that this question would not be more appropriate as an issue in a specific repository
• I have searched existing discussions and documentation for answers

Question Category

• Protocol Specification
• SDK Usage
• Server Implementation
• General Implementation
• Documentation
• Other

Your Question

I have a tool which invokes another llm and returns streaming response. How do I send this response as part of mcp call tool result? I have look at the examples, couldnt find an example where response is streamed. I saw similar discussion in other programing language library implementations

mcpServer := mcp.NewServer(
					&mcp.Implementation{Name: "pf-mcp", Version: "1.0.0"},
					nil,
				)
				tools.RegisterTools(mcpServer, cfg, documentSearchTool)

				handler := mcp.NewStreamableHTTPHandler(func(_ *http.Request) *mcp.Server {
					return mcpServer
				}, nil)

// Client
				
type Client struct {
	client    *mcp.Client
	transport *mcp.StreamableClientTransport

	clientSession *mcp.ClientSession
	sessionMu     sync.Mutex

	tools  atomic.Value // *mcp.ListToolsResult
	closed bool
}

func NewClient(url string, name string, version string) (*Client, error) {
	client := &Client{
		client: mcp.NewClient(&mcp.Implementation{
			Name:    name,
			Version: version,
		}, nil),
		transport: &mcp.StreamableClientTransport{Endpoint: url},
	}
	err := client.discoverTools(context.Background())

	return client, err
}

func (c *Client) session(ctx context.Context) (*mcp.ClientSession, error) {
	c.sessionMu.Lock()
	defer c.sessionMu.Unlock()

	if c.clientSession != nil && !c.closed {
		return c.clientSession, nil
	}

	session, err := c.client.Connect(ctx, c.transport, nil)
	if err != nil {
		return nil, err
	}

	log.Info(ctx, "connected to MCP server (clientSession ID: %s)", session.ID())
	c.clientSession = session
	c.closed = false

	return c.clientSession, nil
}

func (c *Client) callTool(ctx context.Context, name string, args map[string]any) (*mcp.CallToolResult, error) {
	session, err := c.session(ctx)
	if err != nil {
		return nil, fmt.Errorf("MCP client is not connected")
	}

	log.Info(ctx, "calling MCP tool with name: %s and args: %+v", name, args)

	callToolResult, err := session.CallTool(ctx, &mcp.CallToolParams{
		Name:      name,
		Arguments: args,
	})
	if err != nil {
		log.Errorf(ctx, "Failed to call tool %v", err)

		return nil, fmt.Errorf("failed to call tool: %w", err)
	}

	return callToolResult, nil
}
				```

[findleyr]

The short answer is: I don't think the SDK supports that currently. I also don't think this is well defined in the spec, though please correct me if I'm wrong. The transport interface (and the transport concept in the MCP spec) abstracts away the underlying wire format, and so MCP is very request-response oriented.

Just so I understand, you want to be able to stream your response as partial JSON, right?

E.g. you want your consumer to immediately observe the following blob, and be able to parse and extract streaming content elements?

{
  "content": [
    {"text": ...},

[aparnarajan-pf]

Yes. I want to stream the response as partial json or as a character stream. Similar to how plain HTTP supports chunked data transfer.

[findleyr]

Got it. Do you have an example of an MCP client or host that supports this? What are you trying to integrate with?

This is still being discussed at the MCP spec level, for example in modelcontextprotocol/modelcontextprotocol#776. I'm hesitant to add support to the SDK until the larger discussion is resolved. With that said, at the transport level we could theoretically change our SSE streaming responses to be chunked, with multiple data: fields per record (see https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events#data).

Before thinking about that, I'd want to understand if it would actually solve your problem. In order to determine this, we need to see the relevant client logic.

[aparnarajan-pf]

My current implementation is what I shared earlier. I want to add a tool to the mcp service which will invoke an llm using aws bedrock and returns a streaming response. The service is a streamable http service. My client here is an agentic ai app, which stream the repsonse from the mcp service as sse events,

my agentic ai app is equipped to send the data in this format to the front end
`data: {"type":"text_chunk","content":"H","suggestions":null}

data: {"type":"text_chunk","content":"e","suggestions":null}

data: {"type":"text_chunk","content":"r","suggestions":null}

data: {"type":"text_chunk","content":"e","suggestions":null}

data: {"type":"text_chunk","content":"’","suggestions":null}

data: {"type":"text_chunk","content":"s","suggestions":null}

data: {"type":"text_chunk","content":" ","suggestions":null}

data: {"type":"text_chunk","content":"h","suggestions":null}

data: {"type":"text_chunk","content":"o","suggestions":null}

data: {"type":"text_chunk","content":"w","suggestions":null}`

[aparnarajan-pf]

Is there a workaround I can use temporarily to enable streaming from the service?

[aparnarajan-pf]

@findleyr Following up on this. In my use case, I removed the llm call from the mcp service for now, But I am keen to understand more about this

With that said, at the transport level we could theoretically change our SSE streaming responses to be chunked, with multiple data: fields per record (see