jau123/MeiGen-AI-Design-MCP

MeiGen AI Design MCP

Open-source MCP server for AI image & video generation — native to every major AI coding tool
_{Leading models (GPT Image 2 · Nanobanana 2 · Seedream 5.0 · Midjourney V8.1 · Flux 2 Klein · Grok Imagine · Seedance 2.0 · Veo 3.1 · Grok Video · Agnes Video · local ComfyUI) · 1,446 curated prompts · parallel sub-agent orchestration · standalone CLI mode. Works in Claude Code, Cursor, Codex, Windsurf, Roo Code, OpenClaw, Hermes Agent, and any MCP-compatible host.}

Quick Start • Five Skills • HTTP API • Upgrade to 2.0 • Demo • Features • Providers • Commands

English | 中文

---

New in 2.0.1: generate_video accepts multiple reference videos and reference audio (referenceVideos / referenceAudios; local .mp4/.mov/.wav/.mp3 files are uploaded automatically). Per-model limits come from list_models.

> New in 2.0.0: five guided ecommerce/image Skills, original-image enhancement, upload validation, request recovery and Codex setup. Use a Skill · Upgrade guide · HTTP API

What Is This?

An MCP server that helps your AI assistant create images, videos and ecommerce assets. Connect to the remote server (14 tools) or install the local npm server (17 tools). Works in Claude Code, Cursor, Codex, Windsurf, Roo Code, OpenClaw, Hermes Agent, and other compatible MCP hosts.

Version 2.0.0 adds five guided Skills: background removal, Product Detail Images, Marketing Poster, AI Backgrounds and Upscale. These run on MeiGen Cloud and require a MeiGen API key and purchased credits. The local server also supports OpenAI-compatible APIs and ComfyUI for general image generation; those providers do not run the five Skills.

• Local general image generation supports three backends: MeiGen Cloud, OpenAI-compatible APIs, or local ComfyUI. Use list_models for current capabilities.
• Built-in 1,446 curated prompt templates from nanobanana-trending-prompts plus style-aware prompt enhancement
• Callable image/video steps for upstream workflows, optional creative helpers, and a standalone CLI for shell scripts and CI

See It in Action

▶ Watch demo on YouTube

Product Photo — 4 Directions in Parallel

"Create 4 product display images for this perfume, one of which should feature a model."

Process — AI uploads the reference image, crafts 4 distinct prompts, then generates all 4 in parallel:

Result — 4 creative directions delivered in under 2 minutes:

Generated images:

---

Quick Start

Ask your AI assistant to install

Copy this entire block into Codex, Claude Code, Cursor, or another AI assistant that can configure MCP servers. It can set up the connection and guide you through credentials. ChatGPT web uses the separate setup below.

Install MeiGen MCP for this AI client using this guide:
https://github.com/jau123/MeiGen-AI-Design-MCP#quick-start
Detect the current client and inspect its MCP configuration without printing
credentials. Preserve other servers and reuse an existing MeiGen entry.
Prefer Streamable HTTP at https://www.meigen.ai/api/mcp. For Codex, use
codex mcp add meigen --url https://www.meigen.ai/api/mcp
Add bearer_token_env_var = "MEIGEN_API_TOKEN" only after that local
environment variable is configured; otherwise leave authentication unset.
If I need automatic local-file preparation, ComfyUI, or local-only tools, use
the stdio command npx -y meigen@2.0.1 instead. Check that this exact npm
version exists before configuring it; report an unavailable version.
Guide me to enter my MeiGen key in local credentials settings or the launch
environment, never in this chat. Public lookups can be tested without a key.
Reload/reconnect, inspect the actual tool list, and call list_skills to verify.
If you cannot configure or reconnect this client, give me the exact manual
steps and say what remains unverified. If list_skills is missing, report it.
Do not upload images, generate anything, or spend credits during installation.

For manual setup, jump to Codex / ChatGPT desktop, ChatGPT web, or the client-specific instructions below.

1. Prepare your account

You can browse inspiration and inspect models or Skill prices without a key. To generate with MeiGen:

1. Open API Keys in a desktop browser, sign in, and create a key. The key starts with meigen_sk_; the mobile site currently redirects this page. 2. Open your profile and select Top Up to add purchased credits to the same account; on mobile use Premium. API generation does not use daily free credits; the five Skills have no free attempts, including the first cutout. Use list_skills for current Skill prices. 3. Add the key to your MCP host's connection settings. Keep it out of chat messages and shared config files.

2. Choose one connection

