Struct MCPServer 

pub struct MCPServer { /* private fields */ }

Main MCP server implementation

Implementations

impl MCPServer

pub fn new(config: MCPServerConfig) -> Self

Create a new MCP server

pub fn with_dht(self, dht: Arc<RwLock<DHT>>) -> Self

Create MCP server with DHT integration

pub async fn with_network_sender(self, sender: Arc<dyn NetworkSender>) -> Self

Set the network sender for P2P communication

pub async fn set_network_sender(&self, sender: Arc<dyn NetworkSender>)

Set the network sender for P2P communication (async method for post-creation setup)

pub async fn start(&self) -> Result<()>

Start the MCP server

pub async fn register_tool(&self, tool: Tool) -> Result<()>

Register a tool

pub async fn call_tool( &self, tool_name: &str, arguments: Value, context: MCPCallContext, ) -> Result<Value>

Call a tool by name

pub async fn list_tools( &self, _cursor: Option<String>, ) -> Result<(Vec<MCPTool>, Option<String>)>

List available tools

pub async fn get_stats(&self) -> MCPServerStats

Get server statistics

pub async fn handle_heartbeat(&self, heartbeat: Heartbeat) -> Result<()>

Handle incoming heartbeat from a remote service

pub async fn get_service_health( &self, service_id: &str, ) -> Option<ServiceHealth>

Get health status of a specific service

pub async fn get_all_service_health(&self) -> HashMap<String, ServiceHealth>

Get health status of all services

pub async fn get_healthy_services(&self) -> Vec<String>

Get healthy services only

pub async fn update_service_health( &self, service_id: String, status: ServiceHealthStatus, error_message: Option<String>, )

Update service health status manually

pub fn subscribe_health_events(&self) -> UnboundedReceiver<HealthEvent>

Subscribe to health events

pub async fn is_service_healthy(&self, service_id: &str) -> bool

Check if a service is healthy

pub async fn get_service_load_info(&self) -> HashMap<String, f32>

Get service load balancing information

pub async fn call_remote_tool( &self, peer_id: &PeerId, tool_name: &str, arguments: Value, context: MCPCallContext, ) -> Result<Value>

Call a tool on a remote node

pub async fn handle_p2p_message( &self, message_data: &[u8], source_peer: &PeerId, ) -> Result<Option<Vec<u8>>>

Handle incoming P2P MCP message

pub async fn generate_auth_token( &self, peer_id: &PeerId, permissions: Vec<MCPPermission>, ttl: Duration, ) -> Result<String>

Generate authentication token for peer

pub async fn verify_auth_token(&self, token: &str) -> Result<TokenPayload>

Verify authentication token

pub async fn check_permission( &self, peer_id: &PeerId, permission: &MCPPermission, ) -> Result<bool>

Check if peer has permission for operation

pub async fn check_rate_limit(&self, peer_id: &PeerId) -> Result<bool>

Check rate limit for peer

pub async fn grant_permission( &self, peer_id: &PeerId, permission: MCPPermission, ) -> Result<()>

Grant permission to peer

pub async fn revoke_permission( &self, peer_id: &PeerId, permission: &MCPPermission, ) -> Result<()>

Revoke permission from peer

pub async fn add_trusted_peer(&self, peer_id: PeerId) -> Result<()>

Add trusted peer

pub async fn is_trusted_peer(&self, peer_id: &PeerId) -> bool

Check if peer is trusted

pub async fn set_tool_security_policy( &self, tool_name: String, level: SecurityLevel, ) -> Result<()>

Set security policy for tool

pub async fn get_tool_security_policy(&self, tool_name: &str) -> SecurityLevel

Get security policy for tool

pub async fn get_peer_security_stats(&self, peer_id: &PeerId) -> Option<PeerACL>

Get peer security statistics

pub async fn get_security_audit( &self, limit: Option<usize>, ) -> Vec<SecurityAuditEntry>

Get recent security audit entries

pub async fn security_cleanup(&self) -> Result<()>

Perform security housekeeping

pub async fn announce_local_services(&self) -> Result<()>

Announce local services to the network

pub async fn discover_remote_services(&self) -> Result<Vec<MCPService>>

Discover services from other peers

pub async fn refresh_service_discovery(&self) -> Result<()>

Refresh service discovery and update remote services cache

pub async fn get_all_services(&self) -> Result<Vec<MCPService>>

Get all known services (local + remote)

pub async fn find_services_with_tool( &self, tool_name: &str, ) -> Result<Vec<MCPService>>

Find services that provide a specific tool

pub async fn handle_service_advertisement( &self, message: P2PMCPMessage, ) -> Result<()>

Handle service advertisement

pub async fn handle_service_discovery( &self, message: P2PMCPMessage, ) -> Result<Option<Vec<u8>>>

Handle service discovery request

pub async fn shutdown(&self) -> Result<()>

Shutdown the server