A high-performance Model Context Protocol (MCP) server supporting multiple AI providers (Cerebras, OpenRouter, OpenAI, Anthropic, Gemini, and more). Designed for planning with Claude Code, Cline, or Cursor while leveraging fast providers like Cerebras for code generation to maximize speed and avoid API limits.

The Go implementation offers significant advantages over the Node.js version:

• 10x faster performance for large code generation tasks
• Single binary deployment - no Node.js runtime required
• Lower memory footprint and better resource utilization
• Cross-platform compilation for easy deployment
• Type safety and better error handling
• Concurrent processing for handling multiple requests

• 🎯 Smart API Routing with automatic fallback between Cerebras and OpenRouter
• 🔧 Single 'write' Tool for ALL code operations (creation, editing, generation)
• 🎨 Enhanced Visual Diffs with emoji indicators (✅ additions, ❌ removals, 🔍 changes)
• 🔄 Auto-Instruction System that enforces proper MCP tool usage
• 📁 Context-Aware Processing with multiple file support
• 💻 Multi-IDE Support - Claude Code, Cursor, Cline, VS Code
• ⚙️ Interactive Configuration Wizard for easy setup
• 📝 Comprehensive Logging with debug support

• Go 1.21+ (for building from source)
• Cerebras API Key (primary) or OpenRouter API Key (fallback)
• Supported IDE: Claude Code, Cursor, Cline, or VS Code

# Download the latest release for your platform
curl -L https://github.com/cecil-the-coder/mcp-code-api/releases/latest/download/mcp-code-api-$(uname -s)-$(uname -m) -o mcp-code-api

# Make it executable
chmod +x mcp-code-api

# Move to your PATH
sudo mv mcp-code-api /usr/local/bin/

# Clone the repository
git clone https://github.com/cecil-the-coder/mcp-code-api.git
cd mcp-code-api

# Build the binary
make build

# Install to system PATH
make install

mcp-code-api config

The wizard will guide you through:

• Setting up API keys for Cerebras and/or OpenRouter
• Configuring your preferred IDE
• Testing API connections
• Generating configuration files

# Cerebras API (Primary)
export CEREBRAS_API_KEY="your_cerebras_api_key"

# OpenRouter API (Optional Fallback)
export OPENROUTER_API_KEY="your_openrouter_api_key"

# Set model preferences (optional)
export CEREBRAS_MODEL="zai-glm-4.6"
export OPENROUTER_MODEL="qwen/qwen3-coder"

mcp-code-api server

The configuration wizard automatically sets up Claude Code. After configuration:

1. Restart Claude Code
2. The write tool will appear in your tool list
3. Use it for all code operations

1. Run the configuration wizard
2. Copy the generated rules to Cursor → Settings → Developer → User Rules
3. Restart Cursor

1. Run the configuration wizard
2. Restart Cline
3. The write tool will be available

1. Install an MCP extension for VS Code
2. Run the configuration wizard
3. Restart VS Code
4. The write tool will be available via MCP

The MCP tool provides a single write tool that handles ALL code operations:

# In your IDE, use natural language:

"Create a REST API with Express.js that handles user authentication"

"Add input validation to the login function in auth.js"

"Generate a Python script that processes CSV files and outputs to JSON"

"Refactor the database connection in models.js using the pattern from utils.js"

# The tool will automatically read context files:
# - models.js (existing file to modify)
# - utils.js (context for patterns)

The write tool accepts:

• file_path (required): Absolute path to the target file
• prompt (required): Detailed description of what to create/modify
• context_files (optional): Array of file paths for context

The Go implementation enhances visual diffs with:

• ✅ Green indicators for new lines
• ❌ Red indicators for removed lines
• 🔍 Change indicators for modified content
• 📊 Summary statistics (additions, removals, modifications)
• 📁 Full file paths for clarity

The Go implementation includes an enhanced auto-instruction system that:

• Automatically enforces MCP tool usage
• Prevents direct file editing
• Provides clear instructions to AI models
• Ensures consistent behavior across all IDEs

# Build for current platform
make build

# Build for Linux (cross-compile)
make linux

# Build all platforms
make release

