Struct LambdaMcpServerBuilder 

pub struct LambdaMcpServerBuilder { /* private fields */ }

High-level builder for Lambda MCP servers

This provides a clean, fluent API for building Lambda MCP servers similar to the framework’s McpServer::builder() pattern.

Example

use std::sync::Arc;
use turul_mcp_aws_lambda::LambdaMcpServerBuilder;
use turul_mcp_session_storage::InMemorySessionStorage;
use turul_mcp_derive::McpTool;
use turul_mcp_server::{McpResult, SessionContext};

#[derive(McpTool, Clone, Default)]
#[tool(name = "example", description = "Example tool")]
struct ExampleTool {
    #[param(description = "Example parameter")]
    value: String,
}

impl ExampleTool {
    async fn execute(&self, _session: Option<SessionContext>) -> McpResult<String> {
        Ok(format!("Got: {}", self.value))
    }
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let server = LambdaMcpServerBuilder::new()
        .name("my-lambda-server")
        .version("1.0.0")
        .tool(ExampleTool::default())
        .storage(Arc::new(InMemorySessionStorage::new()))
        .cors_allow_all_origins()
        .build()
        .await?;

    // Use with Lambda runtime...
    Ok(())
}

Implementations

impl LambdaMcpServerBuilder

pub fn new() -> Self

Create a new Lambda MCP server builder

pub fn name(self, name: impl Into<String>) -> Self

Set the server name

pub fn version(self, version: impl Into<String>) -> Self

Set the server version

pub fn title(self, title: impl Into<String>) -> Self

Set the server title

pub fn instructions(self, instructions: impl Into<String>) -> Self

Set optional instructions for clients

pub fn tool<T: McpTool + 'static>(self, tool: T) -> Self

Register a tool with the server

Tools can be created using any of the framework’s 4 creation levels:

• Function macros: #[mcp_tool]
• Derive macros: #[derive(McpTool)]
• Builder pattern: ToolBuilder::new(...).build()
• Manual implementation: Custom struct implementing McpTool

pub fn tool_fn<F, T>(self, func: F) -> Self

where F: Fn() -> T, T: McpTool + 'static,

Register a function tool created with #[mcp_tool] macro

pub fn tools<T: McpTool + 'static, I: IntoIterator<Item = T>>( self, tools: I, ) -> Self

Register multiple tools

pub fn resource<R: McpResource + 'static>(self, resource: R) -> Self

Register a resource with the server

pub fn resources<R: McpResource + 'static, I: IntoIterator<Item = R>>( self, resources: I, ) -> Self

Register multiple resources

pub fn prompt<P: McpPrompt + 'static>(self, prompt: P) -> Self

Register a prompt with the server

pub fn prompts<P: McpPrompt + 'static, I: IntoIterator<Item = P>>( self, prompts: I, ) -> Self

Register multiple prompts

pub fn elicitation<E: McpElicitation + 'static>(self, elicitation: E) -> Self

Register an elicitation provider with the server

pub fn elicitations<E: McpElicitation + 'static, I: IntoIterator<Item = E>>( self, elicitations: I, ) -> Self

Register multiple elicitation providers

pub fn sampling_provider<S: McpSampling + 'static>(self, sampling: S) -> Self

Register a sampling provider with the server

pub fn sampling_providers<S: McpSampling + 'static, I: IntoIterator<Item = S>>( self, sampling: I, ) -> Self

Register multiple sampling providers

pub fn completion_provider<C: McpCompletion + 'static>( self, completion: C, ) -> Self

Register a completion provider with the server

pub fn completion_providers<C: McpCompletion + 'static, I: IntoIterator<Item = C>>( self, completions: I, ) -> Self

Register multiple completion providers

pub fn logger<L: McpLogger + 'static>(self, logger: L) -> Self

Register a logger with the server

pub fn loggers<L: McpLogger + 'static, I: IntoIterator<Item = L>>( self, loggers: I, ) -> Self

Register multiple loggers

pub fn root_provider<R: McpRoot + 'static>(self, root: R) -> Self

Register a root provider with the server

pub fn root_providers<R: McpRoot + 'static, I: IntoIterator<Item = R>>( self, roots: I, ) -> Self

Register multiple root providers

pub fn notification_provider<N: McpNotification + 'static>( self, notification: N, ) -> Self

Register a notification provider with the server

pub fn notification_providers<N: McpNotification + 'static, I: IntoIterator<Item = N>>( self, notifications: I, ) -> Self

Register multiple notification providers

pub fn sampler<S: McpSampling + 'static>(self, sampling: S) -> Self

