Installation

This guide covers installation options for both users connecting to an existing Go Bananas! instance and operators deploying their own.

For Users (MCP Client Setup)

If you're connecting to an existing Go Bananas! instance, you only need to configure your MCP client.

Fastest route

Open gobananasai.com/connect for copy-ready steps for Claude, ChatGPT, Cursor, VS Code, Claude Code, Codex, Gemini CLI and the command line. The MCP server's address is https://mcp.gobananasai.com; the older https://gobananasai.com/mcp still works.

Go Bananas is also listed on the official MCP Registry as com.gobananasai/go-bananas, so registry-aware clients can find it by that name.

Plugin for Claude Code and Codex

The go-bananas plugin adds the MCP server and a skill that teaches your agent how to use it.

# Claude Code (run inside a session), then /mcp to sign in
/plugin marketplace add davendra/go-bananas-plugins
/plugin install go-bananas@go-bananas

# Codex
codex plugin marketplace add davendra/go-bananas-plugins
codex plugin add go-bananas@go-bananas
codex mcp login go-bananas

ChatGPT

Settings → Security and login → turn on Developer mode, then create an app with the URL https://mcp.gobananasai.com and sign in. Needs a Plus, Pro, Business, Enterprise or Edu plan.

Cursor and VS Code

Use the one-click Add to Cursor or Install in VS Code buttons on /connect. Each opens the editor, then asks you to sign in.

Gemini CLI

gemini mcp add --transport http go-bananas https://mcp.gobananasai.com

Then run /mcp auth go-bananas inside Gemini CLI.

Prerequisites

