Backplane.McpProtocol.Client (backplane_mcp_protocol v0.5.0)

Copy Markdown

MCP (Model Context Protocol) client for connecting to MCP servers.

This module provides a fully functional MCP client with automatic supervision, transport management, and all standard MCP operations. No macros needed — just add it to your supervision tree with the desired configuration.

Usage

Add the client to your supervision tree:

children = [
  {Backplane.McpProtocol.Client,
   name: MyApp.MCPClient,
   transport: {:stdio, command: "uvx", args: ["mcp-server-anthropic"]},
   client_info: %{"name" => "MyApp", "version" => "1.0.0"},
   capabilities: %{"roots" => %{}},
   protocol_version: :auto}
]

Use the client by passing the registered name:

{:ok, tools} = Backplane.McpProtocol.Client.list_tools(MyApp.MCPClient)
{:ok, result} = Backplane.McpProtocol.Client.call_tool(MyApp.MCPClient, "search", %{query: "elixir"})

Capabilities

Capabilities are passed as a map with string keys:

%{"roots" => %{}, "sampling" => %{}}

For convenience, use parse_capability/2 to build from atoms:

capabilities =
  [:roots, {:sampling, list_changed?: true}]
  |> Enum.reduce(%{}, &Backplane.McpProtocol.Client.parse_capability/2)

Transport Configuration

When starting the client, provide transport configuration:

  • {:stdio, command: "cmd", args: ["arg1", "arg2"]}
  • {:sse, base_url: "http://localhost:8000"}
  • {:websocket, url: "ws://localhost:8000/ws"}
  • {:streamable_http, url: "http://localhost:8000/mcp"}

Process Naming

The :name option controls process registration. You can use any valid GenServer.name() — an atom, a PID, or a {:via, module, term} tuple:

# Atom name
{Backplane.McpProtocol.Client, name: MyApp.MCPClient, transport: ...}

# For distributed systems with registries (e.g., Horde)
{Backplane.McpProtocol.Client,
 name: {:via, Horde.Registry, {MyCluster, "client_1"}},
 transport_name: {:via, Horde.Registry, {MyCluster, "transport_1"}},
 transport: ...}

When using via tuples or other non-atom names, you must explicitly provide the :transport_name option. For atom names, the transport is automatically named as Module.concat(ClientName, "Transport").

Dynamic Client Management

For applications that need to manage multiple client connections dynamically (e.g., user-configured MCP servers), use a DynamicSupervisor:

DynamicSupervisor.start_child(
  MyApp.DynamicSupervisor,
  {Backplane.McpProtocol.Client,
   name: {:via, Registry, {MyApp.Registry, client_id}},
   transport_name: {:via, Registry, {MyApp.Registry, {client_id, :transport}}},
   transport: {:streamable_http, base_url: url},
   client_info: %{"name" => "MyApp", "version" => "1.0.0"},
   capabilities: %{},
   protocol_version: :auto}
)

Summary

Types

capabilities()

MCP client capabilities

capabilities_input()
capability()
capability_opts()
client_info()

MCP client metadata info

elicitation_callback()

Elicitation callback function type.

log_callback()

Log callback function type.

option()

MCP client initialization options

progress_callback()

Progress callback function type.

root()

Root directory specification.

t()
transport()

MCP client transport options

Functions

add_root(client, uri, name \\ nil, opts \\ [])

Adds a root directory to the client's roots list.

await_ready(client, opts \\ [])

Blocks until the client has completed protocol negotiation.

call_tool(client, name, arguments \\ nil, opts \\ [])

Calls a tool on the server.

cancel_all_requests(client, reason \\ "client_cancelled", opts \\ [])

Cancels all pending requests.

cancel_request(client, request_id, reason \\ "client_cancelled", opts \\ [])

Cancels an in-progress request.

child_spec(init_arg)

Returns a child specification for starting the client under a supervisor.

clear_roots(client, opts \\ [])

Clears all root directories.

close(client)

Closes the client connection and terminates the process.

close_subscription(client, subscription, opts \\ [])

Closes a modern subscription with the cancellation mechanism required by its transport.

complete(client, ref, argument, opts \\ [])

Requests autocompletion suggestions for prompt arguments or resource URIs.

