Skip to main content
Glama

OpenAI Image Generation for Claude

Generate and edit images with OpenAI right inside Claude. This free, open-source add-on lets Claude Desktop and Claude Code create pictures with OpenAI's GPT Image models (the successor to DALL·E). Ask Claude for "a watercolor fox in the snow" and the image shows up in your chat and is saved to a folder you choose. It runs entirely on your own computer as a local MCP server and uses your own OpenAI API key, so there's no website to sign up for, nothing hosted online, and no middleman between you and OpenAI.

If you've been looking for a way to make AI images in Claude, use ChatGPT's image generator from Claude, or add text-to-image generation to Claude Code, this is it.

What you can do

Once it's set up, you talk to Claude normally. Claude decides when to use the image tool, and asks your permission before each call.

  • Create images from a description. "Make a landscape banner of a lighthouse at dusk, flat illustration style."

  • Revise in conversation. "Make the cat black." "Now add sunglasses." Each change edits the previous version instead of drawing a new picture, so the subject, scene, and style stay the same, and every version is kept.

  • Edit your own images. "Take C:\Users\me\Pictures\room.jpg and repaint the walls sage green."

  • Combine images. "Use these three product photos as references and make a single gift-basket shot."

  • Get transparent PNGs for logos, icons, and stickers.

  • Pick the model. It uses OpenAI's newest image model automatically, but you can ask for any model your account has, including older, cheaper ones.

Every image is saved at full resolution in a folder on your computer, so nothing gets lost when the chat ends.

Related MCP server: gpt-image-2-combined

How it works

Claude can't make images by itself. What it can do is use tools: small programs that give it new abilities. The standard way to plug a tool into Claude is the Model Context Protocol (MCP), and a program that offers tools this way is called an MCP server.

This project is an MCP server. You tell Claude Desktop and Claude Code where it is once, and from then on:

sequenceDiagram
    participant You
    participant Claude as Claude (Desktop or Code)
    participant Server as This server (on your PC)
    participant OpenAI as OpenAI Image API
    You->>Claude: "Draw a red fox in watercolor"
    Claude->>Server: generate_image(prompt, size, quality)
    Server->>OpenAI: Request, signed with your API key
    OpenAI-->>Server: The finished image
    Server->>Server: Save full-size file to Pictures\Claude Images
    Server-->>Claude: Preview + file path
    Claude-->>You: Shows the image and where it's saved

A few details that tend to come up:

  • You never start it yourself. Each Claude app launches the server in the background when the app (or a Claude Code session) starts, and stops it when the app closes. There's nothing to run at boot and no port to open.

  • One install serves both apps. Claude Desktop and Claude Code each get a one-line entry pointing at the same program, and a single setup command adds both.

  • It's local. The server runs on your machine and talks to exactly one outside service: api.openai.com.

  • Your key stays in your system's credential store, not in a file. See Your API key.

  • Claude sees a preview, you get the original. The chat gets a smaller copy (768 pixels on the long edge) so the conversation stays fast. The full-resolution file is in your images folder.

What you need

  • An OpenAI API key. This is a developer key from platform.openai.com, billed per use. A ChatGPT Plus or Pro subscription doesn't include API access; the two are billed separately.

  • OpenAI Organization Verification. OpenAI requires it for GPT Image models. Complete it once under your organization's settings on the OpenAI platform, or image requests may be refused.

  • Claude Desktop and/or Claude Code.

  • uv, a Python project tool. It installs the right Python version and this project's libraries for you.

  • Git, to download the project.

This project is built and tested on Windows. The code is cross-platform and should work on macOS (Keychain) and Linux (Secret Service), but the instructions use Windows paths.

What it costs

The server is free. OpenAI bills your account for each image it creates:

  • A typical image costs a few cents to a few tens of cents, depending on the model, size, and quality. See OpenAI's pricing page for current rates.

  • Older models are usually cheaper. See Choosing a model to pin one.

  • quality: "low" is the cheapest and fastest; "max" is the most expensive.

  • Asking for several images at once (n) bills each one.

Set a monthly spending limit on your OpenAI project so a long creative session can't surprise you.

Setup

This takes about five minutes. Run the commands in PowerShell or Windows Terminal.

1. Download the project

Pick a permanent home for it, because both Claude apps will point at this folder.

cd $HOME\Documents
git clone https://github.com/rogadev/openai-image-mcp.git
cd openai-image-mcp
uv sync

