haive.mcp.client

MCP Client Implementation Package.

This package provides native MCP protocol client implementation for connecting to and communicating with MCP servers according to the Model Context Protocol specification.

Key Components

Core Classes

  • MCPClient: Main client for protocol communication

  • MCPTransport: Transport layer abstraction

  • MCPConnection: Connection management

  • MCPProtocol: Protocol implementation

Transport Support

  • STDIO: Communication via stdin/stdout

  • HTTP: RESTful communication

  • SSE: Server-sent events

  • WebSocket: Real-time bidirectional communication

  • Docker: Run MCP servers in Docker containers via stdio

Usage Examples

Basic Connection

from haive.mcp.client import MCPClient, StdioTransport

# Create transport and client
transport = StdioTransport(
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem"]
)
client = MCPClient(transport)

# Connect and use
await client.connect()
tools = await client.list_tools()
result = await client.call_tool("read_file", {"path": "/etc/hosts"})
await client.disconnect()

Context Manager Usage

async with MCPClient(transport) as client:
    tools = await client.list_tools()
    result = await client.call_tool("tool_name", args)

Available Classes

Transport Classes

  • StdioTransport - Standard I/O transport

  • HttpTransport - HTTP-based transport

  • SseTransport - Server-Sent Events transport

  • WebSocketTransport - WebSocket transport

  • DockerTransport - Docker container transport

Exception Classes

  • MCPError - Base MCP exception

  • MCPConnectionError - Connection-related errors

  • MCPProtocolError - Protocol violation errors

  • MCPTimeoutError - Timeout-related errors

  • MCPTransportError - Transport layer errors

  • MCPAuthenticationError - Authentication failures

  • MCPCapabilityError - Capability negotiation errors

  • MCPToolError - Tool execution errors

Note

This is a native implementation of the MCP protocol, designed to work with any MCP-compliant server. It handles the full protocol lifecycle including initialization, capability discovery, and tool execution.

Submodules