# AI Fuzz Testing MCP 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:
```bash
poetry install
```

Using pip:
```bash
pip install -e .
```

### API Key Configuration

Copy the example environment file and add your API keys:
```bash
cp .env.example .env
```

Edit `.env` and add your API keys:
```env
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:
```bash
python src/main.py
# or
mcp dev src/main.py
```

#### HTTP Mode
For web-based or remote clients:
```bash
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:
```bash
python src/main.py --transport sse --port 8000
# Test with:
mcp dev src.main.py
```

### Command Line Options

```bash
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
```json
{
  "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
```json
{
  "name": "get_models", 
  "arguments": {
    "provider": "anthropic"
  }
}
```

#### Provider Status
```json
{
  "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:
```bash
mcp dev src/main.py
```

Test specific transport modes:
```bash
# 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