From rust-mcp-development
Generates complete Rust MCP server projects with Cargo.toml, tools, prompts, resources, tests using rmcp SDK. Inputs: name, transport (stdio/sse/http), tools.
npx claudepluginhub passelin/marketplace-test --plugin rust-mcp-developmentThis skill uses the workspace's default tool permissions.
You are a Rust MCP server generator. Create a complete, production-ready Rust MCP server project using the official `rmcp` SDK.
Searches, retrieves, and installs Agent Skills from prompts.chat registry using MCP tools like search_skills and get_skill. Activates for finding skills, browsing catalogs, or extending Claude.
Searches prompts.chat for AI prompt templates by keyword or category, retrieves by ID with variable handling, and improves prompts via AI. Use for discovering or enhancing prompts.
Guides MCP server integration in Claude Code plugins via .mcp.json or plugin.json configs for stdio, SSE, HTTP types, enabling external services as tools.
You are a Rust MCP server generator. Create a complete, production-ready Rust MCP server project using the official rmcp SDK.
Ask the user for:
Generate this structure:
{project-name}/
├── Cargo.toml
├── .gitignore
├── README.md
├── src/
│ ├── main.rs
│ ├── handler.rs
│ ├── tools/
│ │ ├── mod.rs
│ │ └── {tool_name}.rs
│ ├── prompts/
│ │ ├── mod.rs
│ │ └── {prompt_name}.rs
│ ├── resources/
│ │ ├── mod.rs
│ │ └── {resource_name}.rs
│ └── state.rs
└── tests/
└── integration_test.rs
[package]
name = "{project-name}"
version = "0.1.0"
edition = "2021"
[dependencies]
rmcp = { version = "0.8.1", features = ["server"] }
rmcp-macros = "0.8"
tokio = { version = "1", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
anyhow = "1.0"
tracing = "0.1"
tracing-subscriber = "0.3"
schemars = { version = "0.8", features = ["derive"] }
async-trait = "0.1"
# Optional: for HTTP transports
axum = { version = "0.7", optional = true }
tower-http = { version = "0.5", features = ["cors"], optional = true }
[dev-dependencies]
tokio-test = "0.4"
[features]
default = []
http = ["dep:axum", "dep:tower-http"]
[[bin]]
name = "{project-name}"
path = "src/main.rs"
/target
Cargo.lock
*.swp
*.swo
*~
.DS_Store
# {Project Name}
{Server description}
## Installation
```bash
cargo build --release
cargo run
cargo run --features http -- --transport sse
cargo run --features http -- --transport http
Configure in your MCP client (e.g., Claude Desktop):
{
"mcpServers": {
"{project-name}": {
"command": "path/to/target/release/{project-name}",
"args": []
}
}
}
Run tests:
cargo test
Run with logging:
RUST_LOG=debug cargo run
### src/main.rs
```rust
use anyhow::Result;
use rmcp::{
protocol::ServerCapabilities,
server::Server,
transport::StdioTransport,
};
use tokio::signal;
use tracing_subscriber;
mod handler;
mod state;
mod tools;
mod prompts;
mod resources;
use handler::McpHandler;
#[tokio::main]
async fn main() -> Result<()> {
// Initialize tracing
tracing_subscriber::fmt()
.with_max_level(tracing::Level::INFO)
.with_target(false)
.init();
tracing::info!("Starting {project-name} MCP server");
// Create handler
let handler = McpHandler::new();
// Create transport (stdio by default)
let transport = StdioTransport::new();
// Build server with capabilities
let server = Server::builder()
.with_handler(handler)
.with_capabilities(ServerCapabilities {
tools: Some(Default::default()),
prompts: Some(Default::default()),
resources: Some(Default::default()),
..Default::default()
})
.build(transport)?;
tracing::info!("Server started, waiting for requests");
// Run server until Ctrl+C
server.run(signal::ctrl_c()).await?;
tracing::info!("Server shutting down");
Ok(())
}
use rmcp::{
model::*,
protocol::*,
server::{RequestContext, ServerHandler, RoleServer, ToolRouter},
ErrorData,
};
use rmcp::{tool_router, tool_handler};
use async_trait::async_trait;
use crate::state::ServerState;
use crate::tools;
pub struct McpHandler {
state: ServerState,
tool_router: ToolRouter,
}
#[tool_router]
impl McpHandler {
// Include tool definitions from tools module
#[tool(
name = "example_tool",
description = "An example tool",
annotations(read_only_hint = true)
)]
async fn example_tool(params: Parameters<tools::ExampleParams>) -> Result<String, String> {
tools::example::execute(params).await
}
pub fn new() -> Self {
Self {
state: ServerState::new(),
tool_router: Self::tool_router(),
}
}
}
#[tool_handler]
#[async_trait]
impl ServerHandler for McpHandler {
async fn list_prompts(
&self,
_request: Option<PaginatedRequestParam>,
_context: RequestContext<RoleServer>,
) -> Result<ListPromptsResult, ErrorData> {
let prompts = vec![
Prompt {
name: "example-prompt".to_string(),
description: Some("An example prompt".to_string()),
arguments: Some(vec![
PromptArgument {
name: "topic".to_string(),
description: Some("The topic to discuss".to_string()),
required: Some(true),
},
]),
},
];
Ok(ListPromptsResult { prompts })
}
async fn get_prompt(
&self,
request: GetPromptRequestParam,
_context: RequestContext<RoleServer>,
) -> Result<GetPromptResult, ErrorData> {
match request.name.as_str() {
"example-prompt" => {
let topic = request.arguments
.as_ref()
.and_then(|args| args.get("topic"))
.ok_or_else(|| ErrorData::invalid_params("topic required"))?;
Ok(GetPromptResult {
description: Some("Example prompt".to_string()),
messages: vec![
PromptMessage::user(format!("Let's discuss: {}", topic)),
],
})
}
_ => Err(ErrorData::invalid_params("Unknown prompt")),
}
}
async fn list_resources(
&self,
_request: Option<PaginatedRequestParam>,
_context: RequestContext<RoleServer>,
) -> Result<ListResourcesResult, ErrorData> {
let resources = vec![
Resource {
uri: "example://data/info".to_string(),
name: "Example Resource".to_string(),
description: Some("An example resource".to_string()),
mime_type: Some("text/plain".to_string()),
},
];
Ok(ListResourcesResult { resources })
}
async fn read_resource(
&self,
request: ReadResourceRequestParam,
_context: RequestContext<RoleServer>,
) -> Result<ReadResourceResult, ErrorData> {
match request.uri.as_str() {
"example://data/info" => {
Ok(ReadResourceResult {
contents: vec![
ResourceContents::text("Example resource content".to_string())
.with_uri(request.uri)
.with_mime_type("text/plain"),
],
})
}
_ => Err(ErrorData::invalid_params("Unknown resource")),
}
}
}
use std::sync::Arc;
use tokio::sync::RwLock;
#[derive(Clone)]
pub struct ServerState {
// Add shared state here
counter: Arc<RwLock<i32>>,
}
impl ServerState {
pub fn new() -> Self {
Self {
counter: Arc::new(RwLock::new(0)),
}
}
pub async fn increment(&self) -> i32 {
let mut counter = self.counter.write().await;
*counter += 1;
*counter
}
pub async fn get(&self) -> i32 {
*self.counter.read().await
}
}
pub mod example;
pub use example::ExampleParams;
use rmcp::model::Parameters;
use serde::{Deserialize, Serialize};
use schemars::JsonSchema;
#[derive(Debug, Deserialize, JsonSchema)]
pub struct ExampleParams {
pub input: String,
}
pub async fn execute(params: Parameters<ExampleParams>) -> Result<String, String> {
let input = ¶ms.inner().input;
// Tool logic here
Ok(format!("Processed: {}", input))
}
#[cfg(test)]
mod tests {
use super::*;
#[tokio::test]
async fn test_example_tool() {
let params = Parameters::new(ExampleParams {
input: "test".to_string(),
});
let result = execute(params).await.unwrap();
assert!(result.contains("test"));
}
}
// Prompt implementations can go here if needed
// Resource implementations can go here if needed
use rmcp::{
model::*,
protocol::*,
server::{RequestContext, ServerHandler, RoleServer},
};
// Replace with your actual project name in snake_case
// Example: if project is "my-mcp-server", use my_mcp_server
use my_mcp_server::handler::McpHandler;
#[tokio::test]
async fn test_list_tools() {
let handler = McpHandler::new();
let context = RequestContext::default();
let result = handler.list_tools(None, context).await.unwrap();
assert!(!result.tools.is_empty());
assert!(result.tools.iter().any(|t| t.name == "example_tool"));
}
#[tokio::test]
async fn test_call_tool() {
let handler = McpHandler::new();
let context = RequestContext::default();
let request = CallToolRequestParam {
name: "example_tool".to_string(),
arguments: Some(serde_json::json!({
"input": "test"
})),
};
let result = handler.call_tool(request, context).await;
assert!(result.is_ok());
}
#[tokio::test]
async fn test_list_prompts() {
let handler = McpHandler::new();
let context = RequestContext::default();
let result = handler.list_prompts(None, context).await.unwrap();
assert!(!result.prompts.is_empty());
}
#[tokio::test]
async fn test_list_resources() {
let handler = McpHandler::new();
let context = RequestContext::default();
let result = handler.list_resources(None, context).await.unwrap();
assert!(!result.resources.is_empty());
}
#[tool], #[tool_router], and #[tool_handler] macros for cleaner codeschemars::JsonSchema for all parameter typesResult types with proper error messagesArc<RwLock<T>> for shared statetracing macros (info!, debug!, warn!, error!)#[derive(Debug, Deserialize, JsonSchema)]
pub struct GreetParams {
pub name: String,
}
#[tool(
name = "greet",
description = "Greets a user by name",
annotations(read_only_hint = true, idempotent_hint = true)
)]
async fn greet(params: Parameters<GreetParams>) -> String {
format!("Hello, {}!", params.inner().name)
}
#[derive(Debug, Deserialize, JsonSchema)]
pub struct DivideParams {
pub a: f64,
pub b: f64,
}
#[tool(name = "divide", description = "Divides two numbers")]
async fn divide(params: Parameters<DivideParams>) -> Result<f64, String> {
let p = params.inner();
if p.b == 0.0 {
Err("Cannot divide by zero".to_string())
} else {
Ok(p.a / p.b)
}
}
#[tool(
name = "increment",
description = "Increments the counter",
annotations(destructive_hint = true)
)]
async fn increment(state: &ServerState) -> i32 {
state.increment().await
}
After generation:
cd {project-name}
cargo build
cargo test
cargo run
For Claude Desktop integration:
{
"mcpServers": {
"{project-name}": {
"command": "path/to/{project-name}/target/release/{project-name}",
"args": []
}
}
}
Now generate the complete project based on the user's requirements!