mcp-protocol-sdk 0.5.1

Production-ready Rust SDK for the Model Context Protocol (MCP) with multiple transport support
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//! Client builder for MCP clients
//!
//! Provides a builder pattern for creating and configuring MCP clients.

use crate::client::McpClient;
use crate::core::error::McpResult;
use crate::protocol::types::ClientCapabilities;
use std::time::Duration;

/// Configuration for retry behavior
#[derive(Debug, Clone)]
pub struct RetryConfig {
    /// Maximum number of retry attempts
    pub max_attempts: Option<u32>,
    /// Initial delay between retry attempts (ms)
    pub initial_delay_ms: u64,
    /// Maximum delay between retry attempts (ms)
    pub max_delay_ms: u64,
    /// Backoff multiplier for retry delays
    pub backoff_multiplier: f64,
}

impl Default for RetryConfig {
    fn default() -> Self {
        Self {
            max_attempts: Some(3),
            initial_delay_ms: 1000,
            max_delay_ms: 30000,
            backoff_multiplier: 2.0,
        }
    }
}

/// Configuration for connections
#[derive(Debug, Clone)]
pub struct ConnectionConfig {
    /// Connection timeout in milliseconds
    pub timeout_ms: u64,
    /// Whether to enable keep-alive
    pub keep_alive: bool,
    /// Whether to enable compression
    pub compression: bool,
}

impl Default for ConnectionConfig {
    fn default() -> Self {
        Self {
            timeout_ms: 30000,
            keep_alive: true,
            compression: false,
        }
    }
}

/// Builder for creating MCP clients with configuration
pub struct McpClientBuilder {
    name: Option<String>,
    version: Option<String>,
    capabilities: Option<ClientCapabilities>,
    timeout: Option<Duration>,
    retry_config: Option<RetryConfig>,
    connection_config: Option<ConnectionConfig>,
}

impl McpClientBuilder {
    /// Create a new client builder
    pub fn new() -> Self {
        Self {
            name: None,
            version: None,
            capabilities: None,
            timeout: None,
            retry_config: None,
            connection_config: None,
        }
    }

    /// Set client name
    pub fn with_name<S: Into<String>>(mut self, name: S) -> Self {
        self.name = Some(name.into());
        self
    }

    /// Set client version
    pub fn with_version<S: Into<String>>(mut self, version: S) -> Self {
        self.version = Some(version.into());
        self
    }

    /// Set client capabilities
    pub fn with_capabilities(mut self, capabilities: ClientCapabilities) -> Self {
        self.capabilities = Some(capabilities);
        self
    }

    /// Set request timeout
    pub fn with_timeout(mut self, timeout: Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    /// Set retry configuration
    pub fn with_retry_config(mut self, retry_config: RetryConfig) -> Self {
        self.retry_config = Some(retry_config);
        self
    }

    /// Set connection configuration
    pub fn with_connection_config(mut self, connection_config: ConnectionConfig) -> Self {
        self.connection_config = Some(connection_config);
        self
    }

    /// Build the client
    pub fn build(self) -> McpResult<McpClient> {
        let mut client = McpClient::new(
            self.name.unwrap_or_else(|| "mcp-client".to_string()),
            self.version.unwrap_or_else(|| "1.0.0".to_string()),
        );

        client.set_capabilities(self.capabilities.unwrap_or_default());

        Ok(client)
    }
}

impl Default for McpClientBuilder {
    fn default() -> Self {
        Self::new()
    }
}

// Legacy alias for compatibility - single definition only
pub type ClientBuilder = McpClientBuilder;