Struct MicrokernelServer

pub struct MicrokernelServer<P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static, S: OAuthStorage + Clone + 'static, M: McpServerHandler = McpServer> { /* private fields */ }

Microkernel server builder that composes independent handlers

This builder demonstrates the microkernel principle where services are composed from independent, single-responsibility components. Now supports any OAuth provider, storage backend, MCP server, and custom routers through trait abstraction.

Implementations

impl<P: OAuthProviderTrait<S, DefaultClientManager<S>> + 'static, S: OAuthStorage + Clone + 'static, M: McpServerHandler> MicrokernelServer<P, S, M>

pub fn new() -> Self

Create a new microkernel server builder

Examples found in repository

examples/simple_custom_router_test.rs (line 53)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing custom router functionality...");

    // Create OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: "test_client_id".to_string(),
        client_secret: "test_client_secret".to_string(),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    let health_router = Router::new()
        .route("/health", get(health_check));

    let api_router = Router::new()
        .route("/status", get(api_status));

    // Build microkernel server with custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_router(health_router)
        .with_custom_router_config(
            api_router,
            CustomRouterConfig::with_prefix("/api"),
        );

    // Test that the router can be built
    let router = microkernel.build_router()?;
    println!("✅ Router built successfully!");

    // Print available endpoints
    println!("\n📋 Server would have these endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom:");
    println!("    GET  /health");
    println!("    GET  /api/status");
    
    println!("\n🎉 Custom router functionality is working correctly!");
    println!("   The server can be built and all routers are properly attached.");

    Ok(())
}

examples/custom_mcp_server_example.rs (line 478)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting Custom MCP Server example with Cognito and DynamoDB storage...");

    // Create Cognito OAuth configuration
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: format!(
            "http://{}:{}/oauth/callback",
            config.server.host, config.server.port
        ),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };

    // Get DynamoDB configuration
    let table_name =
        env::var("DYNAMODB_TABLE_NAME").unwrap_or_else(|_| "oauth-storage".to_string());
    let create_table = env::var("DYNAMODB_CREATE_TABLE")
        .unwrap_or_else(|_| "true".to_string())
        .parse::<bool>()
        .unwrap_or(true);

    // Log configuration
    log_startup_info(&config, &table_name, create_table);

    // Create DynamoDB storage
    let (storage, client_manager) = create_dynamodb_storage(
        table_name.clone(),
        create_table,
        Some("expires_at".to_string()),
    )
    .await
    .map_err(|e| {
        remote_mcp_kernel::error::AppError::Internal(format!(
            "Failed to create DynamoDB storage: {}",
            e
        ))
    })?;

    // Create Cognito OAuth provider with DynamoDB storage
    let oauth_handler = oauth_provider_rs::CognitoOAuthHandler::new_simple(
        storage,
        client_manager,
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
    );

    let oauth_provider = OAuthProvider::new(oauth_handler);

    // Create custom MCP server
    let custom_mcp_server = CustomMcpServer::new("Custom File & System MCP Server".to_string());

    // Build microkernel with custom MCP server using convenience methods
    let microkernel = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_mcp_streamable_handler(custom_mcp_server.clone())
        .with_mcp_sse_handler(custom_mcp_server, SseHandlerConfig::default());

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    tracing::info!("🚀 Starting microkernel server on {}", bind_address);
    microkernel.serve(bind_address).await?;

    Ok(())
}