default_protocol_preference()

Returns the protocol preference used when a client does not explicitly pin a version.

get_prompt(client, name, arguments \\ nil, opts \\ [])

Gets a specific prompt from the server.

get_protocol_info(client, opts \\ [])

Returns the negotiated protocol version, era, peer metadata, and negotiation status.

get_schema(atom)
get_server_capabilities(client, opts \\ [])

Gets the server's capabilities as reported during initialization.

get_server_info(client, opts \\ [])

Gets the server's information as reported during initialization.

is_client_capability(capability)

Guard to check if an atom is a valid client capability.

is_supported_capability(capabilities, capability)

Guard to check if a capability is supported by checking map keys.

list_prompts(client, opts \\ [])

Lists available prompts from the server.

list_resource_templates(client, opts \\ [])

Lists available resource templates from the server.

list_resources(client, opts \\ [])

Lists available resources from the server.

list_roots(client, opts \\ [])

Gets a list of all root directories.

list_tools(client, opts \\ [])

Lists available tools from the server.

listen_subscriptions(client, filters, opts \\ [])

Opens a modern subscriptions/listen stream and waits for its acknowledgement.

merge_capabilities(client, additional_capabilities, opts \\ [])

Merges additional capabilities into the client's capabilities.

parse_capability(capability, capabilities)

Converts a capability atom or tuple into a map entry.

parse_options(data)
parse_options!(data)
ping(client, opts \\ [])

Sends a legacy ping request to the server to check connection health.

read_resource(client, uri, opts \\ [])

Reads a specific resource from the server.

register_elicitation_callback(client, callback)

Registers a callback function to handle elicitation requests from the server.

register_log_callback(client, callback, opts \\ [])

Registers a callback function to be called when log messages are received.

register_progress_callback(client, progress_token, callback, opts \\ [])

Registers a callback function to be called when progress notifications are received for the specified progress token.

register_sampling_callback(client, callback)

Registers a callback function to handle sampling requests from the server.

remove_root(client, uri, opts \\ [])

Removes a root directory from the client's roots list.

send_progress(client, progress_token, progress, total \\ nil, opts \\ [])

Sends a progress notification to the server for a long-running operation.

set_log_level(client, level)

Sets the minimum log level for a legacy server to send log messages.

start_link(opts)

Starts the client supervision tree (client + transport).

subscribe_resource(client, uri, opts \\ [])

Subscribes to updates for a specific resource URI.

unregister_elicitation_callback(client)

Unregisters the elicitation callback.

unregister_log_callback(client, opts \\ [])

Unregisters a previously registered log callback.

unregister_progress_callback(client, progress_token, opts \\ [])

Unregisters a previously registered progress callback for the specified token.

unregister_sampling_callback(client)

Unregisters the sampling callback.

unsubscribe_resource(client, uri, opts \\ [])

Unsubscribes from updates for a previously-subscribed resource URI.

Types

capabilities()

@type capabilities() :: %{
  optional(:roots | String.t()) => %{
    optional(:listChanged | String.t()) => boolean()
  },
  optional(:sampling | String.t()) => %{},
  optional(:elicitation | String.t()) => %{}
}

MCP client capabilities

  • :roots - Capabilities related to the roots resource
    • :listChanged - Whether the client can handle listChanged notifications
  • :sampling - Capabilities related to sampling
  • :elicitation - Capabilities related to elicitation (server-initiated user input requests, 2025-06-18)

MCP describes these client capabilities on its specification

capabilities_input()

@type capabilities_input() :: [
  capability() | {capability(), capability_opts()} | map()
]

capability()

@type capability() :: :roots | :sampling | :elicitation

capability_opts()

@type capability_opts() :: [{:list_changed?, boolean()}]

client_info()

@type client_info() :: %{
  required(:name | String.t()) => String.t(),
  optional(:version | String.t()) => String.t()
}

MCP client metadata info

  • :name - The name of the client (required)
  • :version - The version of the client

elicitation_callback()

@type elicitation_callback() :: (message :: String.t(), requested_schema :: map() ->
                             {:accept, map()}
                             | :decline
                             | :cancel
                             | {:error, String.t()})

