Openrouter-Nano-banana-assets-generator-MCP
Provides a GitHub Copilot Agent Skill for generating and editing web assets using OpenRouter's Nano Banana Pro model, allowing natural language commands for asset creation.
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., "@Openrouter-Nano-banana-assets-generator-MCPGenerate a set of modern icons for my landing page"
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.
OpenRouter Nano Banana Pro Assets Generator
A powerful asset generation solution that leverages OpenRouter's Nano Banana Pro (Google Gemini 3 Pro Image Preview) for professional web asset generation and editing.
Available as both a Model Context Protocol (MCP) server and a GitHub Copilot Agent Skill (following the official GitHub specification).
Overview
This project enables AI assistants to generate high-quality web assets, asset packs, and perform advanced image editing while maintaining brand consistency. It uses Nano Banana Pro, Google's most advanced image-generation and editing model built on Gemini 3 Pro.
Two Ways to Use
GitHub Copilot Agent Skill - Official GitHub Copilot agent skill that loads automatically when you need asset generation
MCP Server - A full Model Context Protocol server for MCP-compatible clients
Key Features
šØ Professional Asset Generation: Create icons, banners, backgrounds, UI elements, and more
š¦ Asset Pack Creation: Generate cohesive sets of related assets with consistent branding
āļø Advanced Image Editing: Fine-grained controls for lighting, focus, localized edits, and transformations
šÆ Brand Consistency: Maintain visual identity across multiple assets with identity preservation
š¼ļø Multi-Modal Input: Support for reference images, color palettes, and logo files
š Flexible Formats: Multiple aspect ratios (1:1, 16:9, 9:16, 21:9, etc.) and resolutions (up to 4K)
š Web-Optimized: Assets designed specifically for web development workflows
Related MCP server: Nano-Banana MCP Server
š Required: OpenRouter API Key
This skill requires an OpenRouter API key to function. Get yours at openrouter.ai.
For GitHub Copilot coding agent: Add your API key as a repository secret named OPENROUTER_API_KEY.
ā Setup Instructions
For local development: Set the OPENROUTER_API_KEY environment variable.
ā Setup Instructions
Quick Start
Choose your preferred method:
Option 1: GitHub Copilot Agent Skill (Recommended)
The GitHub Copilot Agent Skill is automatically loaded by GitHub Copilot when you need asset generation.
For GitHub Copilot Coding Agent
Add your API key to the copilot environment:
Go to: Settings ā Environments ā copilot
Under "Environment secrets," click Add environment secret
Name:
OPENROUTER_API_KEYSecret: Your OpenRouter API key from openrouter.ai
Use with GitHub Copilot coding agent:
Just ask naturally when working on a PR or in your repository:
"Generate a modern home icon for my website" "Create a hero banner with blue and purple gradient" "I need a social media kit for my brand"Copilot automatically:
Loads your API key from the copilot environment
Uses the skill in
.github/skills/nano-banana-assets/Generates your assets!
For Local Development / VS Code
Set your API key locally:
# Run the interactive setup script ./setup-api-key.sh # Or manually set it in your shell export OPENROUTER_API_KEY="your-api-key-here"Test the skill:
cd .github/skills/nano-banana-assets/scripts python generate_asset.py "Test icon" "1:1" "512x512"
š Full Agent Skill Documentation ā
š Copilot Usage Guide ā
Option 2: MCP Server
The MCP Server provides dedicated tools for MCP-compatible clients like Claude Desktop.
Set your API key:
export OPENROUTER_API_KEY="your-api-key-here"Install dependencies:
npm install npm run buildSet your API key:
export OPENROUTER_API_KEY="your-api-key-here"Configure MCP client (e.g., Claude Desktop):
MacOS:
~/Library/Application Support/Claude/claude_desktop_config.json
Windows:%APPDATA%/Claude/claude_desktop_config.json{ "mcpServers": { "nano-banana-assets": { "command": "node", "args": ["/absolute/path/to/openrouter-nano-banana-mcp/dist/index.js"], "env": { "OPENROUTER_API_KEY": "your-api-key-here" } } } }
Get your API key from OpenRouter.
Comparison: Agent Skill vs MCP Server
Feature | Agent Skill | MCP Server |
Installation | Copy directory | npm install + build |
Configuration | Environment variable | MCP client config |
Platform Support | All Agent Skills-compatible platforms | MCP-compatible clients |
Portability | Highly portable | Requires Node.js |
Usage | Natural language | Tool calls |
Maintenance | Minimal | Standard npm package |
Use Agent Skill when:
You want maximum portability
You're using multiple AI platforms
You prefer minimal setup
Use MCP Server when:
You're already using MCP clients
You want structured tool calls
You prefer the MCP ecosystem
Both provide the same capabilities and quality!
Available Capabilities
1. generate_asset
Generate a single web asset with full control over style, format, and branding.
Parameters:
prompt(required): Detailed description of the assetaspectRatio: "1:1", "16:9", "9:16", "4:3", "21:9", etc.resolution: "1920x1080", "2K", "4K", etc.referenceImages: Array of image URLs for style guidance (max 5)colorPalette: Array of hex color codeslogoFile: Logo URL or base64 dataeditInstructions: Optional editing instructions
Example:
Generate a hero banner with:
- Prompt: "Modern tech startup hero banner with gradient background"
- Aspect Ratio: 16:9
- Resolution: 1920x1080
- Color Palette: ["#667EEA", "#764BA2"]2. generate_asset_pack
Create a complete set of related assets with consistent branding.
Parameters:
description(required): Overall purpose of the asset packassetTypes(required): Array of asset types to generatebrandGuidelines: Brand style requirementsreferenceImages: Reference images for visual stylecolorPalette: Brand color palettelogoFile: Brand logoaspectRatio: Default aspect ratioresolution: Default resolution
Example:
Generate an asset pack with:
- Description: "Social media kit for eco-friendly brand"
- Asset Types: ["instagram-post", "facebook-cover", "twitter-header", "icon-set"]
- Brand Guidelines: "Minimalist, nature-inspired, clean aesthetics"
- Color Palette: ["#2ECC71", "#27AE60", "#F1C40F"]3. edit_asset
Edit existing assets with advanced controls.
Parameters:
sourceImage(required): Image URL or base64 dataeditInstructions(required): Detailed editing instructionspreserveElements: Elements to keep unchangedaspectRatio: Target aspect ratioresolution: Target resolution
Example:
Edit an asset with:
- Source Image: [URL or base64]
- Edit Instructions: "Adjust lighting to be warmer, increase contrast, soften shadows"
- Preserve Elements: ["logo", "text"]4. ensure_brand_consistency
Analyze assets for brand consistency and get recommendations.
Parameters:
assets(required): Array of asset URLs to analyzebrandGuidelines(required): Brand guidelinesreferenceImages: Brand reference imagescolorPalette: Official brand colorslogoFile: Official logo
Example:
Check consistency of:
- Assets: [multiple URLs]
- Brand Guidelines: "Modern, professional, use primary blue #667EEA"
- Color Palette: ["#667EEA", "#764BA2", "#FFFFFF"]Model Capabilities
Nano Banana Pro (via OpenRouter) offers:
Advanced Multimodal Reasoning: Understands context from reference images, logos, and descriptions
High-Fidelity Visual Synthesis: Professional-quality outputs suitable for production
Text Rendering: Industry-leading text placement in images with multilingual support
Identity Preservation: Consistent styling across multiple assets (up to 5 subject references)
Fine-Grained Controls: Localized edits, lighting adjustments, focus control, camera transformations
Flexible Output: Support for multiple aspect ratios (1:1, 16:9, 9:16, 21:9, etc.)
Search Grounding: Real-time information integration for context-rich graphics
Base64 Image Output: Generated images are returned as base64-encoded data URLs
How It Works
The server uses OpenRouter's image generation API with the following key features:
Modalities: Requests specify
["image", "text"]to enable image generationImage Configuration: Aspect ratios are passed via
image_config.aspect_ratioReference Images: Input images are provided as URLs or base64 data for style guidance
Response Format: Generated images are returned in the
message.imagesarray as base64 data URLsMultiple Outputs: The model can generate multiple variations or asset types in a single request
Use Cases
Web Development: Generate UI components, icons, backgrounds, and layouts
Brand Identity: Create consistent asset packs for marketing materials
Product Design: Visualize products and create mockups
Content Creation: Social media graphics, blog headers, and promotional materials
Prototyping: Quick generation of design concepts and variations
Asset Management: Edit and refine existing assets while maintaining brand consistency
Technical Details
MCP Server
Model:
google/gemini-3-pro-image-previewvia OpenRouterAPI Endpoint:
https://openrouter.ai/api/v1/chat/completionsProtocol: Model Context Protocol (MCP)
Transport: stdio
Runtime: Node.js with TypeScript
Image Format: Base64-encoded data URLs (PNG)
Modalities:
["image", "text"]for image generation capabilities
Agent Skill
Standard: Agent Skills specification v1.0
Format: SKILL.md with YAML frontmatter + Markdown instructions
Compatibility: All Agent Skills-compatible platforms
Scripts: Bash and Python helper scripts included
Documentation: Comprehensive references and templates
Requirements: OpenRouter API key, internet access
API Implementation
The server implements OpenRouter's multimodal image generation API:
{
model: "google/gemini-3-pro-image-preview",
messages: [{ role: "user", content: [...] }],
modalities: ["image", "text"],
image_config: {
aspect_ratio: "16:9" // Configurable
}
}Response format:
{
choices: [{
message: {
content: "...", // Text description
images: [{ // Generated images
image_url: { url: "data:image/png;base64,..." }
}]
}
}]
}Development
MCP Server Development
# Install dependencies
npm install
# Build
npm run build
# Watch mode for development
npm run watch
# Test
npm run testAgent Skill Development
The Agent Skill is ready to use - no build step required! To modify:
Edit
nano-banana-assets-skill/SKILL.mdfor instructionsUpdate scripts in
nano-banana-assets-skill/scripts/as neededAdd reference materials to
nano-banana-assets-skill/references/Test with a compatible AI agent
Project Structure
.
āāā src/ # MCP server source code
ā āāā index.ts # Main server implementation
āāā dist/ # Built MCP server
ā āāā index.js # Compiled server
āāā nano-banana-assets-skill/ # Agent Skill (portable)
ā āāā SKILL.md # Main skill definition
ā āāā README.md # Skill documentation
ā āāā scripts/ # Helper scripts
ā ā āāā generate_asset.sh # Bash helper
ā ā āāā generate_asset.py # Python helper
ā āāā references/ # Reference docs
ā ā āāā api-reference.md # API documentation
ā ā āāā prompt-templates.md # Prompt examples
ā āāā assets/ # Example assets
āāā README.md # This file
āāā EXAMPLES.md # Usage examples
āāā CONFIG.md # Configuration guide
āāā QUICKSTART.md # Quick start guide
āāā package.json # npm package configRequirements
For MCP Server
Node.js 18 or higher
OpenRouter API key
MCP-compatible client (e.g., Claude Desktop)
For Agent Skill
OpenRouter API key
Agent Skills-compatible AI platform
Internet access
(Optional) Python 3.10+ for Python scripts
Documentation
Agent Skill Documentation - Complete guide to using the Agent Skill
Quick Start Guide - Get started quickly with MCP server
Examples - Detailed usage examples
Configuration - Configuration options
API Reference - API documentation
License
MIT
Contributing
Contributions are welcome! Please feel free to submit issues or pull requests.
Acknowledgments
Built with Model Context Protocol SDK
Follows Agent Skills specification
Powered by OpenRouter
Uses Google's Nano Banana Pro (Gemini 3 Pro Image Preview)
Available Tools
4 toolsedit_assetB
Edit an existing asset with fine-grained controls. Supports localized edits, lighting adjustments, focus changes, camera transformations, and more using Nano Banana Pro's advanced editing capabilities.
| Name | Required | Description | Default |
|---|---|---|---|
| resolution | No | Target resolution if upscaling/downscaling needed | |
| aspectRatio | No | Target aspect ratio if different from source | |
| sourceImage | Yes | Source image URL or base64-encoded data URL to edit | |
| editInstructions | Yes | Detailed editing instructions (e.g., 'Adjust lighting to be warmer, increase contrast, blur background') | |
| preserveElements | No | Elements to preserve during editing (e.g., ['logo', 'text', 'main-subject']) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits itself. It describes the knd of edits supported but not whether the original asset is replaced, what gets returned, or any constraints/limitations of Nano Banana Pro. It does not contradict any annotations because none are present, but it leaves important operational behavior underspecified.
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 sentence that front-loads the action and object, then expands with a concise list of supported edits. 'And more' is mildly vague but does not inflate the description or waste space.
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?
The tool is moderately complex with no output schema and no annotations, so the description should cover the output/response behavior and any crucial side effects. It does not say what the edited asset result is or whether the source is modified in place. The rich schema compensates for parameter understanding but not for the missing behavioral contract.
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 coverage is 100%, so the schema already explains all five parameters, including the purpose of sourceImage, editInstructions, resolution, aspectRatio, and preserveElements. The description adds general capability context but not parameter-level meaning, so the baseline 3 is appropriate.
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 uses a specific verb-and-resource structure: 'Edit an existing asset', and the resource is clearly distinguished from the sibling generation tools. The listed capabilities (lighting, focus, camera transformations) make the purpose tangible, though it does not explicitly contrast itself with ensure_brand_consistency.
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?
The phrase 'existing asset' implies this tool is for modification rather than generation, giving some implicit guidance against the generate siblings. However, it never explicitly states when to prefer this tool over generate_asset, generate_asset_pack, or ensure_brand_consistency, so the routing decision is mostly left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ensure_brand_consistencyC
Analyze and refine assets to ensure they follow brand guidelines. Uses Nano Banana Pro's identity preservation to maintain consistency across multiple images.
| Name | Required | Description | Default |
|---|---|---|---|
| assets | Yes | Array of asset URLs or base64 data to analyze for consistency | |
| logoFile | No | Official logo file | |
| colorPalette | No | Official brand colors as hex codes | |
| brandGuidelines | Yes | Detailed brand guidelines including color usage, typography, style, tone | |
| referenceImages | No | Brand reference images showing the desired style |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for explaining behavior. It says the tool 'analyzes and refines' assets, but does not clarify whether it modifies input files, creates new assets, returns analysis results, or requires persistence. The mention of identity preservation is helpful but still leaves significant behavioral gaps.
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 short and reasonably structured, with the primary purpose stated first and the mechanism second. 'Nano Banana Pro' is somewhat marketing-oriented but not excessive. No redundant or filler content is present.
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 five parameters, no output schema, and no annotations, the description leaves too much unstated. It does not specify what the tool returns, whether assets are modified in place, what happens to non-conforming assets, or which inputs are required beyond the schema defaults. An agent would struggle to call this tool confidently without further guidance.
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 coverage is 100%, so the input schema already documents all five parameters. The description references brand guidelines and consistency but adds no parameter-specific details beyond what the schema already states. 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.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: analyze and refine assets to follow brand guidelines. It mentions using Nano Banana Pro's identity preservation for multi-image consistency, which helps distinguish it from the generation-focused siblings. However, it does not explicitly differentiate itself from 'edit_asset', which could also refine assets.
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?
The description provides no explicit guidance on when to use this tool versus generate_asset, generate_asset_pack, or edit_asset. The intended use case is implied from the tool name and opening sentence, but there is no mention of alternatives or conditions that would make this tool the right choice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_assetA
Generate a single web asset using Nano Banana Pro. Supports reference images, color palettes, logos, and various aspect ratios/resolutions (including 2K/4K). Can generate icons, banners, backgrounds, UI elements, and more.
| Name | Required | Description | Default |
|---|---|---|---|
| prompt | Yes | Detailed description of the asset to generate (e.g., 'Create a modern hero banner with gradient background for a tech startup') | |
| logoFile | No | Logo file URL or base64-encoded data URL to include in the asset | |
| resolution | No | Target resolution (e.g., '1920x1080', '2K', '4K', '1080x1080') | |
| aspectRatio | No | Aspect ratio for the asset (e.g., '16:9', '1:1', '4:3', '21:9', '9:16') | |
| colorPalette | No | Array of hex color codes to incorporate into the design (e.g., ['#FF5733', '#3498DB']) | |
| referenceImages | No | Array of reference image URLs or base64-encoded data URLs for style guidance (max 5) | |
| editInstructions | No | Optional editing instructions if modifying an existing asset (e.g., 'Adjust lighting', 'Change background color') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry behavioral disclosure on its own. It does disclose supported inputs and output types at a high level, such as reference images, color palettes, logos, aspect ratios, and 2K/4K resolutions. It does not disclose output format, side effects, costs, or failure modes, so transparency is adequate but not rich.
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 two sentences with no filler. The core purpose is front-loaded, and the capability list is compact and useful. Every sentence earns its place.
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?
For a 7-param tool with no annotations and no output schema, the description is reasonably complete: it summarizes capabilities and defers parameter details to the schema. However, it does not explain what the tool returns (URL, base64, file path), nor does it provide any guidance about edit vs generate workflows, leaving some practical gaps.
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 100%, so the baseline is 3. The description reinforces some parameters by mentioning reference images, color palettes, logos, aspect ratios, and resolutions, but it adds no meaning beyond the schema for parameters like editInstructions. It does not need to compensate much because the schema is already detailed.
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?
Purpose is immediately clear: 'Generate a single web asset using Nano Banana Pro' names a specific verb, resource, and scope. The phrase 'single' distinguishes it from the sibling generate_asset_pack, and listing asset types (icons, banners, backgrounds, UI elements) further aids selection.
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?
The description implies the tool is for creating one new asset, which hints at when to use it over generate_asset_pack or edit_asset. However, it never explicitly says when not to use it, nor does it mention alternatives by name, leaving the routing decision partially to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
generate_asset_packB
Generate a complete pack of related web assets maintaining brand consistency. Perfect for creating cohesive sets of icons, banners, social media graphics, or UI kits.
| Name | Required | Description | Default |
|---|---|---|---|
| logoFile | No | Brand logo to incorporate across assets | |
| assetTypes | Yes | Types of assets to generate (e.g., ['hero-banner', 'icon-set', 'background', 'social-media-post', 'button-set']) | |
| resolution | No | Default resolution (can be overridden per asset type) | |
| aspectRatio | No | Default aspect ratio for assets (can be overridden per asset type) | |
| description | Yes | Overall description of the asset pack and its purpose (e.g., 'Social media kit for eco-friendly brand') | |
| colorPalette | No | Brand color palette as hex codes | |
| brandGuidelines | No | Brand guidelines and style requirements to ensure consistency | |
| referenceImages | No | Reference images to establish visual style (max 5) |
TDQS
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 explaining behavior. It does not disclose what the output looks like, how many assets are produced, whether files are returned directly, or how brand consistency is enforced. 'Complete pack' is a vague outcome rather than a clear behavioral contract.
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 two sentences with no filler. The first sentence states the core action and outcome, and the second provides usage context via concrete examples. It is front-loaded and appropriately sized.
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?
For a tool with eight parameters, no annotations, and no output schema, the description is too thin. It does not explain what the generated pack consists of, how inputs like logoFile or referenceImages are used, or what the agent should expect as a result. The description supports tool selection but not confident invocation.
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 100%, so the structured schema already documents all eight parameters. The description does not add meaningful parameter-level detail beyond the high-level idea of brand consistency and asset sets. Baseline 3 is appropriate because the schema handles the heavy lifting.
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 states a specific verb ('Generate') and resource ('complete pack of related web assets') while emphasizing brand consistency. Concrete examples like icons, banners, social media graphics, and UI kits clarify scope. It implies differentiation from the sibling generate_asset by focusing on packs rather than single assets, but it does not explicitly name the sibling.
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?
The phrase 'Perfect for creating cohesive sets' gives clear context for when to use the tool. It conveys that this is the right choice when multiple related assets are needed. However, it does not mention exclusions or explicitly contrast with generate_asset or ensure_brand_consistency.
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.
4 tool updates
v1.0.0- First observed
edit_asset - First observed
ensure_brand_consistency - First observed
generate_asset - First observed
generate_asset_pack
TDQS
Scored across 4 tools
generate_asset and generate_asset_pack are clearly differentiated by single versus pack output, while edit_asset targets existing assets. ensure_brand_consistency overlaps thematically with generation features that mention brand consistency, but its analyze-and-refine role is distinct enough to avoid serious confusion.
All tool names follow a consistent verb_noun snake_case pattern: generate_asset, generate_asset_pack, edit_asset, ensure_brand_consistency. There is no mixing of camelCase, vague verbs, or inconsistent styles.
Four tools is well-scoped for an asset generation server: one for single assets, one for packs, one for editing, and one for brand consistency. Each tool covers a distinct, necessary workflow without redundancy or bloat.
The core asset lifecycle is covered: create single, create pack, edit, and enforce brand consistency. There is no explicit read/inspect or delete operation, but those are less central to a generation-focused server and agents can work around them using existing editing capabilities.
Maintenance
Related MCP Connectors
MCP server for NanoBanana AI image generation and editing
MCP server for Qwen Image 3 AI image generation
Generate game-ready 3D models, textures, and audio from natural language, over MCP.
MCP server for Flux AI image generation
Related MCP Servers
- AlicenseDqualityCmaintenanceAn MCP server that allows Claude to use OpenAI's image generation capabilities (gpt-image-1) to create image assets for users, which is particularly useful for game and web development projects.153 npm3MIT
- AlicenseAqualityDmaintenanceAn MCP server that provides AI image generation and editing capabilities using Google's Gemini 2.5 Flash Image API. It allows users to create new images from text, modify existing files, and perform iterative edits through natural language prompts.6403 npmMIT
- AlicenseNot gradedqualityCmaintenanceAI-powered image generation MCP server with 16 specialized tools for generating, editing, analyzing, and processing images using Google's Nano Banana 2 model. Supports custom API endpoints and integrates with AI coding assistants via natural language.64 npm1MIT
- AlicenseNot gradedqualityDmaintenanceAn MCP server that provides image generation using Google's Nano Banana Gemini models, with additional tools for background removal, upscaling, and format conversion via deterministic post-processing.1MIT