Rust MCP Sdk

🚀 Rust-MCP-SDK Documentation

rust-mcp-sdk is a Rust library for building and managing MCP (Machine Learning Platform) services. It offers functional modules for both the server and client sides and supports the use of macros to simplify the creation and operation of tool structures.

✨ Features

Available Features

• server: Activates MCP server functionality, providing the modules and APIs required for building and managing MCP services.
• client: Activates MCP client functionality, offering modules and APIs for communicating with the MCP server.
• macros: Provides procedural macros for simplifying the creation and operation of MCP tool structures.

Default Behavior

All features (server, client, and macros) are enabled by default. When including rust-mcp-sdk as a dependency in your project, all features will be enabled by default:

[dependencies]
rust-mcp-sdk = "0.2.0"

Using Only the Server Feature

If you only need the functionality of the MCP server, you can disable the default features and explicitly enable the server feature. Add the following to your Cargo.toml:

[dependencies]
rust-mcp-sdk = { version = "0.2.0", default-features = false, features = ["server","macros"] }

Using Only the Client Feature

If you only need the functionality of the MCP client, you can disable the default features and explicitly enable the client feature. Add the following to your Cargo.toml:

[dependencies]
rust-mcp-sdk = { version = "0.2.0", default-features = false, features = ["client"] }

Choosing Between mcp_server_handler and mcp_server_handler_core

rust-mcp-sdk provides two types of handler traits for processing MCP messages:

• mcp_server_handler: This is the recommended trait for your MCP project. It offers default implementations for all types of MCP messages, such as handling initialization or responding to heartbeat requests. You only need to override and customize the handler functions relevant to your specific requirements.

  Refer to examples/hello-world-mcp-server/src/handler.rs for an example.

• mcp_server_handler_core: If you need more control over MCP messages, you can consider using mcp_server_handler_core. It provides three main methods for processing three types of MCP messages: request, notification, and error. Although it still provides type-safe objects within these methods, it allows you to determine how to handle each message based on its type and parameters.

  Refer to examples/hello-world-mcp-server-core/src/handler.rs for an example.

⚠️ Important Note

Depending on whether you choose mcp_server_handler or mcp_server_handler_core, you need to use the corresponding server_runtime::create_server() or server_runtime_core::create_server() method.

Choosing Between mcp_client_handler and mcp_client_handler_core

Similarly, for client handlers:

• mcp_client_handler: The recommended trait that provides default implementations for all types of MCP client messages.

• mcp_client_handler_core: You can use this core version if you need more control.

💻 Usage Examples

Server-side Example

use mcp_sdk::server::{McpServer, McpMessage};

#[derive(Debug)]
struct MyServerHandler {
    // Custom state or properties
}

impl McpServer for MyServerHandler {
    fn handle_message(&mut self, message: &McpMessage) -> Result<(), Box<dyn Error>> {
        // Logic to handle the message
        println!("Received message: {}", message);
        Ok(())
    }
}

Client-side Example

use mcp_sdk::client::{McpClient, McpMessage};

#[derive(Debug)]
struct MyClientHandler {
    // Custom state or properties
}

impl McpClient for MyClientHandler {
    fn handle_response(&mut self, response: &McpMessage) -> Result<(), Box<dyn Error>> {
        // Logic to handle the response
        println!("Received response: {}", response);
        Ok(())
    }
}

🤝 Contribution Guidelines

Submitting Code

1. Clone the repository:

   git clone https://github.com/rust-mcp-sdk/rust-mcp-sdk.git
   cd rust-mcp-sdk
   

2. Create a feature branch:

   git checkout -b feature/my_new_feature
   

3. Write code and test:

   • Add new files or modify existing ones in the src/ directory.
   • Add example projects in the examples/ directory if necessary.
   • Run the test suite: cargo test

4. Commit changes:

   git add .
   git commit -m "feat: Add a new feature"
   

5. Create a pull request:

   • Go to the GitHub repository
   • Click the "Pull Request" button
   • Fill in the PR description and submit

Commit Specification

Follow the following commit specifications:

1. Type:

   • feat: Adding new features
   • fix: Fixing issues
   • refactor: Code refactoring
   • test: Adding test cases
   • doc: Updating documentation

2. Description: Briefly describe the content of the commit.

3. Scope: Use scopes, for example:

   • mcp-sdk: Changes to the core library
   • examples: Changes to example projects
   • docs: Changes to documentation

4. Format example:

   feat(mcp-sdk): Add support for a new server endpoint
   fix(doc): Fix spelling errors in the documentation
   

🛠️ Development Guide

Installing Dependencies

Make sure you have installed the following tools:

• Rust compiler: rustup install
• Package manager: cargo install cargo-edit

Adding Dependencies to Cargo.toml

Add the rust-mcp-sdk dependency to your project:

[dependencies]
rust-mcp-sdk = "0.2.0"

Running Examples

After cloning the repository, run the following command to run an example project:

cargo run --example my_example

Contributing Code

• When submitting code, please follow the commit specifications.
• Add test cases for your features.
• Update the documentation to reflect your changes.

📄 License

rust-mcp-sdk is released under the MIT License. See the LICENSE file for details.