Rust-Mcp-Server
Rust-Mcp-Server是一款code方向的AI技能，核心价值是Best practices for building Model Context Protocol servers in Rust using the official rmcp SDK with async/await patterns，可用于解决开发者在code领域的实际问题，帮助用户提升效率、自动化重复任务或优化工作流。
Best practices for building Model Context Protocol servers in Rust using the official rmcp SDK with async/await patterns
mkdir -p ./skills/rust-mcp-server && curl -sfL https://raw.githubusercontent.com/github/awesome-copilot/main/skills/rust-mcp-server/SKILL.md -o ./skills/rust-mcp-server/SKILL.mdRun in terminal / PowerShell. Requires curl (Unix) or PowerShell 5+ (Windows).
Skill Content
# Rust MCP Server Development Best Practices
This guide provides best practices for building Model Context Protocol (MCP) servers using the official Rust SDK (`rmcp`).
Installation and Setup
Add Dependencies
Add the `rmcp` crate to your `Cargo.toml`:
[dependencies]
rmcp = { version = "0.8.1", features = ["server"] }
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"For macros support:
[dependencies]
rmcp-macros = "0.8"
schemars = { version = "0.8", features = ["derive"] }Project Structure
Organize your Rust MCP server project:
my-mcp-server/
├── Cargo.toml
├── src/
│ ├── main.rs # Server entry point
│ ├── handler.rs # ServerHandler implementation
│ ├── tools/
│ │ ├── mod.rs
│ │ ├── calculator.rs
│ │ └── greeter.rs
│ ├── prompts/
│ │ ├── mod.rs
│ │ └── code_review.rs
│ └── resources/
│ ├── mod.rs
│ └── data.rs
└── tests/
└── integration_tests.rsServer Implementation
Basic Server Setup
Create a server with stdio transport:
use rmcp::{
protocol::ServerCapabilities,
server::{Server, ServerHandler},
transport::StdioTransport,
};
use tokio::signal;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
tracing_subscriber::fmt::init();
let handler = MyServerHandler::new();
let transport = StdioTransport::new();
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)?;
server.run(signal::ctrl_c()).await?;
Ok(())
}ServerHandler Implementation
Implement the `ServerHandler` trait:
use rmcp::{
model::*,
protocol::*,
server::{RequestContext, ServerHandler, RoleServer},
ErrorData,
};
pub struct MyServerHandler {
tool_router: ToolRouter,
}
impl MyServerHandler {
pub fn new() -> Self {
Self {
tool_router: Self::create_tool_router(),
}
}
fn create_tool_router() -> ToolRouter {
// Initialize and return tool router
ToolRouter::new()
}
}
#[async_trait::async_trait]
impl ServerHandler for MyServerHandler {
async fn list_tools(
&self,
_request: Option<PaginatedRequestParam>,
_context: RequestContext<RoleServer>,
) -> Result<ListToolsResult, ErrorData> {
let items = self.tool_router.list_all();
Ok(ListToolsResult::with_all_items(items))
}
async fn call_tool(
&self,
request: CallToolRequestParam,
context: RequestContext<RoleServer>,
) -> Result<CallToolResult, ErrorData> {
let tcc = ToolCallContext::new(self, request, context);
self.tool_router.call(tcc).await
}
}Tool Development
Using Macros for Tools
Use the `#[tool]` macro for declarative tool definitions:
use rmcp::tool;
use rmcp::model::Parameters;
use serde::{Deserialize, Serialize};
use schemars::JsonSchema;
#[derive(Debug, Deserialize, JsonSchema)]
pub struct CalculateParams {
pub a: f64,
pub b: f64,
pub operation: String,
}
/// Performs mathematical calculations
#[tool(
name = "calculate",
description = "Performs basic arithmetic operations",
annotations(read_only_hint = true)
)]
pub async fn calculate(params: Parameters<CalculateParams>) -> Result<f64, String> {
let p = params.inner();
match p.operation.as_str() {
"add" => Ok(p.a + p.b),
"subtract" => Ok(p.a - p.b),
"multiply" => Ok(p.a * p.b),
"divide" => {
if p.b == 0.0 {
Err("Division by zero".to_string())
} else {
🎯 Best For
- UI designers
- Product designers
- Claude users
- GitHub Copilot users
- Software engineers
💡 Use Cases
- Generating component mockups
- Creating design system tokens
- Code quality improvement
- Best practice enforcement
📖 How to Use This Skill
- 1
Install the Skill
Copy the install command from the Terminal tab and run it. The SKILL.md file downloads to your local skills directory.
- 2
Load into Your AI Assistant
Open Claude or GitHub Copilot and reference the skill. Paste the SKILL.md content or use the system prompt tab.
- 3
Apply Rust-Mcp-Server to Your Work
Open your project in the AI assistant and ask it to apply the skill. Start with a small module to verify the output quality.
- 4
Review and Refine
Review AI suggestions before committing. Run tests, check for regressions, and iterate on the skill output.
❓ Frequently Asked Questions
Does this work with Figma?
Some design skills integrate with Figma plugins. Check the Works With section for supported tools.
Is Rust-Mcp-Server compatible with Cursor and VS Code?
Yes — this skill works with any AI coding assistant including Cursor, VS Code with Copilot, and JetBrains IDEs.
Do I need specific dependencies for Rust-Mcp-Server?
Check the install command and Works With section. Most code skills only require the AI assistant and your codebase.
How do I install Rust-Mcp-Server?
Copy the install command from the Terminal tab and run it. The skill downloads to ./skills/rust-mcp-server/SKILL.md, ready to use.
Can I customize this skill for my team?
Absolutely. Edit the SKILL.md file to add team-specific instructions, examples, or workflows.
⚠️ Common Mistakes to Avoid
Skipping usability testing
AI-generated designs should be validated with real users before development.
Skipping validation
Always test AI-generated code changes, even for simple refactors.
Missing dependency updates
Check if the skill requires updated dependencies or new packages.