Supported MCP Clients

Supported MCP Clients

MCP Client Tester has been tested with a wide range of MCP client implementations. This page provides detailed compatibility information, known issues, and configuration guidance for each supported client.

Client Compatibility Matrix

Client	Version	STDIO	HTTP	SSE	Streaming	Tools	Resources	Prompts	Sampling	Progress	Cancellation
Claude Desktop	1.3.x	✓	△	✗	✗	✓	✓	✓	✗	✓	✓
Claude Desktop	1.2.x	✓	✗	✗	✗	✓	✓	△	✗	△	✓
FastMCP Client	2.12+	✓	✓	✓	✓	✓	✓	✓	✓	✓	✓
Python MCP SDK	1.0+	✓	✓	△	△	✓	✓	✓	△	✓	✓
TypeScript MCP SDK	1.0+	✓	✓	✓	△	✓	✓	✓	△	✓	✓
Custom Integration	Various	△	△	△	△	△	△	△	△	△	△

Legend:

• ✓ Fully Supported
• △ Partial Support / Version Dependent
• ✗ Not Supported

Claude Desktop

Claude Desktop is Anthropic’s official desktop application that supports MCP integration.

Supported Versions

• 1.3.x: Latest version with enhanced MCP support
• 1.2.x: Stable version with basic MCP features
• 1.1.x: Legacy version with limited support

Configuration

Tip

Claude Desktop uses STDIO transport exclusively. Configure your MCP Client Tester session accordingly.

Basic Configuration:

{
  "mcpServers": {
    "mcp-client-tester": {
      "command": "docker",
      "args": [
        "compose", "exec", "backend",
        "python", "-m", "app.mcp.stdio_server"
      ],
      "env": {
        "SESSION_ID": "your-session-id"
      }
    }
  }
}

Advanced Configuration with Session Tracking:

{
  "mcpServers": {
    "mcp-client-tester": {
      "command": "docker",
      "args": [
        "compose", "exec", "backend",
        "python", "-m", "app.mcp.stdio_server",
        "--session-name", "Claude Desktop Test",
        "--auto-detect", "true",
        "--enable-metrics", "true"
      ]
    }
  }
}

Capabilities

Version 1.3.x Features:

• ✅ Tools: Full support for tool calling and discovery
• ✅ Resources: Complete resource access and reading
• ✅ Prompts: Template prompts with parameters
• ✅ Progress: Progress notifications for long operations
• ✅ Cancellation: Operation cancellation support
• ✅ Roots: Directory/workspace root support
• ✅ List Changed: Notifications when tool/resource lists change
• ❌ Sampling: Server-initiated LLM sampling not supported
• ⚠️ HTTP Transport: Limited HTTP support (experimental)

Version 1.2.x Limitations:

• ❌ HTTP transport not supported
• ⚠️ Limited prompt parameter support
• ⚠️ Basic progress notification support

Known Issues

1. STDIO Buffer Limits: Large responses may be truncated

   • Workaround: Use chunked responses for large data

2. Connection Timeout: Long initialization may timeout

   • Workaround: Optimize server startup time

3. Unicode Handling: Some Unicode characters may not display correctly

   • Workaround: Use ASCII equivalents where possible

Testing Recommendations

Essential Tests for Claude Desktop:

• Tool discovery and invocation
• Resource listing and reading
• Progress notification handling
• Connection recovery after errors
• Large response handling

FastMCP Client

FastMCP provides a Python-based MCP client implementation with comprehensive protocol support.

Installation

pip install fastmcp[client]

Configuration

from fastmcp import FastMCPClient

client = FastMCPClient(
    transport="http",
    base_url="https://api.mcp-tester.local/mcp",
    timeout=30,
    max_retries=3
)

Capabilities

FastMCP Client offers the most comprehensive MCP support:

• ✅ All Transports: STDIO, HTTP, SSE, HTTP-streaming
• ✅ Full Protocol: Complete MCP specification support
• ✅ Advanced Features: Sampling, elicitation, progress, cancellation
• ✅ Error Handling: Robust error recovery and retry logic
• ✅ Async Support: Full asyncio integration

Usage Examples

Basic Tool Calling:

import asyncio
from fastmcp import FastMCPClient

async def test_tools():
    client = FastMCPClient(
        transport="http",
        base_url="https://api.mcp-tester.local/mcp/session/test-123"
    )

    # List available tools
    tools = await client.tools.list()
    print(f"Available tools: {[tool.name for tool in tools]}")

    # Call a tool
    result = await client.tools.call(
        "search_database",
        {"query": "test data", "limit": 10}
    )
    print(f"Tool result: {result.content}")

Resource Access:

async def test_resources():
    client = FastMCPClient(
        transport="sse",
        base_url="https://api.mcp-tester.local/mcp/sse/session/test-123"
    )

    # List resources
    resources = await client.resources.list()

    # Read a resource
    content = await client.resources.read("file:///path/to/data.txt")
    print(f"Resource content: {content}")

