Crate turbomcp_client 

TurboMCP Client

MCP (Model Context Protocol) client implementation for connecting to MCP servers and consuming their capabilities (tools, prompts, resources, and sampling).

Features

• Connection management with automatic reconnection
• Error handling and recovery mechanisms
• Support for all MCP capabilities
• Transport-agnostic design (works with any Transport implementation)
• Type-safe protocol communication
• Request/response correlation tracking
• Timeout and cancellation support
• Automatic capability negotiation

Architecture

The client follows a layered architecture:

Application Layer
       ↓
Client API (this crate)
       ↓  
Protocol Layer (turbomcp-protocol)
       ↓
Transport Layer (turbomcp-transport)

Usage

use turbomcp_client::{Client, ClientBuilder};
use turbomcp_transport::stdio::StdioTransport;

// Create a client with stdio transport
let transport = StdioTransport::new();
let mut client = Client::new(transport);

// Initialize connection and negotiate capabilities
let result = client.initialize().await?;
println!("Connected to: {}", result.server_info.name);

// List and call tools
let tools = client.list_tools().await?;
for tool in tools {
    println!("Tool: {}", tool);
}

// Access resources
let resources = client.list_resources().await?;
for resource in resources {
    println!("Resource: {}", resource);
}

Error Handling

The client provides comprehensive error handling with automatic retry logic:

match client.call_tool("my_tool", None).await {
    Ok(result) => println!("Tool result: {:?}", result),
    Err(e) => eprintln!("Tool call failed: {}", e),
}

Structs

Client

MCP client for communicating with servers

ClientBuilder

Builder for configuring and creating MCP clients

ClientCapabilities

Client capability configuration

InitializeResult

Result of client initialization

PublicServerCapabilities

Server capabilities per MCP 2025-06-18 specification