Elicitation callback function type.

Called when the server sends an elicitation/create request. The callback receives the human-readable message and the requestedSchema (a restricted JSON Schema subset). It must return one of:

  • {:accept, content} — user submitted content (a flat map matching the schema)
  • :decline — user explicitly declined
  • :cancel — user dismissed without an explicit choice
  • {:error, reason} — internal error; sent back as a JSON-RPC error

log_callback()

@type log_callback() :: (level :: String.t(),
                   data :: term(),
                   logger :: String.t() | nil ->
                     any())

Log callback function type.

Called when log message notifications are received from the server.

Parameters

  • level - Log level as a string (e.g., "debug", "info", "warning", "error")
  • data - Log message data, typically a map with message details
  • logger - Optional logger name identifying the source

Returns

  • The return value is ignored

option()

@type option() ::
  {:name, GenServer.name()}
  | {:transport, transport()}
  | {:client_info, map()}
  | {:capabilities, map()}
  | {:protocol_version, String.t() | :auto}
  | GenServer.option()

MCP client initialization options

  • :name - Following the GenServer patterns described on "Name registration".
  • :transport - The MCP transport options
  • :client_info - Information about the client
  • :capabilities - Client capabilities to advertise to the MCP server
  • :protocol_version - Protocol preference (:auto by default, or an explicit version string)

Any other option support by GenServer.

progress_callback()

@type progress_callback() :: (progress_token :: String.t() | integer(),
                        progress :: number(),
                        total :: number() | nil ->
                          any())

Progress callback function type.

Called when progress notifications are received for a specific progress token.

Parameters

  • progress_token - String or integer identifier for the progress operation
  • progress - Current progress value
  • total - Total expected value (nil if unknown)

Returns

  • The return value is ignored

root()

@type root() :: %{uri: String.t(), name: String.t() | nil}

Root directory specification.

Represents a root directory that the client has access to.

Fields

  • :uri - File URI for the root directory (e.g., "file:///home/user/project")
  • :name - Optional human-readable name for the root

t()

@type t() :: GenServer.server()

transport()

@type transport() :: [
  layer:
    Backplane.McpProtocol.Transport.STDIO
    | Backplane.McpProtocol.Transport.SSE
    | Backplane.McpProtocol.Transport.WebSocket
    | Backplane.McpProtocol.Transport.StreamableHTTP,
  name: GenServer.server()
]

MCP client transport options

Functions

add_root(client, uri, name \\ nil, opts \\ [])

@spec add_root(t(), String.t(), String.t() | nil, opts :: Keyword.t()) :: :ok

Adds a root directory to the client's roots list.

Parameters

  • client - The client process
  • uri - The URI of the root directory (must start with "file://")
  • name - Optional human-readable name for the root
  • opts - Additional options
    • :timeout - Request timeout in milliseconds

await_ready(client, opts \\ [])

@spec await_ready(
  t(),
  keyword()
) :: :ok | {:error, Backplane.McpProtocol.MCP.Error.t()}

Blocks until the client has completed protocol negotiation.

Returns :ok once modern discovery or legacy initialization succeeds, and {:error, error} after a terminal negotiation failure. Otherwise, the caller is parked until negotiation completes or the GenServer call times out.

Options

  • :timeout - Maximum time to wait in milliseconds (default: 30s)

Examples

{:ok, _supervisor} = Backplane.McpProtocol.Client.start_link(opts)
:ok = Backplane.McpProtocol.Client.await_ready(MyApp.MCPClient, timeout: 10_000)
{:ok, tools} = Backplane.McpProtocol.Client.list_tools(MyApp.MCPClient)

call_tool(client, name, arguments \\ nil, opts \\ [])

@spec call_tool(t(), String.t(), map() | nil, keyword()) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Calls a tool on the server.

Options

  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
  • :progress - Progress tracking options
    • :token - A unique token to track progress (string or integer)
    • :callback - A function to call when progress updates are received

cancel_all_requests(client, reason \\ "client_cancelled", opts \\ [])

@spec cancel_all_requests(t(), String.t(), opts :: Keyword.t()) ::
  {:ok, [Backplane.McpProtocol.Client.Request.t()]}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Cancels all pending requests.