examples/custom_router_example.rs (line 168)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing for logging
    tracing_subscriber::fmt::init();

    // Create GitHub OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "demo_client_id".to_string()),
        client_secret: std::env::var("GITHUB_CLIENT_SECRET").unwrap_or_else(|_| "demo_client_secret".to_string()),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    
    // 1. Health and basic endpoints router
    let health_router = Router::new()
        .route("/health", get(health_check))
        .route("/webhooks", post(webhook_handler));

    // 2. Monitoring router with path prefix
    let monitoring_router = Router::new()
        .route("/metrics", get(metrics));

    // 3. API router with versioned endpoints
    let api_router = Router::new()
        .route("/v1/status", get(api_status))
        .route("/{version}/status", get(api_status));

    // 4. Admin router with HTML interface
    let admin_router = Router::new()
        .route("/", get(admin_dashboard));

    // Configure custom routers with different configurations
    let custom_routers = vec![
        // Health router without prefix (attached to root)
        (health_router, CustomRouterConfig::default()),
        
        // Monitoring router with prefix and name
        (
            monitoring_router,
            CustomRouterConfig::with_name_and_prefix("Monitoring", "/monitoring"),
        ),
        
        // API router with prefix
        (
            api_router,
            CustomRouterConfig::with_name_and_prefix("API", "/api"),
        ),
        
        // Admin router with prefix
        (
            admin_router,
            CustomRouterConfig::with_name_and_prefix("Admin Dashboard", "/admin"),
        ),
    ];

    // Build the microkernel server with OAuth provider and custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_routers(custom_routers);

    // Define the bind address
    let bind_address: SocketAddr = "127.0.0.1:8080".parse()?;

    // Print available endpoints
    println!("🚀 Starting microkernel server with custom routers...");
    println!("📍 Server listening on: http://{}", bind_address);
    println!("\n📋 Available endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom Endpoints:");
    println!("    GET  /health                  - Health check");
    println!("    POST /webhooks                - Webhook handler");
    println!("    GET  /monitoring/metrics      - System metrics");
    println!("    GET  /api/v1/status           - API status");
    println!("    GET  /api/{{version}}/status   - Versioned API status");
    println!("    GET  /admin                   - Admin dashboard");
    println!("\n🔧 Try these commands:");
    println!("  curl http://localhost:8080/health");
    println!("  curl http://localhost:8080/monitoring/metrics");
    println!("  curl http://localhost:8080/api/v1/status");
    println!("  open http://localhost:8080/admin");

    // Start the server
    microkernel.serve(bind_address).await?;

    Ok(())
}

pub fn with_oauth_provider(self, oauth_provider: OAuthProvider<P, S>) -> Self

Add OAuth provider handler

Examples found in repository

examples/simple_custom_router_test.rs (line 54)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing custom router functionality...");

    // Create OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: "test_client_id".to_string(),
        client_secret: "test_client_secret".to_string(),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    let health_router = Router::new()
        .route("/health", get(health_check));

    let api_router = Router::new()
        .route("/status", get(api_status));

    // Build microkernel server with custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_router(health_router)
        .with_custom_router_config(
            api_router,
            CustomRouterConfig::with_prefix("/api"),
        );

    // Test that the router can be built
    let router = microkernel.build_router()?;
    println!("✅ Router built successfully!");

    // Print available endpoints
    println!("\n📋 Server would have these endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom:");
    println!("    GET  /health");
    println!("    GET  /api/status");
    
    println!("\n🎉 Custom router functionality is working correctly!");
    println!("   The server can be built and all routers are properly attached.");

    Ok(())
}

examples/custom_mcp_server_example.rs (line 479)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting Custom MCP Server example with Cognito and DynamoDB storage...");

    // Create Cognito OAuth configuration
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: format!(
            "http://{}:{}/oauth/callback",
            config.server.host, config.server.port
        ),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };

    // Get DynamoDB configuration
    let table_name =
        env::var("DYNAMODB_TABLE_NAME").unwrap_or_else(|_| "oauth-storage".to_string());
    let create_table = env::var("DYNAMODB_CREATE_TABLE")
        .unwrap_or_else(|_| "true".to_string())
        .parse::<bool>()
        .unwrap_or(true);

    // Log configuration
    log_startup_info(&config, &table_name, create_table);

    // Create DynamoDB storage
    let (storage, client_manager) = create_dynamodb_storage(
        table_name.clone(),
        create_table,
        Some("expires_at".to_string()),
    )
    .await
    .map_err(|e| {
        remote_mcp_kernel::error::AppError::Internal(format!(
            "Failed to create DynamoDB storage: {}",
            e
        ))
    })?;

    // Create Cognito OAuth provider with DynamoDB storage
    let oauth_handler = oauth_provider_rs::CognitoOAuthHandler::new_simple(
        storage,
        client_manager,
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
    );

    let oauth_provider = OAuthProvider::new(oauth_handler);

    // Create custom MCP server
    let custom_mcp_server = CustomMcpServer::new("Custom File & System MCP Server".to_string());

    // Build microkernel with custom MCP server using convenience methods
    let microkernel = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_mcp_streamable_handler(custom_mcp_server.clone())
        .with_mcp_sse_handler(custom_mcp_server, SseHandlerConfig::default());

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    tracing::info!("🚀 Starting microkernel server on {}", bind_address);
    microkernel.serve(bind_address).await?;

    Ok(())
}

