Struct Client 

pub struct Client {
    pub http_client: Client,
    pub user_agent: String,
    pub x_title: String,
    pub http_referer: String,
    pub connect_timeout: Duration,
    pub backoff_current_interval: Duration,
    pub backoff_initial_interval: Duration,
    pub backoff_randomization_factor: f64,
    pub backoff_multiplier: f64,
    pub backoff_max_interval: Duration,
    pub backoff_max_elapsed_time: Duration,
    pub call_timeout: Duration,
}

Client for creating MCP connections.

Holds shared configuration (HTTP client, headers, backoff parameters) and creates Connection instances via connect.

Fields

http_client: Client

HTTP client for making requests.

user_agent: String

User-Agent header value.

x_title: String

X-Title header value.

http_referer: String

Referer header value.

connect_timeout: Duration

Timeout for the initial connection (initialize request).

backoff_current_interval: Duration

Current backoff interval for retry logic.

backoff_initial_interval: Duration

Initial backoff interval for retry logic.

backoff_randomization_factor: f64

Randomization factor for backoff jitter.

backoff_multiplier: f64

Multiplier for exponential backoff growth.

backoff_max_interval: Duration

Maximum backoff interval.

backoff_max_elapsed_time: Duration

Maximum total time to spend on retries.

call_timeout: Duration

Timeout for individual RPC calls after connection is established.

Implementations

impl Client

pub fn new( http_client: Client, user_agent: String, x_title: String, http_referer: String, connect_timeout: Duration, backoff_current_interval: Duration, backoff_initial_interval: Duration, backoff_randomization_factor: f64, backoff_multiplier: f64, backoff_max_interval: Duration, backoff_max_elapsed_time: Duration, call_timeout: Duration, ) -> Self

Creates a new MCP client.

pub async fn connect( &self, url: String, session_id: Option<String>, headers: Option<IndexMap<String, String>>, ) -> Result<Connection, Error>

Connects to an MCP server using the Streamable HTTP transport.

Sends an initialize JSON-RPC request to the server and extracts the Mcp-Session-Id from the response. Returns a [Connection] that can be used to list/call tools and list/read resources.

headers are forwarded on every request this connection makes to the upstream — both the initial initialize POST and every subsequent RPC. The client merges its own defaults (User-Agent, X-Title, Referer, HTTP-Referer) into this map, but caller-supplied values for any of those win on conflict. Authorization (when needed) is just another entry in headers. The Mcp-Session-Id header is reserved — pass it via session_id instead so the explicit argument can never be clobbered by the headers map.

SSE handoff

Accept is text/event-stream, application/json — stream first — so the server is encouraged to keep the underlying connection open. If the response comes back as SSE we read the initialize event off the stream and hand the still-open line reader to the returned [Connection]’s list-changed listener. The listener starts reading from that pre-opened stream immediately, which closes the race where a peer (e.g. an in-process rmcp upstream) would broadcast notifications/tools/list_changed before our listener had managed to open its own GET / SSE.

If the response is unary JSON and the server advertises either tools.list_changed or resources.list_changed, we proactively open a GET / SSE stream before returning and hand it to the listener for the same reason. If neither capability is set, no listener is needed and we return without touching SSE.

Trait Implementations

impl Clone for Client

fn clone(&self) -> Client

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Client

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.