Parameters

  • client - The client process
  • reason - Optional reason for cancellation (defaults to "client_cancelled")

Returns

  • {:ok, requests} - A list of the Request structs that were cancelled
  • {:error, reason} - If an error occurred

cancel_request(client, request_id, reason \\ "client_cancelled", opts \\ [])

@spec cancel_request(t(), String.t(), String.t(), opts :: Keyword.t()) ::
  :ok | {:error, Backplane.McpProtocol.MCP.Error.t()}

Cancels an in-progress request.

Parameters

  • client - The client process
  • request_id - The ID of the request to cancel
  • reason - Optional reason for cancellation

Returns

  • :ok if the cancellation was successful
  • {:error, reason} if an error occurred
  • {:not_found, request_id} if the request ID was not found

child_spec(init_arg)

Returns a child specification for starting the client under a supervisor.

This starts a supervision tree containing both the client GenServer and the configured transport process, linked with a :one_for_all strategy.

clear_roots(client, opts \\ [])

@spec clear_roots(t(), opts :: Keyword.t()) :: :ok

Clears all root directories.

Parameters

  • client - The client process
  • opts - Additional options
    • :timeout - Request timeout in milliseconds

close(client)

@spec close(t()) :: :ok

Closes the client connection and terminates the process.

close_subscription(client, subscription, opts \\ [])

@spec close_subscription(
  t(),
  Backplane.McpProtocol.Client.Subscription.t(),
  keyword()
) ::
  :ok | {:error, Backplane.McpProtocol.MCP.Error.t()}

Closes a modern subscription with the cancellation mechanism required by its transport.

complete(client, ref, argument, opts \\ [])

@spec complete(t(), map(), map(), keyword()) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Requests autocompletion suggestions for prompt arguments or resource URIs.

Parameters

  • client - The client process
  • ref - Reference to what is being completed (required)
    • For prompts: %{"type" => "ref/prompt", "name" => prompt_name}
    • For resources: %{"type" => "ref/resource", "uri" => resource_uri}
  • argument - The argument being completed (required)
    • %{"name" => arg_name, "value" => current_value}
  • opts - Additional options
    • :timeout - Request timeout in milliseconds
    • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
    • :progress - Progress tracking options
      • :token - A unique token to track progress (string or integer)
      • :callback - A function to call when progress updates are received

Returns

Returns {:ok, response} with completion suggestions if successful, or {:error, reason} if an error occurs.

The response result contains a "completion" object with:

  • values - List of completion suggestions (maximum 100)
  • total - Optional total number of matching items
  • hasMore - Boolean indicating if more results are available

default_protocol_preference()

@spec default_protocol_preference() :: :auto

Returns the protocol preference used when a client does not explicitly pin a version.

get_prompt(client, name, arguments \\ nil, opts \\ [])

@spec get_prompt(t(), String.t(), map() | nil, keyword()) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Gets a specific prompt from the server.

Options

  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
  • :progress - Progress tracking options
    • :token - A unique token to track progress (string or integer)
    • :callback - A function to call when progress updates are received

get_protocol_info(client, opts \\ [])

@spec get_protocol_info(t(), opts :: Keyword.t()) :: map()

Returns the negotiated protocol version, era, peer metadata, and negotiation status.

get_schema(atom)

get_server_capabilities(client, opts \\ [])

@spec get_server_capabilities(t(), opts :: Keyword.t()) :: map() | nil

Gets the server's capabilities as reported during initialization.

Returns nil if the client has not been initialized yet.

get_server_info(client, opts \\ [])

@spec get_server_info(t(), opts :: Keyword.t()) :: map() | nil

Gets the server's information as reported during initialization.

Returns nil if the client has not been initialized yet.

is_client_capability(capability)

(macro)

Guard to check if an atom is a valid client capability.

is_supported_capability(capabilities, capability)

(macro)

Guard to check if a capability is supported by checking map keys.

list_prompts(client, opts \\ [])

@spec list_prompts(
  t(),
  keyword()
) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Lists available prompts from the server.

Options

  • :cursor - Pagination cursor for continuing a previous request
  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
  • :progress - Progress tracking options
    • :token - A unique token to track progress (string or integer)
    • :callback - A function to call when progress updates are received

