imagine-mcp
imagine-mcp is an MCP server for multimodal image/video understanding and generation across Gemini, OpenAI, and Grok.
Understand media: Describe, classify, or reason over one or more image/video URLs with a prompt; Gemini supports mixed image+video in one call.
Generate media: Create images or videos from text prompts; image-to-image via
reference_image_url; video generation is async (poll withjob_id).Switch providers/tiers: Choose
gemini,openai, orgrokandpoor(cheap/fast) orrich(high-quality) per request.Configure at runtime: Check credential status, set log level, default provider/tier, cache TTL, and clear response cache.
Open credential form: Use
config__open_relayto launch the browser relay setup form.Get help: Fetch full Markdown docs for
understand,generate, orconfig.Self-host options: Run via stdio with env keys or as an OAuth-gated HTTP daemon for remote/multi-user use.
Security built in: SSRF/LFI prevention for media URLs, sanitized errors, degraded start without keys, and encrypted credential storage.
Enables image and video understanding and generation using OpenAI's gpt-image model, including image-to-image editing and generation from text prompts.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@imagine-mcpgenerate a photorealistic image of a cat wearing a spacesuit on Mars"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ARCHIVED 2026-09-13 — This repository is no longer maintained. Use your image provider's native API instead of this MCP server. Existing installations keep working but receive no updates or support.
imagine-mcp
mcp-name: io.github.n24q02m/imagine-mcp
Image and video understanding + generation for AI agents -- across Gemini, OpenAI, and Grok.
Project | Tagline | Tag |
Peer AI agents chat in a shared folder — no human relay, no orchestrator, wor... | Tooling | |
Knowledge graph for token-efficient code reviews -- semantic search and call-... | MCP | |
2-way Google Drive sync with .driveignore filter — rclone engine, Windows tray | Tooling | |
IMAP/SMTP email for AI agents -- read, send, organize folders, and manage att... | MCP | |
Composite MCP server for Godot Engine -- 17 composite tools for AI-assisted g... | MCP | |
Markdown-first Notion for AI agents -- pages, databases, blocks, and comments... | MCP | |
Drop-in python-semantic-release fork with built-in release-safety guards (orp... | Tooling | |
Telegram for AI agents -- messages, chats, media, and contacts across both bo... | MCP | |
Google Workspace MCP server (Docs/Drive/Calendar/Gmail/Sheets/Slides/Tasks/Ch... | MCP | |
Claude Code plugin marketplace for the n24q02m MCP servers -- install web sea... | Marketplace | |
Image and video understanding + generation for AI agents -- across Gemini, Op... | MCP | |
Chrome Extension for bulk operations on Jules tasks via batchexecute API -- a... | Tooling | |
Shared foundation for building MCP servers -- Streamable HTTP transport, OAut... | MCP | |
Persistent AI memory with hybrid search and embedded sync. Open, free, unlimi... | MCP | |
Lightweight Qwen3 text embedding and reranking via ONNX Runtime and GGUF | Library | |
Secrets without the server. | CLI | |
A self-distilling neuro-symbolic cascade that amortises LLM cost across knowl... | Tooling | |
Shared web infrastructure package for search, scraping, HTTP security, and st... | Library | |
Open-source MCP server for AI agents: web search, content extraction, and lib... | MCP |
Table of contents
Related MCP server: mcp-media-engine
Features
Multimodal understanding -- Describe, classify, or reason over images and videos (Gemini handles mixed image + video in one call)
Image generation -- Text-to-image and image-to-image (edit / inpaint) across Gemini Imagen, OpenAI gpt-image, Grok Imagine
Video generation -- Text-to-video and image-to-video (Gemini Veo 3.1, Grok Imagine Video)
3 providers x 2 tiers -- Same interface for
gemini/openai/grokatpoor(cheap/fast) orrich(high quality); swap via parameterOpen model passthrough -- Understanding routes through litellm; pass any
provider/model, or configure an ordered model chain (no hardcoded catalog)Degraded mode -- Server starts with zero credentials and surfaces remaining providers as you add keys
Response cache -- Disk-based caching of
understandresponses with configurable TTLDual transport -- pure stdio with provider env vars (default) or HTTP multi-user with paste-token relay form
Install
Run with uvx (no install step) or pull the container image:
# uvx -- recommended, runs the published PyPI package
uvx imagine-mcp
# Docker
docker run -it --rm ghcr.io/n24q02m/imagine-mcp:latestAdd it to an MCP client by pointing the client at the uvx imagine-mcp command and
supplying at least one provider key (see Configuration):
{
"mcpServers": {
"imagine": {
"command": "uvx",
"args": ["imagine-mcp"],
"env": { "GEMINI_API_KEY": "AIza..." }
}
}
}For per-client snippets (Claude Code, Codex, Gemini CLI, Cursor, Windsurf) and the browser-based HTTP setup, see the Setup docs.
Install with an AI agent -- paste this to your AI coding agent:
Install MCP server
imagine-mcpfollowing the steps at https://raw.githubusercontent.com/n24q02m/claude-plugins/main/plugins/imagine-mcp/setup-with-agent.md
Smithery
imagine-mcp ships a smithery.yaml so it can be installed and
run through Smithery. The entry launches the published
PyPI package over stdio (uvx --python 3.13 imagine-mcp) with an empty config
schema -- no setup fields are required at deploy time. Provider keys are supplied
at runtime through the server's own credential flow (env vars in stdio mode, or
the browser setup form in HTTP mode; see Configuration).
Configuration
Two transports (default stdio; opt into http with --http, MCP_TRANSPORT=http,
or TRANSPORT_MODE=http):
stdio (default) -- single-user, reads credentials from env vars only. Exits if none of the three provider keys are set.
http -- HTTP daemon. Local self-host on
127.0.0.1by default, or multi-user remote (per-JWT-sub credential isolation) whenPUBLIC_URL+MCP_DCR_SERVER_SECRETare set. In HTTP mode credentials are entered through a browser form at/authorize.
Provider keys
All optional -- the server starts in degraded mode and surfaces whichever providers have a key. Set at least one.
Env var | Provider | Get a key at |
| Gemini (image + video) | aistudio.google.com/apikey |
| OpenAI (image) | platform.openai.com/api-keys |
| Grok / xAI (image + video) | console.x.ai |
When a tool is called without an explicit provider, the first key present wins in the
order XAI_API_KEY -> OPENAI_API_KEY -> GEMINI_API_KEY.
Model chains (optional)
Model choice passes straight through to litellm (understand) or the native
provider SDK (generate) -- there is no hardcoded model catalog. Each chain is a
CSV of litellm provider/model entries; the order is the fallback order.
Env var | Purpose |
| Ordered model chain for |
| Ordered model chain for |
| CSV of provider names reordering generation auto-fallback. Defaults to |
Understanding is routed through litellm (provider/model passthrough), so any litellm
provider works -- supply that provider's <PROVIDER>_API_KEY. Generation stays on the
native provider SDKs (Gemini, OpenAI, Grok). Example:
{
"mcpServers": {
"imagine": {
"command": "uvx",
"args": ["imagine-mcp"],
"env": {
"UNDERSTAND_MODELS": "gemini/<model-id>,openai/<model-id>",
"GEMINI_API_KEY": "AIza...",
"OPENAI_API_KEY": "sk-..."
}
}
}
}Runtime knobs
config(action="set", key=..., value=...) adjusts log_level, default_provider,
default_tier, and cache_ttl_seconds at runtime.
CLI
The imagine-mcp console command installed by the package takes no
subcommands -- it starts the MCP server directly. Transport is selected by a
single flag or its environment-variable equivalents:
imagine-mcp # stdio transport (default); reads provider keys from env vars
imagine-mcp --http # HTTP daemon; credentials via the browser setup formInvocation | Equivalent env | Result |
|
| stdio, single-user, env-var credentials |
|
| HTTP daemon -- local |
In stdio mode the server exits if none of the provider keys are set. The remote
HTTP bind knobs (MCP_HOST, MCP_PORT) apply only when PUBLIC_URL is set; see
Configuration.
Remote (HTTP mode)
An HTTP deployment serves clients that support remote HTTP MCP servers. It is
OAuth-gated -- an unauthenticated request returns 401 with a
WWW-Authenticate: Bearer challenge -- and credentials are provisioned through
the browser setup form. Point an HTTP-capable MCP client at
https://<your-host>/mcp and complete the OAuth flow to connect.
To stand one up, see Deploy to Cloudflare.
Documentation
Full docs at mcp.n24q02m.com/servers/imagine-mcp/setup/:
Setup -- install methods for Claude Code, Codex, Gemini CLI, Cursor, Windsurf, mcp.json
Modes overview -- stdio / local-relay / remote-relay / remote-oauth
Multi-user setup -- per-JWT-sub credential model
Tools
4 MCP tools (understand, generate, config, help), plus config__open_relay (framework-injected by mcp-core):
Tool | Actions | Description |
| -- | Describe or reason over one or more image/video URLs. |
| -- | Generate an image or video from a text prompt. |
|
| Credential + runtime config: check credential state, set runtime knobs (log level, default provider, TTL), clear response cache. |
| -- | Full Markdown documentation for |
| -- | Framework-injected helper (mcp-core); opens the browser credential form. |
Model choice is caller-driven (litellm provider/model passthrough or a *_MODELS
env chain) -- see Model chains above.
Comparison
How imagine-mcp stacks up against direct competitors in each pillar:
Capability | imagine-mcp | EverArt MCP | fal.ai MCP | Replicate Flux MCP |
Image/video understanding | Yes (describe / classify / reason over image + video URLs) | No | No | No |
Image generation | Yes (text-to-image + image-to-image via | Yes (single | Yes (text/image-to-image, edit, inpaint) | Yes (single |
Video generation | Yes (text-to-video + image-to-video, async | No | Yes (text/image-to-video) | No |
Multi-provider backends | Yes (Gemini / OpenAI / Grok, auto-fallback) | No (EverArt only) | No (fal.ai only) | No (Replicate Flux only) |
Quality/cost tiers | Yes ( | No | No | No |
Self-hostable / open source | Yes (Apache-2.0, stdio + HTTP self-host) | Yes (MIT, archived) | Yes (MIT) | Yes (MIT, archived) |
Security
SSRF + LFI prevention -- All
media_urlsandreference_image_urlare validated at the dispatch boundary; onlyhttp://andhttps://schemes reach the providers.file://,ftp://,gopher://, and scheme-less URLs are rejected.No credentials in errors -- Provider-side errors are sanitized before being returned.
Degraded start -- Missing credentials do not prevent the server from starting; affected actions surface actionable errors instead of crashing at boot.
Credential storage -- Credentials submitted through the browser credential form are stored encrypted via
mcp-core(AES-GCM, machine-bound key) at~/.imagine-mcp/config.json.
Workspace username (HTTP setup form)
The browser credential form has an optional workspace username field. Entering
the same username always lands you in the same per-sub bucket, so your provider
keys stay reachable across a re-authorization and across devices, instead of being
tied to the one-off subject minted for each /authorize round-trip. Leaving it
blank keeps the previous per-authorize behaviour.
Trust boundary: when the form is gated by a shared MCP_RELAY_PASSWORD, the
username is a partition key, not a secret -- anyone who knows that password can
type any username and reach that bucket. That is fine for a trusted group; an
untrusted multi-tenant deployment needs a per-user secret or delegated OAuth
instead.
One-time migration: existing users must re-enter their credentials once after this change. Nothing is deleted; credentials stored under the old random subject are simply no longer addressed.
Build from Source
git clone https://github.com/n24q02m/imagine-mcp.git
cd imagine-mcp
mise run setup # or: uv sync --group dev
mise run dev # run the server in stdio mode (add --http for the HTTP daemon)Deploy to Cloudflare
Run your own imagine instance serverless on Cloudflare (Worker + Container + KV). Storage
is KV-only -- the per-user credential vault lives in KV, and generation returns base64 only
because the container filesystem is ephemeral (IMAGINE_OUTPUT_MODE=base64).
Prerequisites: a Cloudflare account on the Workers Paid plan -- required for Containers (the Cloudflare free tier does not include Containers) -- and the wrangler CLI.
git clone https://github.com/n24q02m/imagine-mcp && cd imagine-mcpwrangler loginCreate the KV namespace (imagine is KV-only -- no D1 or Vectorize), then paste the returned id into
wrangler.jsonc(the<imagine-kv-namespace-id>placeholder):wrangler kv namespace create imagine-kvPush the container image to your Cloudflare managed registry (CF Containers cannot pull from external registries directly), then set
<YOUR_ACCOUNT_ID>inwrangler.jsonc:docker pull ghcr.io/n24q02m/imagine-mcp:beta docker tag ghcr.io/n24q02m/imagine-mcp:beta imagine-mcp:beta wrangler containers push imagine-mcp:beta # prints registry.cloudflare.com/<ACCOUNT_ID>/imagine-mcp:betaPoint the remaining
wrangler.jsoncplaceholders at your own domain:<YOUR_PUBLIC_URL>(thevars.PUBLIC_URL, e.g.https://imagine.example.com) and<YOUR_WORKER_DOMAIN>(theroutescustom-domain pattern, e.g.imagine.example.com).Set secrets.
CREDENTIAL_SECRET(stable JWT signing key + per-user vault key) andMCP_DCR_SERVER_SECRET(proof of an intentional multi-user deploy) are required;MCP_RELAY_PASSWORDgates the browser setup form's login. Provider keys are optional server defaults -- users normally paste their own through the setup form instead:wrangler secret put CREDENTIAL_SECRET wrangler secret put MCP_DCR_SERVER_SECRET wrangler secret put MCP_RELAY_PASSWORD wrangler secret put GEMINI_API_KEY # optional provider default wrangler secret put OPENAI_API_KEY # optional provider default wrangler secret put XAI_API_KEY # optional provider defaultwrangler deploy, then open your Worker domain and finish setup in the browser relay form.
The http container image already runs multi-user (MCP_TRANSPORT=http is baked into the
image target). Storage maps to Cloudflare via MCP_STORAGE_BACKEND=cf-kv (encrypted
credential vault) with IMAGINE_OUTPUT_MODE=base64, which forces base64 responses so no
media path is written to the ephemeral container filesystem.
Deployment
The Cloudflare deployment is CD-managed: publishing a release triggers the
deploy-cf job in .github/workflows/cd.yml,
which checks out the released tag, builds the http-slim container image
tagged with the released version, pushes it to Cloudflare's managed registry,
deploys the Worker + Container stack, and gates on a canary -- a failed canary
fails the job rather than landing a bad deploy, so the live image always
corresponds to a released, immutable image tag. Hand-running wrangler deploy
against that deployment breaks the release-to-tag correspondence and is not
the supported path; to run your own instance instead, see
Deploy to Cloudflare.
The job is currently gated off: the repository Actions variable
CF_HOSTED_ENABLED is set to false, so releases do not auto-deploy and no
hosted endpoint is operated. Self-hosting (above) is the active HTTP path.
Trust Model
This plugin implements TC-Local (machine-bound, single trust principal). See mcp-core trust model for full classification.
Mode | Storage | Encryption | Who can read your data? |
stdio (default) |
| AES-GCM, machine-bound key | Only your OS user (file perm 0600) |
HTTP self-host | Same as stdio | Same | Only you (admin = user) |
Contributing
See CONTRIBUTING.md for the full development workflow, commit convention, and release process. Issues + Discussions welcome.
License
Apache-2.0 -- see LICENSE.
Available Tools
5 toolsconfigConfigBDestructive
Server config + credential setup (MERGED). Actions: (setup) setup_status|setup_skip|setup_reset|setup_complete|warmup (relay_status|relay_skip|relay_reset|relay_complete honored as deprecated aliases); (runtime) status|set|cache_clear. Use the config__open_relay tool to open the credential form.
| Name | Required | Description | Default |
|---|---|---|---|
| key | No | ||
| value | No | ||
| action | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations declare destructiveHint=true and readOnlyHint=false for the whole tool, but the description never says which actions mutate versus read, nor what setup_reset or cache_clear actually destroy. The only behavioral detail added is that relay_* names are honored as deprecated aliases. Given a blanket destructive annotation over mixed read/write actions, this leaves a meaningful gap.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Purpose is front-loaded, and the dense parenthetical/pipe notation packs the action list into minimal space. Some of the grouping syntax is harder to parse than plain prose, but nothing is padding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be explained, and the sibling routing is covered. Still, for a merged tool spanning ~11 actions, the absence of per-action behavior and of key/value semantics leaves an agent guessing about several invocations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must carry the load. It usefully enumerates the valid action strings (which the schema leaves as an unconstrained string), but never mentions 'key' or 'value' or which action consumes them, leaving two of three parameters undocumented anywhere.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific scope ('Server config + credential setup') and enumerates the exact action values, so an agent knows the tool is a multi-action config router. It also explicitly distinguishes itself from the sibling config__open_relay. It stops short of 5 because the individual actions are listed but never explained, so the purpose of each branch is opaque.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It groups actions into (setup) and (runtime) and explicitly routes the credential-form task to config__open_relay, which is real guidance. However, it gives no when-to-use guidance for choosing between setup_status, status, set, or cache_clear, and no prerequisites are stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
config__open_relayConfig Open RelayA
Get the relay configuration URL for imagine-mcp, opening it in the user's browser when possible. Returns the relay URL, whether the browser launched, and the current status.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that the browser may be opened and lists returned fields, but it does not cover prerequisites, authentication, or failure behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, well-structured sentence that front-loads the primary action and adds the side effect. Every phrase is relevant and there is no wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple zero-parameter interface and the existence of an output schema, the description provides enough context for the tool's purpose and side effect. It does not need to explain return values in depth, and the lack of explicit usage alternatives is a minor gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and the schema is empty, so there are no parameter semantics to document. The baseline for a zero-parameter tool is 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the specific action and resource: getting the relay configuration URL for imagine-mcp. It does not explicitly differentiate from the sibling config tool, but the relay-specific scope is evident from the tool name and description.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied by the relay configuration context, but the description offers no explicit guidance on when to use this versus config, help, or other siblings. The 'when possible' phrase describes browser behavior, not tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generateGenerateA
Generate an image or video from a text prompt. Video is async: first call returns job_id; call again with job_id to poll.
| Name | Required | Description | Default |
|---|---|---|---|
| tier | No | poor | |
| model | No | ||
| job_id | No | ||
| prompt | Yes | ||
| provider | No | ||
| media_type | Yes | ||
| output_mode | No | both | |
| aspect_ratio | No | 16:9 | |
| duration_seconds | No | ||
| reference_image_url | No |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false, idempotentHint=false, openWorldHint=true, so the safety profile is covered. The description usefully adds the async/polling behavior for video, which annotations cannot express, but omits significant behavioral traits such as cost/quality implications of the default 'poor' tier and any rate or duration limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the core action front-loaded and the polling caveat immediately after. Every clause carries information an agent needs; there is no filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Return values need not be explained because an output schema exists, and the async flow is described. However, for a 10-parameter, no-schema-description tool, the missing explanation of tier defaults, output modes, aspect ratios, and durations leaves the definition short of complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across 10 parameters, so the description carries the full burden and does not meet it. It only clarifies job_id (poll to resume) and media_type (image vs video), leaving tier, model, provider, output_mode, aspect_ratio, duration_seconds, and reference_image_url completely undefined.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Generate an image or video from a text prompt') and even subdivides by media type, so the agent knows exactly what the tool produces. It does not explicitly differentiate itself from the sibling tools (understand, help, config), but those are clearly different domains, so the risk of confusion is low.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear operational context for the video path: the first call returns a job_id and subsequent calls with job_id poll for completion. There is no explicit when-not guidance or comparison to alternatives, but no real alternative generation tool exists among the siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
helpHelpARead-onlyIdempotent
Full documentation. Topics: understand | generate | config.
| Name | Required | Description | Default |
|---|---|---|---|
| topic | No | understand |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, non-destructive and non-open-world, so the safety profile is fully covered. The description adds nothing beyond what the annotations provide — no note on output size, truncation, or how the documented topics relate to the sibling tools.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two terse fragments, front-loaded with the purpose and then the option set. No sentence is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, return values need no explanation, and there is only one optional parameter. The description covers the topic set adequately, but it never links those topics to the sibling tools an agent is choosing between, which is the main remaining gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the schema types the topic as a bare string with no enum, so the description's enumerated values ('understand | generate | config') are the only place the valid topic set is documented. It adds real meaning over the schema, though it omits the default and what each topic covers.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource: it returns 'full documentation' scoped by topic. The topic list maps directly onto the sibling tool names (understand, generate, config), which lets an agent connect this helper to those tools, though it never says so explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: listing 'understand | generate | config' as topics hints that an agent calls help to learn about those siblings, but there is no stated when-to-use, no when-not-to-use, and no explicit routing to an alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
understandUnderstandBRead-onlyIdempotent
Understand images and/or videos (multi-URL) with a prompt. Gemini supports mixed image+video in one call; OpenAI/Grok are image-only.
| Name | Required | Description | Default |
|---|---|---|---|
| tier | No | poor | |
| model | No | ||
| prompt | Yes | ||
| provider | No | ||
| max_tokens | No | ||
| media_urls | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
No output parameters | ||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, openWorld, and non-destructive behavior, so the safety profile is covered. The description adds provider capability constraints (mixed media on Gemini, image-only elsewhere), which is a genuine behavioral fact beyond the structured fields, but says nothing about limits or output behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two tight sentences with the core action front-loaded and the provider caveat immediately following. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values need not be described, and annotations cover safety. But for a 6-parameter tool with 0% schema coverage, the description leaves half the parameters unexplained (tier, model, provider, max_tokens), making it incomplete relative to the tool's actual surface.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% across 6 parameters. The description only clarifies that media_urls is multi-URL and that a prompt accompanies it; it says nothing about tier, model, provider, or max_tokens, leaving four parameters entirely undocumented in both the schema and the description.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a concrete verb (understand) and resource (images and/or videos with a prompt), and clarifies multi-URL input. It is clear on its own, though it never names or contrasts with the sibling 'generate', so the agent must infer the distinction between understanding and generating media.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It implicitly guides provider choice by noting Gemini handles mixed image+video while OpenAI/Grok are image-only, which is real usage context. However, it gives no guidance on when to use this tool versus 'generate' or any other sibling, leaving tool selection to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
v1.11.0- Added
help
1 tool update
v1.10.1- Removed
help
5 tool updates
v1.8.1- First observed
config - First observed
config__open_relay - First observed
generate - First observed
help - First observed
understand
TDQS
Scored across 5 tools
understand and generate are clearly distinct (analysis vs creation), and help is obviously documentation. However, config is heavily overloaded with merged setup/relay/runtime actions, and config__open_relay partially overlaps with config's relay setup actions, creating ambiguity about which tool to use for credential configuration.
understand, generate, help, and config follow a consistent single-word lowercase convention. config__open_relay uses a double-underscore namespace style that deviates from the others but is a predictable way to group config sub-tools.
Five tools is well-scoped for a media understanding/generation server covering the core operations plus docs and config. Each tool earns its place without bloat.
The surface covers analysis, generation, documentation, and configuration for images/videos, which is the core domain. Minor gaps exist around job/asset management beyond polling generate, but core workflows are covered.
Maintenance
Related MCP Connectors
MCP server for MiniMax H3 multimodal video generation
Focused MCP server for OpenAI image/audio generation (v2.0.0). Wraps endpoints via HAPI CLI.
MCP server for Google Veo AI video generation
MCP server for Qwen Image 3 AI image generation
Related MCP Servers
- AlicenseAqualityAmaintenanceUse XAI's latest api functionalities with Grok MCP. It supports image understanding and generation, live search, latest models and more.2252MIT
- AlicenseAqualityBmaintenanceMCP server for AI-powered image, audio, and video generation, enabling media creation directly from Claude, Cursor, and other MCP clients.1141 npmMIT
- AlicenseAqualityDmaintenanceMCP server for multi-provider AI image generation (AWS Bedrock, OpenAI, Google Gemini) enabling image generation, transformation, and editing through a unified interface.41MIT
- FlicenseBqualityDmaintenanceA production-ready MCP server that enables Claude and other LLMs to generate images and videos using Google's Gemini AI models (Gemini 2.0 Flash and Veo 2.0).32-