feat: Adding MCP Client-Side Sampling to Roo Code

[neno-is-ooo]

Overview

Implement support for MCP (Model Context Protocol) bidirectional "sampling" capability in Roo Code. This feature would allow MCP servers to request LLM completions from client-managed models while preserving privacy and client control.

Background

What is MCP Sampling?

The Model Context Protocol's sampling feature reverses the traditional client-server relationship for LLM interactions. Instead of clients making requests to servers, sampling allows MCP servers to request LLM completions from the client. This gives clients full control over model selection, hosting, privacy, and cost management.

From the [MCP documentation](https://modelcontextprotocol.io/docs/concepts/sampling):

Sampling is a powerful MCP feature that allows servers to request LLM completions through the client, enabling sophisticated agentic behaviors while maintaining security and privacy.

Currently, Roo Code implements a traditional MCP client that only sends requests to servers. Adding sampling support would enable bidirectional communication that maintains user privacy while expanding capabilities.

Areas Requiring Investigation

Before proceeding with implementation, we need to investigate:

1. MCP Sampling Protocol Specification

   • Review the official MCP sampling protocol details
   • Identify required request/response format
   • Understand capability reporting requirements

2. Latest SDK Requirements

   • Determine if our current @modelcontextprotocol/sdk version (1.7.0) supports sampling
   • Identify any new SDK dependencies required

3. Model Completion Integration

   • Evaluate how completions would be executed in Roo Code's architecture
   • Assess integration points with existing model providers

4. UI/UX Patterns

   • Examine existing approval flow patterns in the webview
   • Determine appropriate notification design for sampling requests

Proposed Changes

Based on what we can determine from the codebase, these components would likely need modification:

1. McpHub Class (src/services/mcp/McpHub.ts)

The central MCP client implementation would need to be extended to:

• Register a sampling handler with the MCP client
• Process incoming sampling requests
• Implement approval flow for sampling similar to existing tool approvals
• Report sampling capabilities to servers

2. Types and Interfaces (src/shared/mcp.ts)

New interfaces would be needed for:

• Sampling request structure
• Sampling response structure
• Configuration options

3. Configuration Schema

The existing server configuration schema in McpHub.ts would need extension for sampling-specific settings, potentially including:

• Enable/disable sampling
• Approval requirements
• Default parameters

4. UI Components (webview-ui)

The UI would need additional components for:

• Sampling request notifications
• Approval/denial controls
• Configuration interface

Potential Implementation Approach

Without making assumptions about specific implementation details, the general approach would involve:

1. Capability Reporting

   • Update client initialization to report sampling capability to servers

2. Request Handling

   • Implement handler for incoming sampling requests according to MCP protocol
   • Create validation for request parameters

3. Approval Flow

   • Extend existing approval mechanisms to handle sampling requests
   • Create UI notifications for sampling requests

4. Model Integration

   • Create flexible interface for connecting to various model providers
   • Implement completion execution with configurable parameters

5. Configuration

   • Add settings for sampling preferences
   • Create security controls for request filtering

User Experience Considerations

From the user perspective, sampling would involve:

1. Configuration: Users configure sampling settings for each MCP server.

2. Approval Process: When an MCP server requests a completion:

   • User receives notification with request details
   • User can approve, modify, or reject the request
   • Settings could allow auto-approval for trusted servers

3. Security Controls: Users can configure:

   • Which servers can use sampling
   • What models can be used
   • Default parameter values

Implementation Plan

A phased approach is recommended, with specific timelines to be determined after further investigation:

Phase 1: Research and Protocol Implementation

• Investigate MCP sampling protocol details
• Update SDK dependencies if needed
• Implement core protocol handlers

Phase 2: Model Integration

• Design model provider interface
• Implement completion execution
• Create basic approval flow

Phase 3: UI and Configuration

• Develop sampling request UI
• Implement configuration options
• Add security controls

Phase 4: Testing and Refinement

• Test with compatible MCP servers
• Optimize performance
• Document the feature

Open Questions

1. What is the exact structure of the MCP sampling protocol?
2. How should model completions be executed within Roo Code's architecture?
3. What model providers should be supported initially?
4. What security measures are needed to prevent abuse of sampling?
5. How should sensitive data be filtered from sampling requests?
6. What metrics should be collected to monitor sampling usage?

Next Steps

1. Research the official MCP sampling protocol specification
2. Assess SDK version compatibility
3. Investigate model integration options
4. Design initial approval flow mockups
5. Create a detailed technical specification after research

References

1. [MCP Sampling Documentation](https://modelcontextprotocol.io/docs/concepts/sampling)
2. [Model Context Protocol Specification](https://spec.modelcontextprotocol.io/specification/)
3. [Roo Code MCP Documentation](https://docs.roocode.com/features/mcp/overview/)

[eddiehorng]

Good to know roo code is going to support MCP sampling feature.
Could you please share the estimated implementation schedule?

[strawgate]

Sampling significantly improves MCP tools, would love to see this.

[LzxHahaha]

Any updates on this?