Struct McpClientBuilder

pub struct McpClientBuilder { /* private fields */ }

Builder for creating McpClient

Example

use mcp_attr::client::McpClientBuilder;
use mcp_attr::schema::Root;
use mcp_attr::server::{McpServer, mcp_server};

struct MyServer;

#[mcp_server]
impl McpServer for MyServer {}

let server = MyServer;
let roots = vec![Root {
    name: Some("my_root".to_string()),
    uri: "/path/to/root".to_string(),
}];

let client = McpClientBuilder::new()
    .with_expose_internals(true)
    .with_roots(roots)
    .build_with_server(server)
    .await?;

Implementations

impl McpClientBuilder

pub fn new() -> Self

Creates a new McpClient

pub fn with_handler( self, sampling_handler: impl McpClientHandler + Send + Sync + 'static, ) -> Self

Creates a McpClientBuilder with a specified McpClientHandler

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

Specifies the values to be returned by roots/list

Also sets the roots capabilities that the MCP client will return.

pub fn with_expose_internals(self, expose_internals: bool) -> Self

Sets whether to expose internal information in errors

See Error for details about internal information

pub async fn build( self, reader: impl AsyncBufRead + Send + Sync + 'static, writer: impl AsyncWrite + Send + Sync + 'static, ) -> SessionResult<McpClient>

Builds a McpClient client using the specified reader and writer

pub async fn build_with_command( self, command: &mut Command, ) -> SessionResult<McpClient>

Launches a MCP server process with the specified command and builds McpClient that communicates with it using stdio transport

pub async fn build_with_server( self, server: impl McpServer, ) -> SessionResult<McpClient>

Builds a McpClient client that communicates with the specified McpServer

The specified McpServer will be owned by the returned McpClient.

pub fn build_raw( self, ) -> (impl Handler, SessionOptions, InitializeRequestParams)

Builds a McpClient using a custom method

This method returns the values needed for McpClient::initialize. It is provided for using transports that cannot be handled by build, build_with_command, or build_with_server.

Example

use mcp_attr::client::{McpClientBuilder, McpClient};
use tokio::process::Command;
use jsoncall::Session;

let mut command = Command::new("cargo");
command.args(&["run", "--bin", "mcp-attr", "--example", "char_count"]);

let builder = McpClientBuilder::new();
let (handler, options, initialize_params) = builder.build_raw();
let client = McpClient::initialize(Session::from_command(handler, &mut command, &options)?, initialize_params).await?;

Trait Implementations

impl Default for McpClientBuilder

fn default() -> Self

Returns the “default value” for a type.