AI Fuzz Testing Server

A Model Context Protocol (MCP) server for LLM fuzzing and testing, providing secure access to multiple AI providers through a standardized interface.

Overview

This MCP server enables:

• Multi-provider AI access: Support for Cerebras and Anthropic APIs
• Comprehensive testing: Full parameter support for fuzzing and testing LLMs
• Dynamic documentation: Real-time SDK documentation access
• Multiple transport modes: stdio, HTTP, and Server-Sent Events (SSE)
• Secure configuration: Environment-based API key management

Features

AI Provider Support

• Cerebras Cloud SDK: Complete chat completion API with streaming support
• Anthropic API: Full Claude model access with message completions
• Unified interface: Consistent API across all providers
• Model enumeration: List available models for each provider

MCP Tools

• chat_completion: Create chat completions with any supported provider
• get_models: List available models for a provider
• get_client_info: Get client configuration and status
• list_providers: Show all available providers and their status

Documentation Resources

• docs://{provider}/sdk/{path}: Dynamic SDK documentation browser
• Real-time introspection of provider SDKs
• Hierarchical navigation through SDK components

Installation

Prerequisites

• Python 3.11+
• Poetry (recommended) or pip

Install Dependencies

Using Poetry:

poetry install

Using pip:

pip install -e .

API Key Configuration

Copy the example environment file and add your API keys:

cp .env.example .env

Edit .env and add your API keys:

ANTHROPIC_API_KEY=your_anthropic_api_key_here
CEREBRAS_API_KEY=your_cerebras_api_key_here

Usage

MCP Client Integration

The server supports multiple transport modes for different MCP client requirements:

stdio Mode (Default)

For local MCP clients:

python src/main.py
# or
mcp dev src/main.py

HTTP Mode

For web-based or remote clients:

python src/main.py --transport http --port 8000
# Test with:
mcp dev src/main.py

Server-Sent Events (SSE) Mode

For real-time streaming applications:

python src/main.py --transport sse --port 8000
# Test with:
mcp dev src.main.py

Command Line Options

python src/main.py [OPTIONS]

Options:
  -t, --transport {stdio,sse,http}  Transport mode (default: stdio)
  -p, --port PORT                   Port for HTTP/SSE modes (default: 8000)
  --host HOST                       Host address (default: localhost)
  --log-level {DEBUG,INFO,WARNING,ERROR}  Logging level (default: INFO)
  --cors                            Enable CORS for HTTP/SSE modes
  --timeout SECONDS                 Server timeout for testing

Tool Usage Examples

Chat Completion

{
  "name": "chat_completion",
  "arguments": {
    "provider": "cerebras",
    "kwargs": {
      "messages": [{"role": "user", "content": "Hello!"}],
      "model": "llama3.1-8b",
      "stream": true,
      "temperature": 0.7,
      "max_tokens": 100
    }
  }
}

List Models

{
  "name": "get_models", 
  "arguments": {
    "provider": "anthropic"
  }
}

Provider Status

{
  "name": "list_providers",
  "arguments": {}
}

Resource Access

Browse SDK documentation dynamically:

• docs://cerebras/sdk/ - List all Cerebras SDK components
• docs://anthropic/sdk/Anthropic - Anthropic client documentation
• docs://cerebras/sdk/chat.completions - Chat completions module docs

Development

Project Structure

src/
├── main.py                     # MCP server entry point
└── basic_mcp_example/
    ├── __init__.py
    ├── base_client.py          # Abstract base client
    ├── cerebras.py             # Cerebras implementation
    └── anthropic.py            # Anthropic implementation

Adding New Providers

1. Create a new client module in src/basic_mcp_example/
2. Implement the BaseClient abstract class
3. Add provider instantiation in main.py
4. Update the get_client_by_provider function

Testing

Run the development server:

mcp dev src/main.py

Test specific transport modes:

# Test HTTP mode
python src/main.py --transport http --port 8000 &
mcp dev src.main.py

# Test SSE mode  
python src/main.py --transport sse --port 8001 &
mcp dev src.main.py

Security Considerations

• API keys are loaded from environment variables only
• No API keys are logged or exposed in responses
• Client configurations validate required credentials
• Transport modes support secure connection options

Dependencies

Core dependencies:

• mcp: Model Context Protocol implementation
• python-dotenv: Environment variable management
• cerebras_cloud_sdk: Cerebras AI provider
• anthropic: Anthropic AI provider

Optional dependencies for HTTP/SSE modes:

• uvicorn: ASGI server
• starlette: Web framework

Contributing

This is an example project. For production use, consider:

• Enhanced error handling and logging
• Rate limiting and quota management
• Authentication and authorization
• Monitoring and observability
• Extended provider support