examples/custom_router_example.rs (line 169)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing for logging
    tracing_subscriber::fmt::init();

    // Create GitHub OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "demo_client_id".to_string()),
        client_secret: std::env::var("GITHUB_CLIENT_SECRET").unwrap_or_else(|_| "demo_client_secret".to_string()),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    
    // 1. Health and basic endpoints router
    let health_router = Router::new()
        .route("/health", get(health_check))
        .route("/webhooks", post(webhook_handler));

    // 2. Monitoring router with path prefix
    let monitoring_router = Router::new()
        .route("/metrics", get(metrics));

    // 3. API router with versioned endpoints
    let api_router = Router::new()
        .route("/v1/status", get(api_status))
        .route("/{version}/status", get(api_status));

    // 4. Admin router with HTML interface
    let admin_router = Router::new()
        .route("/", get(admin_dashboard));

    // Configure custom routers with different configurations
    let custom_routers = vec![
        // Health router without prefix (attached to root)
        (health_router, CustomRouterConfig::default()),
        
        // Monitoring router with prefix and name
        (
            monitoring_router,
            CustomRouterConfig::with_name_and_prefix("Monitoring", "/monitoring"),
        ),
        
        // API router with prefix
        (
            api_router,
            CustomRouterConfig::with_name_and_prefix("API", "/api"),
        ),
        
        // Admin router with prefix
        (
            admin_router,
            CustomRouterConfig::with_name_and_prefix("Admin Dashboard", "/admin"),
        ),
    ];

    // Build the microkernel server with OAuth provider and custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_routers(custom_routers);

    // Define the bind address
    let bind_address: SocketAddr = "127.0.0.1:8080".parse()?;

    // Print available endpoints
    println!("🚀 Starting microkernel server with custom routers...");
    println!("📍 Server listening on: http://{}", bind_address);
    println!("\n📋 Available endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom Endpoints:");
    println!("    GET  /health                  - Health check");
    println!("    POST /webhooks                - Webhook handler");
    println!("    GET  /monitoring/metrics      - System metrics");
    println!("    GET  /api/v1/status           - API status");
    println!("    GET  /api/{{version}}/status   - Versioned API status");
    println!("    GET  /admin                   - Admin dashboard");
    println!("\n🔧 Try these commands:");
    println!("  curl http://localhost:8080/health");
    println!("  curl http://localhost:8080/monitoring/metrics");
    println!("  curl http://localhost:8080/api/v1/status");
    println!("  open http://localhost:8080/admin");

    // Start the server
    microkernel.serve(bind_address).await?;

    Ok(())
}

pub fn with_streamable_handler( self, streamable_handler: StreamableHttpHandler<M>, ) -> Self

Add streamable HTTP handler

pub fn with_sse_handler( self, sse_handler: SseHandler<M>, config: SseHandlerConfig, ) -> Self

Add SSE handler with configuration

pub fn with_mcp_sse_handler( self, mcp_server: M, config: SseHandlerConfig, ) -> Self

Create SSE handler with MCP server and configuration

Examples found in repository

