You are writing in Claude, planning a blog post or product concept, and suddenly need a quick image: not a separate design session, just a usable visual artifact from the same conversation.
With a NanoBanana MCP connector, Claude can call an image generation and editing tool directly, then return the resulting image link back into the chat.
What you can do
The source document describes a Claude.ai web integration for NanoBanana MCP, a remote MCP server that wraps Google Gemini 2.5 Flash Image series capabilities behind tools Claude can call.
Once connected, Claude can:
- Generate images from text descriptions with
nanobanana_generate_image. - Edit images, make partial modifications, or apply style transfers with
nanobanana_edit_image. - Query a single task with
nanobanana_get_task. - Query multiple tasks in batch with
nanobanana_get_tasks_batch.
That tool split is important. Image generation often behaves like an asynchronous workflow: submit a prompt, receive a task, query the task, then display the final image URL. In a normal API integration you would write that orchestration yourself. With MCP attached to Claude, the assistant can do the submit-and-poll loop from the chat.
How it works
Claude.ai supports custom connectors. For NanoBanana MCP, the connector is added from Claude's settings:
https://claude.ai/customize/connectors
From there, choose Add custom connector and configure these fields:
| Field | Value |
|---|---|
| Name | NanoBanana |
| URL | https://nanobanana.mcp.acedata.cloud/mcp |
The document notes that Claude.ai uses OAuth direct connection for this flow, so there is no API token to copy into Claude. On first connection, Claude redirects to Ace Data Cloud for authorization. After allowing access, Claude returns to the connector page and discovers the available tools.
A practical detail from the source guide: set each tool to Always allow if you plan to use it frequently. Image generation commonly triggers more than one tool call, such as a generation call followed by a task query. If every call requires a confirmation dialog, the workflow feels much less conversational.
Start with one concrete prompt
A good first test is a single, specific English prompt. The source document uses this example:
Use NanoBanana to generate one image: a cute corgi astronaut floating in space, soft pastel nebula background, photorealistic, 16:9.
Claude's job is not just to repeat the prompt. It decides which MCP tool to call, passes the prompt and aspect ratio, receives the task information, calls nanobanana_get_task, and returns the final image link when the task is complete.
For best results, give the model enough visual constraints:
- Subject:
a cute corgi astronaut - Scene:
floating in space - Background:
soft pastel nebula background - Style:
photorealistic - Aspect ratio:
16:9
This makes the output easier to reuse as a blog cover, social image, or design placeholder.
Edit an existing image in the same thread
The connector also supports image editing through nanobanana_edit_image. The source guide gives this follow-up prompt:
Take that corgi image and replace the helmet with a giant donut.
The useful pattern here is continuity. Claude can refer to the previous image URL from the conversation and pass it into the edit workflow. Instead of manually downloading and uploading files between tools, you can keep the iteration inside the same thread.
This is especially useful for small creative changes:
- Replace one object while keeping the scene.
- Make a partial modification to a product concept.
- Try a different visual theme after the first generation.
- Turn a rough prompt into several refinements before choosing a final image.
The workflow still needs human review. Treat each result as a candidate, not an automatic final asset.
Generate variations instead of over-editing one image
Sometimes the better move is not to keep editing one result. The guide shows a batch-style request:
Generate 4 variations of that corgi astronaut, each in a different mood.
Claude may issue several generation calls and then use nanobanana_get_tasks_batch to retrieve the results together. This is a good way to explore composition before committing to edits.
A builder-friendly workflow looks like this:
- Ask for 3–4 variations with clear differences.
- Pick the strongest direction.
- Use
nanobanana_edit_imagefor targeted changes. - Save the final CDN image URL for your article, slide, or prototype.
The source document notes that returned images are hosted on Ace Data Cloud's CDN, so the image links can be pasted into blogs, slide decks, or design drafts.
Use it as part of a broader MCP workflow
NanoBanana is most helpful when it becomes one tool in a larger assistant workflow. For example, you can ask Claude to draft a blog outline, generate a cover image, then revise the prompt until the image matches the article angle.
The same connector can handle both generation and editing, while task-query tools handle result retrieval. That makes the chat feel less like a prompt box and more like a lightweight creative pipeline.
A few habits help:
- Keep prompts specific and visual.
- Include the target aspect ratio, such as
16:9, when you know the destination. - Use English prompts when you want more stable adherence, as suggested by the source guide.
- Set tool permissions intentionally instead of approving every call one by one.
Closing thoughts
This setup is useful because it removes the context switch. You stay in Claude, describe the image you need, and let the MCP connector handle generation, editing, and task retrieval.
It is not a replacement for design judgment, but it is a practical way to move from idea to usable visual draft while you are already thinking through the work.
Original setup reference: https://platform.acedata.cloud/documents/claude-mcp-nano-banana
Top comments (0)