MCP服务器模板

# Install cargo-generate if you don't have it
cargo install cargo-generate

# Generate your custom MCP server
cargo generate --git https://github.com/furbyhaxx/mcp-server-rs-template

# Follow the prompts to customize your project!

# Clone the template
git clone https://github.com/yourusername/rmcp-starter-template.git
cd rmcp-starter-template

# Build the project
cargo build --release

# Run with stdio transport (default)
cargo run -- serve

# Run with explicit transport selection
cargo run -- serve --transport stdio
cargo run -- serve --transport http

# Example MCP client interaction (simplified)
{
  "tool": "echo",
  "arguments": {
    "message": "Hello, MCP!"
  }
}
# Returns: "Echo: Hello, MCP!"

{
  "tool": "calculate",
  "arguments": {
    "a": 10.5,
    "b": 5.2,
    "operation": "add"
  }
}
# Returns: {"result": 15.7, "operation": "add", "operands": [10.5, 5.2]}

{
  "tool": "get_counter"
}
# Returns: "Current counter value: 0"

{
  "tool": "increment_counter",
  "arguments": {
    "amount": 3
  }
}
# Returns: "Counter incremented by 3. New value: 3"

{
  "tool": "reset_counter"
}
# Returns: "Counter reset to 0"

# Override server name
MCP_SERVER_NAME="my-mcp-server"

# Set log level to debug
MCP_LOGGING_LEVEL="debug"

# Configure HTTP transport port
MCP_TRANSPORT_HTTP_PORT="8080"

# Use only console logging (no file output)
MCP_LOGGING_TARGETS="console"

# Run with custom transport
cargo run -- serve --transport http

# View help and all options
cargo run -- --help

rmcp-starter-template/
├── src/
│   ├── lib.rs                    # Public library API with prelude
│   ├── main.rs                   # CLI entry point
│   ├── cli.rs                    # Command-line interface (clap)
│   ├── config/                   # Configuration management (figment)
│   │   ├── mod.rs               # Config struct and loading logic
│   │   └── tests.rs             # Configuration tests
│   ├── logging/                  # Production logging setup (tracing)
│   │   └── mod.rs               # Logging initialization with rotation
│   ├── transport/                # Transport layer
│   │   ├── mod.rs               # Transport factory and abstraction
│   │   ├── stdio.rs             # stdio transport implementation
│   │   └── http.rs              # HTTP/SSE transport implementation
│   ├── service.rs                # MCP service with tools/resources/prompts
│   ├── service/
│   │   ├── tools.rs             # Tool parameter types and schemas
│   │   ├── resources.rs         # Resource implementations
│   │   ├── prompts.rs           # Prompt implementations
│   │   └── tests.rs             # Service tests
│   ├── error.rs                  # Comprehensive error handling (thiserror)
│   └── prelude.rs                # Common imports for convenience
├── config/
│   └── default.toml             # Default configuration
├── tests/                       # Integration tests
│   ├── stdio_integration.rs     # stdio transport tests
│   └── http_integration.rs      # HTTP transport tests
├── .env.example                 # Environment variable template
└── CHANGELOG.md                 # Version history

// Dynamic transport creation
let transport_future = create_transport(transport, &config, service)?;

// Supports both stdio and HTTP transports
match transport {
    Transport::Stdio => stdio::serve(service).await,
    Transport::Http => http::serve(service, &config).await,
}

// In src/service/tools.rs
use rmcp::schemars::JsonSchema;
use serde::{Deserialize, Serialize};

#[derive(Debug, Deserialize, Serialize, JsonSchema)]
pub struct MyToolParams {
    /// Input text to process
    pub input: String,
    /// Optional processing mode
    pub mode: Option<String>,
}

// In src/service.rs
use rmcp_starter_template::service::tools::MyToolParams;

#[tool(description = "Process input text with optional mode")]
pub async fn my_tool(&self, #[arg] params: MyToolParams) -> Result<CallToolResult, ErrorData> {
    let mode = params.mode.as_deref().unwrap_or("default");
    let result = format!("Processed '{}' with mode '{}'", params.input, mode);

    Ok(CallToolResult::success(vec![Content::text(result)]))
}

// In src/service.rs, override the ServerHandler methods
async fn list_resources(&self) -> Result<Vec<Annotated<RawResource>>, Error> {
    vec![
        Annotated::new(
            RawResource::new("my://resource".into(), "My custom resource".into()),
        ),
    ]
}

async fn read_resource(&self, uri: &str) -> Result<ReadResourceResult, Error> {
    match uri {
        "my://resource" => {
            let content = Content::text("This is my resource content".to_string());
            Ok(ReadResourceResult {
                contents: vec![content],
            })
        }
        _ => Err(Error::invalid_params("Unknown resource URI")),
    }
}

// In src/service.rs, extend the ServerHandler implementation
async fn list_prompts(&self) -> Result<Vec<Annotated<Prompt>>, Error> {
    vec![
        Annotated::new(Prompt {
            name: "my_prompt".into(),
            description: Some("My custom prompt template".into()),
            arguments: vec![
                PromptArgument {
                    name: "topic".into(),
                    description: Some("The topic to discuss".into()),
                    required: Some(true),
                },
            ],
        }),
    ]
}

async fn get_prompt(&self, name: &str, arguments: Option<GetPromptArguments>) -> Result<GetPromptResult, Error> {
    match name {
        "my_prompt" => {
            let args = arguments.ok_or_else(|| Error::invalid_params("Arguments required"))?;
            let topic = args.arguments
                .get("topic")
                .and_then(|v| v.as_str())
                .ok_or_else(|| Error::invalid_params("Missing 'topic' argument"))?;

            let message = PromptMessage {
                role: PromptRole::User,
                content: Content::text(format!("Tell me about {}", topic)),
            };

            Ok(GetPromptResult {
                description: Some(format!("Prompt about {}", topic)),
                messages: vec![message],
            })
        }
        _ => Err(Error::invalid_params("Unknown prompt name")),
    }
}

pub async fn serve<S>(service: S) -> Result<()>
where
    S: ServerHandler + Send + Sync + Clone + 'static,
{
    // Your transport implementation here
    todo!("Implement your transport")
}

cargo build
cargo build --release  # Optimized release build

# Run all tests
cargo test

# Run specific test
cargo test test_config_loading

# Run with output
cargo test -- --nocapture

# Run integration tests only
cargo test --test integration

# Format code
cargo fmt

# Run linter (will fail on warnings)
cargo clippy -- -D warnings

# Check for formatting issues
cargo fmt -- --check

# Generate documentation
cargo doc --open

# 1. Create development configuration
cp .env.example .env
echo 'MCP_LOGGING_LEVEL="debug"' >> .env
echo 'MCP_LOGGING_TARGETS="console"' >> .env

# 2. Run with console logging for development
cargo run -- serve --transport stdio

# 3. Test changes
cargo test

# 4. Run quality checks
cargo fmt && cargo clippy -- -D warnings

# Enable debug logging
RUST_LOG=debug cargo run -- serve

# Show configuration details
MCP_LOGGING_LEVEL=debug cargo run -- serve

# Minimal CLI server
cargo generate --git https://github.com/furbyhaxx/mcp-server-rs-template \
  --enable-http-transport=false \
  --enable-file-logging=false

# Full-featured HTTP server
cargo generate --git https://github.com/furbyhaxx/mcp-server-rs-template \
  --default-transport http \
  --http-port 8080 \
  --enable-all-features

# Production-ready setup
cargo generate --git https://github.com/furbyhaxx/mcp-server-rs-template \
  --log-level warn \
  --author-name "Production Team" \
  --license MIT