examples/custom_mcp_server_example.rs (line 481)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting Custom MCP Server example with Cognito and DynamoDB storage...");

    // Create Cognito OAuth configuration
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: format!(
            "http://{}:{}/oauth/callback",
            config.server.host, config.server.port
        ),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };

    // Get DynamoDB configuration
    let table_name =
        env::var("DYNAMODB_TABLE_NAME").unwrap_or_else(|_| "oauth-storage".to_string());
    let create_table = env::var("DYNAMODB_CREATE_TABLE")
        .unwrap_or_else(|_| "true".to_string())
        .parse::<bool>()
        .unwrap_or(true);

    // Log configuration
    log_startup_info(&config, &table_name, create_table);

    // Create DynamoDB storage
    let (storage, client_manager) = create_dynamodb_storage(
        table_name.clone(),
        create_table,
        Some("expires_at".to_string()),
    )
    .await
    .map_err(|e| {
        remote_mcp_kernel::error::AppError::Internal(format!(
            "Failed to create DynamoDB storage: {}",
            e
        ))
    })?;

    // Create Cognito OAuth provider with DynamoDB storage
    let oauth_handler = oauth_provider_rs::CognitoOAuthHandler::new_simple(
        storage,
        client_manager,
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
    );

    let oauth_provider = OAuthProvider::new(oauth_handler);

    // Create custom MCP server
    let custom_mcp_server = CustomMcpServer::new("Custom File & System MCP Server".to_string());

    // Build microkernel with custom MCP server using convenience methods
    let microkernel = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_mcp_streamable_handler(custom_mcp_server.clone())
        .with_mcp_sse_handler(custom_mcp_server, SseHandlerConfig::default());

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    tracing::info!("🚀 Starting microkernel server on {}", bind_address);
    microkernel.serve(bind_address).await?;

    Ok(())
}

pub fn with_mcp_streamable_handler(self, mcp_server: M) -> Self

Create streamable HTTP handler with MCP server

Examples found in repository

examples/custom_mcp_server_example.rs (line 480)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting Custom MCP Server example with Cognito and DynamoDB storage...");

    // Create Cognito OAuth configuration
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: format!(
            "http://{}:{}/oauth/callback",
            config.server.host, config.server.port
        ),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };

    // Get DynamoDB configuration
    let table_name =
        env::var("DYNAMODB_TABLE_NAME").unwrap_or_else(|_| "oauth-storage".to_string());
    let create_table = env::var("DYNAMODB_CREATE_TABLE")
        .unwrap_or_else(|_| "true".to_string())
        .parse::<bool>()
        .unwrap_or(true);

    // Log configuration
    log_startup_info(&config, &table_name, create_table);

    // Create DynamoDB storage
    let (storage, client_manager) = create_dynamodb_storage(
        table_name.clone(),
        create_table,
        Some("expires_at".to_string()),
    )
    .await
    .map_err(|e| {
        remote_mcp_kernel::error::AppError::Internal(format!(
            "Failed to create DynamoDB storage: {}",
            e
        ))
    })?;

    // Create Cognito OAuth provider with DynamoDB storage
    let oauth_handler = oauth_provider_rs::CognitoOAuthHandler::new_simple(
        storage,
        client_manager,
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
    );

    let oauth_provider = OAuthProvider::new(oauth_handler);

    // Create custom MCP server
    let custom_mcp_server = CustomMcpServer::new("Custom File & System MCP Server".to_string());

    // Build microkernel with custom MCP server using convenience methods
    let microkernel = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_mcp_streamable_handler(custom_mcp_server.clone())
        .with_mcp_sse_handler(custom_mcp_server, SseHandlerConfig::default());

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    tracing::info!("🚀 Starting microkernel server on {}", bind_address);
    microkernel.serve(bind_address).await?;

    Ok(())
}

pub fn with_custom_router(self, router: Router) -> Self

Attach a custom router to the microkernel server

This method allows attaching arbitrary axum Routers to the microkernel server, enabling extension of the server with custom endpoints while maintaining microkernel architecture principles.

Arguments

• router - The axum Router to attach

Examples

use axum::{Router, routing::get, response::Html};
use remote_mcp_kernel::microkernel::GitHubMicrokernelServer;
 
async fn hello() -> Html<&'static str> {
    Html("<h1>Hello, World!</h1>")
}
 
let custom_router = Router::new()
    .route("/hello", get(hello));
 
