Imagegen MCP

🚀 ImageGen MCP Server

ImageGen MCP Server is a powerful server for AI image generation. It supports multiple cutting - edge models such as OpenAI GPT - Image - 1, Google Imagen 4, Flux 1.1, Qwen Image, SeedDream - 4, and Nano Banana (Gemini 2.5 Flash Image). With it, users can easily generate high - quality images with different styles and formats.

🚀 Quick Start

Option 1: Install from npm (Recommended)

# Install globally
npm install -g imagegen-mcp-server

# Or use with npx (no installation required)
npx imagegen-mcp-server

Option 2: Install from source

# Clone the repository
git clone https://github.com/writingmate/imagegen-mcp.git
cd imagegen-mcp

# Install dependencies
npm install

# Build the project
npm run build

# Run the server
npm start

✨ Features

Model Support

Core Capabilities

• Multiple Output Formats: Supports PNG, JPEG, WebP.
• Flexible Sizing: Allows custom dimensions and aspect ratios.
• Base64 & File Output: Can return images as base64 or save to disk.
• Seed Support: Enables reproducible generation with Flux.
• MCP Compatible: Works seamlessly with any MCP client.

Setup Comparison

📦 Installation

Requirements

• Node.js 18+
• API keys: OPENAI_API_KEY, GOOGLE_API_KEY, and/or REPLICATE_API_TOKEN

Configuration

Create a .env file in your project directory:

# Required: OpenAI API Key for DALL - E models
OPENAI_API_KEY=your - openai - api - key - here

# Required: Google API Key for Imagen and Gemini
GOOGLE_API_KEY=your - google - api - key - here

# Required: Replicate API Token for Flux models
REPLICATE_API_TOKEN=your - replicate - api - token - here

# Optional: Custom Google Imagen endpoint
GOOGLE_IMAGEN_ENDPOINT=

# Optional: Output directory for generated images (default: outputs)
OUTPUT_DIR=outputs

💻 Usage Examples

Generate with OpenAI GPT - Image - 1

const result = await mcpClient.callTool("image.generate.openai", {
  prompt: "A serene mountain landscape at sunset",
  model: "gpt - image - 1",
  size: "1536x1024",
  format: "webp",
  background: "transparent",
  quality: "high"
});

Generate with Google Gemini

const result = await mcpClient.callTool("image.generate.gemini", {
  prompt: "A futuristic city with flying cars",
  returnBase64: true
});

Generate with Flux 1.1

const result = await mcpClient.callTool("image.generate.replicate", {
  prompt: "A detailed portrait of a robot in a cyberpunk setting",
  model: "black - forest - labs/flux - 1.1 - pro", // Default model
  width: 1024,
  height: 1536,
  seed: 12345,
  format: "png"
});

Generate with Qwen Image

const result = await mcpClient.callTool("image.generate.replicate", {
  prompt: "A traditional Chinese landscape painting with mountains and rivers",
  model: "qwen/qwen - image",
  width: 1024,
  height: 1024
});

Generate with SeedDream - 4

const result = await mcpClient.callTool("image.generate.replicate", {
  prompt: "A vibrant abstract art piece with flowing colors",
  model: "bytedance/seedream - 4",
  width: 1024,
  height: 1024 // Minimum 1024x1024 required
});

📚 Documentation

🎬 Quick Demo

⚡ Instant (WritingMate.ai)

1. Visit WritingMate.ai
2. Say: "Generate an image of a cyberpunk city using Flux 1.1"
3. ✅ Done! - No setup, no API keys needed

🛠️ Self - Setup (Other Clients)

# Install and run in one command
npx imagegen-mcp-server

Then in your MCP client:

"Generate an image of a cyberpunk city using Flux 1.1"

✅ Result: High - quality image saved to outputs/ directory

🎨 Model Comparison

Same prompt: "A serene mountain landscape with a crystal clear lake reflecting snow - capped peaks, golden hour lighting, highly detailed"

Available Tools

1. OpenAI GPT - Image - 1 MCP (image.generate.openai)

Parameters:

