How do I use ImaginePro MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@ImaginePro MCP Server create a photorealistic image of a sunset over a mountain lake" 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.

ImaginePro MCP Server

by imaginpro

Overview Schema Related Servers Score Discussions

JavaScript

Remote

ImaginePro MCP Server

Build and Test npm version License: MIT Node.js Version

A fast and powerful MCP (Model Context Protocol) server that brings ImaginePro AI image and video generation capabilities to your AI assistants like Claude, enabling seamless creative content generation through natural language.

Major Improvements:

Automatic Completion Waiting: All generation tools now automatically wait for tasks to complete before returning results
Real-time Progress Updates: See generation progress in real-time during image and video creation
Fixed URL Mapping: Corrected image/video URL field mapping to ensure reliable access to generated content
Enhanced Response Data: All tools now return status and progress information for better tracking
Improved Error Handling: More descriptive error messages with standardized formatting

Breaking Changes: None - all changes are backward compatible!

Related MCP server: Pollinations Multimodal MCP Server

Why ImaginePro MCP?

🚀 Fast & Lightweight: Optimized for quick image and video generation
🎨 Comprehensive: Support for text-to-image, video generation, upscaling, variants, and inpainting
🔧 Easy Integration: Works with Claude Desktop, Claude Code, and any MCP-compatible tool
🎯 Production Ready: Built with TypeScript, full error handling, and robust API integration
📦 Simple Setup: Install with npx or npm in seconds

Features

Text-to-Image Generation: Create stunning AI images from text descriptions
Multi-modal Generation: Combine text and images for advanced generation (Gemini)
Video Generation: Create smooth video animations from start and end frames
Image Upscaling: Enhance image resolution and quality
Image Variants: Generate alternative versions of existing images
Image Rerolling: Regenerate images with the same prompt
Inpainting: Edit specific regions of images using masks
Status Tracking: Check the progress of generation tasks in real-time

Quick Start

Prerequisites

Node.js >= 18.0.0
An ImaginePro API key (sign up for free)
Claude Desktop, Claude Code, or any MCP-compatible tool

Installation

The ImaginePro MCP server can be installed in multiple ways depending on your tool and preference.

Option 1: Quick Install with npx (Recommended)

The easiest way to get started - no installation needed!

Claude Desktop

