Struct McpClient 

pub struct McpClient<T: ClientTransport> { /* private fields */ }

MCP Client for connecting to MCP servers

Implementations

impl<T: ClientTransport> McpClient<T>

pub fn new(transport: T) -> Self

Create a new MCP client with the given transport

pub fn with_roots(self, roots: Vec<Root>) -> Self

Configure roots for this client.

The client will declare roots support during initialization and provide these roots when requested by the server.

Example

use tower_mcp::client::{McpClient, StdioClientTransport};
use tower_mcp::protocol::Root;

let transport = StdioClientTransport::spawn("server", &[]).await?;
let client = McpClient::new(transport)
    .with_roots(vec![Root { uri: "file:///project".into(), name: Some("Project".into()) }]);

pub fn with_capabilities(self, capabilities: ClientCapabilities) -> Self

Configure custom capabilities for this client.

Example

use tower_mcp::client::{McpClient, StdioClientTransport};
use tower_mcp::protocol::ClientCapabilities;

let transport = StdioClientTransport::spawn("server", &[]).await?;
let client = McpClient::new(transport)
    .with_capabilities(ClientCapabilities {
        sampling: Some(Default::default()),
        ..Default::default()
    });

pub fn server_info(&self) -> Option<&InitializeResult>

Get the server info (available after initialization)

pub fn is_initialized(&self) -> bool

Check if the client is initialized

pub fn roots(&self) -> &[Root]

Get the current roots

pub async fn set_roots(&mut self, roots: Vec<Root>) -> Result<()>

Set roots and notify the server if initialized

If the client is already initialized, sends a roots list changed notification.

pub async fn add_root(&mut self, root: Root) -> Result<()>

Add a root and notify the server if initialized

pub async fn remove_root(&mut self, uri: &str) -> Result<bool>

Remove a root by URI and notify the server if initialized

pub fn list_roots(&self) -> ListRootsResult

Get the roots list result (for responding to server’s roots/list request)

Returns a result suitable for responding to a roots/list request from the server.

pub async fn initialize( &mut self, client_name: &str, client_version: &str, ) -> Result<&InitializeResult>

Initialize the MCP connection

pub async fn list_tools(&mut self) -> Result<ListToolsResult>

List available tools

pub async fn call_tool( &mut self, name: &str, arguments: Value, ) -> Result<CallToolResult>

Call a tool

pub async fn list_resources(&mut self) -> Result<ListResourcesResult>

List available resources

pub async fn read_resource(&mut self, uri: &str) -> Result<ReadResourceResult>

Read a resource

pub async fn list_prompts(&mut self) -> Result<ListPromptsResult>

List available prompts

pub async fn get_prompt( &mut self, name: &str, arguments: Option<HashMap<String, String>>, ) -> Result<GetPromptResult>

Get a prompt

pub async fn ping(&mut self) -> Result<()>

Ping the server

pub async fn complete( &mut self, reference: CompletionReference, argument_name: &str, argument_value: &str, ) -> Result<CompleteResult>

Request completion suggestions from the server

This is used to get autocomplete suggestions for prompt arguments or resource URIs.

pub async fn complete_prompt_arg( &mut self, prompt_name: &str, argument_name: &str, argument_value: &str, ) -> Result<CompleteResult>

Request completion for a prompt argument

pub async fn complete_resource_uri( &mut self, resource_uri: &str, argument_name: &str, argument_value: &str, ) -> Result<CompleteResult>

Request completion for a resource URI

pub async fn request<P: Serialize, R: DeserializeOwned>( &mut self, method: &str, params: &P, ) -> Result<R>

Send a raw request

pub async fn notify<P: Serialize>( &mut self, method: &str, params: &P, ) -> Result<()>

Send a notification