{
  prompt: string;              // Required: Image description
  model?: string;              // "dall - e - 2", "dall - e - 3", "gpt - image - 1" (default)
  size?: string;               // "1024x1024", "1792x1024", "1024x1792", etc.
  width?: number;              // Alternative to size
  height?: number;             // Alternative to size
  quality?: "standard" | "hd" | "low" | "medium" | "high" | "auto";
  format?: "png" | "jpeg" | "jpg" | "webp";
  background?: "transparent" | "opaque" | "auto"; // gpt - image - 1 only
  style?: "vivid" | "natural";  // DALL - E 3 only
  returnBase64?: boolean;      // Include base64 in response
  filenameHint?: string;       // Custom filename prefix
}

Model - specific features:

• DALL - E 2: Basic generation, sizes: 256×256, 512×512, 1024×1024
• DALL - E 3: High - quality generation, sizes: 1024×1024, 1792×1024, 1024×1792
• GPT - Image - 1: Latest model with background control, multiple formats, flexible sizing

2. Google Imagen 4 MCP (image.generate.google)

Parameters:

{
  prompt: string;              // Required: Image description
  model?: string;              // Model name
  size?: string;               // Image dimensions
  quality?: string;            // Quality setting
  format?: "png" | "jpeg" | "jpg" | "webp";
  returnBase64?: boolean;
  filenameHint?: string;
}

Requirements:

• Set GOOGLE_IMAGEN_ENDPOINT in your .env file
• Endpoint should accept POST requests with JSON payload
• Response format: { image: { base64: string, mimeType?: string } }

3. Nano Banana MCP (image.generate.gemini)

Parameters:

{
  prompt: string;              // Required: Image description
  model?: string;              // Default: "gemini - 2.5 - flash - image - preview"
  returnBase64?: boolean;
  filenameHint?: string;
}

4. Replicate Models MCP (image.generate.replicate)

Parameters:

{
  prompt: string;              // Required: Image description
  model?: string;              // Default: "black - forest - labs/flux - 1.1 - pro"
  width?: number;              // Image width (default: 1024)
  height?: number;             // Image height (default: 1024)
  size?: string;               // Alternative format: "1024x1024"
  format?: "png" | "jpeg" | "jpg" | "webp";
  seed?: number;               // Reproducible generation
  returnBase64?: boolean;
  filenameHint?: string;
}

Flux Model Features:

• Flux 1.1 Pro: State - of - the - art image quality and prompt following
• High Resolution: Supports various aspect ratios and sizes
• Fast Generation: Optimized for speed and quality
• Seed Support: Reproducible image generation

Output Format

All tools return a consistent response format:

{
  content: [
    {
      type: "text",
      text: "provider=openai model=gpt - image - 1 saved=/path/to/image.png"
    },
    {
      type: "image",        // Only if returnBase64: true
      data: "base64data",
      mimeType: "image/png"
    }
  ]
}

Generated images are automatically saved to the configured output directory with timestamped filenames.

Publishing to npm

The package is ready for npm publishing:

# Update version
npm version patch|minor|major

# Publish
npm publish

API Keys Setup

OpenAI API Key

1. Visit [OpenAI API Keys](https://platform.openai.com/api - keys)
2. Create a new API key
3. Add to .env as OPENAI_API_KEY

Google API Key

1. Visit Google AI Studio
2. Create API key and enable required APIs
3. Add to .env as GOOGLE_API_KEY

Replicate API Token

1. Visit Replicate
2. Sign up and go to your account settings
3. Create an API token
4. Add to .env as REPLICATE_API_TOKEN

Development

npm install    # Install dependencies
npm run dev    # Development with hot reload
npm run build  # Build for production
npm start      # Start production server

🔧 Technical Details

This MCP (Model Context Protocol) server for AI image generation supports multiple models:

• GPT - Image - 1 MCP: OpenAI's latest image generation model
• Nano Banana MCP: Gemini 2.5 Flash Image Preview model
• Google Imagen 4 MCP: Advanced photorealistic image generation
• Flux 1.1 MCP: State - of - the - art prompt following via Replicate

📄 License

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