Can't Make MCP Sampling Work Over Streamable HTTP

[librac123]

Hello,

I'm using the sampling http client and server examples, but it doesn't work for me.
The server receives a tool call and initiates sampling, but the the sampling request never reaches the client.

Code below:

Server:

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/mark3labs/mcp-go/mcp"
	"github.com/mark3labs/mcp-go/server"
)

func main() {
	// Create MCP server with sampling capability
	mcpServer := server.NewMCPServer("sampling-http-server", "1.0.0")

	// Enable sampling capability
	mcpServer.EnableSampling()

	// Add a tool that uses sampling to get LLM responses
	mcpServer.AddTool(mcp.Tool{
		Name:        "ask_llm",
		Description: "Ask the LLM a question using sampling over HTTP",
		InputSchema: mcp.ToolInputSchema{
			Type: "object",
			Properties: map[string]any{
				"question": map[string]any{
					"type":        "string",
					"description": "The question to ask the LLM",
				},
				"system_prompt": map[string]any{
					"type":        "string",
					"description": "Optional system prompt to provide context",
				},
			},
			Required: []string{"question"},
		},
	}, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		fmt.Println("DEBUG - Tool has been called.")
		// Extract parameters
		question, err := request.RequireString("question")
		if err != nil {
			return nil, err
		}
		fmt.Println("DEBUG - question is ", question)

		systemPrompt := request.GetString("system_prompt", "You are a helpful assistant.")

		// Create sampling request
		samplingRequest := mcp.CreateMessageRequest{
			CreateMessageParams: mcp.CreateMessageParams{
				Messages: []mcp.SamplingMessage{
					{
						Role: mcp.RoleUser,
						Content: mcp.TextContent{
							Type: "text",
							Text: question,
						},
					},
				},
				SystemPrompt: systemPrompt,
				MaxTokens:    1000,
				Temperature:  0.7,
			},
		}

		// Request sampling from the client with timeout
		samplingCtx, cancel := context.WithTimeout(ctx, 2*time.Minute)
		defer cancel()

		fmt.Println("About to request sampling from the client.")

		serverFromCtx := server.ServerFromContext(ctx)
		result, err := serverFromCtx.RequestSampling(samplingCtx, samplingRequest)
		if err != nil {
			fmt.Println("DEBUG - error requesting sampling from the client")
			fmt.Println("DEBUG - error is ", err)
			return &mcp.CallToolResult{
				Content: []mcp.Content{
					mcp.TextContent{
						Type: "text",
						Text: fmt.Sprintf("Error requesting sampling: %v", err),
					},
				},
				IsError: true,
			}, nil
		}

		// Extract response text safely
		var responseText string
		if textContent, ok := result.Content.(mcp.TextContent); ok {
			responseText = textContent.Text
		} else {
			responseText = fmt.Sprintf("%v", result.Content)
		}

		fmt.Println("DEBUG - response text is: ", responseText)

		// Return the LLM response
		return &mcp.CallToolResult{
			Content: []mcp.Content{
				mcp.TextContent{
					Type: "text",
					Text: fmt.Sprintf("LLM Response (model: %s): %s", result.Model, responseText),
				},
			},
		}, nil
	})

	// Add a simple echo tool for testing
	mcpServer.AddTool(mcp.Tool{
		Name:        "echo",
		Description: "Echo back the input message",
		InputSchema: mcp.ToolInputSchema{
			Type: "object",
			Properties: map[string]any{
				"message": map[string]any{
					"type":        "string",
					"description": "The message to echo back",
				},
			},
			Required: []string{"message"},
		},
	}, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
		message := request.GetString("message", "")

		return &mcp.CallToolResult{
			Content: []mcp.Content{
				mcp.TextContent{
					Type: "text",
					Text: fmt.Sprintf("Echo: %s", message),
				},
			},
		}, nil
	})

	// Create HTTP server
	httpServer := server.NewStreamableHTTPServer(mcpServer)

	log.Println("Starting HTTP MCP server with sampling support on :8080")
	log.Println("Endpoint: http://localhost:8080/mcp")
	log.Println("")
	log.Println("This server supports sampling over HTTP transport.")
	log.Println("Clients must:")
	log.Println("1. Initialize with sampling capability")
	log.Println("2. Establish SSE connection for bidirectional communication")
	log.Println("3. Handle incoming sampling requests from the server")
	log.Println("4. Send responses back via HTTP POST")
	log.Println("")
	log.Println("Available tools:")
	log.Println("- ask_llm: Ask the LLM a question (requires sampling)")
	log.Println("- echo: Simple echo tool (no sampling required)")

	// Start the server
	if err := httpServer.Start(":8080"); err != nil {
		log.Fatalf("Server failed to start: %v", err)
	}
}

Client:

package main

import (
	"context"
	"fmt"
	"log"
	"os"
	"os/signal"
	"syscall"

	"github.com/mark3labs/mcp-go/client"
	"github.com/mark3labs/mcp-go/client/transport"
	"github.com/mark3labs/mcp-go/mcp"
)

// MockSamplingHandler implements client.SamplingHandler for demonstration.
// In a real implementation, this would integrate with an actual LLM API.
type MockSamplingHandler struct{}