# Run tests
make test

# Run tests with coverage
make coverage

# Format code
make format

# Run linter
make lint

# Build Docker image
make docker-build

# Run Docker container
make docker-run

mcp-code-api/
├── 📄 go.mod              # Go module definition
├── 📄 main.go              # Entry point
├── 📁 cmd/                 # CLI commands
│   ├── 📜 root.go          # Root command
│   ├── 📜 server.go        # Server command
│   └── 📜 config.go        # Configuration command
├── 📁 internal/            # Internal packages
│   ├── 📁 api/             # API integrations
│   │   ├── 📜 router.go    # API router
│   │   ├── 📜 cerebras.go  # Cerebras client
│   │   └── 📜 openrouter.go # OpenRouter client
│   ├── 📁 config/          # Configuration management
│   │   ├── 📜 config.go     # Configuration types
│   │   ├── 📜 constants.go # Constants
│   │   ├── 📜 utils.go      # Utility functions
│   │   └── 📁 interactive/ # Interactive wizards
│   ├── 📁 mcp/             # MCP server implementation
│   │   ├── 📜 server.go    # Main MCP server
│   │   └── 📜 write_tool.go # Write tool handler
│   ├── 📁 utils/           # General utilities
│   │   └── 📜 file_utils.go # File operations
│   ├── 📁 formatting/      # Response formatting
│   │   └── 📜 response_formatter.go # Visual diffs
│   └── 📁 logger/          # Logging system
│       └── 📜 logger.go      # Logger implementation
├── 📄 Makefile             # Build automation
├── 📄 README.md            # This file
└── 📄 LICENSE              # MIT License

# Cerebras Configuration
CEREBRAS_API_KEY=your_key
CEREBRAS_MODEL=zai-glm-4.6
CEREBRAS_TEMPERATURE=0.6
CEREBRAS_MAX_TOKENS=4096

# OpenRouter Configuration
OPENROUTER_API_KEY=your_key
OPENROUTER_MODEL=qwen/qwen3-coder
OPENROUTER_SITE_URL=https://github.com/your-repo
OPENROUTER_SITE_NAME=Your Project

# Server Configuration
CEREBRAS_MCP_LOG_LEVEL=info
CEREBRAS_MCP_LOG_FILE=/path/to/logfile
CEREBRAS_MCP_DEBUG=false
CEREBRAS_MCP_VERBOSE=false

You can also use a YAML configuration file at ~/.mcp-code-api/config.yaml:

cerebras:
  api_key: "your_key"
  model: "zai-glm-4.6"
  temperature: 0.6
  max_tokens: 4096

openrouter:
  api_key: "your_key"
  model: "qwen/qwen3-coder"
  site_url: "https://github.com/your-repo"
  site_name: "Your Project"

logging:
  level: "info"
  verbose: false
  debug: false
  file: "/path/to/logfile"

The server supports multiple API keys per provider for automatic load balancing and failover:

providers:
  cerebras:
    # Multiple keys - automatically load balanced
    api_keys:
      - "${CEREBRAS_API_KEY_1}"
      - "${CEREBRAS_API_KEY_2}"
      - "${CEREBRAS_API_KEY_3}"
    model: "zai-glm-4.6"

  openrouter:
    # Single key - backward compatible
    api_key: "${OPENROUTER_API_KEY}"
    model: "qwen/qwen3-coder"

• Round-robin load balancing: Requests are evenly distributed across all configured keys
• Automatic failover: If one key fails (rate limit, error), automatically tries the next available key
• Exponential backoff: Failed keys enter backoff period: 1s → 2s → 4s → 8s → max 60s
• Health tracking: System monitors each key's health and skips unhealthy keys
• Auto-recovery: Keys automatically recover and rejoin rotation after backoff period

• Rate limit avoidance: Multiply your effective rate limit by using multiple keys
• High availability: Service continues even if some keys fail or are rate limited
• Better throughput: Distribute load across multiple keys for higher concurrency
• Fault tolerance: Automatic recovery from transient failures

• Light usage: 1 key is sufficient
• Production: 2-3 keys recommended for failover capability
• High volume: 3-5 keys for optimal performance and resilience

