mcp-toolbox is a free, open source databases project written in Go and released under Apache-2.0. It has 16,443 GitHub stars, 1,727 forks and 292 open issues, and was last pushed 5 hours ago. On this registry it ranks #39 of 81 tracked projects in Databases, with 5 head-to-head comparisons available. It gained 29 stars over the last 3 tracked days.

What is mcp-toolbox?

MCP Toolbox for Databases is an open source Model Context Protocol (MCP) server, written in Go and licensed under Apache-2.0, that connects AI agents, IDEs, and applications directly to enterprise databases.

What it is

MCP Toolbox lives in the Model Context Protocol ecosystem, the interface layer that lets AI clients and agents call external tools. It runs as a server that sits between an MCP client and a database, exposing database access as tools rather than as hand-written integration code. Topics for the project include agent, agents, ai, genai, llm, mcp, and database, alongside specific engines such as bigquery, clickhouse, cockroachdb, elasticsearch, and firestore. It was originally named "Gen AI Toolbox for Databases" under the repository googleapis/genai-toolbox, because its initial development predated MCP, and was later renamed to align with MCP compatibility; the repository genai-toolbox is now mcp-toolbox.

The concrete problem it solves is boilerplate. Connecting an agent or an IDE to a database normally means writing and maintaining per-database glue code, connection handling, and auth. MCP Toolbox replaces that with a prebuilt server and a custom tools framework, so a developer can query data, explore schemas, and generate code without writing the integration layer. It also targets the safety gap that raw database credentials create for production agents, by letting teams define structured queries and restricted access instead of open-ended access.

Key capabilities

  • Prebuilt generic tools for instant data exploration, including list_tables and execute_sql, usable directly from an IDE or CLI.
  • Custom tools framework for production agents, with predefined logic built around Restricted Access, Structured Queries, Semantic Search, and NL2SQL.
  • Official SDKs across four languages: Python (toolbox-core), JS/TS (@toolbox-sdk/core), Go (github.com/googleapis/mcp-toolbox-sdk-go), and Java (com.google.cloud.mcp/mcp-toolbox-sdk-java).
  • Integration with Agent Development Kit (ADK), LangChain, LlamaIndex, or custom agents in less than 10 lines of code.
  • Connection pooling and integrated authentication (IAM) handled by the server out of the box.
  • End-to-end observability with out-of-the-box metrics and tracing, using built-in OpenTelemetry support.

Who uses it and how

  • Developers connecting Gemini CLI, Google Antigravity, Claude Code, Codex, or another MCP client to a database to query data in plain English.
  • Teams automating schema discovery and code generation from an IDE, avoiding context-switching between editor and database console.
  • Agent engineers building specialized run-time tools for production, using predefined logic and restricted access rather than unrestricted credentials.
  • Application teams embedding database tools into ADK, LangChain, or LlamaIndex agents through the Python, JS/TS, Go, or Java SDK.

Getting started

The README covers installing and running the Toolbox server, then connecting an MCP client or an application through the SDKs. Full instructions live at https://mcp-toolbox.dev/, with an introduction page at https://mcp-toolbox.dev/documentation/introduction/.

How it compares

The facts provided do not name any comparable MCP server or competing product, paid or otherwise. Within this registry it stands alone as the entry covering MCP-based database connectivity.

When to use it — and when not to

A self-hoster must run and operate the Toolbox server itself, and must already have a database and an MCP-capable client to point at it. The README excerpt is only a brief overview and defers to the full documentation site, so anyone needing a self-contained repository walkthrough should expect to read external docs first. The repository rename also adds a migration step for existing clones, which must update their remote with git remote set-url origin https://github.com/googleapis/mcp-toolbox.git.

project readme (upstream, from github) — read inline

logo

MCP Toolbox for Databases

googleapis%2Fmcp-toolbox | Trendshift

License: Apache
2.0 Docs Discord Medium

Python SDK JS/TS SDK Go SDK Java SDK

MCP Toolbox for Databases is an open source Model Context Protocol (MCP) server that connects your AI agents, IDEs, and applications directly to your enterprise databases.

It serves a dual purpose:

  1. Ready-to-use MCP Server (Build-Time): Instantly connect Gemini CLI, Google Antigravity, Claude Code, Codex, or other MCP clients to your databases using our prebuilt generic tools. Talk to your data, explore schemas, and generate code without writing boilerplate.
  2. Custom Tools Framework (Run-Time): A robust framework to build specialized, highly secure AI tools for your production agents. Define structured queries, semantic search, and NL2SQL capabilities safely and easily.

This README provides a brief overview. For comprehensive details, see the full documentation.

[!IMPORTANT]
Repository Name Update: The genai-toolbox repository has been officially renamed to mcp-toolbox. To ensure your local environment reflects the new name, you may update your remote: git remote set-url origin https://github.com/googleapis/mcp-toolbox.git