list_resource_templates(client, opts \\ [])

@spec list_resource_templates(
  t(),
  keyword()
) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Lists available resource templates from the server.

Options

  • :cursor - Pagination cursor for continuing a previous request
  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
  • :progress - Progress tracking options
    • :token - A unique token to track progress (string or integer)
    • :callback - A function to call when progress updates are received

list_resources(client, opts \\ [])

@spec list_resources(
  t(),
  keyword()
) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Lists available resources from the server.

Options

  • :cursor - Pagination cursor for continuing a previous request
  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
  • :progress - Progress tracking options
    • :token - A unique token to track progress (string or integer)
    • :callback - A function to call when progress updates are received

list_roots(client, opts \\ [])

@spec list_roots(t(), opts :: Keyword.t()) :: [map()]

Gets a list of all root directories.

Parameters

  • client - The client process
  • opts - Additional options
    • :timeout - Request timeout in milliseconds

list_tools(client, opts \\ [])

@spec list_tools(
  t(),
  keyword()
) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Lists available tools from the server.

Options

  • :cursor - Pagination cursor for continuing a previous request
  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
  • :progress - Progress tracking options
    • :token - A unique token to track progress (string or integer)
    • :callback - A function to call when progress updates are received

listen_subscriptions(client, filters, opts \\ [])

