# Image Router MCP MCP > Image Router MCP automatically routes your image generation requests to the best available AI model based on specific prompts, required style, or quality needs. This eliminates manual API selection and ensures you use the right backend for realism, artistic flair, or high-resolution output, managing everything from initial creation to final upscaling. ## Overview - **Category:** industry-titans - **Price:** Free - **Tags:** generative-ai, image-generation, model-aggregation, prompt-engineering, stable-diffusion, dall-e ## Description You're dealing with multiple image generation APIs—DALL-E here, Stable Diffusion there. Trying to pick the right model every time is a massive waste of cycles. This MCP solves that. It acts as an intelligent dispatcher for your visuals. You give it a prompt and some constraints (like desired aspect ratio or specific artistic style), and it figures out which underlying model works best to deliver the required output. Beyond initial creation, you can use this connector to modify existing assets with text descriptions, boost resolution, or even create variations of what you just made. It’s all managed through one interface. If your team is building a complex visual pipeline, connecting Image Router via Vinkius gives your agent instant access to an entire catalog of image generation capabilities. ## Tools ### check_imagerouter_status Verifies the connectivity and operational health of the Image Router MCP. ### edit_image Changes specific parts of an existing image based on a new text description. ### generate_image_advanced Generates images while providing full control over size, seed, and negative prompts. ### generate_image Creates an initial image asset using standard parameters from a text prompt. ### generate_variation Creates a new image that is visually similar to an existing one, but with minor changes. ### get_model Retrieves detailed information about a specific underlying AI model. ### get_generation_status Checks the real-time progress of any running or queued image generation job. ### list_models_by_category Filters and lists the available models based on a defined category, like 'realism' or 'artistic'. ### list_models Lists every available AI engine that can be used for image generation. ### list_styles Provides a list of pre-defined artistic styles that can be applied to any generated image. ### upscale_image Increases the resolution and detail level of an existing image asset. ## Prompt Examples **Prompt:** ``` Generate an image of a futuristic city at sunset. ``` **Response:** ``` Image generated! 1024x1024 using Stable Diffusion XL. The scene shows towering glass buildings with warm golden light reflecting off surfaces. ``` **Prompt:** ``` List all available image models. ``` **Response:** ``` 18 models available: Stable Diffusion XL, DALL-E 3, Playground v2.5, DreamShaper XL, and 14 more. Filter by category for specific styles. ``` **Prompt:** ``` Upscale this image to 2x resolution. ``` **Response:** ``` Image upscaled from 512x512 to 1024x1024. Details enhanced with AI super-resolution. ``` ## Capabilities ### Generate images from text Create brand new visuals just by writing out a description. ### Advanced visual creation Control the core parameters of generation, including size, random seed values, and negative prompts to guide the AI away from bad results. ### Modify existing images Edit an image you already have by supplying a text prompt describing the change. ### Increase resolution Take a generated image and upscale it to boost its pixel density without losing quality. ### Find available models Check which underlying AI engines (like DALL-E or SDXL) are currently connected and running through the MCP. ## Use Cases ### Need an ad asset in three styles. A marketing engineer needs one core image concept rendered, but it must be available as a photorealistic shot, a watercolor painting, and a cyberpunk sketch. They call the MCP once; it uses `list_styles` to identify the options and then calls `generate_image` multiple times with different style parameters. ### The initial render was too small. A developer generates an image using `generate_image`, but realizes the final display needs 4K resolution. Instead of re-prompting, they immediately follow up by calling `upscale_image` on the output to boost pixel count. ### The prompt was good, but the detail is lacking. A user generates a basic image and wants more depth. They use `generate_variation` or explicitly call `edit_image`, passing in a targeted instruction like 'Add smoke rising from the ground' to guide the revision. ### Pipeline needs continuous monitoring. An automated workflow starts several large image jobs. Instead of waiting for a timeout, it periodically calls `get_generation_status` until all assets are marked as complete before proceeding with post-processing steps. ## Benefits - Get fine-grained control over the output. Instead of just generating an image, you can use `generate_image_advanced` to set specific seeds and negative prompts, which is critical when you need predictable results for a UI element. - Handle complex assets in one go. If your pipeline requires boosting resolution after generation, you don't switch tools; you call `upscale_image` right after the initial asset creation step. - Speed up development cycles by automating model choice. You avoid hardcoding which API to hit for a specific style; the MCP handles that routing logic for you. - Manage visual assets end-to-end. From initial generation with `generate_image` to checking its progress using `get_generation_status`, the entire workflow is tracked and managed. - Discover what's available instantly. Use `list_models` or `list_models_by_category` to quickly determine if a specific required style (e.g., 'vintage') is supported by any connected backend. ## How It Works The bottom line is: you stop worrying about which API to call and just focus on what visual outcome you need. 1. Your agent calls the Image Router MCP, passing a text prompt and specifying any constraints (e.g., 'ultra-realistic,' or 'comic book style'). 2. The MCP evaluates the request against its internal routing logic—checking model suitability, available styles, and parameter requirements. 3. It executes the job on the optimal backend model and returns the generated image asset, along with metadata like size and model used. ## Frequently Asked Questions **How do I know if an image generation job is finished using generate_image? (get_generation_status)** You use `get_generation_status` to poll the job's status. This tool lets your agent check asynchronously if the asset you requested has completed processing, which prevents pipeline failures due to timeouts. **Which tool do I use for high-resolution images? (upscale_image)** `upscale_image` is the specific function for boosting an image's pixel count. It takes a finished asset and enhances its detail, making it suitable for print or large display. **Can I generate images with advanced settings? (generate_image_advanced)** Yes. `generate_image_advanced` lets you define parameters like the random seed value and negative prompts. This is critical when you need to reproduce a specific visual result or exclude unwanted artifacts. **How do I find out what image styles are available? (list_styles)** You call `list_styles`. This tool returns the names of pre-defined artistic styles, allowing you to specify them in subsequent generation calls for consistent output. **How do I check if my Image Router account is properly connected before running a job using check_imagerouter_status?** You run the check_imagerouter_status tool. It confirms your API key and connectivity are active, which prevents failed generation jobs and saves you time. **If I have an image but need to change specific elements in it, what does the edit_image function do?** The edit_image tool lets you modify existing visual assets. You provide the source image and a text description of the changes you want, and it handles the rest. **I like an initial image, but I need a few slight aesthetic changes; how do I use generate_variation?** The generate_variation tool takes your original image and creates several highly similar alternatives. This is useful for exploring subtle artistic differences without starting the entire generation process over. **Before generating, how can I check the specific capabilities or limitations of a model using get_model?** Use the get_model tool to retrieve detailed specs for any available image model. This lets you confirm things like native resolution limits or required parameters before submitting your request. **Can my AI generate images from text?** Yes. `generate_image` creates images from any text prompt using AI models like Stable Diffusion. **Can I upscale or create variations?** Yes. `upscale_image` increases resolution and `generate_variation` creates visual alternatives of an existing image. **How do I browse available models?** Use `list_models` for all models or `list_models_by_category` to filter by style category.