[!NOTE] This solution was originally named “Gen AI Toolbox for Databases” (github.com/googleapis/genai-toolbox) as its initial development predated MCP, but was renamed to align with the MCP compatibility.

Table of Contents


Why MCP Toolbox?

  • Out-of-the-Box Database Access: Prebuilt generic tools for instant data exploration (e.g., list_tables, execute_sql) directly from your IDE or CLI.
  • Custom Tools Framework: Build production-ready tools with your own predefined logic, ensuring safety through Restricted Access, Structured Queries, and Semantic Search.
  • Simplified Development: Integrate tools into your Agent Development Kit (ADK), LangChain, LlamaIndex, or custom agents in less than 10 lines of code.
  • Better Performance: Handles connection pooling, integrated auth (IAM), and end-to-end observability (OpenTelemetry) out of the box.
  • Enhanced Security: Integrated authentication for more secure access to your data.
  • End-to-end Observability: Out of the box metrics and tracing with built-in support for OpenTelemetry.

Quick Start: Prebuilt Tools

Stop context-switching and let your AI assistant become a true co-developer. By connecting your IDE to your databases with MCP Toolbox, you can query your data in plain English, automate schema discovery and management, and generate database-aware code.

You can use the Toolbox in any MCP-compatible IDE or client (e.g., Gemini CLI, Google Antigravity, Claude Code, Codex, etc.) by configuring the MCP server.

Prebuilt tools are also conveniently available via the Google Antigravity MCP Store with a simple click-to-install experience.

  1. Add the following to your client's MCP configuration file (usually mcp.json or claude_desktop_config.json):

    {
      "mcpServers": {
        "toolbox-postgres": {
          "command": "npx",
          "args": [
            "-y",
            "@toolbox-sdk/server",
            "--prebuilt=postgres",
            "--stdio"
          ]
        }
      }
    }
    
  2. Set the appropriate environment variables to connect, see the Prebuilt Tools Reference.

When you run Toolbox with a --prebuilt= flag, you instantly get access to standard tools to interact with that database. You can also specify a specific toolset using the --prebuilt=/ syntax (e.g., --prebuilt=postgres/data to only load SQL tools).

Supported databases currently include:

  • Google Cloud: AlloyDB, BigQuery, Cloud SQL (PostgreSQL, MySQL, SQL Server), Spanner, Firestore, Knowledge Catalog (formerly known as Dataplex).
  • Other Databases: PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, MongoDB, Redis, Elasticsearch, CockroachDB, ClickHouse, Couchbase, Neo4j, Snowflake, Trino, and more.

For a full list of available tools and their capabilities across all supported databases, see the Prebuilt Tools Reference.

See the Install & Run the Toolbox server section for different execution methods like Docker or binaries.

[!TIP] For users looking for a managed solution, Google Cloud MCP Servers provide a managed MCP experience with prebuilt tools; you can learn more about the differences here.


Quick Start: Custom Tools

Toolbox can also be used as a framework for customized tools. The primary way to configure Toolbox is through the tools.yaml file. If you have multiple files, you can tell Toolbox which to load with the --config tools.yaml flag.

You can find more detailed reference documentation to all resource types in the Resources.

Sources

The sources section of your tools.yaml defines what data sources your Toolbox should have access to. Most tools will have at least one source to execute against.

kind: source
name: my-pg-source
type: postgres
host: 127.0.0.1
port: 5432
database: toolbox_db
user: toolbox_user
password: my-password

For more details on configuring different types of sources, see the Sources.

Tools

The tools section of a tools.yaml define the actions an agent can take: what type of tool it is, which source(s) it affects, what parameters it uses, etc.

kind: tool
name: search-hotels-by-name
type: postgres-sql
source: my-pg-source
description: Search for hotels based on name.
parameters:
  - name: name
    type: string
    description: The name of the hotel.
statement: SELECT * FROM hotels WHERE name ILIKE '%' || $1 || '%';

For more details on configuring different types of tools, see the Tools.

Toolsets

The toolsets section of your tools.yaml allows you to define groups of tools that you want to be able to load together. This can be useful for defining different groups based on agent or application.

kind: toolset
name: my_first_toolset
tools:
    - my_first_tool
    - my_second_tool
---
kind: toolset
name: my_second_toolset
tools:
    - my_second_tool
    - my_third_tool

Prompts

The prompts section of a tools.yaml defines prompts that can be used for interactions with LLMs.

kind: prompt
name: cod

readme truncated — read the full docs on github

Frequently asked questions

Is mcp-toolbox free to use?

mcp-toolbox is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does mcp-toolbox do?

MCP Toolbox for Databases is an open source MCP server for databases.

What is mcp-toolbox written in?

mcp-toolbox is primarily written in Go. Its source is publicly available at https://github.com/googleapis/mcp-toolbox, and it has 16,443 GitHub stars.