# Set multiple keys
export CEREBRAS_API_KEY_1="csk-primary-xxxxx"
export CEREBRAS_API_KEY_2="csk-secondary-xxxxx"
export CEREBRAS_API_KEY_3="csk-tertiary-xxxxx"

# Start server - will automatically use all configured keys
mcp-code-api server

For a complete example configuration, see config.example.yaml.

The server supports API-compatible providers - third-party services that implement the same API format as the major providers. This includes:

• Anthropic-compatible (e.g., z.ai with GLM-4.6, local proxies)
• OpenAI-compatible (e.g., LM Studio, Ollama, LocalAI)
• Custom self-hosted endpoints

The MCP Code API supports any provider that implements the Anthropic Messages API format.

Add to your ~/.mcp-code-api/config.yaml:

providers:
  anthropic:
    # z.ai's authentication token
    api_key: "your-zai-api-key"
    # z.ai's Anthropic-compatible endpoint
    base_url: "https://api.z.ai/api/anthropic"
    # Use Z.ai's GLM-4.6 model (200K context, optimized for coding)
    model: "glm-4.6"

  enabled:
    - anthropic

  preferred_order:
    - anthropic

Available Z.ai Models:

• glm-4.6 - Latest flagship model (200K context, best for coding/reasoning)
• glm-4.5-air - Lighter/faster variant for quick tasks

# z.ai example
export ANTHROPIC_AUTH_TOKEN="your-zai-api-key"
export ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic"

# Start the server
./mcp-code-api server

Note: Both ANTHROPIC_API_KEY and ANTHROPIC_AUTH_TOKEN environment variables are supported.

If you want to use both standard Anthropic AND a compatible provider:

providers:
  # Standard Anthropic
  anthropic:
    api_key: "sk-ant-..."
    base_url: "https://api.anthropic.com"
    model: "claude-3-5-sonnet-20241022"

  # Custom provider: z.ai
  custom:
    zai:
      type: "anthropic"
      name: "Z.ai"
      api_key: "your-zai-api-key"
      base_url: "https://api.z.ai/api/anthropic"
      default_model: "glm-4.6"
      supports_streaming: true
      supports_tool_calling: true
      tool_format: "anthropic"

  enabled:
    - anthropic
    - zai

  preferred_order:
    - zai         # Try z.ai first
    - anthropic   # Fall back to official Anthropic

providers:
  openai:
    api_key: "lm-studio"  # Can be any value for LM Studio
    base_url: "http://localhost:1234/v1"
    model: "local-model"

Or using environment variables:

export OPENAI_API_KEY="lm-studio"
export OPENAI_BASE_URL="http://localhost:1234/v1"

All providers now support custom base URLs via environment variables:

Examples:

# Use an OpenAI-compatible endpoint (like LM Studio)
export OPENAI_API_KEY="lm-studio-key"
export OPENAI_BASE_URL="http://localhost:1234/v1"

# Use a custom Anthropic-compatible endpoint (z.ai)
export ANTHROPIC_AUTH_TOKEN="your-token"
export ANTHROPIC_BASE_URL="https://api.z.ai/api/anthropic"

Authentication fails:

• Verify your token/API key is correct
• Check if the base URL includes the correct API version path
• Some providers require specific headers - check their documentation

Different API format: If the provider uses a slightly different format, you may need to create a custom provider adapter.

Rate limiting: Some compatible providers have different rate limits than the official APIs. Adjust your usage accordingly.

Contributions are welcome! Please see our Contributing Guide for details.

This project is licensed under the MIT License - see the LICENSE file for details.

• 📧 Email: support@cerebras.ai
• 🐛 Issues: GitHub Issues
• 📚 Documentation: Wiki
• 💬 Community: Discussions

• Cerebras Node.js MCP Server - Original Node.js implementation
• Cerebras AI Platform - AI platform
• Model Context Protocol - MCP specification

• Real-time streaming for large code generation
• Plugin system for custom tools
• Workspace management for project-level operations
• Performance monitoring and metrics
• Advanced caching for faster responses
• Multi-model support with automatic selection

⚡ Built with Go for maximum performance and reliability