Struct ServerCapabilities

Source

pub struct ServerCapabilities {
    pub tools: Option<ToolCapabilities>,
    pub prompts: Option<PromptCapabilities>,
    pub resources: Option<ResourceCapabilities>,
    pub logging: Option<LoggingCapabilities>,
    pub completions: Option<CompletionCapabilities>,
    pub sampling: Option<SamplingCapabilities>,
    pub experimental: Option<HashMap<String, Value>>,
}

Expand description

Server capabilities advertised during initialization.

Fields§

§tools: Option<ToolCapabilities>

Tool providing capabilities

§prompts: Option<PromptCapabilities>

Prompt providing capabilities

§resources: Option<ResourceCapabilities>

Resource providing capabilities

§logging: Option<LoggingCapabilities>

Logging capabilities

§completions: Option<CompletionCapabilities>

Completion capabilities

§sampling: Option<SamplingCapabilities>

Sampling capabilities (for LLM providers)

§experimental: Option<HashMap<String, Value>>

Experimental capabilities

Implementations§

Source §

impl ServerCapabilities

Source

pub fn minimal() -> Self

Create a minimal set of server capabilities.

§Examples

use pmcp::ServerCapabilities;

// Create minimal server with no advertised features
let capabilities = ServerCapabilities::minimal();
assert!(!capabilities.provides_tools());
assert!(!capabilities.provides_prompts());
assert!(!capabilities.provides_resources());

// Use in server that implements custom protocol extensions
let server = Server::builder()
    .name("minimal-server")
    .version("1.0.0")
    .capabilities(ServerCapabilities::minimal())
    .build()?;

Source

pub fn tools_only() -> Self

Create capabilities for a tool server.

§Examples

use pmcp::ServerCapabilities;

// Create server that only provides tools
let capabilities = ServerCapabilities::tools_only();
assert!(capabilities.provides_tools());
assert!(!capabilities.provides_prompts());
assert!(!capabilities.provides_resources());

// Use in a tool-focused server
let server = Server::builder()
    .name("calculator-server")
    .version("1.0.0")
    .capabilities(ServerCapabilities::tools_only())
    .tool("calculate", CalculatorTool)
    .build()?;

Source

pub fn prompts_only() -> Self

Create capabilities for a prompt server.

§Examples

use pmcp::ServerCapabilities;

// Create server that only provides prompts
let capabilities = ServerCapabilities::prompts_only();
assert!(!capabilities.provides_tools());
assert!(capabilities.provides_prompts());
assert!(!capabilities.provides_resources());

// Use in a prompt template server
let server = Server::builder()
    .name("prompt-server")
    .version("1.0.0")
    .capabilities(ServerCapabilities::prompts_only())
    .prompt("greeting", GreetingPrompt)
    .build()?;

Source

pub fn resources_only() -> Self

Create capabilities for a resource server.

§Examples

use pmcp::ServerCapabilities;

// Create server that only provides resources
let capabilities = ServerCapabilities::resources_only();
assert!(!capabilities.provides_tools());
assert!(!capabilities.provides_prompts());
assert!(capabilities.provides_resources());

// Check subscription support
let resource_caps = capabilities.resources.unwrap();
assert!(resource_caps.subscribe.unwrap());
assert!(resource_caps.list_changed.unwrap());

// Use in a file system resource server
let server = Server::builder()
    .name("filesystem-server")
    .version("1.0.0")
    .capabilities(ServerCapabilities::resources_only())
    .resources(FileResource)
    .build()?;

Source

pub fn provides_tools(&self) -> bool

Check if the server provides tools.

§Examples

use pmcp::ServerCapabilities;

// Check different server configurations
let tool_server = ServerCapabilities::tools_only();
assert!(tool_server.provides_tools());

let minimal_server = ServerCapabilities::minimal();
assert!(!minimal_server.provides_tools());

// Use in server logic
fn validate_server(caps: &ServerCapabilities) {
    if caps.provides_tools() {
        println!("Server can handle tool calls");
    } else {
        println!("Server does not provide tools");
    }
}

// Combine multiple capabilities
use pmcp::types::capabilities::{ToolCapabilities, PromptCapabilities};
let multi_server = ServerCapabilities {
    tools: Some(ToolCapabilities::default()),
    prompts: Some(PromptCapabilities::default()),
    ..Default::default()
};
assert!(multi_server.provides_tools());
assert!(multi_server.provides_prompts());

Source

pub fn provides_prompts(&self) -> bool

Check if the server provides prompts.

§Examples

use pmcp::ServerCapabilities;

// Check prompt server
let prompt_server = ServerCapabilities::prompts_only();
assert!(prompt_server.provides_prompts());
assert!(!prompt_server.provides_tools());

// Use in client code to check server features
if server_info.capabilities.provides_prompts() {
    // Server supports prompts, we can list them
    let prompts = client.list_prompts(None).await?;
    println!("Available prompts: {}", prompts.prompts.len());
}

Source

pub fn provides_resources(&self) -> bool

Check if the server provides resources.

§Examples

use pmcp::ServerCapabilities;

// Check resource server capabilities
let resource_server = ServerCapabilities::resources_only();
assert!(resource_server.provides_resources());

// Check if subscriptions are supported
if resource_server.provides_resources() {
    if let Some(res_caps) = &resource_server.resources {
        if res_caps.subscribe.unwrap_or(false) {
            println!("Server supports resource subscriptions");
        }
    }
}

// Build a full-featured server
use pmcp::types::capabilities::*;
let full_server = ServerCapabilities {
    tools: Some(ToolCapabilities::default()),
    prompts: Some(PromptCapabilities::default()),
    resources: Some(ResourceCapabilities {
        subscribe: Some(true),
        list_changed: Some(true),
    }),
    ..Default::default()
};
assert!(full_server.provides_tools());
assert!(full_server.provides_prompts());
assert!(full_server.provides_resources());