@spec listen_subscriptions(t(), [String.t()] | map(), keyword()) ::
  {:ok, Backplane.McpProtocol.Client.Subscription.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Opens a modern subscriptions/listen stream and waits for its acknowledgement.

A list of notification method names is accepted as shorthand for the frozen subscription filter. Pass the wire filter map directly when subscribing to individual resource URIs.

The returned handle receives matched notifications in the subscriber process as {:mcp_subscription, handle, notification}. If the client connection is lost, the handle closes; call this function again to open a new subscription with a new ID after reconnecting.

merge_capabilities(client, additional_capabilities, opts \\ [])

@spec merge_capabilities(t(), map(), opts :: Keyword.t()) :: map()

Merges additional capabilities into the client's capabilities.

parse_capability(capability, capabilities)

@spec parse_capability(capability() | {capability(), capability_opts()}, map()) ::
  map()

Converts a capability atom or tuple into a map entry.

Useful for building capability maps from ergonomic shorthand:

capabilities =
  [:roots, {:sampling, list_changed?: true}]
  |> Enum.reduce(%{}, &Backplane.McpProtocol.Client.parse_capability/2)
# => %{"roots" => %{}, "sampling" => %{}}

parse_options(data)

parse_options!(data)

ping(client, opts \\ [])

@spec ping(
  t(),
  keyword()
) :: :pong | {:error, Backplane.McpProtocol.MCP.Error.t()}

Sends a legacy ping request to the server to check connection health.

Returns :pong if successful. Modern 2026-07-28 peers return a local :unsupported_operation error because that revision removed ping.

Options

  • :timeout - Request timeout in milliseconds (default: 30s)
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
  • :progress - Progress tracking options
    • :token - A unique token to track progress (string or integer)
    • :callback - A function to call when progress updates are received

read_resource(client, uri, opts \\ [])

@spec read_resource(t(), String.t(), keyword()) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Reads a specific resource from the server.

Options

  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client
  • :progress - Progress tracking options
    • :token - A unique token to track progress (string or integer)
    • :callback - A function to call when progress updates are received

register_elicitation_callback(client, callback)

@spec register_elicitation_callback(t(), elicitation_callback()) :: :ok

Registers a callback function to handle elicitation requests from the server.

The client must advertise the elicitation capability during initialization for servers to send elicitation/create requests.

Per the MCP specification, the client SHOULD present the request to the user with clear UI, allow them to review and modify their response, and provide decline/cancel options.

register_log_callback(client, callback, opts \\ [])

@spec register_log_callback(t(), log_callback(), opts :: Keyword.t()) :: :ok

Registers a callback function to be called when log messages are received.

Parameters

  • client - The client process
  • callback - A function that takes three arguments: level, data, and logger name

The callback function will be called whenever a log message notification is received.

register_progress_callback(client, progress_token, callback, opts \\ [])

@spec register_progress_callback(
  t(),
  String.t() | integer(),
  progress_callback(),
  opts :: Keyword.t()
) :: :ok

Registers a callback function to be called when progress notifications are received for the specified progress token.

Parameters

  • client - The client process
  • progress_token - The progress token to watch for (string or integer)
  • callback - A function that takes three arguments: progress_token, progress, and total

The callback function will be called whenever a progress notification with the matching token is received.

register_sampling_callback(client, callback)

@spec register_sampling_callback(
  t(),
  (map() -> {:ok, map()} | {:error, String.t()})
) :: :ok

Registers a callback function to handle sampling requests from the server.

The callback function will be called when the server sends a sampling/createMessage request. The callback should implement user approval and return the LLM response.

Callback Function

The callback receives the sampling parameters and must return:

  • {:ok, response_map} - Where response_map contains:
    • "role" - Usually "assistant"
    • "content" - Message content (text, image, or audio)
    • "model" - The model that was used
    • "stopReason" - Why generation stopped (e.g., "endTurn")
  • {:error, reason} - If the user rejects or an error occurs

remove_root(client, uri, opts \\ [])

@spec remove_root(t(), String.t(), opts :: Keyword.t()) :: :ok

Removes a root directory from the client's roots list.

Parameters

  • client - The client process
  • uri - The URI of the root directory to remove
  • opts - Additional options
    • :timeout - Request timeout in milliseconds

send_progress(client, progress_token, progress, total \\ nil, opts \\ [])

@spec send_progress(
  t(),
  String.t() | integer(),
  number(),
  number() | nil,
  opts :: Keyword.t()
) :: :ok | {:error, term()}

Sends a progress notification to the server for a long-running operation.

Parameters

  • client - The client process
  • progress_token - The progress token provided in the original request (string or integer)
  • progress - The current progress value (number)
  • total - The optional total value for the operation (number)

Returns :ok if notification was sent successfully, or {:error, reason} otherwise.

set_log_level(client, level)

@spec set_log_level(t(), String.t()) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Sets the minimum log level for a legacy server to send log messages.

Modern 2026-07-28 peers return a local :unsupported_operation error because that revision removed logging/setLevel.

Parameters

  • client - The client process
  • level - The minimum log level (debug, info, notice, warning, error, critical, alert, emergency)

Returns {:ok, result} if successful, {:error, reason} otherwise.

start_link(opts)

@spec start_link(keyword()) :: Supervisor.on_start()

Starts the client supervision tree (client + transport).

This is the primary entry point for starting a client. It creates a supervisor that manages both the client GenServer and the transport process.

subscribe_resource(client, uri, opts \\ [])

@spec subscribe_resource(t(), String.t(), keyword()) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Subscribes to updates for a specific resource URI.

After a successful subscribe, the server may send notifications/resources/updated notifications for this URI. The server must declare the resources.subscribe capability for this method to succeed.

Options

  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client

unregister_elicitation_callback(client)

@spec unregister_elicitation_callback(t()) :: :ok

Unregisters the elicitation callback.

unregister_log_callback(client, opts \\ [])

@spec unregister_log_callback(t(), opts :: Keyword.t()) :: :ok

Unregisters a previously registered log callback.

Parameters

  • client - The client process
  • callback - The callback function to unregister

unregister_progress_callback(client, progress_token, opts \\ [])

@spec unregister_progress_callback(t(), String.t() | integer(), opts :: Keyword.t()) ::
  :ok

Unregisters a previously registered progress callback for the specified token.

Parameters

  • client - The client process
  • progress_token - The progress token to stop watching (string or integer)

unregister_sampling_callback(client)

@spec unregister_sampling_callback(t()) :: :ok

Unregisters the sampling callback.

unsubscribe_resource(client, uri, opts \\ [])

@spec unsubscribe_resource(t(), String.t(), keyword()) ::
  {:ok, Backplane.McpProtocol.MCP.Response.t()}
  | {:error, Backplane.McpProtocol.MCP.Error.t()}

Unsubscribes from updates for a previously-subscribed resource URI.

Options

  • :timeout - Request timeout in milliseconds
  • :meta - Additional request metadata; protocol-reserved fields are supplied by the client