let server: GitHubMicrokernelServer = GitHubMicrokernelServer::new()
    .with_custom_router(custom_router);

Examples found in repository

examples/simple_custom_router_test.rs (line 55)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing custom router functionality...");

    // Create OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: "test_client_id".to_string(),
        client_secret: "test_client_secret".to_string(),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    let health_router = Router::new()
        .route("/health", get(health_check));

    let api_router = Router::new()
        .route("/status", get(api_status));

    // Build microkernel server with custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_router(health_router)
        .with_custom_router_config(
            api_router,
            CustomRouterConfig::with_prefix("/api"),
        );

    // Test that the router can be built
    let router = microkernel.build_router()?;
    println!("✅ Router built successfully!");

    // Print available endpoints
    println!("\n📋 Server would have these endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom:");
    println!("    GET  /health");
    println!("    GET  /api/status");
    
    println!("\n🎉 Custom router functionality is working correctly!");
    println!("   The server can be built and all routers are properly attached.");

    Ok(())
}

pub fn with_custom_router_config( self, router: Router, config: CustomRouterConfig, ) -> Self

Attach a custom router with configuration to the microkernel server

This method provides more control over how the custom router is attached, allowing for custom configuration such as path prefixes and names.

Arguments

• router - The axum Router to attach
• config - Configuration for the custom router

Examples

use axum::{Router, routing::get, response::Html};
use remote_mcp_kernel::microkernel::{GitHubMicrokernelServer, CustomRouterConfig};
 
async fn api_status() -> Html<&'static str> {
    Html("<h1>API Status: OK</h1>")
}
 
let custom_router = Router::new()
    .route("/status", get(api_status));
 
let config = CustomRouterConfig {
    name: Some("API Router".to_string()),
    path_prefix: Some("/api".to_string()),
};
 
let server: GitHubMicrokernelServer = GitHubMicrokernelServer::new()
    .with_custom_router_config(custom_router, config);

Examples found in repository

examples/simple_custom_router_test.rs (lines 56-59)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing custom router functionality...");

    // Create OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: "test_client_id".to_string(),
        client_secret: "test_client_secret".to_string(),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    let health_router = Router::new()
        .route("/health", get(health_check));

    let api_router = Router::new()
        .route("/status", get(api_status));

    // Build microkernel server with custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_router(health_router)
        .with_custom_router_config(
            api_router,
            CustomRouterConfig::with_prefix("/api"),
        );

    // Test that the router can be built
    let router = microkernel.build_router()?;
    println!("✅ Router built successfully!");

    // Print available endpoints
    println!("\n📋 Server would have these endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom:");
    println!("    GET  /health");
    println!("    GET  /api/status");
    
    println!("\n🎉 Custom router functionality is working correctly!");
    println!("   The server can be built and all routers are properly attached.");

    Ok(())
}

pub fn with_custom_routers( self, routers: Vec<(Router, CustomRouterConfig)>, ) -> Self

Attach multiple custom routers at once

This method allows attaching multiple custom routers efficiently.

Arguments

• routers - A vector of tuples containing (Router, CustomRouterConfig)

Examples

use axum::{Router, routing::get, response::Html};
use remote_mcp_kernel::microkernel::{GitHubMicrokernelServer, CustomRouterConfig};
 
async fn health() -> Html<&'static str> {
    Html("<h1>Health: OK</h1>")
}
 
async fn metrics() -> Html<&'static str> {
    Html("<h1>Metrics: OK</h1>")
}
 
let health_router = Router::new().route("/health", get(health));
let metrics_router = Router::new().route("/metrics", get(metrics));
 
let routers = vec![
    (health_router, CustomRouterConfig::default()),
    (metrics_router, CustomRouterConfig {
        name: Some("Metrics".to_string()),
        path_prefix: Some("/monitoring".to_string()),
    }),
];
 
let server: GitHubMicrokernelServer = GitHubMicrokernelServer::new()
    .with_custom_routers(routers);

Examples found in repository

