Getting Started with Nano Banana MCP for AI Image Workflows

September 18, 2026

When an AI assistant can talk through an idea but cannot actually create or modify the image you need, the workflow breaks: you leave the conversation, open another tool, copy prompts around, wait for output, and then come back. The Nano Banana MCP setup documented by Ace Data Cloud gives builders a cleaner path: expose image generation and image editing as tools inside MCP-capable clients such as Claude Desktop, VS Code, and Cursor.

What you can do

The Nano Banana MCP Server is meant for practical image work from inside an AI client. According to the source guide, it supports text-to-image generation, editing or combining existing images, virtual try-on, product placement in real scenes, multi-model usage across nano-banana, nano-banana-2, and nano-banana-pro, plus task querying so you can monitor progress and retrieve results.

That makes it useful for builder workflows where images are part of a larger task rather than a standalone design session. For example, you might ask your AI client to prepare product listing copy, generate a product-in-context image, and then edit the same image after you review it. Or you might keep a brand asset in the project and ask the assistant to combine it with a new background. The important part is that the image step becomes callable from the same environment where you are already planning, coding, or writing.

How it works

MCP, or Model Context Protocol, provides a standardized way for AI models and clients to call external tools. In this case, the external tool server is the Nano Banana MCP Server. Once the server is installed and configured, your client can discover tools such as nanobanana_generate_image, nanobanana_edit_image, nanobanana_get_task, and nanobanana_get_tasks_batch.

The configuration is intentionally small. You install the package, provide an Ace Data Cloud API token through the ACEDATACLOUD_API_TOKEN environment variable, restart the client, and then call the tools through natural language. The token stays in your local MCP configuration; do not paste it into prompts or commit it into a repository.

Install the MCP server

The recommended installation path in the guide is the Python package mcp-nanobanana-pro:

pip install mcp-nanobanana-pro

If you prefer to work from source, the documented flow is:

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

After installation, the command exposed by the package is mcp-nanobanana-pro. That command is what your MCP client will launch when it needs the server.

Configure Claude Desktop

For Claude Desktop, edit the local 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.

A minimal configuration looks like this:

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

If you do not want to install the package in advance, the guide also documents a uvx version:

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

After saving the file, restart Claude Desktop. The restart matters because the client needs to reload MCP server definitions before the Nano Banana tools become available in conversation.

Configure VS Code or Cursor

For project-based work, VS Code and Cursor use a project-level MCP configuration. Create .vscode/mcp.json in the project root and add the server definition:

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

The uvx form is also supported in this client style:

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

This is a good fit when image generation is part of a repository workflow. You can keep prompts, product specs, or UI notes in the project, then ask the AI client to generate a concept image, edit an existing image, or query task status without leaving the IDE.

Use the tools from natural language

Once the server is configured, you do not have to manually call a REST endpoint from your chat. The client can route requests to the MCP tools. The guide gives examples such as generating a watercolor landscape, placing clothing onto a person, placing a product into a café scene, or generating a portrait with the nano-banana-pro model.

For day-to-day use, I would make the request specific and reviewable. Instead of saying “make a product image,” describe the asset, target setting, lighting, and constraints. If the task is asynchronous, use nanobanana_get_task to check a single task, or nanobanana_get_tasks_batch when you have several image jobs running.

A practical first workflow

Install mcp-nanobanana-pro or configure the server through uvx.
Add ACEDATACLOUD_API_TOKEN to the MCP server environment.
Restart Claude Desktop, VS Code, or Cursor.
Ask for a small image task first, such as a product placement or an edit of one existing image.
Use the task query tool if the result is not immediately returned.

The useful mental model is simple: keep the creative instruction in the same place where you keep the context. For builders, that reduces handoffs. You can draft, generate, edit, and inspect progress from the client you already use.

For the complete source configuration and tool list, read the Nano Banana MCP Integration Guide.

Search This Blog

AceDataCloud