• The Go Bananas! server URL (default: https://gobananasai.com)
• An MCP-compatible client
• Either remote HTTP OAuth support in your client, or a Go Bananas API key / local CLI login for the STDIO proxy

Choose an Auth Mode

Go Bananas supports two MCP auth modes. Use only one go-bananas entry per client/scope.

Mode	Use When	Auth Steps
Remote HTTP OAuth	Claude.ai connectors, Claude Code, Codex, Cursor/VS Code builds that support remote MCP OAuth	Add https://mcp.gobananasai.com, then authenticate inside that client
Local STDIO proxy	Claude Desktop config files, older editors, cloud agents, or clients without remote HTTP OAuth	Run npx -y gobananas-cli auth login, or set GO_BANANAS_API_KEY

Important: gobananas-cli auth login authenticates the local gobananas-mcp STDIO proxy only. It does not authenticate a separate direct HTTP entry like "url": "https://mcp.gobananasai.com".

Claude Code (Remote HTTP OAuth, server only)

One-command install:

claude mcp add --transport http -s user go-bananas https://mcp.gobananasai.com

Then run /mcp, choose Authenticate, and complete the Go Bananas browser login.

Project-level .mcp.json for direct HTTP OAuth:

{
  "mcpServers": {
    "go-bananas": {
      "type": "http",
      "url": "https://mcp.gobananasai.com"
    }
  }
}

Codex (Remote HTTP OAuth)

codex mcp add go-bananas --url https://mcp.gobananasai.com
codex mcp login go-bananas

Verify with:

codex mcp get go-bananas

Hermes Agent

Installed Hermes 0.20.4 supports this remote setup:

hermes mcp add go-bananas --url https://mcp.gobananasai.com --auth oauth --connect-timeout 60
hermes mcp login go-bananas

For a new entry needing image generation and history, merge into ~/.hermes/config.yaml:

mcp_servers:
  go-bananas:
    url: https://mcp.gobananasai.com
    auth: oauth
    connect_timeout: 60
    timeout: 300
    oauth:
      scope: "images:read images:generate sessions:read"

Remove history permission when unnecessary; adding permissions to an existing restricted registration requires renewed registration/consent as appropriate. Initial discovery and per-tool timeouts are separate. Request an actual list_models call in Hermes before generation. Installed Hermes registered 53 staging HTTP tools and dispatched successful image/history reads, real Gemini generation and readback. Its STDIO connection advertised 54 tools and completed local JPEG upload/readback. Tests used a harness-issued token in an isolated profile. Native browser consent and LLM chat remain unverified. See the official Hermes MCP guide.

For local-file upload/import, use the local STDIO proxy described below, with a separate entry in Hermes's mcp_servers YAML using command, args and env. Authenticate the proxy as the same local account, request images:edit for upload_image_for_editing plus images:read for readback (the separate upload_media tool instead requires media:upload), and set GO_BANANAS_SERVER_URL to the selected server. Direct HTTP cannot read local disk paths. Hermes reasoning credentials and Go Bananas image-provider credentials are separate billing paths; this does not enable the hosted ChatGPT subscription runner.

OpenClaw and readiness

OpenClaw's official CLI documents outbound remote MCP setup. Check the installed version before configuring it:

openclaw mcp add go-bananas --url https://mcp.gobananasai.com --transport streamable-http --auth oauth
openclaw mcp login go-bananas
openclaw mcp doctor go-bananas --probe

This is a documented recipe, not a completed Go Bananas/OpenClaw compatibility test. Confirm tools are available in the intended runtime. See the official OpenClaw reference.

OAuth permissions

Initial consent without a requested scope defaults to images:read images:generate; it does not grant session history, edits, asset libraries or analytics. A live SDK generation succeeded while history was correctly denied without sessions:read.

For Codex image workflows with history, the verified local CLI option is:

codex mcp login go-bananas --scopes images:read,images:generate,sessions:read

New dynamic registrations that omit scope can request these advertised scopes with fresh consent. Explicitly restricted and older registrations keep their ceiling, so invalid_scope can require registering a new client and renewed consent. Refresh does not add permissions. Claude Code's --scope user is configuration scope, not an OAuth permission, and its checked CLI has no OAuth-scope flag. For a separate STDIO proxy connection, the Go Bananas CLI supports explicit space-separated permissions:

npx -y gobananas-cli auth login --scope 'images:read images:generate sessions:read'

This authenticates the local proxy only. For reusable assets, request each needed :read or :manage permission; manage does not imply read. Avoid requesting every scope by default. Native client registration upgrades remain unverified.

Verify the connection

After browser consent, call list_models from the actual client. codex mcp get or a saved configuration file alone cannot prove tool execution. On 7 September 2026, Codex 0.153.4 and Claude Code 2.1.221 both made successful direct HTTP get_image_info calls using harness-issued OAuth tokens and one-off configuration. Native browser login and client-managed refresh remain unverified. Separate SDK tests verified OAuth refresh rotation and renewed-token readback. The Codex noninteractive readback needed an explicitly authorised per-tool approval; this is not blanket approval for other tools. Skills do not establish a connection automatically. Use a distinct server name and staging URL when testing staging.

Ordinary provider generation uses workspace Gemini/OpenAI credentials. The public deployment makes the hosted subscription tools available to signed-in users when the runner is configured; self-hosted deployments remain disabled by default and have separate release gates.

Claude Desktop / Claude.ai Remote Connector

In Claude, go to Settings > Connectors > Add custom connector and enter:

https://mcp.gobananasai.com

Authenticate in the browser when Claude prompts you.

Local STDIO Proxy (Claude Desktop, Cursor, Codex, Cloud Agents)

Run browser login once on the same machine/user account as the MCP client:

npx -y gobananas-cli auth login

Then configure the client to launch gobananas-mcp.

Config file location:

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

{
  "mcpServers": {
    "go-bananas": {
      "command": "npx",
      "args": ["-y", "gobananas-mcp"],
      "env": {
        "GO_BANANAS_SERVER_URL": "https://gobananasai.com",
        "GO_BANANAS_MCP_TRANSPORT": "streamable-http"
      }
    }
  }
}

For Claude Code STDIO:

claude mcp add -s user go-bananas \
  -e GO_BANANAS_SERVER_URL=https://gobananasai.com \
  -e GO_BANANAS_MCP_TRANSPORT=streamable-http \
  -- npx -y gobananas-mcp

For Codex STDIO:

codex mcp add go-bananas \
  --env GO_BANANAS_SERVER_URL=https://gobananasai.com \
  --env GO_BANANAS_MCP_TRANSPORT=streamable-http \
  -- npx -y gobananas-mcp

For Cursor .cursor/mcp.json:

{
  "mcpServers": {
    "go-bananas": {
      "command": "npx",
      "args": ["-y", "gobananas-mcp"],
      "env": {
        "GO_BANANAS_SERVER_URL": "https://gobananasai.com",
        "GO_BANANAS_MCP_TRANSPORT": "streamable-http"
      }
    }
  }
}

For CI/headless setups, add an API key to the same env object:

"GO_BANANAS_API_KEY": "sk_live_your_api_key_here"

Restart the desktop app/editor after saving.

VS Code (Remote HTTP or STDIO)

Add to .vscode/settings.json or user settings:

{
  "mcp": {
    "servers": {
      "go-bananas": {
        "type": "http",
        "url": "https://mcp.gobananasai.com"
      }
    }
  }
}

If your VS Code MCP extension does not support remote HTTP OAuth, use the STDIO proxy config above.

Codex Config File (STDIO Alternative)

Add to ~/.codex/config.toml:

[mcp_servers.go-bananas]
command = "npx"
args = ["-y", "gobananas-mcp"]

[mcp_servers.go-bananas.env]
GO_BANANAS_SERVER_URL = "https://gobananasai.com"
GO_BANANAS_MCP_TRANSPORT = "streamable-http"

Run npx -y gobananas-cli auth login first, or add GO_BANANAS_API_KEY.

Other STDIO Clients (Windsurf, Goose, Gemini CLI, Factory, OpenCode)

Use the same STDIO proxy pattern. Example JSON:

{
  "mcpServers": {
    "go-bananas": {
      "command": "npx",
      "args": ["-y", "gobananas-mcp"],
      "env": {
        "GO_BANANAS_SERVER_URL": "https://gobananasai.com",
        "GO_BANANAS_MCP_TRANSPORT": "streamable-http"
      }
    }
  }
}

Use the client-specific config path:

Client	Config Location
Windsurf	~/.codeium/windsurf/mcp_config.json
Goose	~/.config/goose/config.json
Gemini CLI	~/.gemini/settings.json
Factory	.factory/mcp.json or ~/.factory/mcp.json
OpenCode	opencode.json

OpenCode uses a slightly different shape:

{
  "mcp": {
    "go-bananas": {
      "type": "local",
      "command": ["npx", "-y", "gobananas-mcp"],
      "enabled": true,
      "environment": {
        "GO_BANANAS_SERVER_URL": "https://gobananasai.com",
        "GO_BANANAS_MCP_TRANSPORT": "streamable-http"
      }
    }
  }
}

Verify Connection

After configuration, test the connection:

1. Open Claude Desktop or your MCP client
2. Type: "What image generation tools do you have available?"
3. Claude should list Go Bananas! tools (53 total, or 54 through the STDIO proxy, which adds go_bananas_diagnose)
4. If available, run go_bananas_diagnose to confirm the exact endpoint and auth mode

---

For Self-Hosters

Deploy your own Go Bananas! instance on Cloudflare.

Prerequisites

• Node.js 24 - Download
• Cloudflare Account - Sign up free
• Google AI Studio Account - Get API key
• Git - For cloning the repository

Step 1: Clone and Install

# Clone the repository
git clone https://github.com/davendra/go-bananas-app.git
cd go-bananas-app

# Install dependencies
npm install

Step 2: Create Cloudflare Resources

Login to Cloudflare and create the required resources:

# Login to Cloudflare
npx wrangler login

# Create D1 Database
npx wrangler d1 create go-bananas-db
# Note the database_id from output

# Create KV Namespace
npx wrangler kv:namespace create API_KEYS
# Note the id from output

# Create R2 Bucket
npx wrangler r2 bucket create go-bananas-images

Step 3: Configure wrangler.jsonc

Update wrangler.jsonc with your resource IDs:

{
  "name": "go-bananas",
  "main": "src/index.ts",
  "compatibility_date": "2024-01-01",

  "d1_databases": [
    {
      "binding": "DB",
      "database_name": "go-bananas-db",
      "database_id": "YOUR_D1_DATABASE_ID"  // Replace this
    }
  ],

  "kv_namespaces": [
    {
      "binding": "API_KEYS",
      "id": "YOUR_KV_NAMESPACE_ID"  // Replace this
    }
  ],

  "r2_buckets": [
    {
      "binding": "R2_IMAGES",
      "bucket_name": "go-bananas-images"
    }
  ],

  "durable_objects": {
    "bindings": [
      {
        "name": "MCP_OBJECT",
        "class_name": "GoBananasMcpAgent"
      }
    ]
  }
}

Step 4: Generate Secrets

Generate the required encryption keys:

# Generate 256-bit encryption key for API key storage
openssl rand -hex 32
# Output: e.g., a1b2c3d4e5f6...

# Generate session secret
openssl rand -hex 32

# Generate admin token
openssl rand -hex 32

Step 5: Set Secrets

# Set the encryption key (64-char hex string)
npx wrangler secret put ENCRYPTION_KEY
# Paste your encryption key when prompted

# Set the session secret
npx wrangler secret put SESSION_SECRET
# Paste your session secret when prompted

# Set the admin token
npx wrangler secret put ADMIN_TOKEN
# Paste your admin token when prompted

Step 6: Initialize Database

# Initialize the database schema
npm run db:init

Step 7: Deploy

# Deploy to Cloudflare
npm run deploy

Your instance is now live at https://go-bananas.your-account.workers.dev

Step 8: Create First Tenant

# Interactive tenant setup
npm run setup-tenant

Follow the prompts to create your first tenant with an API key.

Verify Installation

Health Check

curl https://gobananasai.com/health

Expected response:

{
  "status": "ok",
  "timestamp": "2024-01-15T10:30:00Z"
}

MCP Test

curl -X POST https://mcp.gobananasai.com \
  -H "X-API-Key: sk_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{"method":"tools/list"}'

Should return a list of 53 available tools. (The STDIO proxy, gobananas-mcp, adds a 54th: go_bananas_diagnose.)

Environment Overview

Resource	Purpose
Worker	Entry point, authentication, routing
Durable Object	MCP session state management
D1 Database	Metadata, relationships, analytics
R2 Bucket	Image storage (full + thumbnails)
KV Store	API key caching

Next Steps

• Quick Start Tutorial →
• Self-Hosting Configuration →
• Create Tenants →