func (h *MockSamplingHandler) CreateMessage(ctx context.Context, request mcp.CreateMessageRequest) (*mcp.CreateMessageResult, error) {
	fmt.Println("DEBUG - sampling handler activated")
	// Extract the user's message
	if len(request.Messages) == 0 {
		return nil, fmt.Errorf("no messages provided")
	}

	// Get the last user message
	lastMessage := request.Messages[len(request.Messages)-1]
	userText := ""
	if textContent, ok := lastMessage.Content.(mcp.TextContent); ok {
		userText = textContent.Text
	}

	// Generate a mock response
	responseText := fmt.Sprintf("Mock LLM response to: '%s'", userText)

	log.Printf("Mock LLM generating response: %s", responseText)

	result := &mcp.CreateMessageResult{
		SamplingMessage: mcp.SamplingMessage{
			Role: mcp.RoleAssistant,
			Content: mcp.TextContent{
				Type: "text",
				Text: responseText,
			},
		},
		Model:      "mock-model-v1",
		StopReason: "endTurn",
	}

	return result, nil
}

func main() {
	// Create sampling handler
	samplingHandler := &MockSamplingHandler{}

	// Create HTTP transport directly
	httpTransport, err := transport.NewStreamableHTTP(
		"http://localhost:8080/mcp", // Replace with your MCP server URL
		// You can add HTTP-specific options here like headers, OAuth, etc.
	)

	if err != nil {
		log.Fatalf("Failed to create HTTP transport: %v", err)
	}
	defer httpTransport.Close()

	// Create client with sampling support
	mcpClient := client.NewClient(
		httpTransport,
		client.WithSamplingHandler(samplingHandler),
	)

	// Start the client
	ctx := context.Background()
	err = mcpClient.Start(ctx)
	if err != nil {
		log.Fatalf("Failed to start client: %v", err)
	}

	// Initialize the MCP session
	initRequest := mcp.InitializeRequest{
		Params: mcp.InitializeParams{
			ProtocolVersion: mcp.LATEST_PROTOCOL_VERSION,
			Capabilities:    mcp.ClientCapabilities{
				// Sampling capability will be automatically added by the client
			},
			ClientInfo: mcp.Implementation{
				Name:    "sampling-http-client",
				Version: "1.0.0",
			},
		},
	}

	_, err = mcpClient.Initialize(ctx, initRequest)
	if err != nil {
		log.Fatalf("Failed to initialize MCP session: %v", err)
	}

	ctx = context.Background()
	result, err := mcpClient.ListTools(ctx, mcp.ListToolsRequest{})
	fmt.Println(result)
	fmt.Println("About to print the results of the request:")
	requestResult, err := mcpClient.CallTool(ctx, mcp.CallToolRequest{
		Params: mcp.CallToolParams{
			Name: "ask_llm",
			Arguments: map[string]interface{}{
				"question": "What's the capital city of the UK?",
				"format":   "text",
			},
		},
	})

	fmt.Println(requestResult)

	log.Println("HTTP MCP client with sampling support started successfully!")
	log.Println("The client is now ready to handle sampling requests from the server.")
	log.Println("When the server sends a sampling request, the MockSamplingHandler will process it.")

	// In a real application, you would keep the client running to handle sampling requests
	// For this example, we'll just demonstrate that it's working

	// Keep the client running (in a real app, you'd have your main application logic here)
	sigChan := make(chan os.Signal, 1)
	signal.Notify(sigChan, os.Interrupt, syscall.SIGTERM)

	select {
	case <-ctx.Done():
		log.Println("Client context cancelled")
	case <-sigChan:
		log.Println("Received shutdown signal")
	}
}

Server log:

2025/09/17 14:07:42 Starting HTTP MCP server with sampling support on :8080
2025/09/17 14:07:42 Endpoint: http://localhost:8080/mcp
2025/09/17 14:07:42 
2025/09/17 14:07:42 This server supports sampling over HTTP transport.
2025/09/17 14:07:42 Clients must:
2025/09/17 14:07:42 1. Initialize with sampling capability
2025/09/17 14:07:42 2. Establish SSE connection for bidirectional communication
2025/09/17 14:07:42 3. Handle incoming sampling requests from the server
2025/09/17 14:07:42 4. Send responses back via HTTP POST
2025/09/17 14:07:42 
2025/09/17 14:07:42 Available tools:
2025/09/17 14:07:42 - ask_llm: Ask the LLM a question (requires sampling)
2025/09/17 14:07:42 - echo: Simple echo tool (no sampling required)

Client log:

&{{{<nil>} } [{<nil> ask_llm Ask the LLM a question using sampling over HTTP {map[] object map[question:map[description:The question to ask the LLM type:string] system_prompt:map[description:Optional system prompt to provide context type:string]] [question]} [] {map[]  map[] []} [] { <nil> <nil> <nil> <nil>}} {<nil> echo Echo back the input message {map[] object map[message:map[description:The message to echo back type:string]] [message]} [] {map[]  map[] []} [] { <nil> <nil> <nil> <nil>}}]}
About to print the results of the request:
&{{<nil>} [{{<nil>} <nil> text Error requesting sampling: context deadline exceeded}] <nil> true}
2025/09/17 14:39:04 HTTP MCP client with sampling support started successfully!
2025/09/17 14:39:04 The client is now ready to handle sampling requests from the server.
2025/09/17 14:39:04 When the server sends a sampling request, the MockSamplingHandler will process it.

Any help would be appreciated.