Getting Started with Nano Banana MCP in Claude Desktop, VS Code, and Cursor

If you already use an AI coding assistant every day, the friction is rarely the prompt itself; it is the handoff between the assistant, a browser, an API page, and the generated image you wanted to inspect or iterate on.

The Nano Banana MCP setup solves that problem by putting image generation and image editing tools directly inside MCP-capable clients such as Claude Desktop, VS Code, and Cursor. Instead of switching context, you can ask your assistant to generate a concept image, edit an existing asset, combine references, or check a task result from the same conversation where you are writing code or planning a workflow.

What you can do

The Ace Data Cloud Nano Banana MCP Server exposes a small, practical set of tools:

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

The documented feature set is broader than simple text-to-image. It includes image generation, image editing, virtual try-on, product placement, multi-model support for nano-banana, nano-banana-2, and nano-banana-pro, and task querying so your client can monitor progress and fetch results when generation completes.

How it works

MCP, short for Model Context Protocol, gives an AI client a standard way to call external tools. In this setup, the local MCP command is mcp-nanobanana-pro. Your client starts that command, passes the API token through an environment variable named ACEDATACLOUD_API_TOKEN, and then discovers the Nano Banana tools.

That means you do not usually write direct image API calls inside your project. You configure the MCP server once, restart the client, and then use natural language to invoke the tools. For example, you might ask the assistant to “place this product in a café scene,” “Photoshop this clothing onto this person,” or “generate a high-quality portrait using the nano-banana-pro model.” The important part is that the assistant has a real tool boundary: generation, editing, and task lookup are separate capabilities rather than vague chat responses.

Install the MCP server

The recommended installation path in the documentation is the Python package:

pip install mcp-nanobanana-pro

If you prefer source installation, the guide documents this flow:

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

After installation, the MCP server can be started with the mcp-nanobanana-pro command. You will also need an Ace Data Cloud API token. The guide points users to the Nano Banana Images API page on the Ace Data Cloud platform to acquire the token. Keep that token out of source control; treat it like any other API credential.

Configure Claude Desktop

For Claude Desktop, edit the client configuration file. The documented locations are:

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

Add a server entry under mcpServers:

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

If you prefer not to install the package in advance, the guide also documents a uvx configuration:

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

Save the file and restart Claude Desktop. After the restart, the client should be able to use the Nano Banana tools during a conversation.

Configure VS Code or Cursor

For VS Code or Cursor, create .vscode/mcp.json in your project root. The schema uses servers instead of mcpServers:

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

The uvx version is similar:

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

This project-level configuration is useful when image work is part of a codebase: product screenshots, landing-page art direction, generated placeholders, or design iteration notes can live near the implementation.

A practical workflow for builders

A good first workflow is to separate creative intent from task management:

1. Ask the assistant to generate or edit an image with a specific use case.
2. Let it call nanobanana_generate_image or nanobanana_edit_image.
3. If the result is asynchronous, query the task with nanobanana_get_task.
4. For multiple pending jobs, use nanobanana_get_tasks_batch.
5. Review the image, then ask for a narrower edit rather than starting over blindly.

For product teams, this is especially useful for product placement and virtual try-on experiments. For solo builders, it can shorten the loop between “I need a visual direction” and “I have an asset candidate I can discuss, test, or refine.”

Where to go next

The cleanest way to approach Nano Banana MCP is to start small: configure one client, verify the tool list, generate one image, then test one edit. Once that loop works, you can decide whether the workflow belongs in your desktop assistant, your IDE, or both.

Read the full Nano Banana MCP Integration Guide for the original configuration snippets and tool list.