Tiny MCP Server (Rust): Rock-Solid Security & Lightning Speed

What is Tiny MCP Server (Rust): Rock-Solid Security & Lightning Speed?

Tiny MCP Server is a lightweight Rust implementation of the Machine Conversation Protocol (MCP), designed to deliver both uncompromising security and high-speed performance. It simplifies building communication servers that handle tool registration, lifecycle management, and multiple transport methods like stdio and Server-Sent Events (SSE). Built for reliability, it leverages Rust's memory safety and async capabilities to ensure robust, type-safe interactions.

How to Use Tiny MCP Server (Rust): Rock-Solid Security & Lightning Speed?

Getting started is straightforward. First, add the crate to your Cargo.toml:

[dependencies]
    tiny_mcp_server = "0.1.0"

Then, use the prelude for quick setup:

use tiny_mcp_server::prelude::*;
    // Register tools and start the server with stdio or SSE

For demos, run examples via cargo run --example stdio or sse. Adjust ports as needed, like 127.0.0.1:8080.

Key Features of Tiny MCP Server (Rust): Rock-Solid Security & Lightning Speed?

• Multi-Transport Flexibility: Switch between stdio for CLI tools or SSE for real-time web communication.
• Tool Ecosystem: Easily extend servers with custom tools using simple annotations and async functions.
• Async Performance: Built on Tokio for non-blocking I/O and high throughput.
• Type Safety: Rust’s strong typing ensures protocol compliance and reduces runtime errors.
• Production-Ready: MIT/Apache-2.0 licensed, thoroughly tested, and backed by extensive documentation.

Use Cases of Tiny MCP Server (Rust): Rock-Solid Security & Lightning Speed?

Perfect for scenarios needing secure, fast inter-process communication:

• Command-line tools requiring bidirectional stdio pipelines
• Real-time data feeds via SSE for dashboards or IoT systems
• Microservices needing lightweight, protocol-driven APIs
• Embedded systems where memory safety and speed are critical

FAQ from Tiny MCP Server (Rust): Rock-Solid Security & Lightning Speed?

Why Rust?

Rust’s zero-cost abstractions and memory safety ensure rock-solid security without performance trade-offs. Its async ecosystem also makes high-concurrency workloads effortless.

How do I avoid SSE port conflicts?

Use the provided cleanup script ./scripts/cleanup_sse.sh before running tests. For manual testing, check port 3000 first.

Can I contribute?

Absolutely! Check the contributing guidelines for setup and testing best practices. Pull Requests are warmly welcomed.

Where’s the full documentation?

Head to the API docs for in-depth guides and examples. The examples/ folder also ships with practical use cases.

Tiny MCP Server (Rust)

这是一个用Rust实现的MCP（Machine Conversation Protocol）服务器。

功能

• 支持MCP协议的生命周期管理
• 支持多种传输方式（stdio、SSE）
• 提供工具注册和调用机制

运行测试

运行所有测试：

cargo test

运行SSE测试

SSE测试需要启动实际的服务器进程，可能会导致端口冲突和进程残留问题。这些测试默认被标记为#[ignore]，需要手动运行。

要运行SSE测试，请按照以下步骤操作：

1. 首先清理可能残留的进程：

./scripts/cleanup_sse.sh

2. 然后手动运行SSE示例：

cargo run --example sse

3. 在另一个终端窗口中，使用curl测试SSE服务器：

curl http://localhost:3000/schema

4. 如果需要关闭SSE服务器，可以使用以下命令：

lsof -i :3000 -t | xargs kill -9

清理残留进程

如果测试过程中出现问题，可能会有SSE服务器进程残留。使用以下脚本清理：

./scripts/cleanup_sse.sh

示例

运行stdio服务器

cargo run --example stdio

运行SSE服务器

cargo run --example sse

默认监听127.0.0.1:3000。可以指定不同的地址：

cargo run --example sse -- 127.0.0.1:8080

Features

• Multiple Transport Layers : Supports both stdio and Server-Sent Events (SSE) transports
• Extensible Tool System : Easily register custom tools with the server
• Type-Safe API : Leverages Rust's type system for safe and reliable communication
• Asynchronous Design : Built on tokio for high-performance async I/O
• Simple Integration : Just add a single dependency to your project
• Convenient Imports : Use the prelude module to import all necessary types and traits

Installation

Add this to your Cargo.toml:

[dependencies]
tiny_mcp_server = "0.1.0"
tokio = { version = "1.0", features = ["full"] }
serde_json = "1.0"

Quick Start

For convenience, you can use the prelude module to import all necessary types and traits:

use serde_json::{Value, json};
use std::error::Error;
use tiny_mcp_server::prelude::*;

#[mcp_tool(
    description = "A simple greeting tool",
    version = "1.0.0",
    category = "examples"
)]
pub async fn say_hello(name: String) -> MCPResult<Value> {
    Ok(json!({
        "greeting": format!("Hello {name}")
    }))
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    // Start with stdio transport
    server::start_stdio().await
}

Documentation

For more detailed documentation, see the API documentation.

Examples

Check out the examples directory for more usage examples:

• stdio.rs: Example using stdio transport
• sse.rs: Example using SSE transport

License

This project is licensed under either of:

• MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
• Apache License, Version 2.0, (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)

at your option.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.