RustでMCPサーバーを構築する方法 ─ rmcp公式SDKによる実装ガイド

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

cargo new my-mcp-server
cd my-mcp-server

[package]
name = "my-mcp-server"
version = "0.1.0"
edition = "2021"

[dependencies]
rmcp = { version = "0.14", features = ["server", "transport-io"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
schemars = "0.8"
anyhow = "1"
tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] }

use rmcp::{
    ServerHandler, ServiceExt,
    model::*,
    tool, tool_router,
    transport::stdio,
    ErrorData as McpError,
    schemars,
};
use serde::Deserialize;

#[derive(Debug, Clone)]
pub struct MyServer;

#[derive(Debug, Deserialize, schemars::JsonSchema)]
pub struct GreetParams {
    /// 挨拶する相手の名前
    pub name: String,
}

#[tool_router]
impl MyServer {
    #[tool(description = "指定された名前に挨拶を返す")]
    async fn greet(&self, #[tool(params)] params: GreetParams) -> Result<CallToolResult, McpError> {
        let message = format!("こんにちは、{}さん！", params.name);
        Ok(CallToolResult::success(vec![
            Content::text(message),
        ]))
    }
}

use rmcp::tool_handler;

#[tool_handler]
impl ServerHandler for MyServer {
    fn get_info(&self) -> ServerInfo {
        ServerInfo {
            instructions: Some("名前を指定して挨拶を返すサーバーです".into()),
            capabilities: ServerCapabilities::builder()
                .enable_tools()
                .build(),
            ..Default::default()
        }
    }
}

use tracing_subscriber::EnvFilter;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // ロギングの初期化（stderr出力）
    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .with_writer(std::io::stderr)
        .init();

    tracing::info!("MCPサーバーを起動します");

    let service = MyServer.serve(stdio()).await?;
    service.waiting().await?;

    Ok(())
}

cargo build --release

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "/path/to/target/release/my-mcp-server",
      "args": []
    }
  }
}

{
  "mcpServers": {
    "my-mcp-server": {
      "command": "/path/to/target/release/my-mcp-server",
      "args": []
    }
  }
}

claude mcp add my-mcp-server /path/to/target/release/my-mcp-server

use rmcp::{
    ServerHandler, ServiceExt,
    model::*,
    tool, tool_handler, tool_router,
    transport::stdio,
    ErrorData as McpError,
    schemars,
};
use serde::Deserialize;
use std::path::PathBuf;

#[derive(Debug, Clone)]
pub struct FileSearchServer {
    root_dir: PathBuf,
}

impl FileSearchServer {
    pub fn new(root_dir: PathBuf) -> Self {
        Self { root_dir }
    }
}

#[derive(Debug, Deserialize, schemars::JsonSchema)]
pub struct SearchParams {
    /// 検索するファイル名のパターン（部分一致）
    pub pattern: String,
    /// 検索対象の拡張子（例: "rs", "toml"）
    pub extension: Option<String>,
}

#[tool_router]
impl FileSearchServer {
    #[tool(description = "指定パターンに一致するファイルを検索する")]
    async fn search_files(
        &self,
        #[tool(params)] params: SearchParams,
    ) -> Result<CallToolResult, McpError> {
        let mut results = Vec::new();

        self.walk_dir(&self.root_dir, &params.pattern, &params.extension, &mut results)
            .map_err(|e| McpError {
                code: -1,
                message: format!("ファイル検索エラー: {}", e).into(),
                data: None,
            })?;

        if results.is_empty() {
            return Ok(CallToolResult::success(vec![
                Content::text("一致するファイルが見つかりませんでした"),
            ]));
        }

        let output = results.join("\n");
        Ok(CallToolResult::success(vec![Content::text(output)]))
    }
}

impl FileSearchServer {
    fn walk_dir(
        &self,
        dir: &PathBuf,
        pattern: &str,
        extension: &Option<String>,
        results: &mut Vec<String>,
    ) -> anyhow::Result<()> {
        for entry in std::fs::read_dir(dir)? {
            let entry = entry?;
            let path = entry.path();
            if path.is_dir() {
                self.walk_dir(&path, pattern, extension, results)?;
            } else if let Some(name) = path.file_name().and_then(|n| n.to_str()) {
                let matches_pattern = name.contains(pattern);
                let matches_ext = extension.as_ref().map_or(true, |ext| {
                    path.extension().and_then(|e| e.to_str()) == Some(ext.as_str())
                });
                if matches_pattern && matches_ext {
                    results.push(path.display().to_string());
                }
            }
        }
        Ok(())
    }
}

#[tool_handler]
impl ServerHandler for FileSearchServer {
    fn get_info(&self) -> ServerInfo {
        ServerInfo {
            instructions: Some("プロジェクト内のファイルを検索するサーバーです".into()),
            capabilities: ServerCapabilities::builder()
                .enable_tools()
                .build(),
            ..Default::default()
        }
    }
}

use rmcp::ErrorData as McpError;

Err(McpError {
    code: -32602,
    message: "nameパラメータは必須です".into(),
    data: None,
})

Ok(CallToolResult::error(vec![
    Content::text("指定されたファイルが見つかりません"),
]))

npx @modelcontextprotocol/inspector target/release/my-mcp-server

RUST_LOG=debug target/release/my-mcp-server