Getting Started with Nano Banana MCP for Image Generation in Claude, VS Code, and Cursor

August 10, 2026

If you already use Claude Desktop, VS Code, or Cursor as a working surface, image generation becomes much more useful when it sits inside the same conversation where you are planning, editing, and reviewing assets.

This guide walks through setting up the Nano Banana MCP server from Ace Data Cloud so an AI client can call image tools directly: generate an image from a prompt, edit or combine existing images, run virtual try-on and product placement workflows, and check task status without leaving the IDE or chat client.

What you can do

The Nano Banana MCP server exposes a compact set of image-oriented tools through the Model Context Protocol. According to the source guide, the server supports:

Image generation: create images from text prompts.
Image editing: modify an existing image or combine multiple images.
Virtual try-on: place clothing on photos of people.
Product placement: put a product into a realistic scene, such as a café or lifestyle setup.
Multi-model use: work with nano-banana, nano-banana-2, and nano-banana-pro.
Task querying: monitor generation progress and retrieve results.

The important part is not only that these tools exist. It is that they become callable from the same place where you are already writing prompts, comparing options, and asking the model to revise the visual direction.

How it works

MCP, or Model Context Protocol, gives an AI client a standard way to call external tools. In this setup, your client starts the mcp-nanobanana-pro command as an MCP server and passes an Ace Data Cloud token through an environment variable named ACEDATACLOUD_API_TOKEN.

Once the client restarts, the tools appear to the AI assistant. You can then ask naturally for operations like “generate a watercolor landscape painting,” “Photoshop this clothing onto this person,” or “place this product in a café scene.” The client routes the request to the MCP server, and the server handles the image task.

Install the MCP server

The recommended installation path is a normal Python package install:

pip install mcp-nanobanana-pro

If you prefer to install from source, the guide provides the repository workflow:

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

After installation, the command you configure in your MCP client is mcp-nanobanana-pro. Keep the API token out of prompts and code samples you share publicly; it belongs in the client configuration environment.

Configure Claude Desktop

Claude Desktop reads MCP server definitions from its desktop configuration file. On macOS, the file is located at ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows, it is located at %APPDATA%\Claude\claude_desktop_config.json.

Add a server entry like this:

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

If you use uvx and do not want to install the package ahead of time, the guide also supports this form:

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

Save the file, restart Claude Desktop, and then ask the assistant to use Nano Banana image tools in a normal conversation.

Configure VS Code or Cursor

For editor-based workflows, create a .vscode/mcp.json file in your project root. The direct command configuration is:

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

The uvx version mirrors the Claude Desktop setup:

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

This is useful when the image work is tied to a real project: a landing page hero, product mockups, social assets, or visual references for a README. The asset discussion stays close to the code and copy.

Use the tools in a practical workflow

The available MCP tool names are intentionally straightforward:

nanobanana_generate_image generates images from text prompts.
nanobanana_edit_image edits or combines existing images.
nanobanana_get_task queries the status of a single task.
nanobanana_get_tasks_batch queries multiple task statuses.

A builder-style workflow might look like this:

Ask for three visual directions for a product screenshot scene.
Generate the first concept with nanobanana_generate_image.
Attach a product image and ask for placement in a café scene with nanobanana_edit_image.
Use nanobanana_get_task to check progress and retrieve the result.
Ask the assistant to compare the output against your brand constraints before generating another variant.

For model choice, the guide names nano-banana, nano-banana-2, and nano-banana-pro. Use the lighter path when you are exploring composition, and reserve the stronger model for the version that is closer to production.

Closing notes

The main advantage of an MCP-based image workflow is context. Instead of copying prompts between tools, you let your AI client coordinate the request, the source image, the revision notes, and the task result in one thread. That makes it easier to iterate with intent rather than generate a pile of disconnected images.

For the complete setup details, read the Nano Banana MCP Integration Guide.

Search This Blog

AceDataCloud