solidmcp 0.4.0

A high-level Rust toolkit for building Model Context Protocol (MCP) servers with type safety and minimal boilerplate. Supports tools, resources, and prompts with automatic JSON schema generation.
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

//! MCP Protocol Implementation
//!
//! Handles MCP protocol versioning, capabilities, and server information.

use {
    serde_json::{json, Value},
    tracing::info,
};

pub struct McpProtocol {
    version: String,
    server_name: String,
    server_version: String,
}

impl McpProtocol {
    pub fn new() -> Self {
        Self {
            version: "2025-06-18".to_string(),
            server_name: "mcp-server".to_string(),
            server_version: env!("CARGO_PKG_VERSION").to_string(),
        }
    }

    /// Get protocol version
    pub fn version(&self) -> &str {
        &self.version
    }

    /// Get server name
    pub fn server_name(&self) -> &str {
        &self.server_name
    }

    /// Get server version
    pub fn server_version(&self) -> &str {
        &self.server_version
    }

    /// Create initialization response
    pub fn create_initialize_response(&self) -> Value {
        info!("🔧 MCP client initializing");
        json!({
            "protocolVersion": self.version,
            "capabilities": {
                "tools": {}
            },
            "serverInfo": {
                "name": self.server_name,
                "version": self.server_version
            }
        })
    }

    /// Create error response
    pub fn create_error_response(&self, id: Value, code: i32, message: &str) -> Value {
        json!({
            "jsonrpc": "2.0",
            "id": id,
            "error": {
                "code": code,
                "message": message
            }
        })
    }

    /// Create success response
    pub fn create_success_response(&self, id: Value, result: Value) -> Value {
        json!({
            "jsonrpc": "2.0",
            "id": id,
            "result": result
        })
    }
}

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

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn test_initialize_response() {
        let proto = McpProtocol::new();
        let resp = proto.create_initialize_response();
        assert_eq!(resp["protocolVersion"], proto.version());
        assert_eq!(resp["serverInfo"]["name"], proto.server_name());
        assert_eq!(resp["serverInfo"]["version"], proto.server_version());
    }

    #[test]
    fn test_error_response() {
        let proto = McpProtocol::new();
        let err = proto.create_error_response(json!(42), -1, "fail");
        assert_eq!(err["id"], 42);
        assert_eq!(err["error"]["code"], -1);
        assert_eq!(err["error"]["message"], "fail");
    }

    #[test]
    fn test_success_response() {
        let proto = McpProtocol::new();
        let ok = proto.create_success_response(json!(7), json!({"foo": 1}));
        assert_eq!(ok["id"], 7);
        assert_eq!(ok["result"]["foo"], 1);
    }
}