examples/custom_router_example.rs (line 170)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing for logging
    tracing_subscriber::fmt::init();

    // Create GitHub OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "demo_client_id".to_string()),
        client_secret: std::env::var("GITHUB_CLIENT_SECRET").unwrap_or_else(|_| "demo_client_secret".to_string()),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    
    // 1. Health and basic endpoints router
    let health_router = Router::new()
        .route("/health", get(health_check))
        .route("/webhooks", post(webhook_handler));

    // 2. Monitoring router with path prefix
    let monitoring_router = Router::new()
        .route("/metrics", get(metrics));

    // 3. API router with versioned endpoints
    let api_router = Router::new()
        .route("/v1/status", get(api_status))
        .route("/{version}/status", get(api_status));

    // 4. Admin router with HTML interface
    let admin_router = Router::new()
        .route("/", get(admin_dashboard));

    // Configure custom routers with different configurations
    let custom_routers = vec![
        // Health router without prefix (attached to root)
        (health_router, CustomRouterConfig::default()),
        
        // Monitoring router with prefix and name
        (
            monitoring_router,
            CustomRouterConfig::with_name_and_prefix("Monitoring", "/monitoring"),
        ),
        
        // API router with prefix
        (
            api_router,
            CustomRouterConfig::with_name_and_prefix("API", "/api"),
        ),
        
        // Admin router with prefix
        (
            admin_router,
            CustomRouterConfig::with_name_and_prefix("Admin Dashboard", "/admin"),
        ),
    ];

    // Build the microkernel server with OAuth provider and custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_routers(custom_routers);

    // Define the bind address
    let bind_address: SocketAddr = "127.0.0.1:8080".parse()?;

    // Print available endpoints
    println!("🚀 Starting microkernel server with custom routers...");
    println!("📍 Server listening on: http://{}", bind_address);
    println!("\n📋 Available endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom Endpoints:");
    println!("    GET  /health                  - Health check");
    println!("    POST /webhooks                - Webhook handler");
    println!("    GET  /monitoring/metrics      - System metrics");
    println!("    GET  /api/v1/status           - API status");
    println!("    GET  /api/{{version}}/status   - Versioned API status");
    println!("    GET  /admin                   - Admin dashboard");
    println!("\n🔧 Try these commands:");
    println!("  curl http://localhost:8080/health");
    println!("  curl http://localhost:8080/monitoring/metrics");
    println!("  curl http://localhost:8080/api/v1/status");
    println!("  open http://localhost:8080/admin");

    // Start the server
    microkernel.serve(bind_address).await?;

    Ok(())
}

pub fn build_router(self) -> AppResult<Router>

Build the composed router from all registered handlers

This method demonstrates the microkernel composition principle where independent components are combined into a unified service. Now includes support for custom routers with path prefixes and configuration.

Examples found in repository

examples/simple_custom_router_test.rs (line 62)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Testing custom router functionality...");

    // Create OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: "test_client_id".to_string(),
        client_secret: "test_client_secret".to_string(),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    let health_router = Router::new()
        .route("/health", get(health_check));

    let api_router = Router::new()
        .route("/status", get(api_status));

    // Build microkernel server with custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_router(health_router)
        .with_custom_router_config(
            api_router,
            CustomRouterConfig::with_prefix("/api"),
        );

    // Test that the router can be built
    let router = microkernel.build_router()?;
    println!("✅ Router built successfully!");

    // Print available endpoints
    println!("\n📋 Server would have these endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom:");
    println!("    GET  /health");
    println!("    GET  /api/status");
    
    println!("\n🎉 Custom router functionality is working correctly!");
    println!("   The server can be built and all routers are properly attached.");

    Ok(())
}

pub async fn serve(self, bind_address: SocketAddr) -> AppResult<()>

Start the microkernel server

Examples found in repository

examples/oauth_standard_mcp_server.rs (line 38)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting MCP OAuth server with microkernel architecture...");

    // Create OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: config.github.client_id.clone(),
        client_secret: config.github.client_secret.clone(),
        redirect_uri: config.github.redirect_uri.clone(),
        scope: config.github.scope.clone(),
        provider_name: "github".to_string(),
    };
    let oauth_provider = GitHubOAuthProvider::new_github(github_config);

    // Log configuration
    log_startup_info(&config);

    // Create microkernel server with all handlers composed
    let microkernel = create_full_github_microkernel(oauth_provider);

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    microkernel.serve(bind_address).await?;

    Ok(())
}

