Labsco
github logo

rust-mcp-server-generator

✓ Official★ 36,200

by github · part of github/awesome-copilot

Scaffolds production-ready Rust MCP server projects with tools, prompts, resources, and full test coverage. Generates complete project structure with Cargo.toml, handler implementations, and integration tests using the official rmcp SDK Supports multiple transport types (stdio, SSE, HTTP) with configurable features and async/await patterns throughout Includes macros for tool definition ( #[tool] , #[tool_router] , #[tool_handler] ) and type-safe parameter handling via schemars::JsonSchema...

🔥🔥🔥🔥✓ VerifiedFreeQuick setup
#git#weather
🧩 One of 7 skills in the github/awesome-copilot package — works on its own, and pairs well with its siblings.

Scaffolds production-ready Rust MCP server projects with tools, prompts, resources, and full test coverage. Generates complete project structure with Cargo.toml, handler implementations, and integration tests using the official rmcp SDK Supports multiple transport types (stdio, SSE, HTTP) with configurable features and async/await patterns throughout Includes macros for tool definition ( #[tool] , #[tool_router] , #[tool_handler] ) and type-safe parameter handling via schemars::JsonSchema...

Inspect the full instructions your agent will receiveExpand

This is the exact playbook injected into your agent when the skill activates — shown here so you can audit it before installing. You don't need to read it to use the skill.

by github

Scaffolds production-ready Rust MCP server projects with tools, prompts, resources, and full test coverage. Generates complete project structure with Cargo.toml, handler implementations, and integration tests using the official rmcp SDK Supports multiple transport types (stdio, SSE, HTTP) with configurable features and async/await patterns throughout Includes macros for tool definition ( #[tool] , #[tool_router] , #[tool_handler] ) and type-safe parameter handling via schemars::JsonSchema... npx skills add https://github.com/github/awesome-copilot --skill rust-mcp-server-generator Download ZIPGitHub36.2k

Rust MCP Server Generator

You are a Rust MCP server generator. Create a complete, production-ready Rust MCP server project using the official rmcp SDK.

Project Structure

Generate this structure:

Copy & paste — that's it
{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

File Templates

Cargo.toml

Copy & paste — that's it
[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"

.gitignore

Copy & paste — that's it
/target
Cargo.lock
*.swp
*.swo
*~
.DS_Store

README.md

Copy & paste — that's it
# {Project Name}

{Server description}

## Tools

- **{tool_name}**: {Tool description}

## Development

Run tests:

cargo test

Copy & paste — that's it

 Run with logging:

RUST_LOG=debug cargo run

Copy & paste — that's it

src/main.rs

Copy & paste — that's it
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(())
}

src/handler.rs

Copy & paste — that's it
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 ) -> Result {
 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 ,
 _context: RequestContext ,
 ) -> Result {
 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 ,
 ) -> Result {
 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 ,
 _context: RequestContext ,
 ) -> Result {
 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 ,
 ) -> Result {
 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")),
 }
 }
}

src/state.rs

Copy & paste — that's it
use std::sync::Arc;
use tokio::sync::RwLock;

#[derive(Clone)]
pub struct ServerState {
 // Add shared state here
 counter: Arc >,
}

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
 }
}

src/tools/mod.rs

Copy & paste — that's it
pub mod example;

pub use example::ExampleParams;

src/tools/example.rs

Copy & paste — that's it
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 ) -> Result {
 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"));
 }
}

src/prompts/mod.rs

Copy & paste — that's it
// Prompt implementations can go here if needed

src/resources/mod.rs

Copy & paste — that's it
// Resource implementations can go here if needed

tests/integration_test.rs

Copy & paste — that's it
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());
}

Implementation Guidelines

  • Use rmcp-macros: Leverage #[tool], #[tool_router], and #[tool_handler] macros for cleaner code

  • Type Safety: Use schemars::JsonSchema for all parameter types

  • Error Handling: Return Result types with proper error messages

  • Async/Await: All handlers must be async

  • State Management: Use Arc<RwLock<T>> for shared state

  • Testing: Include unit tests for tools and integration tests for handlers

  • Logging: Use tracing macros (info!, debug!, warn!, error!)

  • Documentation: Add doc comments to all public items

Example Tool Patterns

Simple Read-Only Tool

Copy & paste — that's it
#[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 ) -> String {
 format!("Hello, {}!", params.inner().name)
}

Tool with Error Handling

Copy & paste — that's it
#[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 ) -> Result {
 let p = params.inner();
 if p.b == 0.0 {
 Err("Cannot divide by zero".to_string())
 } else {
 Ok(p.a / p.b)
 }
}

Tool with State

Copy & paste — that's it
#[tool(
 name = "increment",
 description = "Increments the counter",
 annotations(destructive_hint = true)
)]
async fn increment(state: &ServerState) -> i32 {
 state.increment().await
}