# Google MCP Toolbox

> Google-published MCP server for databases — one Go binary speaks Postgres, MySQL, BigQuery, Spanner, AlloyDB, Snowflake, ClickHouse, MongoDB, Redis, and more.

[Canonical HTML page](https://top-mcps.com/mcp/google-mcp-toolbox) · [server.json](https://top-mcps.com/mcp/google-mcp-toolbox.json) · [methodology](https://top-mcps.com/about/methodology)

## Install

### Claude Desktop — `claude_desktop_config.json`

Paste under mcpServers. Fully quit and reopen Claude after editing.

```json
{
  "mcpServers": {
    "google-mcp-toolbox": {
      "command": "brew",
      "args": [
        "install",
        "mcp-toolbox",
        "&&",
        "toolbox",
        "--tools-file",
        "tools.yaml"
      ]
    }
  }
}
```

### Claude Code — `CLI or .mcp.json`

Run from your repo. Commit .mcp.json to share with your team.

```shell
claude mcp add google-mcp-toolbox -- brew install mcp-toolbox && toolbox --tools-file tools.yaml
```

### Cursor — `.cursor/mcp.json`

Global path: ~/.cursor/mcp.json. Reload window after editing.

```json
{
  "mcpServers": {
    "google-mcp-toolbox": {
      "command": "brew",
      "args": [
        "install",
        "mcp-toolbox",
        "&&",
        "toolbox",
        "--tools-file",
        "tools.yaml"
      ]
    }
  }
}
```

### VS Code — `.vscode/mcp.json`

VS Code uses the "servers" key (not "mcpServers").

```jsonc
{
  "servers": {
    "google-mcp-toolbox": {
      "command": "brew",
      "args": [
        "install",
        "mcp-toolbox",
        "&&",
        "toolbox",
        "--tools-file",
        "tools.yaml"
      ]
    }
  }
}
```

### Windsurf — `~/.codeium/windsurf/mcp_config.json`

Open via Cascade → hammer icon → Configure.

```json
{
  "mcpServers": {
    "google-mcp-toolbox": {
      "command": "brew",
      "args": [
        "install",
        "mcp-toolbox",
        "&&",
        "toolbox",
        "--tools-file",
        "tools.yaml"
      ]
    }
  }
}
```

### Cline — `cline_mcp_settings.json`

Open via the Cline sidebar → MCP Servers → Edit.

```json
{
  "mcpServers": {
    "google-mcp-toolbox": {
      "command": "brew",
      "args": [
        "install",
        "mcp-toolbox",
        "&&",
        "toolbox",
        "--tools-file",
        "tools.yaml"
      ]
    }
  }
}
```

### Continue — `~/.continue/config.json`

Continue uses modelContextProtocolServers with a transport block.

```json
{
  "experimental": {
    "modelContextProtocolServers": [
      {
        "transport": {
          "type": "stdio",
          "command": "brew",
          "args": [
            "install",
            "mcp-toolbox",
            "&&",
            "toolbox",
            "--tools-file",
            "tools.yaml"
          ]
        }
      }
    ]
  }
}
```

### Codex CLI — `~/.codex/config.toml`

Codex uses TOML. Each server is a [mcp_servers.<name>] subtable.

```shell
# ~/.codex/config.toml
[mcp_servers.google-mcp-toolbox]
command = "brew"
args = [
  "install",
  "mcp-toolbox",
  "&&",
  "toolbox",
  "--tools-file",
  "tools.yaml",
]
```

### Zed — `~/.config/zed/settings.json`

Zed calls them "context_servers". Settings live-reload on save.

```jsonc
{
  "context_servers": {
    "google-mcp-toolbox": {
      "command": {
        "path": "brew",
        "args": [
          "install",
          "mcp-toolbox",
          "&&",
          "toolbox",
          "--tools-file",
          "tools.yaml"
        ]
      }
    }
  }
}
```

### ChatGPT — `ChatGPT → Apps directory`

Google MCP Toolbox doesn't ship a hosted HTTPS endpoint today. ChatGPT supports remote MCP servers only — to use this server in ChatGPT you'll need to deploy it to a public HTTPS URL first (e.g. via Cloudflare Workers or Vercel) or wait for an official remote build.

```none

```

## At a glance

- **Maintainer:** Google (googleapis)
- **Transport:** stdio, Streamable HTTP
- **Auth model:** API key
- **Required secrets:** None
- **Supported clients:** Claude, Cursor, VS Code, Windsurf, Any MCP-compatible client, Postgres, MySQL, BigQuery, Spanner, AlloyDB, Snowflake, ClickHouse, MongoDB, Redis
- **License:** Apache-2.0
- **Language:** Go
- **Latest version:** latest
- **Last verified:** 2026-06-15
- **GitHub stars:** 15,627 (fetched 2026-06-22T09:44:48.771Z)
- **Score:** 92/100 (rubric 2026-04 — see https://top-mcps.com/about/methodology)
- **Source:** https://github.com/googleapis/mcp-toolbox
- **Homepage:** https://googleapis.github.io/mcp-toolbox/

## Security & scope

- **Access scope:** read-write
- **Sandbox:** Tools are explicitly declared in `tools.yaml`. Only the queries you define are callable by the agent — there is no implicit `execute_sql` unless you add it. Connections use the DB host's native auth (Postgres roles, BigQuery IAM, MongoDB users, etc.).
- **Gotchas:**
  - A generic `execute_sql` tool in `tools.yaml` is the same risk surface as direct DB access — only add it for read-only DB users on dev/staging.
  - IAM-bound Google Cloud sources inherit the service account or user credentials of the running binary — scope the binary's identity tightly, not your personal account.
  - The streamable-HTTP endpoint (`:5000/mcp`) binds to localhost by default; if you expose it on a network, gate it behind auth at the network or proxy layer.

## Quick answer

**What it does.** Runs as a single Go binary (or container) that connects to one or more databases via a `tools.yaml` config and exposes them as MCP tools — prebuilt schema/query tools plus user-defined custom tools per source.

**Best for:**
- Multi-database agent workflows
- Declarative `tools.yaml` query control
- Google Cloud-native data (AlloyDB, BigQuery, Spanner, Firestore)
- NL2SQL and RAG over enterprise data sources
- One binary, many backends

**Not for:**
- Single-database setups already served by a per-DB MCP
- Workflows where ad-hoc unconstrained SQL is required (use a per-DB MCP with read-only credentials)
- Teams without Go binary / container deploy tooling

## Recipes

### Cross-database lookup: Postgres user + BigQuery activity

```
Using the MCP Toolbox, look up user 42 in Postgres (`get_user_by_id`), then pull their last 30 days of events from BigQuery (`get_recent_events`). Return name, email, event count, and the top three event types.
```

_Tested with: Claude Code, Cursor, Claude Desktop_

## Description

MCP Toolbox for Databases (formerly GenAI Toolbox) is the official open-source MCP server from the `googleapis` GitHub organization that wraps an enterprise database stack behind one MCP. A single Go binary speaks Postgres, MySQL, SQL Server, Oracle, MongoDB, Redis, Elasticsearch, CockroachDB, ClickHouse, Couchbase, Neo4j, Snowflake, Trino, AlloyDB, BigQuery, Cloud SQL, Spanner, and Firestore. Tools are defined declaratively in a `tools.yaml` config — start with the prebuilt `list_tables` / `execute_sql` / schema-exploration tools, then layer in custom NL2SQL or RAG tools per data source as the agent matures.

## Why it matters

Per-database MCPs (Postgres MCP Pro, BigQuery MCP, Snowflake MCP) win on depth; Google MCP Toolbox wins on breadth and on declarative tool definition. For teams whose agents need to span more than one data store — query Postgres for the user record, BigQuery for the analytics aggregate, Redis for the cache state — one configured Toolbox instance is fewer moving parts than three separate MCPs. The declarative `tools.yaml` also turns "what queries can the agent run" into a reviewable, source-controlled artifact.

## Key features

- Published by `googleapis` GitHub org (15.6k stars, Apache-2.0)
- 18+ databases: Postgres, MySQL, SQL Server, Oracle, MongoDB, Redis, Elasticsearch, CockroachDB, ClickHouse, Couchbase, Neo4j, Snowflake, Trino, AlloyDB, BigQuery, Cloud SQL, Spanner, Firestore
- Declarative `tools.yaml` config
- Prebuilt tools: `list_tables`, `execute_sql`, schema exploration, semantic search
- IAM-integrated for Google Cloud sources
- Go binary, container, brew, or `npx @toolbox-sdk/server`
- Streamable-HTTP endpoint at `:5000/mcp` plus stdio

## FAQ

### What is the difference vs. Postgres MCP Pro or Supabase MCP?

Postgres MCP Pro and Supabase MCP are per-database specialists with deep tool surfaces. Google MCP Toolbox is a multi-database server defined declaratively in `tools.yaml`. Pick a per-DB MCP if you only touch one DB and want full depth; pick Toolbox when an agent needs to span Postgres + BigQuery + Redis (or similar) in one workflow.

### Is it tied to Google Cloud?

No. It is published by `googleapis` and IAM-integrates with Google Cloud sources (AlloyDB, BigQuery, Spanner, Firestore), but it speaks Postgres, MySQL, SQL Server, MongoDB, Redis, Snowflake, ClickHouse, and more against any host. Apache-2.0; the binaries are public.

### How do I limit what the agent can do?

Tools are defined explicitly in `tools.yaml`. If you only declare `list_tables` and `get_orders_by_id`, the agent only has those two tools — no ad-hoc SQL. This is the security thesis: declarative > generic `execute_sql`. Combine with a read-only DB user as defence in depth.

### How do I install it?

Four options: pre-compiled binary from `storage.googleapis.com/mcp-toolbox-for-databases/`, `brew install mcp-toolbox`, container at `us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox`, or `npx @toolbox-sdk/server --config tools.yaml`. Binary or container is the recommended path for production.

### Is it active?

Yes — 15.6k stars, last push within the last 24 hours as of 2026-06-15, with a healthy release cadence. The repo was renamed from `genai-toolbox` to `mcp-toolbox` to reflect MCP-first positioning.

## Changelog

- **2026-06-15** — Refreshed install snippets and fact sheet; verified for 2026.
- **2025-04-09** — Initial directory listing.