examples/oauth_cognito_mcp_server.rs (line 43)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting MCP OAuth server with Cognito and microkernel architecture...");

    // Create Cognito OAuth provider
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: config.cognito.redirect_uri.clone(),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };
    let oauth_provider = CognitoOAuthProvider::new_cognito(
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
    );

    // Log configuration
    log_startup_info(&config);

    // Create microkernel server with all handlers composed
    let microkernel = create_full_cognito_microkernel(oauth_provider);

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    microkernel.serve(bind_address).await?;

    Ok(())
}

examples/oauth_cognito_dynamodb_mcp_server.rs (line 110)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting MCP OAuth server with Cognito and DynamoDB storage...");

    // Create Cognito OAuth configuration
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: format!(
            "http://{}:{}/oauth/callback",
            config.server.host, config.server.port
        ),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };

    // Get DynamoDB configuration
    let table_name =
        env::var("DYNAMODB_TABLE_NAME").unwrap_or_else(|_| "oauth-storage".to_string());
    let create_table = env::var("DYNAMODB_CREATE_TABLE")
        .unwrap_or_else(|_| "true".to_string())
        .parse::<bool>()
        .unwrap_or(true);

    // Log configuration
    log_startup_info(&config, &table_name, create_table);

    // Create microkernel server with Cognito OAuth and DynamoDB storage
    let microkernel = create_full_cognito_microkernel_dynamodb(
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
        table_name,
        create_table,
    )
    .await
    .map_err(|e| {
        remote_mcp_kernel::error::AppError::Internal(format!("Failed to create microkernel: {}", e))
    })?;

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    microkernel.serve(bind_address).await?;

    Ok(())
}

examples/custom_mcp_server_example.rs (line 486)

async fn main() -> AppResult<()> {
    // Load environment variables
    dotenv::dotenv().ok();

    // Load configuration
    let config = Config::from_env()?;

    // Initialize tracing
    init_tracing(&config)?;

    tracing::info!("Starting Custom MCP Server example with Cognito and DynamoDB storage...");

    // Create Cognito OAuth configuration
    let cognito_config = CognitoOAuthConfig {
        client_id: config.cognito.client_id.clone(),
        client_secret: config.cognito.client_secret.clone().unwrap_or_default(),
        redirect_uri: format!(
            "http://{}:{}/oauth/callback",
            config.server.host, config.server.port
        ),
        scope: config.cognito.scope.clone(),
        provider_name: "cognito".to_string(),
    };

    // Get DynamoDB configuration
    let table_name =
        env::var("DYNAMODB_TABLE_NAME").unwrap_or_else(|_| "oauth-storage".to_string());
    let create_table = env::var("DYNAMODB_CREATE_TABLE")
        .unwrap_or_else(|_| "true".to_string())
        .parse::<bool>()
        .unwrap_or(true);

    // Log configuration
    log_startup_info(&config, &table_name, create_table);

    // Create DynamoDB storage
    let (storage, client_manager) = create_dynamodb_storage(
        table_name.clone(),
        create_table,
        Some("expires_at".to_string()),
    )
    .await
    .map_err(|e| {
        remote_mcp_kernel::error::AppError::Internal(format!(
            "Failed to create DynamoDB storage: {}",
            e
        ))
    })?;

    // Create Cognito OAuth provider with DynamoDB storage
    let oauth_handler = oauth_provider_rs::CognitoOAuthHandler::new_simple(
        storage,
        client_manager,
        cognito_config,
        config.cognito.cognito_domain.clone(),
        config.cognito.region.clone(),
        config.cognito.user_pool_id.clone(),
    );

    let oauth_provider = OAuthProvider::new(oauth_handler);

    // Create custom MCP server
    let custom_mcp_server = CustomMcpServer::new("Custom File & System MCP Server".to_string());

    // Build microkernel with custom MCP server using convenience methods
    let microkernel = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_mcp_streamable_handler(custom_mcp_server.clone())
        .with_mcp_sse_handler(custom_mcp_server, SseHandlerConfig::default());

    // Start the microkernel server
    let bind_address = config.bind_socket_addr()?;
    tracing::info!("🚀 Starting microkernel server on {}", bind_address);
    microkernel.serve(bind_address).await?;

    Ok(())
}

