Ethereal Rust

🚀 MCP-RS

An MCP (Model Context Protocol) server implemented in Rust. This is a Rust port of the original TypeScript implementation here.

🚀 Quick Start

📦 Installation

Add the following to your Cargo.toml:

[dependencies]
mcp-rs = "0.1.0"

💻 Usage Examples

🔍 Basic Usage

The following is a basic example of using this library:

use mcp_rs::{Emcp, SimpleToolBuilder};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new server instance
    let server = Emcp::new("my-mcp-server", "1.0.0", None);
    
    // Add a tool
    let add_tool = SimpleToolBuilder::new("add", |args| async move {
        let a = args["a"].as_f64().unwrap_or(0.0);
        let b = args["b"].as_f64().unwrap_or(0.0);
        Ok(json!(a + b))
    })
    .description("Add two numbers")
    .input_schema(json!({
        "type": "object",
        "properties": {
            "a": { "type": "number" },
            "b": { "type": "number" }
        },
        "required": ["a", "b"]
    }))
    .build();
    
    server.add_tool(add_tool);
    
    // Start the server
    server.start(None).await?;
    
    Ok(())
}

🔐 Authentication Example

use mcp_rs::{Emcp, EmcpOptions, SimpleToolBuilder};
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create an authentication handler
    let auth_handler = Box::new(|request| {
        // Check authentication headers, tokens, etc.
        Box::pin(async { 
            // Return true if the request is authorized
            true 
        })
    });
    
    // Create a new server with the authentication handler
    let server = Emcp::new(
        "mcp-server-with-auth",
        "1.0.0",
        Some(EmcpOptions {
            authentication_handler: Some(auth_handler),
        }),
    );
    
    // Add tools, resources, or prompts...
    
    // Start the server
    server.start(None).await?;
    
    Ok(())
}

🛠️ Middleware Example

use mcp_rs::{Emcp, SimpleToolBuilder};
use std::time::Instant;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create a new server
    let mut server = Emcp::new("mcp-server-with-middleware", "1.0.0", None);
    
    // Add a timing middleware
    server.use_middleware(|request, next| {
        let start_time = Instant::now();
        let method = request.method.clone();
        
        Box::pin(async move {
            // Processing logic...
            
            Ok(())
        })
    });
    
    // Start the server
    server.start(None).await?;
    
    Ok(())
}

🏃‍♂️ Running Examples

The repository contains several examples demonstrating the library's capabilities:

# Run the basic example
cargo run --example basic

# Run the authentication example
cargo run --example auth

# Run the middleware example
cargo run --example middleware

# Run the standard IO transport example
cargo run --example stdio_transport

✨ Features

This Rust implementation provides all core MCP features:

• All core MCP server functionalities
• Built-in authentication handler
• Support for custom hierarchical middleware
• Flexible transport options (standard input/output and SSE)

📄 License

MIT