Getting Started with Nano Banana MCP for Image Generation in Your IDE

September 19, 2026

If your AI assistant can write code but cannot create or edit the image assets your project needs, you end up leaving the IDE, opening another tool, copying prompts around, and manually downloading files. Nano Banana MCP is a practical way to keep that workflow inside an AI client such as Claude Desktop, VS Code, or Cursor.

The idea is simple: install an MCP server, provide an Ace Data Cloud API token through an environment variable, and let your assistant call image tools from the conversation. The documented server is mcp-nanobanana-pro, and it exposes tools for generating, editing, combining, and checking image tasks.

What you can do

The Nano Banana MCP server is built around image work that developers and product builders often need while prototyping:

Generate images from text prompts, for example a watercolor landscape, an illustration, or a product visual.
Edit existing images or combine multiple images into a new result.
Run virtual try-on workflows, such as applying clothing to a person in a photo.
Place products into real scenes, for example showing an object in a café environment.
Use multiple Nano Banana models: nano-banana, nano-banana-2, and nano-banana-pro.
Query task progress so your client can monitor generation and retrieve results when they are ready.

The useful part is not only the model access. It is the shape of the workflow: your coding assistant can reason about the asset you need, call the appropriate MCP tool, and keep the image task connected to the rest of your project context.

How it works

MCP, or Model Context Protocol, gives AI clients a standardized way to call external tools. In this setup, the external tool server is the Nano Banana MCP server from Ace Data Cloud. Your AI client starts the server process, passes in ACEDATACLOUD_API_TOKEN, and then discovers the tools the server provides.

The documented tools are:

nanobanana_generate_image — generate images from text prompts.
nanobanana_edit_image — edit or combine existing images.
nanobanana_get_task — query the status of a single task.
nanobanana_get_tasks_batch — query multiple task statuses in a batch.

Once configured, you do not usually call these tools by writing JSON by hand. You can ask your AI client in natural language, such as “Generate a high-quality portrait using the nano-banana-pro model” or “Place this product in a café scene.” The client decides which MCP tool to call.

Install the MCP server

The recommended installation path in the documentation is pip:

pip install mcp-nanobanana-pro

After installation, the server can be started with the mcp-nanobanana-pro command. If you prefer to work from source, the documented source installation is:

git clone https://github.com/AceDataCloud/NanoBananaMCP.git
cd NanoBananaMCP
pip install -e .

Before connecting it to an AI client, make sure you have an Ace Data Cloud API token. The documentation describes getting one from the Nano Banana Images API page, then passing it to the MCP server as ACEDATACLOUD_API_TOKEN.

Configure Claude Desktop

For Claude Desktop, edit the configuration file for your operating system:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Add an MCP server entry named nanobanana:

{
  "mcpServers": {
    "nanobanana": {
      "command": "mcp-nanobanana-pro",
      "env": {
        "ACEDATACLOUD_API_TOKEN": "Your API Token"
      }
    }
  }
}

If you use uvx, the documentation also supports running the package without installing it in advance:

{
  "mcpServers": {
    "nanobanana": {
      "command": "uvx",
      "args": ["mcp-nanobanana-pro"],
      "env": {
        "ACEDATACLOUD_API_TOKEN": "Your API Token"
      }
    }
  }
}

Save the file, restart Claude Desktop, and the Nano Banana tools should be available in the conversation.

Configure VS Code or Cursor

For VS Code or Cursor, create .vscode/mcp.json in the project root. The direct command configuration is:

{
  "servers": {
    "nanobanana": {
      "command": "mcp-nanobanana-pro",
      "env": {
        "ACEDATACLOUD_API_TOKEN": "Your API Token"
      }
    }
  }
}

The uvx version follows the same structure, but adds the package name under args:

{
  "servers": {
    "nanobanana": {
      "command": "uvx",
      "args": ["mcp-nanobanana-pro"],
      "env": {
        "ACEDATACLOUD_API_TOKEN": "Your API Token"
      }
    }
  }
}

This setup is useful when image generation is part of a repository workflow. For example, you can keep prompts, product screenshots, or design notes in the project, then ask the assistant to create assets while it still has access to the surrounding code and documentation context.

A practical builder workflow

A simple way to start is to treat the MCP server as an asset-generation companion during prototyping:

Install mcp-nanobanana-pro.
Add the MCP configuration to Claude Desktop, VS Code, or Cursor.
Restart the client so it can discover the server.
Ask for a small, concrete task: “Generate a watercolor landscape painting,” “Photoshop this clothing onto this person,” or “Place this product in a café scene.”
If the task is asynchronous, use the task-querying tools exposed by the server to check progress and retrieve the result.

For builders, the advantage is less context switching. You can iterate on product images, hero graphics, UI placeholders, or campaign visuals from the same assistant that already understands your brief. Keep the first prompt narrow, inspect the result, then ask for edits rather than trying to get the final asset in one pass.

Where to go next

If you want the exact installation notes, supported client configurations, and tool list, read the Nano Banana MCP Integration Guide.

Search This Blog

AceDataCloud