Python MCP SDK

The official Python SDK for MCP client development.

Installation

pip install mcp

Configuration

from mcp import Client
from mcp.transports.stdio import StdioClientTransport

transport = StdioClientTransport(
    command="python",
    args=["-m", "your_mcp_server"],
    env={"SESSION_ID": "test-session"}
)

client = Client(transport)

Capabilities

• ✅ Core Protocol: Tools, resources, prompts
• ✅ STDIO/HTTP: Primary transport support
• ⚠️ SSE/Streaming: Limited or experimental support
• ⚠️ Sampling: Basic support, implementation dependent
• ✅ Progress/Cancellation: Full support

Best Practices

1. Error Handling: Always wrap client calls in try-catch blocks
2. Connection Management: Properly close connections
3. Timeouts: Set appropriate timeouts for operations
4. Resource Cleanup: Use context managers when available

TypeScript MCP SDK

Official TypeScript/JavaScript SDK for browser and Node.js environments.

Installation

npm install @modelcontextprotocol/sdk

Configuration

import { Client } from '@modelcontextprotocol/sdk/client';
import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio';

const transport = new StdioClientTransport({
  command: 'python',
  args: ['-m', 'your_mcp_server']
});

const client = new Client(transport);

Browser Support

For browser-based clients, use HTTP or SSE transports:

import { HTTPClientTransport } from '@modelcontextprotocol/sdk/client/http';

const transport = new HTTPClientTransport({
  baseUrl: 'https://api.mcp-tester.local/mcp'
});

Custom Integrations

MCP Client Tester supports testing of custom MCP client implementations.

Integration Guidelines

1. Protocol Compliance: Implement JSON-RPC 2.0 message format
2. Transport Support: Choose appropriate transport for your use case
3. Error Handling: Handle all standard MCP error codes
4. Feature Detection: Implement capability detection and negotiation

Testing Custom Clients

Create Test Session:

curl -X POST "https://api.mcp-tester.local/api/v1/sessions" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Custom Client Test",
    "transport": "http",
    "config": {
      "auto_detect_client": true,
      "detailed_logging": true
    }
  }'

Connect Your Client:

Point your custom client to the provided endpoint and start testing. MCP Client Tester will automatically:

• Detect client capabilities
• Log all protocol interactions
• Analyze performance characteristics
• Generate compatibility reports

Common Integration Patterns

Polling-based HTTP Client:

import requests
import json

def send_mcp_request(session_url, request):
    response = requests.post(
        session_url,
        json=request,
        headers={"Content-Type": "application/json"}
    )
    return response.json()

# Initialize connection
init_response = send_mcp_request(session_url, {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {"protocolVersion": "1.0"}
})

WebSocket-based Client:

const WebSocket = require('ws');

const ws = new WebSocket('wss://api.mcp-tester.local/mcp/ws/session/test-123');

ws.on('message', (data) => {
  const message = JSON.parse(data);
  console.log('Received:', message);
});

// Send initialization
ws.send(JSON.stringify({
  jsonrpc: '2.0',
  id: 1,
  method: 'initialize',
  params: { protocolVersion: '1.0' }
}));

Client Detection Features

MCP Client Tester automatically detects and analyzes client characteristics:

Automatic Detection

• Client Type: Identification based on user agent, behavior patterns
• Version: Version detection from initialization parameters
• Capabilities: Feature support analysis through protocol interaction
• Performance: Response time, throughput, error rate analysis

Manual Client Registration

For better testing results, consider registering your client:

curl -X POST "https://api.mcp-tester.local/api/v1/clients/register" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Custom Client",
    "version": "1.0.0",
    "user_agent": "MyClient/1.0.0",
    "capabilities": {
      "tools": true,
      "resources": true,
      "prompts": false,
      "sampling": false
    },
    "supported_transports": ["http", "sse"]
  }'

Troubleshooting Client Issues

Common Problems

1. Connection Failures

   • Check transport configuration
   • Verify network connectivity
   • Review authentication setup

2. Protocol Errors

   • Validate JSON-RPC message format
   • Check method names and parameters
   • Review error handling logic

3. Performance Issues

   • Monitor message sizes
   • Check timeout configurations
   • Analyze connection patterns

4. Feature Detection Problems

   • Implement proper initialization sequence
   • Provide accurate capability information
   • Test with multiple feature combinations

Getting Support

If you encounter issues with client compatibility:

1. Check Logs: Review MCP Client Tester logs for error details
2. Export Session: Download session data for analysis
3. Report Issues: Submit compatibility reports with session data
4. Community: Join discussions about client implementations

---

Ready to test your client? Start with our Quick Start Guide or explore Client Detection for advanced analysis features.