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

If you already use an AI coding assistant, the fastest way to make image generation useful is to bring it into the same conversation where you plan, write, and iterate. The Nano Banana MCP Server lets Claude Desktop, VS Code, Cursor, and similar MCP-capable clients call image tools through a standard interface, so you can generate or edit visuals without switching workflows.

What you can do

The Nano Banana MCP integration is designed around practical image work that happens during product and content building. According to the integration guide, the server supports image generation from text prompts, image editing, combining multiple images, virtual try-on, product placement, multi-model usage, and task querying.

In day-to-day builder terms, that means you can ask your AI client to create a header image, adapt an existing product shot into a scene, try clothing on a person photo, or check the status of a generation task. The available MCP tools are intentionally small:

• 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 task statuses in a batch.

The supported model names in the guide are nano-banana, nano-banana-2, and nano-banana-pro. Rather than building a separate internal tool for every model, you configure one MCP server and let your AI client decide when to call the right image tool.

How it works

MCP, or Model Context Protocol, gives AI clients a standardized way to call external tools. In this setup, the local client starts a command named mcp-nanobanana-pro. That command exposes Nano Banana tools to the client. Your Ace Data Cloud API token is passed through the environment variable ACEDATACLOUD_API_TOKEN.

The important operational detail is that the API token lives in the MCP server environment, not in every prompt you write. Your client can call tools, but your normal conversation does not need to contain the token. Treat the token like any other credential: keep it out of screenshots, repository commits, logs, and shared config files.

Install the MCP server

The guide provides two installation paths. If you just want the package available on your machine, install it with pip:

pip install mcp-nanobanana-pro

If you prefer to inspect or modify the source locally, use the source installation flow from the guide:

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

After installation, the command your MCP client will run is mcp-nanobanana-pro. That command is the bridge between the AI client and the Nano Banana image tools.

Configure Claude Desktop

For Claude Desktop, edit the desktop configuration file. On macOS, the guide lists ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows, it lists %APPDATA%\Claude\claude_desktop_config.json.

Add an MCP 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 first, 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 the Nano Banana tools should be available in conversation. A useful first test is a small, specific prompt such as: “Generate a clean product hero image for a developer tool in a dark UI style.”

Configure VS Code or Cursor

For VS Code and Cursor, create a file named .vscode/mcp.json in your project root. The structure is slightly different: the top-level key is servers instead of mcpServers.

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

The uvx version is also supported:

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

This project-local setup is handy when a repository has repeatable visual workflows: blog covers, product screenshots, social cards, test assets, or UI mockups. The MCP config lives beside the codebase, while the actual token value should still be handled carefully and not committed accidentally.

Practical prompts to start with

Once the server is configured, you can use natural language. The guide gives examples such as generating a watercolor landscape, placing clothing onto a person, placing a product in a café scene, or generating a high-quality portrait with nano-banana-pro. For real projects, I would keep the first prompt constrained and iterative:

• Describe the target artifact: hero image, product scene, portrait, or edited asset.
• Name the intended use: documentation, landing page, internal demo, or blog cover.
• Specify visual constraints: aspect ratio, background, style, and objects to preserve.
• Ask the client to query task status if the result is not immediately available.

The most reliable workflow is not “one perfect prompt.” It is a short loop: generate, inspect, edit, and query task state when needed. MCP makes that loop feel natural because it happens inside the same assistant you already use for planning and coding.

Where to go next

Nano Banana MCP is a good fit when image generation is part of a larger builder workflow rather than a separate design session. Start with the minimal config, verify that your client can see nanobanana_generate_image and nanobanana_edit_image, then build a repeatable prompt pattern for your team or project.

Read the source integration guide here: Nano Banana MCP Integration Guide.