docs

Author: ezynda3

examples/sampling_client/sampling_client

@@ -18,6 +18,7 @@ import (
     "fmt"
 
     "github.com/mark3labs/mcp-go/client"
+    "github.com/mark3labs/mcp-go/client/transport"
     "github.com/mark3labs/mcp-go/mcp"
 )
 
@@ -66,18 +67,18 @@ func main() {
     // Create sampling handler
     samplingHandler := &MySamplingHandler{}
 
+    // Create stdio transport
+    stdioTransport := transport.NewStdio("/path/to/mcp/server", nil)
+    
     // Create client with sampling support
-    mcpClient, err := client.NewStdioClient(
-        "/path/to/mcp/server",
-        client.WithSamplingHandler(samplingHandler),
-    )
-    if err != nil {
-        log.Fatalf("Failed to create client: %v", err)
-    }
-    defer mcpClient.Close()
+    mcpClient := client.NewClient(stdioTransport, client.WithSamplingHandler(samplingHandler))
 
-    // Connect to server
+    // Start the client
     ctx := context.Background()
+    if err := mcpClient.Start(ctx); err != nil {
+        log.Fatalf("Failed to start client: %v", err)
+    }
+    defer mcpClient.Close()
     if err := mcpClient.Connect(ctx); err != nil {
         log.Fatalf("Failed to connect: %v", err)
     }
@@ -150,18 +151,18 @@ func main() {
 
     serverPath := os.Args[1]
 
+    // Create stdio transport
+    stdioTransport := transport.NewStdio(serverPath, nil)
+    
     // Create client with mock sampling handler
-    mcpClient, err := client.NewStdioClient(
-        serverPath,
-        client.WithSamplingHandler(&MockSamplingHandler{}),
-    )
-    if err != nil {
-        log.Fatalf("Failed to create client: %v", err)
-    }
-    defer mcpClient.Close()
+    mcpClient := client.NewClient(stdioTransport, client.WithSamplingHandler(&MockSamplingHandler{}))
 
-    // Connect and test
+    // Start the client
     ctx := context.Background()
+    if err := mcpClient.Start(ctx); err != nil {
+        log.Fatalf("Failed to start client: %v", err)
+    }
+    defer mcpClient.Close()
     if err := mcpClient.Connect(ctx); err != nil {
         log.Fatalf("Failed to connect: %v", err)
     }
@@ -375,10 +376,8 @@ When you provide a sampling handler, the client automatically declares the sampl
 
 ```go
 // This automatically adds sampling capability
-mcpClient, err := client.NewStdioClient(
-    serverPath,
-    client.WithSamplingHandler(handler), // Enables sampling capability
-)
+stdioTransport := transport.NewStdio(serverPath, nil)
+mcpClient := client.NewClient(stdioTransport, client.WithSamplingHandler(handler))
 ```
 
 The client will include this in the initialization request:
@@ -460,8 +459,39 @@ go build -o my_client
 ./my_client ./sampling_server
 ```
 
+## Transport Support
+
+Sampling is available on the following transports:
+
+### STDIO Transport
+
+For STDIO clients, create the transport and client separately:
+
+```go
+stdioTransport := transport.NewStdio("/path/to/server", nil)
+mcpClient := client.NewClient(stdioTransport, client.WithSamplingHandler(&MySamplingHandler{}))
+```
+
+### In-Process Transport
+
+For in-process clients, use the dedicated constructor:
+
+```go
+mcpClient, err := client.NewInProcessClientWithSamplingHandler(
+    mcpServer, 
+    &MySamplingHandler{},
+)
+```
+
+In-process sampling uses direct method calls instead of JSON-RPC serialization.
+
+### Unsupported Transports
+
+SSE and StreamableHTTP transports do not support sampling due to their one-way or stateless nature.
+
 ## Next Steps
 
 - Learn about [server-side sampling implementation](/servers/advanced-sampling)
 - Explore [client operations](/clients/operations)
-- Check out the [sampling examples](https://github.com/mark3labs/mcp-go/tree/main/examples/sampling_client)
+- Check out the [sampling examples](https://github.com/mark3labs/mcp-go/tree/main/examples/sampling_client)
+- See [in-process transport documentation](/transports/inprocess) for embedded scenarios

www/docs/pages/clients/advanced-sampling.mdx

@@ -352,8 +352,48 @@ func getTextFromContent(content interface{}) string {
 }
 ```
 
+## Transport Support
+
+Sampling is supported on the following transports:
+
+### STDIO Transport
+
+STDIO transport provides full sampling support with JSON-RPC message passing:
+
+```go
+// Start STDIO server with sampling
+server.ServeStdio(mcpServer)
+```
+
+The client must implement a `SamplingHandler` and declare sampling capability during initialization.
+
+### In-Process Transport
+
+In-process transport offers the most efficient sampling implementation with direct method calls:
+
+```go
+// Create in-process client with sampling handler
+mcpClient, err := client.NewInProcessClientWithSamplingHandler(mcpServer, samplingHandler)
+if err != nil {
+    log.Fatal(err)
+}
+```
+
+**Benefits of in-process sampling:**
+- **Direct Method Calls**: No JSON-RPC serialization overhead
+- **Type Safety**: Compile-time type checking
+
+### Unsupported Transports
+
+The following transports do not currently support sampling:
+- **SSE Transport**: One-way streaming nature prevents bidirectional sampling
+- **StreamableHTTP Transport**: Stateless HTTP requests don't support sampling callbacks
+
+For these transports, consider implementing LLM integration directly in your tool handlers rather than using sampling.
+
 ## Next Steps
 
 - Learn about [client-side sampling implementation](/clients/advanced-sampling)
 - Explore [advanced server features](/servers/advanced)
-- Check out the [sampling examples](https://github.com/mark3labs/mcp-go/tree/main/examples/sampling_server)
+- Check out the [sampling examples](https://github.com/mark3labs/mcp-go/tree/main/examples/sampling_server)
+- See [in-process sampling documentation](/transports/inprocess#sampling-support) for embedded scenarios

www/docs/pages/servers/advanced-sampling.mdx

@@ -13,12 +13,12 @@ Transport layers handle the communication between MCP clients and servers. Each
 
 ## Transport Comparison
 
-| Transport | Use Case | Pros | Cons |
-|-----------|----------|------|------|
-| **STDIO** | CLI tools, desktop apps | Simple, secure, no network | Single client, local only |
-| **SSE** | Web apps, real-time | Multi-client, real-time, web-friendly | HTTP overhead, one-way streaming |
-| **StreamableHTTP** | Web services, APIs | Standard protocol, caching, load balancing | No real-time, more complex |
-| **In-Process** | Embedded, testing | No serialization, fastest | Same process only |
+| Transport | Use Case | Pros | Cons | Sampling Support |
+|-----------|----------|------|------|------------------|
+| **STDIO** | CLI tools, desktop apps | Simple, secure, no network | Single client, local only | ✅ Full support |
+| **SSE** | Web apps, real-time | Multi-client, real-time, web-friendly | HTTP overhead, one-way streaming | ❌ Not supported |
+| **StreamableHTTP** | Web services, APIs | Standard protocol, caching, load balancing | No real-time, more complex | ❌ Not supported |
+| **In-Process** | Embedded, testing | No serialization, fastest | Same process only | ✅ Full support |
 
 ## Quick Example
 
@@ -131,12 +131,14 @@ func handleEcho(ctx context.Context, req mcp.CallToolRequest) (*mcp.CallToolResu
 - Testing and development
 - High-performance scenarios
 - Library integrations
+- Sampling-enabled applications
 
 **Example use cases:**
 - Testing MCP implementations
 - Embedded analytics engines
 - High-frequency trading systems
 - Real-time game servers
+- LLM-powered applications with bidirectional communication
 
 ## Transport Configuration