Add to your ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "imaginepro": {
      "command": "npx",
      "args": ["-y", "imaginepro-mcp-server"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Claude Code

Quick Install (Recommended):

# Set your API key first
export IMAGINEPRO_API_KEY="sk-your-api-key-here"

# Add the server with the API key
claude mcp add-json imaginepro '{"command":"npx","args":["-y","imaginepro-mcp-server"],"env":{"IMAGINEPRO_API_KEY":"'"$IMAGINEPRO_API_KEY"'"}}' -s local

Make your API key permanent:

echo 'export IMAGINEPRO_API_KEY="sk-your-api-key-here"' >> ~/.zshrc
source ~/.zshrc

Manual Configuration:

Edit your MCP settings:

{
  "mcpServers": {
    "imaginepro": {
      "command": "npx",
      "args": ["-y", "imaginepro-mcp-server"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Using Shell Environment Variable:

Configure without the env block:

{
  "mcpServers": {
    "imaginepro": {
      "command": "npx",
      "args": ["-y", "imaginepro-mcp-server"]
    }
  }
}

Then export in your shell:

export IMAGINEPRO_API_KEY="sk-your-api-key-here"

Note: The MCP configuration env block takes precedence over shell environment variables.

Other MCP Tools

For tools like Cursor, Goose, or LM Studio, use similar configuration:

{
  "imaginepro": {
    "command": "npx",
    "args": ["-y", "imaginepro-mcp-server"],
    "env": {
      "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
    }
  }
}

Install globally with npm:

npm install -g imaginepro-mcp-server

Then configure:

{
  "mcpServers": {
    "imaginepro": {
      "command": "imaginepro-mcp-server",
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

For development or customization:

git clone https://github.com/imaginpro/imaginepro-mcp-server.git
cd imaginepro-mcp-server
npm install
npm run build

Then configure:

{
  "mcpServers": {
    "imaginepro": {
      "command": "node",
      "args": ["/absolute/path/to/imaginepro-mcp-server/dist/index.js"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Codex

Add to ~/.codex/config.toml:

[mcp_servers.imaginepro]
command = "npx"
args = ["-y", "imaginepro-mcp-server"]

[mcp_servers.imaginepro.env]
IMAGINEPRO_API_KEY = "sk-your-api-key-here"

Get Your API Key

Sign up at imaginepro.ai
Navigate to your account settings
Generate an API key
Copy and use it in the configuration above

The ImaginePro MCP server works with many popular AI development tools. Below are specific configuration instructions for each client.

Cursor

Add to your Cursor settings (.cursor/config.json or via Settings UI):

{
  "mcpServers": {
    "imaginepro": {
      "command": "npx",
      "args": ["-y", "imaginepro-mcp-server"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Windsurf (Codeium)

{
  "mcpServers": {
    "imaginepro": {
      "command": "npx",
      "args": ["-y", "imaginepro-mcp-server"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Gemini CLI, VS Code, Goose, LM Studio, Warp Terminal, Amp

For most other MCP-compatible tools, use the standard configuration:

{
  "mcpServers": {
    "imaginepro": {
      "command": "npx",
      "args": ["-y", "imaginepro-mcp-server"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Note: Some tools may use slightly different config keys (e.g., mcp.servers for VS Code, amp.mcpServers for Amp). Refer to your tool's MCP documentation.

Tools Reference

The ImaginePro MCP server provides 8 powerful tools for AI image and video generation. All tools return structured responses with URLs to generated content.

Core Generation Tools

`generate-image`

Generate AI images from text descriptions using advanced text-to-image models.

Parameters:

prompt (string, required): Detailed description of the image to generate
ref (string, optional): Reference ID for tracking
webhookOverride (string, optional): Webhook URL for async notifications

Returns:

messageId: Unique identifier for the generated image
imageUrl: Direct URL to the generated image
status: Generation status (DONE, FAIL, etc.)
progress: Completion percentage (0-100)

Note: This tool now waits for the image to complete before returning (typically 30-60 seconds).

Example Usage:

Generate a photorealistic image of a serene mountain lake at sunrise, with mist rising from the water and pine trees reflected in the still surface

`gemini-imagine`

Generate images using multi-modal inputs, combining text prompts with existing images.

Parameters:

contents (array, required): Array of content items with type ('text' or 'image'), text, and url
model (string, optional): Model to use (default: gemini-2.5-flash-image-preview)
ref (string, optional): Reference ID for tracking
webhookOverride (string, optional): Webhook URL

Returns:

messageId: Unique identifier
imageUrl: Direct URL to the generated image
status: Generation status
progress: Completion percentage

Note: Automatically waits for completion before returning.

Example Usage:

Use this image [cat.jpg] and make the cat wearing a royal crown and sitting on a throne

`generate-video`

Create smooth video animations transitioning between two frames.

Parameters:

prompt (string, required): Description of the video transition/animation
startFrameUrl (string, required): URL of the starting frame image
endFrameUrl (string, required): URL of the ending frame image
ref (string, optional): Reference ID
webhookOverride (string, optional): Webhook URL

Returns:

messageId: Unique identifier
videoUrl: Direct URL to the generated video
status: Generation status
progress: Completion percentage

Note: Video generation takes longer (typically 1-3 minutes). The tool waits for completion.

Example Usage:

Create a smooth morphing video between sunset.jpg and night.jpg with a natural day-to-night transition

Image Enhancement Tools

`upscale-image`

Enhance image resolution and quality using AI upscaling.

Parameters:

messageId (string, required): Message ID of the image to upscale
ref (string, optional): Reference ID
webhookOverride (string, optional): Webhook URL

Returns:

messageId: New message identifier
imageUrl: URL to the upscaled image
status: Generation status
progress: Completion percentage

Note: Waits for upscaling to complete before returning.

Example Usage:

Upscale the image with message ID abc123 to higher resolution

`create-variant`

Generate alternative versions of an existing image with different styles or variations.

Parameters:

messageId (string, required): Message ID of the base image
ref (string, optional): Reference ID
webhookOverride (string, optional): Webhook URL

Returns:

messageId: New message identifier
imageUrl: URL to the variant image
status: Generation status
progress: Completion percentage

Note: Waits for variant generation to complete before returning.

Example Usage:

Create a variant of the image abc123

`reroll-image`

Regenerate an image using the same original prompt.

Parameters:

messageId (string, required): Message ID of the image to reroll
ref (string, optional): Reference ID
webhookOverride (string, optional): Webhook URL

Returns:

messageId: New message identifier
imageUrl: URL to the new image
status: Generation status
progress: Completion percentage

Note: Waits for regeneration to complete before returning.

Example Usage:

Reroll the image abc123 to get a different result

Image Editing Tools

`inpaint-image`

Edit specific regions of an image by providing a mask indicating areas to modify.

Parameters:

messageId (string, required): Message ID of the base image
maskUrl (string, required): URL of the mask image (white areas will be edited)
prompt (string, required): Description of what to generate in masked areas
ref (string, optional): Reference ID
webhookOverride (string, optional): Webhook URL

Returns:

messageId: New message identifier
imageUrl: URL to the inpainted image
status: Generation status
progress: Completion percentage

Note: Waits for inpainting to complete before returning.

Example Usage:

Inpaint the image abc123 using mask at mask.png and add a rainbow in the sky

Utility Tools

`fetch-status`

Check the real-time status and progress of any generation task.

Parameters:

messageId (string, required): Message ID to check status for

Returns:

status: Current status (pending, processing, completed, failed)
progress: Progress percentage (0-100)
imageUrl: URL of generated image (when ready)
videoUrl: URL of generated video (when ready)

Example Usage:

Check the status of generation task abc123

Usage Examples

Here are practical examples demonstrating different use cases with the ImaginePro MCP server.

Example 1: Simple Image Generation

Just describe what you want in natural language:

Generate an image of a cozy coffee shop interior with warm lighting, wooden furniture,
and customers reading books. Make it photorealistic.

The assistant will automatically:

Call generate-image with your prompt
Return the image URL and message ID
Display the result

Combine existing images with text descriptions:

I have this image of a cat at cat.jpg. Can you make it wearing a wizard hat
and holding a magic wand, maintaining the same artistic style?

Uses gemini-imagine to process both the image and your modification request.

Example 3: Video Generation Workflow

Create smooth video transitions:

I have two images: sunset-beach.jpg and night-beach.jpg.
Create a 5-second video showing the smooth transition from day to night.

Calls generate-video to create an animated transition between frames.

Example 4: Image Enhancement Pipeline

Complete workflow for refining images:

1. Generate an image of a fantasy castle
2. Create 3 variants to see different options
3. Upscale the best variant to higher resolution
4. Use inpainting to add dragons flying in the sky

This demonstrates chaining multiple tools together for a complete creative workflow.

Example 5: Async Status Tracking

Monitor long-running generations:

Check the status of my video generation task abc123

Uses fetch-status to monitor progress of asynchronous operations.

Environment Variables

Variable	Required	Default	Description
`IMAGINEPRO_API_KEY`	Yes	-	Your ImaginePro API key from imaginepro.ai
`IMAGINEPRO_BASE_URL`	No	`https://api.imaginepro.ai`	Custom API endpoint (for enterprise users)
`IMAGINEPRO_TIMEOUT`	No	`300000` (5 min)	Request timeout in milliseconds

Configuration Files

You can use a JSON configuration file instead of environment variables:

File locations (checked in order):

~/.imaginepro/config.json (global)
./.imaginepro.json (project-specific)

Example (~/.imaginepro/config.json):

{
  "apiKey": "sk-your-api-key-here",
  "baseUrl": "https://api.imaginepro.ai",
  "timeout": 300000
}

Priority: Environment variables > Config file > Defaults

Custom Timeout Example

For video generation or large batches:

{
  "mcpServers": {
    "imaginepro": {
      "command": "npx",
      "args": ["-y", "imaginepro-mcp-server"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key",
        "IMAGINEPRO_TIMEOUT": "600000"
      }
    }
  }
}

Prerequisites

Node.js >= 18.0.0
npm or yarn
TypeScript knowledge
An ImaginePro API key for testing

Setup

git clone https://github.com/imaginpro/imaginepro-mcp-server.git
cd imaginepro-mcp-server
npm install
npm run build

Commands

Command	Description
`npm run build`	Compile TypeScript to JavaScript
`npm run dev`	Watch mode - auto-rebuild on changes
`npm start`	Run the compiled server
`npm run clean`	Remove build artifacts

Testing with Claude Desktop

Point your config to your local build:

{
  "mcpServers": {
    "imaginepro-dev": {
      "command": "node",
      "args": ["/absolute/path/to/imaginepro-mcp-server/dist/index.js"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-test-key"
      }
    }
  }
}

Troubleshooting

Common Issues

"IMAGINEPRO_API_KEY environment variable is required"

Cause: The server couldn't find your API key.

Solutions:

Ensure your API key is set in the MCP configuration:

"env": {
  "IMAGINEPRO_API_KEY": "sk-your-actual-key"
}

Or export it in your shell before starting:

export IMAGINEPRO_API_KEY="sk-your-api-key"

Restart your MCP client (Claude Desktop, etc.) after changing configuration

"Failed to generate image" or API Errors

Possible causes and solutions:

Invalid API key: Verify your key at imaginepro.ai
Insufficient credits: Check your account balance
Network issues: Verify internet connection and firewall settings
Rate limiting: Wait a few moments and try again
Invalid parameters: Check that image URLs are accessible and prompts are valid

"Module not found" or Import Errors

For npm package installation:

npm install -g imaginepro-mcp-server

For local development:

cd imaginepro-mcp-server
npm install
npm run build

Server Not Responding

Check if the server is actually running (look for startup message in logs)
Verify the command path in your MCP configuration is correct
Ensure Node.js >= 18.0.0 is installed: node --version
Check MCP client logs for detailed error messages

"Command not found: imaginepro-mcp"

This happens when using global installation but the binary isn't in PATH.

Solution: Use npx instead:

{
  "command": "npx",
  "args": ["-y", "imaginepro-mcp-server"]
}

"spawn node ENOENT" or "Failed to connect" (Claude Code with nvm)

Cause: If you're using nvm (Node Version Manager), Claude Code cannot find the node executable because it doesn't inherit your shell's PATH.

Error in logs: spawn node /path/to/dist/index.js ENOENT

Solution: Use the full path to node in your configuration:

Find your node path:

which node
# Example output: /Users/username/.nvm/versions/node/v22.19.0/bin/node

Update your MCP configuration to use the full path:

{
  "mcpServers": {
    "imaginepro": {
      "command": "/Users/username/.nvm/versions/node/v22.19.0/bin/node",
      "args": ["/absolute/path/to/imaginepro-mcp-server/dist/index.js"],
      "env": {
        "IMAGINEPRO_API_KEY": "sk-your-api-key-here"
      }
    }
  }
}

Alternative: If using the published npm package with npx, this issue doesn't occur since npx handles the node executable automatically.

Getting Help

If you're still experiencing issues:

Check the logs: Most MCP clients provide detailed logs
Review examples: See the Usage Examples section
Open an issue: GitHub Issues
Contact support: ImaginePro Support

Contributing

We welcome contributions! Whether it's bug reports, feature requests, documentation improvements, or code contributions.

Quick Start

Fork and clone the repository
Create a feature branch: git checkout -b feature/amazing-feature
Make your changes and test them
Commit: git commit -m 'Add amazing feature'
Push: git push origin feature/amazing-feature
Open a Pull Request

Guidelines

Follow TypeScript best practices
Use clear, descriptive commit messages
Update documentation as needed
Test with Claude Desktop before submitting

Reporting Issues

Include:

Your environment (OS, Node version, MCP client)
Steps to reproduce
Expected vs actual behavior
Error messages and logs

Support & Links

ImaginePro API: imaginepro.ai | Support
GitHub Issues: Report bugs or request features
Documentation: Claude Code | MCP Protocol

License

MIT License - see LICENSE file for details.

Built with Model Context Protocol | Powered by ImaginePro AI

Available Tools

8 tools

create-variantCreate Image VariantB

Generate alternative versions of an existing image

ParametersJSON Schema

Name	Required	Description
`messageId`	Yes	Message ID of the base image
`ref`	No	Optional reference ID
`webhookOverride`	No	Optional webhook URL

Output Schema

ParametersJSON Schema

Name	Required	Description
`error`	No
`status`	No
`success`	Yes
`imageUrl`	No
`progress`	No
`messageId`	No

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool generates image variants but doesn't explain what 'alternative versions' means (e.g., style variations, size changes, content edits), whether this is a read-only or mutating operation, or any performance characteristics like rate limits or processing time.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy for an agent to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (which handles return values) and 100% schema coverage for parameters, the description's minimal approach is somewhat adequate. However, for a tool that likely involves image processing with behavioral nuances, more context about what 'alternative versions' entails would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional meaning about parameters beyond implying 'messageId' refers to an existing image. This meets the baseline of 3 when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Generate alternative versions') and resource ('of an existing image'), making the purpose immediately understandable. However, it doesn't distinguish this from sibling tools like 'reroll-image' or 'inpaint-image' that might also create variations, missing an opportunity for clearer differentiation.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'reroll-image' or 'inpaint-image'. It doesn't mention prerequisites (e.g., needing an existing image via 'messageId') or contextual constraints, leaving the agent to infer usage from the tool name and parameters alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

fetch-statusFetch Generation StatusB

Check the status of an image or video generation task

ParametersJSON Schema

Name	Required	Description	Default
`messageId`	Yes	Message ID to check status for

Output Schema

ParametersJSON Schema

Name	Required	Description
`error`	No
`status`	No
`success`	Yes
`imageUrl`	No
`progress`	No
`videoUrl`	No

TDQS

B3.2/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the action ('Check the status') but does not describe traits like whether this is a read-only operation, potential rate limits, error conditions, or what the status response includes (e.g., pending, completed, failed). This leaves significant gaps for an agent to understand the tool's behavior.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence that efficiently conveys the core purpose without unnecessary words. It is front-loaded and appropriately sized for the tool's functionality, with no wasted information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (a status check with one parameter) and the presence of an output schema (which handles return values), the description is reasonably complete. However, it lacks behavioral details (e.g., read-only nature, error handling) that would be beneficial for an agent, especially without annotations, slightly reducing completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, with the 'messageId' parameter documented as 'Message ID to check status for'. The description does not add any additional meaning beyond this, such as explaining where to obtain the messageId or its format. Given the high schema coverage, a baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('Check') and resource ('status of an image or video generation task'), making the purpose specific and understandable. However, it does not explicitly differentiate from potential sibling tools like 'create-variant' or 'reroll-image' that might also involve status checking, though those appear to be creation tools rather than status queries.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing a messageId from a prior generation task) or specify scenarios where this is the appropriate choice among the sibling tools, such as 'generate-image' for new tasks.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

gemini-imagineGemini Multi-modal Image GenerationB

Generate images using multi-modal inputs (text + images)

ParametersJSON Schema

Name	Required	Description
`contents`	Yes	Array of content items (text and/or images)
`model`	No	Model to use (default: gemini-2.5-flash-image-preview)
`ref`	No	Optional reference ID
`webhookOverride`	No	Optional webhook URL

Output Schema

ParametersJSON Schema

Name	Required	Description
`error`	No
`status`	No
`success`	Yes
`imageUrl`	No
`progress`	No
`messageId`	No

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool generates images but doesn't mention any behavioral traits such as rate limits, authentication needs, output format, or potential side effects (e.g., whether it modifies input images). This leaves significant gaps in understanding how the tool behaves beyond its basic function.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose ('Generate images') and specifies the input method. There is no wasted language or unnecessary elaboration, making it highly concise and well-structured for quick understanding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (multi-modal image generation with 4 parameters) and the presence of an output schema (which handles return values), the description is minimally adequate. However, with no annotations and incomplete behavioral context, it doesn't fully prepare an agent for safe and effective use, especially compared to sibling tools that might have overlapping functions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description adds no additional meaning beyond implying that 'contents' can include both text and images, which is already clear from the schema's enum and descriptions. This meets the baseline for high schema coverage without extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Generate images') and the input modality ('using multi-modal inputs (text + images)'), which distinguishes it from text-only generation tools. However, it doesn't explicitly differentiate from sibling tools like 'generate-image' or 'inpaint-image' that might also create images, leaving some ambiguity about when to choose this specific tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'generate-image' or 'inpaint-image' from the sibling list. It mentions multi-modal inputs but doesn't specify scenarios where text+image inputs are preferred over text-only or other methods, offering no usage context or exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate-imageGenerate ImageB

Generate an AI image from a text prompt using ImaginePro

ParametersJSON Schema

Name	Required	Description
`prompt`	Yes	Detailed description of the image to generate
`ref`	No	Optional reference ID for tracking
`webhookOverride`	No	Optional webhook URL for async notifications

Output Schema

ParametersJSON Schema

Name	Required	Description
`error`	No
`success`	Yes
`imageUrl`	No
`messageId`	No

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the core action ('Generate an AI image') but lacks details on permissions, rate limits, costs, async behavior (implied by 'webhookOverride' but not explained), or output format. For a generative tool with potential side effects, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence: 'Generate an AI image from a text prompt using ImaginePro.' It's front-loaded with the core purpose, has zero waste, and is appropriately sized for the tool's complexity. Every word earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (which handles return values), 100% schema coverage for inputs, and no annotations, the description is minimally adequate. However, it lacks context on behavioral traits (e.g., async processing, costs) and sibling differentiation, making it incomplete for optimal agent use despite the structured data support.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all three parameters ('prompt', 'ref', 'webhookOverride') with clear descriptions. The description adds no additional semantic context beyond implying the tool uses a 'text prompt,' which is redundant with the schema. Baseline 3 is appropriate as the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate an AI image from a text prompt using ImaginePro.' It specifies the verb ('Generate'), resource ('AI image'), and mechanism ('from a text prompt using ImaginePro'). However, it doesn't explicitly differentiate from siblings like 'gemini-imagine' or 'create-variant,' which might offer similar functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'gemini-imagine' (possibly another image generator), 'create-variant' (for modifying images), and 'reroll-image' (for regenerating), there's no indication of when this specific tool is preferred or what distinguishes it from others in the server.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate-videoGenerate VideoB

Generate a video animation from start and end frame images

ParametersJSON Schema

Name	Required	Description
`prompt`	Yes	Description of the video transition/animation
`startFrameUrl`	Yes	URL of the starting frame image
`endFrameUrl`	Yes	URL of the ending frame image
`ref`	No	Optional reference ID
`webhookOverride`	No	Optional webhook URL

Output Schema

ParametersJSON Schema

Name	Required	Description
`error`	No
`status`	No
`success`	Yes
`progress`	No
`videoUrl`	No
`messageId`	No

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions generating a video animation but fails to describe critical traits: whether this is a long-running process, if it requires authentication, rate limits, output format, or error handling. For a tool with 5 parameters and no annotations, this is a significant gap in transparency.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise—a single sentence that directly states the tool's core function. It's front-loaded with no wasted words, making it easy to parse quickly. Every part of the sentence contributes to understanding the purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (5 parameters, no annotations, but with an output schema), the description is minimally adequate. The output schema likely covers return values, reducing the need for that in the description. However, for a video generation tool with no behavioral context, the description should do more to explain process characteristics and usage scenarios to be fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description implies parameters like 'start and end frame images' but doesn't add meaningful semantics beyond what the schema provides. With 100% schema description coverage, the schema already documents all 5 parameters thoroughly. The description doesn't explain relationships between parameters (e.g., how 'prompt' relates to the frames) or usage nuances, so it meets the baseline without adding extra value.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate a video animation from start and end frame images.' This specifies the action (generate), resource (video animation), and key inputs (frame images). However, it doesn't differentiate from sibling tools like 'generate-image' or 'create-variant' beyond mentioning 'video animation,' leaving some ambiguity about its unique role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'generate-image' and 'create-variant' available, there's no indication of scenarios where this tool is preferred, prerequisites, or exclusions. This lack of context makes it harder for an agent to choose appropriately.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

inpaint-imageInpaint ImageB

Edit specific regions of an image using a mask

ParametersJSON Schema

Name	Required	Description
`messageId`	Yes	Message ID of the base image
`maskUrl`	Yes	URL of the mask image (white areas will be edited)
`prompt`	Yes	Description of what to generate in masked areas
`ref`	No	Optional reference ID
`webhookOverride`	No	Optional webhook URL

Output Schema

ParametersJSON Schema

Name	Required	Description
`error`	No
`status`	No
`success`	Yes
`imageUrl`	No
`progress`	No
`messageId`	No

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Edit' implies mutation, it doesn't specify what kind of editing occurs, whether it's destructive to the original image, what permissions are required, or how the editing process works. The description lacks critical behavioral context for an image editing operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise at just 8 words, front-loading the core functionality with zero wasted words. Every element ('Edit specific regions', 'image', 'using a mask') contributes essential information about the tool's purpose and method.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that there's an output schema (which handles return values) and 100% schema description coverage, the description is reasonably complete for its length. However, for an image editing tool with no annotations and multiple sibling tools, it should provide more context about when to use it and what the editing entails.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value beyond what's in the schema - it mentions 'mask' which relates to 'maskUrl' and 'specific regions' which relates to the editing concept, but doesn't provide additional semantic context about parameter relationships or usage patterns.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Edit specific regions') and resource ('image') using a specific method ('using a mask'). It distinguishes from siblings like 'create-variant' or 'generate-image' by focusing on editing existing images with masks rather than creating new ones. However, it doesn't explicitly differentiate from 'reroll-image' or 'upscale-image' which might also involve image modification.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'create-variant', 'reroll-image', and 'upscale-image' that might also modify images, there's no indication of when inpaint-image is appropriate versus those other tools. No prerequisites or exclusions are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

reroll-imageReroll ImageB

Regenerate an image using the same prompt

ParametersJSON Schema

Name	Required	Description
`messageId`	Yes	Message ID of the image to reroll
`ref`	No	Optional reference ID
`webhookOverride`	No	Optional webhook URL

Output Schema

ParametersJSON Schema

Name	Required	Description
`error`	No
`status`	No
`success`	Yes
`imageUrl`	No
`progress`	No
`messageId`	No

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits such as whether this is a read/write operation, rate limits, authentication needs, or what 'regenerate' entails (e.g., creates a new image, modifies existing). This leaves significant gaps for a tool that likely involves mutation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (which handles return values) and 100% schema coverage, the description is minimally adequate. However, for a mutation tool with no annotations, it should provide more behavioral context (e.g., side effects, permissions) to be fully complete, leaving room for improvement.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents parameters. The description adds no meaning beyond the schema, as it doesn't explain how 'messageId' relates to the image or what 'reroll' implies for parameters. Baseline 3 is appropriate since the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Regenerate') and resource ('image'), specifying it uses the same prompt. However, it doesn't differentiate from sibling tools like 'create-variant' or 'generate-image', which might have overlapping functionality.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'create-variant' or 'generate-image'. It lacks context about prerequisites (e.g., needing an existing image) or exclusions, leaving the agent to infer usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

upscale-imageUpscale ImageB

Enhance image resolution and quality

ParametersJSON Schema

Name	Required	Description
`messageId`	Yes	Message ID of the image to upscale
`ref`	No	Optional reference ID
`webhookOverride`	No	Optional webhook URL

Output Schema

ParametersJSON Schema

Name	Required	Description
`error`	No
`status`	No
`success`	Yes
`imageUrl`	No
`progress`	No
`messageId`	No

TDQS

B3.1/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'enhance resolution and quality' but lacks details on how the enhancement works (e.g., AI upscaling, interpolation), potential side effects (e.g., file size increase, quality loss), rate limits, or authentication needs. This is inadequate for a tool that likely performs a non-trivial operation.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence with no wasted words. It is front-loaded with the core purpose, making it easy to scan and understand quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's moderate complexity (image processing), no annotations, and an existing output schema (which handles return values), the description is minimally adequate. However, it lacks context on behavioral aspects like how enhancement is performed or error conditions, leaving gaps for an AI agent to fully understand the tool's operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% description coverage, so parameters are well-documented in the schema itself. The description adds no additional meaning beyond implying that 'messageId' refers to an image, which is already clear from the schema. This meets the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description 'Enhance image resolution and quality' clearly states the tool's function with specific verbs ('enhance') and resource ('image'), distinguishing it from siblings like 'inpaint-image' or 'generate-image'. However, it doesn't explicitly differentiate from 'create-variant' or 'reroll-image', which might also involve image modifications, keeping it from a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives like 'create-variant' or 'reroll-image', nor does it mention prerequisites such as needing an existing image message ID. It only states what the tool does, not when or why to invoke it.

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. Dates show when Glama detected each change.

8 tool updatesJan 26, 2026
- First observedcreate-variant
- First observedfetch-status
- First observedgemini-imagine
- First observedgenerate-image
- First observedgenerate-video
- First observedinpaint-image
- First observedreroll-image
- First observedupscale-image

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.4/5.0

Disambiguation4/5

Most tools have distinct purposes, but 'gemini-imagine' and 'generate-image' could cause confusion as both generate images from text prompts. The other tools target clearly different operations like upscaling, inpainting, and video generation.

Naming Consistency3/5

The naming is mixed with hyphenated and underscore styles, and verbs vary (e.g., 'create-variant' vs. 'generate-image'). However, all names are readable and follow a general verb-noun pattern, though not uniformly applied.

Tool Count5/5

With 8 tools, this is well-scoped for an image/video generation server. Each tool addresses a specific need in the creative workflow, from generation to editing and status checking, without being overwhelming.

Completeness4/5

The toolset covers core operations like generation, editing, upscaling, and status tracking. A minor gap is the lack of a tool for deleting or managing generated assets, but the provided tools support most common workflows effectively.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

Need Help?

Reddit Discussion

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Avocado AI
io.github.Wandersonjack
Generate AI images, videos, music, SFX & speech in any AI assistant. Results appear inline in chat.
AI & Machine Learning Image & Video Processing Marketing
2
fengyinxia-jimeng-mcp
ai.smithery
Create images and videos from prompts, with options for image mixing, reference images, and start/…
Image & Video Processing Multimedia Processing
2
AI Media StudioOAuth
ai.b77
Generate images, videos, voiceovers, and captions from a chat prompt.
AI & Machine Learning Image & Video Processing Audio Processing
1
mcp A
online.editclips
Video, audio, and image processing for AI agents: convert, transcribe, upscale - 150+ operations.
Multimedia Processing Audio Processing Image & Video Processing
51

Related MCP Servers

Gemini Image Generator MCP
Image & Video Processing Autonomous Agents
qhdrl12
A
license
A
quality
D
maintenance
Allows AI assistants to generate and transform high-quality images from text prompts using Google's Gemini model via the MCP protocol.
Updated 6 months ago (2026-03-15 15:36 UTC)
3
34
MIT
Pollinations Multimodal MCP
Image & Video Processing Text-to-Speech Multimedia Processing
tusharpatil2912
A
license
B
quality
D
maintenance
Enables AI assistants to generate images, text, and audio content through the Pollinations APIs. Provides direct access to multimodal generation capabilities including image creation from text prompts, text-to-speech, and text generation.
Updated a year ago (2025-08-16 07:47 UTC)
12
134
MIT
MCP OpenAI Image Generation
Image & Video Processing App Automation
LupinLin1
A
license
Not graded
quality
Not graded
maintenance
Enables AI assistants to generate and edit images through OpenAI's DALL-E models via MCP tools. Supports text-to-image generation and image-to-image editing with configurable parameters for size, quality, and style.
Updated a year ago (2025-08-31 10:04 UTC)
-
sora-mcp-server
AI & Machine Learning Image & Video Processing
Porkbutts
A
license
A
quality
D
maintenance
Enables AI assistants to generate, manage, and download AI-generated videos using OpenAI's Sora models, supporting text prompts, image-to-video, remixing, and more.
Updated 8 months ago (2026-01-12 04:46 UTC)
9
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/imaginpro/imaginepro-mcp-server'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

ImaginePro MCP Server

Table of Contents

Why ImaginePro MCP?

Features

Quick Start

Prerequisites

Installation

Option 1: Quick Install with npx (Recommended)

Claude Desktop

Claude Code

Other MCP Tools

Codex

Get Your API Key

Cursor

Windsurf (Codeium)

Gemini CLI, VS Code, Goose, LM Studio, Warp Terminal, Amp

Tools Reference

Core Generation Tools

generate-image

gemini-imagine

generate-video

Image Enhancement Tools

upscale-image

create-variant

reroll-image

Image Editing Tools

inpaint-image

Utility Tools

fetch-status

Usage Examples

Example 1: Simple Image Generation

Example 2: Multi-Modal Image Editing

Example 3: Video Generation Workflow

Example 4: Image Enhancement Pipeline

Example 5: Async Status Tracking

Environment Variables

Configuration Files

Custom Timeout Example

Prerequisites

Setup

Commands

Testing with Claude Desktop

Troubleshooting

Common Issues

"IMAGINEPRO_API_KEY environment variable is required"

"Failed to generate image" or API Errors

"Module not found" or Import Errors

Server Not Responding

"Command not found: imaginepro-mcp"

"spawn node ENOENT" or "Failed to connect" (Claude Code with nvm)

Getting Help

Contributing

Quick Start

Guidelines

Reporting Issues

Support & Links

License

Available Tools

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Output Schema

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

`generate-image`

`gemini-imagine`

`generate-video`

`upscale-image`

`create-variant`

`reroll-image`

`inpaint-image`

`fetch-status`