Rust 2.6 MB of memory.
2.6 MB of memory.
That's the whole runtime.
zeromcp vs rmcp — side by side.
Dependencies
3 ZeroMCP
vs. 6 Official SDK
Throughput
5.40K req/s ZeroMCP
vs. 2.19K req/s Official SDK
Memory
4 MB ZeroMCP
vs. 2.42 GB Official SDK
This is a hello world
Proc-macro imports, a server builder, tool attribute macros, and transport setup. 12 lines before your tool does anything.
rmcp 12 lines
use rmcp::{Server, Tool, tool};
#[tool(description = "Say hello")]
async fn hello(name: String) -> String {
format!("Hello, {name}!")
}
#[tokio::main]
async fn main() {
Server::new("test", "1.0.0")
.tool(hello)
.serve_stdio()
.await;
}This is the whole server
No proc macros. No server builder. No attribute ceremony.
Register a closure and serve.
ZeroMCP 8 lines
let mut server = Server::new();
server.add_tool("hello", "Say hello",
Input::new().required("name", "string"),
|args: Value, _ctx: Ctx| Box::pin(async move {
let name = args["name"].as_str().unwrap_or("world");
Ok(Value::String(format!("Hello, {name}!")))
})
);
server.serve().await;HTTP Performance — Head to Head
Mixed workload across all 7 MCP method types. 5-minute sustained load in Docker. Actix for ZeroMCP, stdio proxy for the official SDK.
req/s CPU Memory Ratio
ZeroMCP (Actix) 5.40K 0.17% 4 MB 2.5x
Official SDK 2.19K 0.03% 2.42 GB
The official Rust SDK leaks memory — 2.42 GB over 5 minutes. ZeroMCP Actix holds steady at 4 MB.
The tradeoff
Choose rmcp
If you want the macro-based tool registration system and don't mind pinning to nightly-adjacent Rust versions.
- Macro-based tools — derive macros for tool definitions
- Spec parity — tracks every spec change immediately
- Enterprise support — maintained by the MCP specification team at Anthropic
Choose ZeroMCP
If you want stable Rust (1.78+), predictable memory (4 MB flat), and a handler that embeds in Actix or Axum.
- Stable Rust 1.78+
- Actix + Axum
- 4 MB memory — flat under sustained load
- Built-in sandbox with enforced permissions
- 5.40K req/s on Actix