examples/custom_router_example.rs (line 197)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize tracing for logging
    tracing_subscriber::fmt::init();

    // Create GitHub OAuth provider
    let github_config = GitHubOAuthConfig {
        client_id: std::env::var("GITHUB_CLIENT_ID").unwrap_or_else(|_| "demo_client_id".to_string()),
        client_secret: std::env::var("GITHUB_CLIENT_SECRET").unwrap_or_else(|_| "demo_client_secret".to_string()),
        redirect_uri: "http://localhost:8080/oauth/callback".to_string(),
        scope: "read:user".to_string(),
        provider_name: "github".to_string(),
    };

    let github_oauth_provider = GitHubOAuthProvider::new_github(github_config);
    let oauth_provider = OAuthProvider::new(github_oauth_provider);

    // Create custom routers
    
    // 1. Health and basic endpoints router
    let health_router = Router::new()
        .route("/health", get(health_check))
        .route("/webhooks", post(webhook_handler));

    // 2. Monitoring router with path prefix
    let monitoring_router = Router::new()
        .route("/metrics", get(metrics));

    // 3. API router with versioned endpoints
    let api_router = Router::new()
        .route("/v1/status", get(api_status))
        .route("/{version}/status", get(api_status));

    // 4. Admin router with HTML interface
    let admin_router = Router::new()
        .route("/", get(admin_dashboard));

    // Configure custom routers with different configurations
    let custom_routers = vec![
        // Health router without prefix (attached to root)
        (health_router, CustomRouterConfig::default()),
        
        // Monitoring router with prefix and name
        (
            monitoring_router,
            CustomRouterConfig::with_name_and_prefix("Monitoring", "/monitoring"),
        ),
        
        // API router with prefix
        (
            api_router,
            CustomRouterConfig::with_name_and_prefix("API", "/api"),
        ),
        
        // Admin router with prefix
        (
            admin_router,
            CustomRouterConfig::with_name_and_prefix("Admin Dashboard", "/admin"),
        ),
    ];

    // Build the microkernel server with OAuth provider and custom routers
    let microkernel: GitHubMicrokernelServer = MicrokernelServer::new()
        .with_oauth_provider(oauth_provider)
        .with_custom_routers(custom_routers);

    // Define the bind address
    let bind_address: SocketAddr = "127.0.0.1:8080".parse()?;

    // Print available endpoints
    println!("🚀 Starting microkernel server with custom routers...");
    println!("📍 Server listening on: http://{}", bind_address);
    println!("\n📋 Available endpoints:");
    println!("  OAuth:");
    println!("    GET  /oauth/login");
    println!("    GET  /oauth/callback");
    println!("    POST /oauth/token");
    println!("  Custom Endpoints:");
    println!("    GET  /health                  - Health check");
    println!("    POST /webhooks                - Webhook handler");
    println!("    GET  /monitoring/metrics      - System metrics");
    println!("    GET  /api/v1/status           - API status");
    println!("    GET  /api/{{version}}/status   - Versioned API status");
    println!("    GET  /admin                   - Admin dashboard");
    println!("\n🔧 Try these commands:");
    println!("  curl http://localhost:8080/health");
    println!("  curl http://localhost:8080/monitoring/metrics");
    println!("  curl http://localhost:8080/api/v1/status");
    println!("  open http://localhost:8080/admin");

    // Start the server
    microkernel.serve(bind_address).await?;

    Ok(())
}

Trait Implementations

impl<P: OAuthProviderTrait<S, DefaultClientManager<S>>, S: OAuthStorage + Clone + 'static, M: McpServerHandler> Default for MicrokernelServer<P, S, M>

fn default() -> Self

Returns the “default value” for a type.