| | Remote MCP — recommended | Local npm MCP 2.0.1 | |---|---|---| | Connection | Streamable HTTP at https://www.meigen.ai/api/mcp | Node.js process over stdio | | Tools | 14: MeiGen generation, gallery and the five Skills | The same 14, plus prompt enhancement, preferences and ComfyUI management | | Reference images | Public image link, an existing MeiGen URL, or actual attachment bytes readable by the host | Local files and public image links are prepared automatically | | Local extras | Result URLs; the host handles preview/download | General generation saves files; also CLI, offline prompt library and local ComfyUI | | Plugin extras | A bare MCP connection does not install commands, agents, output styles or hooks | The Claude Code plugin adds these; a bare npm connection also does not include them | | Updates | Backend changes arrive after server deployment; refresh/reconnect if the host caches tools | Local tool changes require an npm release and a client update |

Choose one server entry for this host to avoid duplicate tools. The two entries use the same MeiGen account and purchased credits.

Install for your client: Remote settings · Codex · Claude Code · Cursor / VS Code / Windsurf / Roo · OpenClaw · ChatGPT web.

3. Try your first Skill

After connecting, ask: “List the available Skills and their current prices.” This does not generate an image or spend generation credits. Then provide the required material and describe the result you want:

| Skill / tool | Example request | Required | Optional | Output and cost | |---|---|---|---|---| | Background removal — remove_background | “Remove this background and give me a transparent PNG.” | One source image | No creative brief needed | One cutout; charged from the first request | | Product Detail Images — generate_product_detail_images | “Use this product photo to make a main shot, a detail close-up and a lifestyle image.” | One product image; resolve the desired count/modules | Product name, selling points, copy, logo, model photo, up to two extra product photos, language and marketplace | 1–6 images; one paid image per module | | Marketing Poster — generate_marketing_poster | “Make one poster for a weekend coffee tasting.” | A brand, event, campaign or topic | Display copy, logo, up to three product images, one style reference, language and style | One poster; images are optional | | AI Backgrounds — generate_ai_background | “Put this product on a sunlit stone counter.” | One product image; desired setting for custom mode | White/smart/custom mode, ratio and quality | One product image with a new background; not a transparent cutout | | Upscale — upscale_image | “Make this original product photo clearer while keeping its appearance.” | One original still PNG/JPEG/WebP image | crisp preserves structure (default); creative reconstructs details and requires acceptance of changes | One enhanced image; video enhancement is not exposed |

The assistant chooses the tool, prepares images, checks status and presents preview/download links. You do not need to write prompts, UUIDs or API parameters. It asks only for missing essential information. An explicit request for a specified count, modules or quality already confirms that scope.

Product-detail batches: choose 1–6 modules in total. The presets are main shot (hero), close-up (detail), lifestyle (scene), texture/craft (material), how-to-use (usage) and brand story (brand); custom modules are also supported. MCP requires the assistant to pass modules explicitly, preventing extra images when an argument is omitted. You can specify only the count and let the assistant choose modules. Direct HTTP API calls still default to three images (hero, detail and scene) when modules are omitted. The assistant should calculate the batch cost from the live per-image price and requested count before submitting an unresolved batch.

Copy and quality: ask to preserve your wording when exact copy matters; otherwise the service can draft copy from your brief. State the desired text language. Product details and posters default to Fast; Pro costs more. AI Backgrounds defaults to smart/Fast; white mode uses a fixed output specification and ignores ratio/quality options. Current options and prices come from list_skills.

Poster fields: with autoCopy: true, content is a brief; with autoCopy: false, it is the visible wording to preserve (the selected language may translate it). Put style/layout/design directions in extraNotes or customStyle, not in verbatim content. extraNotes may also contain verified facts or explicitly requested display copy; design instructions in it are directions, not text to print verbatim. Use a catalog preset ID for styleId, not its display label. Omit both written style fields for Auto; nonempty customStyle overrides styleId. styleImage is the primary visual reference, with written style only as a compatible supplement; do not copy its products, wording or layout. Logo and product references preserve identity.

Output and timing: current Product Detail and Poster Fast/Pro tiers both use the 2K preset; quality is not resolution. Actual pixels depend on ratio and provider output. Use current list_skills specifications/prices and do not send an unsupported resolution argument. Queueing, planning, provider execution and image count affect completion time; no fixed number of seconds is guaranteed. Polling intervals and HTTP timeouts are not ETAs.