2. Run setup

uv run manage.py setup

Setup does four things:

  1. Asks for your API key. Paste it at the prompt; it stays hidden, and setup tells you how many characters it received. If Ctrl+V does nothing (common in the older Windows PowerShell window), right-click to paste. Setup asks OpenAI whether the key works before saving it, then stores it in Windows Credential Manager.

  2. Asks where to save images. Press Enter for the default (Pictures\Claude Images), or type desktop, pictures, or any folder path. You can change it later; see Where images are saved.

  3. Adds the server to Claude Code for all your projects, if Claude Code is installed.

  4. Adds the server to Claude Desktop, if it finds Claude Desktop's config file. It backs up the file first, as claude_desktop_config.json.bak-openai-image-mcp.

Then quit Claude Desktop completely (right-click its icon in the system tray and choose Quit; closing the window isn't enough) and open it again.

Don't save your key in a text file to paste from later. Copy it straight from the OpenAI dashboard into the setup prompt.

3. Check and try it

uv run manage.py check

This shows whether a key is stored and accepted by OpenAI, which model is the default, and whether each app is set up. Then:

  • Claude Code: start a new session (a session that was already open won't see the new tool) and ask: "Generate a low-quality 1024x1024 image of a lighthouse at dusk."

  • Claude Desktop: in the message box, select +, then Connectors, and check that openai-images is listed. Then ask for the same image.

Approve the tool when Claude asks. After 10 to 60 seconds the image is saved in Pictures\Claude Images. See Viewing your images for how it shows up in each app.

Claude Code:

claude mcp add --scope user --transport stdio openai-images -- "C:\path\to\openai-image-mcp\.venv\Scripts\openai-image-mcp.exe"

Claude Desktop: open Settings, then Developer, then Edit Config, and add this inside the file's top-level braces, keeping any settings already there. Use double backslashes:

"mcpServers": {
  "openai-images": {
    "command": "C:\\path\\to\\openai-image-mcp\\.venv\\Scripts\\openai-image-mcp.exe",
    "args": []
  }
}

Key: uv run manage.py key.

Using it

Just describe what you want. Claude chooses the options, but you can steer them in plain language:

Say something like

What Claude sets

"quick draft", "rough version"

quality: "low"

"highest quality", "final version"

quality: "high" or "max"

"landscape", "16:9 banner"

size: "1536x1024", or a custom size such as "1920x1080"

"portrait", "phone wallpaper"

size: "1024x1536"

"transparent background", "logo", "sticker"

background: "transparent" with PNG

"give me three options"

n: 3

"use gpt-image-2.5-flare for this one"

model for that request only

Prompting tips:

  • Be specific about subject, style, lighting, composition, and colors. "A close-up photo of a ceramic mug on a wooden desk, morning light, shallow depth of field" beats "a mug".

  • Put text in quotes if you want it rendered in the image: a poster that says "Grand Opening".

  • For edits, give the full file path and say exactly what should change and what should stay the same.

  • Iterate. Claude sees each result, so "warmer colors" or "zoom out a bit" works well.

Revising an image

Ask for changes the way you'd ask a designer: "make the cat black", then "now add sunglasses", then "make the background blue". For each change, Claude edits the most recent version of the image instead of generating a new one. The cat stays the same cat, on the same sofa, in the same light, and only the thing you asked for changes.

Every revision is saved as a new numbered file next to the original, so nothing is overwritten:

2026-11-15_134456_a-cat-sitting-on-a-sofa.png      the original
2026-11-15_134516_a-cat-sitting-on-a-sofa-v2.png   "make the cat black"
2026-11-15_134533_a-cat-sitting-on-a-sofa-v3.png   "now add sunglasses"

That gives you an undo: "go back to the black cat without sunglasses and make it smile instead" edits v2 and saves v4. Revisions work across conversations too, because they start from the saved file: point Claude at any image in the folder, or any PNG, JPEG, or WebP of your own, and ask for a change. Say "start over" or "make a new one" when you want a fresh image instead.

Tips for clean revisions:

  • Change one or two things at a time. Small steps keep everything else stable.

  • Say what should stay the same if something drifts: "keep the pose and the background".

  • Current models keep full detail automatically. GPT Image 2 and later always preserve the input image's detail. If you pin an older model, the input_fidelity option can help it hold onto faces and fine detail.

Viewing your images

  • Claude Desktop shows the image right in the conversation, inside the tool's result.

  • Claude Code runs in a terminal, which can't display pictures. Claude still sees the image (so it can describe or refine it), and its reply includes a link for each file, such as file:///C:/Users/you/Pictures/Claude%20Images/2026-11-15_143205_a-red-fox.png. In Windows Terminal, Ctrl+click the link to open the image in your default viewer. You can also say "and open it" in your request, and the server opens each new image for you as soon as it's saved.

  • Either app: every image is in Pictures\Claude Images, and the reply includes a link to that folder too.

Choosing a model

By default, the server always uses OpenAI's newest image model. Each time it needs a model, it checks which image models your key can use (once an hour at most) and picks the newest one. When OpenAI releases a new model, you get it automatically, with nothing to update. Among variants of the newest version, it prefers the fast everyday one (for example, Flare over Sunburst).

You can change that any time.

You want to

Ask Claude

Or run

See the models your key can use

"Which image models can I use?"

uv run manage.py models

Search them

"Show me the 2.5 image models"

uv run manage.py models 2.5

Use a model for one image only

"Make this one with gpt-image-2.6-sunburst"

Pin one as your default

uv run manage.py model gpt-image-2.5-flare

Go back to the newest

uv run manage.py model latest

A few things worth knowing:

  • Only you can change the saved default. Claude can list models and use any of them for a single image, but changing the default is a command you run yourself. That way nothing Claude reads (a web page, a document) can quietly switch you to a different or pricier model for every future image.

  • Pinning is a choice, not a lock-in. A pinned model stays your default until you change it, even after newer models come out.

  • Dated IDs are fixed snapshots. An ID such as gpt-image-2-2026-04-01 never changes behavior; a plain ID such as gpt-image-2.6-flare may get quiet improvements from OpenAI.

  • Older models may not support every option. The server only sends the options you ask for, so the defaults work with any model. If you ask an old model for something it can't do (for example, a transparent background), OpenAI says so and Claude passes the message on.

  • Your choice is saved in %APPDATA%\openai-image-mcp\settings.json, along with your images folder, and shared by Claude Code and Claude Desktop.

Your API key

Where it's kept

Your key is stored in Windows Credential Manager under the name openai-image-mcp, encrypted with your Windows login. It isn't written to any file in this project or in the Claude apps' config. You can see it in Control Panel, then Credential Manager, then Windows Credentials.

The server reads the key from there at the moment it sends a request, and sends it only to https://api.openai.com/v1. That address is built into the code, so no setting (such as an OPENAI_BASE_URL environment variable) can redirect the key somewhere else. The key never appears in the chat. Anything running as your Windows user could also read it, which is true of any key stored on your computer, so keep the usual protections (an up-to-date system, no untrusted programs).

Replacing an expired or revoked key

Keys get revoked, rotated, or expire. When that happens, Claude tells you "OpenAI rejected the stored API key". To fix it:

uv run manage.py key

Paste the new key. It's checked with OpenAI, then replaces the old one; no copy of the old key is kept. The new key works on the very next request. There's no need to restart Claude.

To check the stored key at any time:

uv run manage.py check

Removing it

uv run manage.py remove-key

The server keeps working but asks for a key the next time you request an image.

Good habits

  • Create a dedicated, project-scoped key for this tool, and set a monthly spending limit on that project.

  • Don't keep the key in a text file. Paste it straight from the OpenAI dashboard into manage.py key.

  • If a key may have leaked, revoke it in the OpenAI dashboard first, then store a new one.

Using an environment variable instead

If no key is stored in Credential Manager, the server uses the OPENAI_API_KEY environment variable. This is handy on a machine without a credential store, but less private: every program you run can see environment variables.

Where images are saved

By default, images go to a Claude Images folder inside your Pictures folder. To choose another folder:

uv run manage.py folder desktop          # straight onto your Desktop
uv run manage.py folder pictures         # your Pictures folder itself
uv run manage.py folder "D:\Art\AI"      # any folder; it's created if needed
uv run manage.py folder default          # back to Pictures\Claude Images
uv run manage.py folder                  # show the current folder

desktop and pictures find your real folders, even when Windows has moved them into OneDrive. The change applies from the next image, in both Claude Code and Claude Desktop, with no restart. The tool checks that it can write to the folder before saving your choice.

Only you can change the folder. Claude can't, so nothing it reads can make it save files somewhere else.

When Claude uses it

Claude has its own ways of making visuals: diagrams, charts, SVG graphics, and artifacts. You decide how OpenAI image generation fits alongside them:

Mode

What happens

Good for

implicit (default)

Claude uses OpenAI whenever it decides an image would help.

Making OpenAI your go-to image tool.

explicit

Claude uses OpenAI only when you ask for it by name, for example "make an OpenAI image of...", "use GPT Image", or "use ChatGPT's image generator". For anything else, such as a README diagram or an icon, it uses its own abilities.

Keeping Claude's own visuals as the default and calling on OpenAI for photographic or product-style images.

uv run manage.py trigger explicit
uv run manage.py trigger implicit
uv run manage.py trigger            # show the current mode

Restart Claude Desktop and start a new Claude Code session after changing it, because Claude reads the tool's instructions when the app starts the server. In explicit mode, follow-up changes to an image OpenAI already made in the conversation ("make it black") still use OpenAI.

Explicit mode works by changing the instructions Claude reads about the tool, which it follows reliably, but it's guidance rather than a hard lock. You still approve each tool call unless you've turned approvals off.

Other settings

These optional environment variables, set in the server's entry in one app, override your saved choices for that app only.

Variable

Default

What it does

IMAGE_OUTPUT_DIR

not set

Saves that app's images to this folder instead of your chosen one.

IMAGE_MODEL

not set

Forces a model for that app, overriding the saved default. latest works here too.

Claude Code:

claude mcp remove openai-images -s user
claude mcp add --scope user --transport stdio --env IMAGE_OUTPUT_DIR=D:\Art\AI openai-images -- "C:\path\to\openai-image-mcp\.venv\Scripts\openai-image-mcp.exe"

Claude Desktop: add an env block to the entry, then restart the app. Running manage.py setup again keeps it.

"openai-images": {
  "command": "C:\\path\\to\\openai-image-mcp\\.venv\\Scripts\\openai-image-mcp.exe",
  "args": [],
  "env": { "IMAGE_OUTPUT_DIR": "D:\\Art\\AI" }
}

Files are named <date>_<time>_<first words of the prompt>.<format>, for example 2026-11-15_143205_a-red-fox-in-watercolor.png. A revision keeps the original's name and adds a version number (-v2, -v3, and so on); an edit of an image from elsewhere ends in -edit. Existing files are never overwritten.

Uninstalling

uv run manage.py uninstall

This removes everything the tool added outside its own folder:

  • the server entry in Claude Code

  • the server entry in Claude Desktop's config (after backing up the file)

  • your API key from Credential Manager, including any older copies

  • your saved model, folder, and trigger choices

It leaves your generated images where they are. To finish, quit Claude Desktop, close Claude Code sessions, and delete the openai-image-mcp folder. Add --keep-key if you're reinstalling and want to keep the key.

Uninstalling doesn't revoke the key with OpenAI. If you won't use it again, delete it in the OpenAI dashboard too.

Troubleshooting

Claude says the tool isn't available, or it doesn't appear. Run uv run manage.py check. For Claude Desktop, fully quit from the system tray and reopen it after any change. For Claude Code, start a new session, then run /mcp; if the server shows as failed, select it and choose Reconnect.

"No OpenAI API key is stored." Run uv run manage.py key. No restart needed.

"OpenAI rejected the stored API key." The key expired, was revoked, or was mistyped. See Replacing an expired or revoked key.

"The key works, but it can't use" a model. Complete Organization Verification on the OpenAI platform, or check that the key's project allows image models. Run uv run manage.py models to see what the key can use.

OpenAI refuses a prompt. That's OpenAI's safety system. The message is passed back to Claude, which can explain it or suggest a rewording.

It takes a long time. Complex, high-quality, or large images can take up to two minutes. Use low quality for drafts. In Claude Code, a call that runs past two minutes moves to a background task and finishes there.

uv sync fails with "the process cannot access the file". A running Claude app is using the server. Quit Claude Desktop and close Claude Code sessions, run uv sync, then reopen them.

Where are the logs? Claude Desktop writes this server's output to mcp-server-openai-images.log in its logs folder, next to claude_desktop_config.json. In Claude Code, run claude --debug to see MCP startup messages.

Reference

manage.py commands

Run each as uv run manage.py <command> in the project folder.

Command

What it does

setup

Stores your key (if none is stored) and adds the server to both apps. Safe to run again.

key

Adds or replaces your API key, after checking it with OpenAI. --no-check skips the check.

check

Tests the stored key and shows the default model, the images folder, and which apps are set up.

models [words]

Lists the image models your key can use, newest first, optionally filtered.

model <id>

Sets your default model: an exact ID to pin it, or latest.

folder [where]

Shows or sets where images are saved: desktop, pictures, a folder path, or default.

trigger [mode]

Shows or sets when Claude uses OpenAI: implicit (on its own) or explicit (only when you ask).

register

Adds the server to both apps without touching the key.

remove-key

Deletes the stored key.

uninstall

Removes the server from both apps, and deletes the key and settings. --keep-key keeps the key.

Tools Claude can use

generate_image

Creates images from a text prompt.

Parameter

Type

Default

Notes

prompt

string

required

What to draw.

size

string

"auto"

"auto" or WIDTHxHEIGHT. Both edges must be multiples of 16, no edge over 3840, aspect ratio between 1:3 and 3:1, and 655,360 to 8,294,400 pixels in total. Common sizes: 1024x1024, 1536x1024, 1024x1536.

quality

string

"auto"

"low", "medium", "high", "xhigh", "max", or "auto".

background

string

"auto"

"transparent", "opaque", or "auto". Transparent needs PNG or WebP.

output_format

string

"png"

"png", "jpeg", or "webp".

n

integer

1

1 to 4 images. Each is billed.

model

string

your default

A model ID for this request only.

open_after

boolean

false

Open each saved image in your default image viewer.

edit_image

Revises an existing image, or combines several as references. Claude uses it for follow-up changes to an image it already made. Takes the same options as generate_image, plus:

Parameter

Type

Notes

image_paths

list of strings

Full paths to one or more local PNG, JPEG, or WebP files, each up to 50 MB.

mask_path

string, optional

A PNG the same size as the first image. Its transparent areas mark where to edit.

input_fidelity

string, optional

"auto" (default), "low", or "high". Sent only if not "auto". Only older models accept it; GPT Image 2 and later always preserve input detail and reject it.

With one image, the result is saved as the next version of that image (-v2, -v3, and so on). With several, it's named from the prompt.

Because this tool uploads files to OpenAI, it checks every file before sending it: the extension must be .png, .jpg, .jpeg, or .webp, the file must actually open as that kind of image, and it must be 50 MB or less. Anything else (a document, a key file, a renamed file) is refused and never leaves your computer.

list_image_models

Lists the image models your key can use, newest first, marking the newest and your current default. Takes an optional query to filter by, such as "2.5" or "flare".

What an image call returns

A text block with the model used and, for each saved file, its full path and a clickable file:/// link, plus a link to the folder. Then one JPEG preview per image. If something goes wrong (a bad size, a missing or rejected key, an OpenAI error), the tool returns a readable error instead, and Claude can explain it or retry.

Development

src/openai_image_mcp/
  server.py   MCP server and its three tools
  images.py   OpenAI image calls, validation, file naming, previews
  models.py   Image model discovery, "latest" selection, saved default
  key.py      Stores, checks, and removes the API key
  apps.py     Adds and removes the server in Claude Code and Claude Desktop
  admin.py    The manage.py commands
manage.py     Command-line entry point
tests/        pytest suite (never calls OpenAI or touches your real key or settings)

Built with the MCP Python SDK (v2), the OpenAI Python SDK, keyring, and Pillow.

uv sync
uv run pytest

To try the server without either Claude app, use the MCP Inspector:

npx @modelcontextprotocol/inspector .venv\Scripts\openai-image-mcp.exe

Branches and releases

Work reaches dev through pull requests from short-lived feature branches (or direct pushes), and dev reaches main through a pull request. Merge with a merge commit once CI is green. Every merged pull request that brings unreleased commits publishes a release, whether it merges into dev or main. A dev-to-main merge of work already released from dev publishes nothing.

  • CI (.github/workflows/ci.yml) runs the tests on Windows for every pull request into dev or main and every push to dev, and fails a pull request into main that doesn't come from dev.

  • Release (.github/workflows/release.yml) runs when a pull request merges into dev or main. A read-only job re-runs the tests on the merge commit and picks the next version from the commits since the last vX.Y.Z tag; a separate job, which runs no project code, publishes the GitHub release with grouped notes. Direct pushes don't release.

Change

How to get it

First release

v0.1.0, the seed version in pyproject.toml.

Patch (0.1.0 to 0.1.1)

The default: fix:, docs:, chore:, and any other commits.

Minor (0.1.0 to 0.2.0)

At least one feat: commit since the last release.

Major (0.4.2 to 1.0.0)

Add the release:major label to the pull request before merging. Nothing else bumps major, including a ! or BREAKING CHANGE in a commit.

The tag is the version of record, so pyproject.toml keeps its seed version and nothing is committed back to dev. To retry a failed release, re-run the failed run from the Actions tab; a commit that's already tagged publishes nothing.

License

MIT. Free to use, change, and share.

Available Tools

3 tools
edit_imageA

Revises an existing image, or combines several as references, and saves the result.

This is the tool for follow-up changes ("make it black", "add sunglasses", "remove the
background"): pass the saved path of the latest version from the previous result. The
result is saved as the next numbered version, so earlier versions stay available.

Args:
    prompt: The change to make, and what must stay the same, for example "Make the cat's
        fur black. Keep the pose, background, and lighting unchanged." For several
        references, describe the new image to build from them.
    image_paths: Full paths to one or more local PNG, JPEG, or WebP files. For a revision,
        the single most recent version.
    mask_path: Optional PNG whose transparent areas mark where to edit the first image.
    size: "auto" or WIDTHxHEIGHT, with the same rules as generate_image.
    quality: "low" for fast drafts up to "max".
    background: "transparent" needs output_format "png" or "webp".
    output_format: File format of the saved image.
    n: Number of results, 1 to 4. Each one is billed.
    model: A model ID for this request only. Leave empty to use the user's default.
    open_after: Open each saved image in the user's default image viewer. Set it when the
        user asks to see or open the result, which helps most in Claude Code, where the chat
        is a terminal that can't display images.
    input_fidelity: Leave as "auto". GPT Image 2 and later always preserve input detail and
        reject this option; "high" helps only older models keep faces and fine detail.

Inputs: prompt (required), image_paths (required), n, size, +7 more.

generate_imageA

Generates new images from a text prompt and saves them to the user's image folder.

For changes to an image that already exists, use edit_image on its saved path instead;
generating again produces a different image rather than a revision.

Args:
    prompt: What to draw. Be specific about subject, style, composition, and any text to render.
    size: "auto", or WIDTHxHEIGHT such as 1024x1024 (square), 1536x1024 (landscape), or
        1024x1536 (portrait). Edges must be multiples of 16, at most 3840.
    quality: "low" for fast drafts up to "max". "auto" lets the model choose.
    background: "transparent" needs output_format "png" or "webp".
    output_format: File format of the saved image.
    n: Number of images, 1 to 4. Each one is billed.
    model: A model ID for this request only. Leave empty to use the user's default
        (the newest model unless they pinned one). See list_image_models.
    open_after: Open each saved image in the user's default image viewer. Set it when the
        user asks to see or open the result, which helps most in Claude Code, where the chat
        is a terminal that can't display images.

Inputs: prompt (required), n, size, model, +4 more.

list_image_modelsA

Lists the OpenAI image models the user's API key can use, newest first.

Shows which model is used by default and whether the user pinned one.

Args:
    query: Optional words to filter by, such as "2.5" or "flare".

Inputs: query. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 3 tools

    Disambiguation5/5

    Each tool targets a clearly distinct action on a distinct resource: create a new image, revise an existing one, or enumerate available models. The descriptions actively steer the agent between them (generate_image explicitly points to edit_image for revisions), removing any realistic misselection risk.

    Naming Consistency5/5

    All three tools follow the same verb_noun snake_case pattern (generate_image, edit_image, list_image_models) and share the 'image' resource prefix, making the set predictable and easy to scan.

    Tool Count4/5

    Three tools is lean but each earns its place, and the parameter surface of generate_image/edit_image carries most of the depth. It sits at the low end of the well-scoped band, with no filler but also no supporting tools such as listing previously saved images.

    Completeness4/5

    The core lifecycle (create, revise, and discover models) is fully covered, with versioned saves on edit and mask/reference support. Minor gaps remain around discovering or managing already-saved images (no list/delete/inspect of the output folder) and no image analysis capability.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers