MCP Sdk Rs

🚀 Model Context Protocol (MCP) Rust SDK

A Rust implementation of the Model Context Protocol (MCP) designed to enable seamless communication between AI models and their runtime environments.

⚠️ Important Note

This SDK is currently under development and not ready for production use.

✨ Features

• 🚀 Full implementation of the MCP protocol specification.
• 🔄 Support for multiple transport layers (WebSocket, Standard Input/Output).
• ⚡ Asynchronous/await support using Tokio.
• 🛡️ Type-safe message handling.
• 🔍 Comprehensive error handling.
• 📦 Zero-copy serialization/deserialization.

📦 Installation

Add the following to your Cargo.toml:

[dependencies]
mcp_sdk_rs = "0.1.0"

🚀 Quick Start

Client Example

use mcp_sdk_rs::{Client, transport::WebSocketTransport};

#[tokio::main]
async fn main() -> Result<(), Error> {
    // Create a transport layer instance
    let transport = WebSocketTransport::new(self.url.as_str())
        .await
        .map_err(|_| Error::Internal)?;

    // Create mpsc channels for communication between the client and the session
    let (request_tx, request_rx): (UnboundedSender<Message>, UnboundedReceiver<Message>) =
        tokio::sync::mpsc::unbounded_channel();
    let (response_tx, response_rx): (UnboundedSender<Message>, UnboundedReceiver<Message>) =
        tokio::sync::mpsc::unbounded_channel();

    // Create and start the session
    // Optionally pass an implementation of ClientHandler to handle custom requests and notifications
    let session = Session::new(Arc::new(transport), response_tx, request_rx, None);
    session.start().await.map_err(|_| Error::Internal)?;

    // Create the client and send requests, receive notifications, etc.
    let client = Client::new(request_tx, response_rx);
    let response = client.request(
        "tools/call",
        Some(json!({
            "name": "methondName",
            "arguments": json!({})
        })),
    )
    .await?
}

Server Example

use mcp_sdk_rs::{Server, transport::StdioTransport};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a standard input/output transport layer instance
    let (transport, _) = StdioTransport::new();

    // Create and start the server
    let server = Server::new(transport);
    server.start().await?;

    Ok(())
}

📚 Documentation

Transport Layers

The SDK supports multiple transport layers:

WebSocket Transport Layer

• Suitable for network-based communication.
• Supports secure (WSS) and standard (WS) connections.
• Built-in reconnection handling mechanism.

Standard Input/Output Transport Layer

• Ideal for local inter-process communication.
• Lightweight and efficient.
• Suitable for command-line tools and local development environments.

Error Handling

The SDK provides comprehensive error handling through the Error type:

use mcp_sdk_rs::Error;

match result {
    Ok(value) => println!("Success: {:?}", value),
    Err(Error::Protocol(code, msg)) => println!("Protocol error code {}: {}", code, msg),
    Err(Error::Transport(e)) => println!("Transport error: {}", e),
    Err(e) => println!("Other error: {}", e),
}

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

Originally forked from https://github.com/Derek-X-Wang/mcp-rust-sdk.