Valid MCP call example: this illustrative request already supplies the event copy and time. Only content below is the exact visible wording; extraNotes describes layout and preservation requirements, not additional text to print. Pass it to client.callTool(...). Use list_skills({skill: "brand-poster"}) for live options and price when choosing. It creates one paid poster without image material. The caller generates and saves a UUID for each real attempt, reuses it for recovery and does not blindly rerun this example.

{
  "name": "generate_marketing_poster",
  "arguments": {
    "requestId": "8f729f7e-934e-4e2c-bae3-bf23a782f964",
    "brand": "Coffee tasting",
    "content": "Coffee tasting\nSaturday, 10:00–12:00",
    "autoCopy": false,
    "extraNotes": "Keep the supplied time. Use a clear headline and a small schedule block.",
    "styleId": "minimalist",
    "language": "en",
    "ratio": "4:5",
    "quality": "low"
  }
}

Images: for the local npm server, provide an actual file path or a public direct HTTPS image link. For remote MCP, the assistant uses upload_skill_image for external links or readable attachment bytes, then passes its imageUrl to the Skill. Existing images.meigen.ai, images.meigen.art or pbs.twimg.com HTTPS URLs can be used directly. upload_skill_image and /api/skills/upload require a positive purchased-credit balance for both local and remote MCP connections. Uploading does not start generation or spend generation credits. If your host cannot read an attachment, provide a direct image URL or use the local npm server.

Local preprocessing accepts source files up to 32 MiB and prepares references up to 4096px / 8 MiB, preserving PNG/WebP transparency. Remote uploads accept a public direct HTTPS image up to 8 MiB, or real base64 bytes up to 3 MiB decoded. Private-network URLs, redirects, authenticated links and IPv6-only sources are unsupported. These are reference image limits, not generated output specifications.

Upscale uses the original: pass an original local file or public direct HTTPS URL to upscale_image; do not resize it with a generic reference uploader. For readable attachment bytes, use upload_skill_image with purpose: "upscale". Originals may be up to 64 MiB / 64 million pixels; base64 remains limited to 3 MiB decoded. Only still JPEG/PNG/WebP is supported. Local uploads fully decode, auto-orient, remove metadata and preserve alpha and dimensions; encoding must fit below 9,500,000 bytes. If it cannot, provide a public original URL.

A source larger than 4096px on either edge or 16 million pixels returns upscale_resize_required before generation or charging. Explain that resizing can produce a result smaller than the original with limited clarity gain; after acceptance, use allowDownscale: true and a new requestId. Both MCP transports require confirmedCredits on the first call too: use the live list_skills quote within the accepted user or upstream workflow budget. This is a pre-dispatch check, not an atomic spending cap. For price_changed, obtain acceptance of the updated quote before submitting a new ID with the accepted confirmedCredits. Explain possible detail changes before choosing creative mode.

Direct HTTP API: developers without an MCP host can use the complete five-Skill API guide, including upload, run and recovery examples. GET /api/skills supplies capabilities and current prices.

Remote MCP Endpoint (zero-install, recommended)

In your host's MCP settings, select Streamable HTTP, enter https://www.meigen.ai/api/mcp, and add the HTTP header Authorization: Bearer YOUR_MEIGEN_API_KEY. The exact settings screen varies by host. Claude Code also supports:

# MEIGEN_API_TOKEN must already be set in this terminal's environment.
claude mcp add --transport http meigen https://www.meigen.ai/api/mcp \
  --header "Authorization: Bearer $MEIGEN_API_TOKEN"

The remote endpoint supports stateless Streamable HTTP, including the 2026-07-28 protocol and compatible 2025 clients. Stateless means no persistent MCP session is required. Accepted generation jobs and their billing records still live on the server, so an interrupted conversation can recover them.

There is no npm install or local server process. Changes to remote tools require a backend deployment, not an npm release; the client may need to reload its tool list. Remote generation still requires an internet connection. Local npm updates remain necessary when local tools or file-handling behavior change.

Codex / ChatGPT desktop (local Codex host)

Use this setup for Codex CLI, the Codex IDE extension, and the desktop app when using a local Codex host. These clients share MCP configuration on the same host. ChatGPT web has a different connection flow. See the official Codex MCP guide.

Remote — recommended for MeiGen Cloud and Skills:

codex mcp add meigen --url https://www.meigen.ai/api/mcp \
  --bearer-token-env-var MEIGEN_API_TOKEN

The equivalent configuration below also sets timeouts suitable for Skills. Merge it into ~/.codex/config.toml; if you used the command above, edit its existing meigen table instead of adding another one. Preserve your other servers.