Register a sampler - convenient alias for sampling_provider

pub fn completer<C: McpCompletion + 'static>(self, completion: C) -> Self

Register a completer - convenient alias for completion_provider

pub fn notification_type<N: McpNotification + 'static + Default>(self) -> Self

Register a notification by type - type determines method automatically

pub fn handler<H: McpHandler + 'static>(self, handler: H) -> Self

Register a handler with the server

pub fn handlers<H: McpHandler + 'static, I: IntoIterator<Item = H>>( self, handlers: I, ) -> Self

Register multiple handlers

pub fn root(self, root: Root) -> Self

Add a single root directory

pub fn with_completion(self) -> Self

Add completion support

pub fn with_prompts(self) -> Self

Add prompts support

pub fn with_resources(self) -> Self

Add resources support

pub fn with_logging(self) -> Self

Add logging support

pub fn with_roots(self) -> Self

Add roots support

pub fn with_sampling(self) -> Self

Add sampling support

pub fn with_elicitation(self) -> Self

Add elicitation support with default mock provider

pub fn with_elicitation_provider<P: ElicitationProvider + 'static>( self, provider: P, ) -> Self

Add elicitation support with custom provider

pub fn with_notifications(self) -> Self

Add notifications support

pub fn session_timeout_minutes(self, minutes: u64) -> Self

Configure session timeout (in minutes, default: 30)

pub fn session_cleanup_interval_seconds(self, seconds: u64) -> Self

Configure session cleanup interval (in seconds, default: 60)

pub fn strict_lifecycle(self, strict: bool) -> Self

Enable strict MCP lifecycle enforcement

pub fn with_strict_lifecycle(self) -> Self

Enable strict MCP lifecycle enforcement (convenience method)

pub fn sse(self, enable: bool) -> Self

Enable or disable SSE streaming support

pub fn with_long_sessions(self) -> Self

Configure sessions with recommended defaults for long-running sessions

pub fn with_short_sessions(self) -> Self

Configure sessions with recommended defaults for short-lived sessions

pub fn storage(self, storage: Arc<BoxedSessionStorage>) -> Self

Set the session storage backend

Supports all framework storage backends:

• InMemorySessionStorage - For development and testing
• SqliteSessionStorage - For single-instance persistence
• PostgreSqlSessionStorage - For multi-instance deployments
• DynamoDbSessionStorage - For serverless AWS deployments

pub fn middleware(self, middleware: Arc<dyn McpMiddleware>) -> Self

Register middleware for request/response interception

Middleware can inspect and modify requests before they reach handlers, inject data into sessions, and transform responses. Multiple middleware can be registered and will execute in FIFO order for before_dispatch and LIFO order for after_dispatch.

Example

use std::sync::Arc;
use turul_mcp_aws_lambda::LambdaMcpServerBuilder;
use turul_http_mcp_server::middleware::McpMiddleware;

let builder = LambdaMcpServerBuilder::new()
    .name("my-server")
    .middleware(Arc::new(AuthMiddleware))
    .middleware(Arc::new(RateLimitMiddleware));

pub fn server_config(self, config: ServerConfig) -> Self

Configure server settings

pub fn stream_config(self, config: StreamConfig) -> Self

Configure streaming/SSE settings

pub fn cors(self, config: CorsConfig) -> Self

Set custom CORS configuration

pub fn cors_allow_all_origins(self) -> Self

Allow all origins for CORS (development only)

pub fn cors_allow_origins(self, origins: Vec<String>) -> Self

Set specific allowed origins for CORS

pub fn cors_from_env(self) -> Self

Configure CORS from environment variables

Uses these environment variables:

• MCP_CORS_ORIGINS - Comma-separated list of allowed origins
• MCP_CORS_CREDENTIALS - Whether to allow credentials (true/false)
• MCP_CORS_MAX_AGE - Preflight cache max age in seconds

pub fn cors_disabled(self) -> Self

Disable CORS (headers will not be added)

pub fn development_config(self) -> Self

Create with in-memory storage and permissive CORS

This is the recommended configuration for development and testing.

pub async fn build(self) -> Result<LambdaMcpServer>

Build the Lambda MCP server

Returns a server that can create handlers when needed.

Trait Implementations

impl Default for LambdaMcpServerBuilder

fn default() -> Self

Returns the “default value” for a type.

impl LambdaMcpServerBuilderExt for LambdaMcpServerBuilder

fn tools<I, T>(self, tools: I) -> Self

where I: IntoIterator<Item = T>, T: McpTool + 'static,

Add multiple tools at once