[mcp_servers.meigen]
url = "https://www.meigen.ai/api/mcp"
bearer_token_env_var = "MEIGEN_API_TOKEN"
startup_timeout_sec = 30
tool_timeout_sec = 240

To try public lookups before configuring a key, omit --bearer-token-env-var from the command and bearer_token_env_var from the TOML. Add them after setting the variable.

Set MEIGEN_API_TOKEN locally in the environment that launches Codex before using authenticated tools. This is your MeiGen key, not an OpenAI API key. Codex does not automatically load a project's .env.local. If a desktop launch does not inherit your terminal variables, enter the Authorization: Bearer … header through its private MCP connection settings when available, or configure http_headers.Authorization yourself in your private user-level config. When using a direct Authorization header, remove bearer_token_env_var so the connection does not depend on that missing environment variable. Keep the key out of chat and shared project files.

Local — for automatic local-file preparation, ComfyUI and local-only tools: use this entry instead of the remote entry. Node.js 22 or newer is recommended.

[mcp_servers.meigen]
command = "npx"
args = ["-y", "meigen@2.0.1"]
env_vars = ["MEIGEN_API_TOKEN"]
startup_timeout_sec = 90
tool_timeout_sec = 240

This forwards your locally configured MEIGEN_API_TOKEN to the npm process. To register just the local command with the CLI, use codex mcp add meigen -- npx -y meigen@2.0.1, then add the environment forwarding and timeout settings shown above. meigen init codex is not supported; use Codex's own MCP configuration.

Restart/reconnect after setup. In Codex CLI, codex mcp list checks registration and /mcp shows connection status. Then ask “List MeiGen's available Skills and current prices” to verify an actual tool call without generating or spending credits. A saved configuration alone does not prove that the server connected. Longer video jobs may need a longer tool timeout.

ChatGPT web (public lookups only)

For accounts and workspaces with custom MCP access, enable Developer mode, create a custom remote app/plugin, enter https://www.meigen.ai/api/mcp, and choose No Authentication. After connecting, select it in a conversation and request a public model, Skill-price or gallery lookup. Follow OpenAI's Developer mode setup for the current settings and availability. A chat message alone cannot install a local npm server into ChatGPT web.

Paid MeiGen tools are not supported through this ChatGPT web connection yet. OpenAI's hosted MCP client cannot send custom API keys, while MeiGen currently requires a Bearer API key for generation, image upload and check_skill recovery (check_generation by known generationId remains public; requestId recovery requires a key). Full support needs a MeiGen OAuth integration. Use Codex or another client that supports Bearer headers for those tools; do not put the key in chat or in the server URL.

Local npm MCP (Node.js)

Node.js 22 or newer is recommended. The examples below pin meigen@2.0.1. After changing an installed version or connection settings, restart or reconnect the host. The five Skills still call MeiGen Cloud and need the account setup above.

Claude Code Plugin (npm, local tools)

# Add the plugin marketplace
/plugin marketplace add jau123/MeiGen-AI-Design-MCP
Install
/plugin install meigen@meigen-marketplace

Restart Claude Code after installation (close and reopen, or open a new terminal tab).

Alternative marketplace — also available via wshobson/agents (30k+ stars):

/plugin marketplace add wshobson/agents
/plugin install meigen-ai-design@claude-code-workflows

This marketplace doesn't bundle MCP server config. After installing, add to your project's .mcp.json:

> { "mcpServers": { "meigen": { "command": "npx", "args": ["-y", "meigen@2.0.1"] } } }

First-Time Setup

Free features work immediately after restart — try:

"Search for some creative inspiration"

The Claude Code plugin includes a setup command:

/meigen:setup

For the five Skills, choose MeiGen Cloud and configure your MeiGen key in the connection settings. For general image generation, the wizard also offers ComfyUI and OpenAI-compatible APIs. Restart Claude Code after changing configuration. Do not paste secrets into a conversation.

Cursor / VS Code / Windsurf / Roo Code

One command to set up MeiGen for any supported AI coding tool:

npx -y meigen@2.0.1 init cursor      # Cursor
npx -y meigen@2.0.1 init vscode      # VS Code / GitHub Copilot
npx -y meigen@2.0.1 init windsurf    # Windsurf
npx -y meigen@2.0.1 init roo         # Roo Code
npx -y meigen@2.0.1 init claude      # Claude Code (project-level)

This writes the correct MCP config file with the right format and path for your tool. If a config file already exists, MeiGen is merged in without overwriting your other servers.

init writes a configuration that follows the default npm release tag; the manual examples above pin 2.0.1. To pin an i