Key takeaways
- With default settings, DBHub, MCP Toolbox and ExecuteAutomation all let writes through on their write paths. DBHub and Toolbox ran 4 of 4 write statements, including a CTE-prefixed
DELETE; each one's read-only setup then blocked all of them. - Of the three HTTP servers we ran, only Faucet rejected an MCP request with no credentials (401). DBHub answered 200 and listened on
0.0.0.0; Toolbox answered 200 but binds to127.0.0.1by default. FreePeak (not tested) documents that its HTTP mode won't start without an API key. - Adding a second database grows some tool lists and not others. DBHub went from 2 tools to 4 (347 to 726 tokens); Faucet stayed at 8 tools. Table count changed nothing for any server at 5, 11 or 50 tables.
- MCP Toolbox had the smallest default tool list (207 tokens, o200k). Faucet's was the largest by size (8 tools, 1,400 tokens): structured CRUD and schema tools rather than a single
execute_sql. - Row caps differ by default: Faucet returned 25 rows (1,000 max) for
SELECT * FROM InvoiceLine; DBHub, Toolbox and ExecuteAutomation returned all 2,240. - ExecuteAutomation's last npm release is 1.1.0 from May 2025, and the advisory for CVE-2025-59333 lists versions through 1.1.0 as affected. It isn't a good pick for new setups.
We pointed four open-source database MCP servers at the same SQLite files on 2026-10-16, tried to write through each one and added a second database. Two more are compared from docs.
We build Faucet, the open-source database-to-REST-API and MCP server, which is one of the six below. It got the same tests as the others, and the order follows fit, not preference.
What is the best open-source MCP server for multiple databases?
It depends on who connects and from where. Google MCP Toolbox for Databases is best for the widest coverage, including NoSQL and Google Cloud. DBHub is best for a light local server for coding agents across six SQL engines. SQL MCP Server (Microsoft Data API builder) is best for governed CRUD without raw SQL. Faucet is best for shared HTTP access with a key and role per agent, plus a REST API. FreePeak db-mcp-server is best for per-database tools with engine-level read-only. ExecuteAutomation database-server is best only for existing local setups; it is unmaintained, with an open CVE. DBHub, MCP Toolbox and ExecuteAutomation all accepted writes with default settings.
Open-source multi-database MCP servers compared at a glance
| Tool | Best for | License / pricing model | Runtime | Databases | Several DBs in one process | Latest release (2026-10-16) | Managed option | Tested by us? |
|---|---|---|---|---|---|---|---|---|
| Google MCP Toolbox | Widest coverage, Google Cloud | Apache-2.0, free | Go binary (or npx) | Relational, NoSQL (MongoDB, Redis, Elasticsearch, Firestore and more), Google Cloud | Yes, sources in tools.yaml | 1.14.0 | Google runs managed MCP servers for its own databases | Yes (SQLite) |
| DBHub | Light local server for coding agents | MIT, free | Node.js 22.5+ | PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLite | Yes, [[sources]] in dbhub.toml; tools per source | 1.5.0 | None | Yes (SQLite) |
| SQL MCP Server (DAB) | Governed CRUD, Entra ID | MIT, “truly free, with no premium tier” | .NET | SQL Server, Azure SQL, PostgreSQL, MySQL, Cosmos DB, Synapse dedicated SQL pool | Yes, multiple data sources | 2.1.5 | None (self-hosted, including on Azure) | No (docs) |
| Faucet | Shared HTTP access with per-key roles | MIT, free | Single Go binary | PostgreSQL, MySQL, MariaDB (MySQL driver), SQL Server, Oracle, Snowflake, SQLite | Yes, one service per DB; same tools | v0.1.15 (pre-1.0) | None | Yes (SQLite; source build) |
| FreePeak db-mcp-server | Per-database tools | MIT, free | Go | MySQL, PostgreSQL (plus TimescaleDB extension), SQLite, Oracle | Yes; tools per DB unless --unified-tools | v1.14.0 | None | No (docs) |
| ExecuteAutomation | Existing local setups | MIT, free | Node.js | SQLite, SQL Server, PostgreSQL, MySQL | No, one DB per process | 1.1.0 (May 2025) | None | Yes (SQLite) |
Security defaults and extras:
| Tool | Transports | HTTP auth by default | Read-only control | Masking / audit | REST API too? |
|---|---|---|---|---|---|
| Google MCP Toolbox | stdio, Streamable HTTP | None (opt-in OAuth 2.1 resource server); binds 127.0.0.1 | Setting on some sources (Cloud SQL, AlloyDB; BigQuery write mode); none for SQLite | Not built in | No table REST API |
| DBHub | stdio, HTTP | None (opt-in static bearer token); listened on 0.0.0.0 | Per tool in dbhub.toml, enforced by the engine too | Not built in | No |
| SQL MCP Server (DAB) | stdio, Streamable HTTP | Default provider is Unauthenticated (expects a trusted front end) | Per-entity role permissions; no raw SQL | Field include/exclude per role; Application Insights and Log Analytics | Yes, plus GraphQL |
| Faucet | stdio, Streamable HTTP | API key required (X-API-Key) | GET-only role per key, or a read-only service | — † | Yes, with OpenAPI 3.1 |
| FreePeak db-mcp-server | stdio; legacy SSE; experimental Streamable HTTP | HTTP won’t start without an API key, which is read-scope by default; SSE has none | read_only per database; max_rows | Column masking and PII redaction | No |
| ExecuteAutomation | stdio | n/a (stdio only) | None (SELECT-prefix check on read_query) | None | No |
† Re-testing on Faucet v0.1.16.
How we evaluated
Hands-on, for four MCP servers. On 2026-10-16 we ran DBHub 1.5.0, MCP Toolbox 1.14.0, ExecuteAutomation 1.1.0 and Faucet against the Chinook 1.4.5 SQLite database on a Linux box with 8 vCPUs and 15 GB of RAM. Faucet was built from source at commit 2327d63 (v0.1.15 plus 4 unreleased commits; the MCP tool definitions and auth paths are the same as in v0.1.15). Every tool and mode got a fresh copy of the file. The harness is a stdlib-only Python MCP client, and every number below comes from its raw JSON output.
For each server we measured:
- Writes. An
INSERTandUPDATEonArtistand aDELETEonInvoiceLine, sent through every write path. Raw-SQL tools also gotWITH x AS (SELECT 1) DELETE ..., which is valid SQLite but doesn’t start withDELETE. The verdict comes from reading the file back over a separate read-only connection, not from the server’s reply. - Read-only setup. We used each tool’s documented mechanism, or said it has none.
- Unauthenticated access. One MCP request with no credentials.
- Tool-list size. Compact JSON bytes of the
tools/listresult, and tokens from tiktoken’so200k_baseencoding (OpenAI’s tokenizer; Claude’s differs). Repeated at 5, 11 and 50 tables and with two databases. - Row cap.
SELECT * FROM InvoiceLine(2,240 rows). - Cold start. Process launch to first successful query, median of 5 runs. Download and install excluded. These aren’t throughput numbers; for load testing, see our MCP database benchmark.
From docs only: SQL MCP Server, FreePeak, and anything about Postgres, MySQL or OAuth behavior. Competitor facts come from each project’s own repo or docs (see sources); Faucet facts come from its source code.
Also considered: Bytebase’s MCP server runs inside the Bytebase platform (parts under an enterprise license), not as a standalone server; DBHub is Bytebase’s open-source option. mcp-alchemy (MPL-2.0) reaches any SQLAlchemy dialect but documents no read-only mode or HTTP auth. CentralMind Gateway (Apache-2.0) generates MCP and OpenAPI 3.1, but hasn’t been updated since July 2025. ExecuteAutomation is included because tutorials still recommend it.
What we measured
| Faucet | DBHub 1.5.0 | MCP Toolbox 1.14.0 | ExecuteAutomation 1.1.0 | |
|---|---|---|---|---|
Tools / bytes / o200k tokens in tools/list | 8 / 6,285 / 1,400 | 2 / 1,481 / 347 | 2 / 917 / 207 | 10 / 1,842 / 404 |
| Same, at 5 and 50 tables | Unchanged | Unchanged | Unchanged | Unchanged |
| Same, with a second database | 8 / 6,285 / 1,400 | 4 / 3,019 / 726 | Depends on the tools you define | Needs a second process |
| Tool annotations | — † | Full set of hints | readOnlyHint:false, destructiveHint:true on both tools, including list_tables | None |
| Writes landed with defaults | — † (raw SQL refused: off by default) | 4/4, CTE DELETE included | 4/4 | 3/3 via write_query; read_query refused 4/4 |
| Writes landed in read-only setup | 0/9 with a GET-only key (REST and MCP); 0/9 with a read-only service, even as admin | 0/4 (readonly = true) | 0/4 (SQLite mode=ro URI) | No read-only mode |
| Unauthenticated MCP request | 401 | 200 | 200 | stdio only |
Rows from SELECT * FROM InvoiceLine | 25 by default, 1,000 max | 2,240 | 2,240 | 2,240 |
| Cold start, median | 0.051 s (HTTP), 0.025 s (stdio) | 1.512 s (HTTP) | 0.114 s (HTTP) | 0.731 s (stdio) |
† Re-testing on Faucet v0.1.16.
DBHub’s README puts its default tools at 1.4k tokens; we count only the tools/list JSON, and the README doesn’t say how it measured, so client overhead may explain the gap.
How do these servers connect to several databases at once?
All but ExecuteAutomation serve several databases from one process; they differ in what the agent sees. DBHub and FreePeak add tools per database. Faucet keeps one tool set and takes the database as a parameter. Toolbox exposes the tools you define per source, and SQL MCP Server exposes entities across data sources.
In our two-database run, DBHub listed execute_sql_db0, search_objects_db0, execute_sql_db1 and search_objects_db1, doubling its token count. Toolbox served one tool per source from a two-source tools.yaml. Faucet listed the same 8 tools for two services as for one.
How should you choose an open-source multi-database MCP server?
Who connects?
One developer’s local agent needs stdio and a read-only setting: DBHub, Toolbox or FreePeak. Several agents sharing databases over a network need per-caller credentials: Faucet’s API keys, SQL MCP Server’s identity providers, or Toolbox with OAuth.
Where is read-only enforced?
Prefer the database engine or role checks over a check on how the statement starts. DBHub and FreePeak use engine mechanisms, SQL MCP Server and Faucet use roles, and ExecuteAutomation’s prefix check has a published bypass.
Is HTTP authenticated by default?
Only Faucet required credentials in our run; DBHub and Toolbox need a flag or config, and FreePeak’s HTTP mode needs a key to start.
How big is the tool list?
Tool definitions cost context on every turn. Toolbox and DBHub start small, DBHub and FreePeak grow per database, and Faucet is the largest but fixed.
1. Google MCP Toolbox for Databases — Best for the widest database coverage
Best for: teams that need one server across many kinds of data, including NoSQL stores and Google Cloud databases.
MCP Toolbox (Apache-2.0) is Google’s database MCP server. The repo was renamed from genai-toolbox to googleapis/mcp-toolbox. Its README lists Google Cloud databases, the major SQL engines, MongoDB, Redis, Elasticsearch, Neo4j, Snowflake and Trino “and more”. We ran its SQLite prebuilt config:
SQLITE_DATABASE=/data/chinook.db ./toolbox --prebuilt sqlite --port 5000
Strengths
- Smallest tool list we measured: two tools (
execute_sql,list_tables) in 917 bytes, 207 tokens, at any table count. Larger prebuilt configs, such as Postgres, carry more tools;--prebuilt=<db>/<toolset>loads a subset. - Quick to install and start. One binary you
chmod, 0.114 s median cold start over HTTP. - Custom tools in
tools.yamlreplace free-form SQL with fixed, parameterized statements, which is the safer pattern for production agents. The same file can hold several sources. - Auth when you turn it on. Toolbox can act as an OAuth 2.1 resource server on
/mcp(anauthServicewithmcpEnabled: true), validating JWTs from your OIDC provider, and it serves protected-resource metadata. - Binds to
127.0.0.1by default (per--help), so an unauthenticated endpoint isn’t reachable from the network unless you change--address. - Google also runs managed MCP servers for AlloyDB, Spanner, Cloud SQL, Bigtable and Firestore if you’d rather not host anything.
Things to know
- No auth on
/mcpunless you configure it. Our unauthenticatedtools/listreturned 200. - No read-only switch for SQLite. Toolbox’s read-only docs cover Cloud SQL (Postgres and MySQL), AlloyDB and BigQuery (through a write mode); the SQLite source in 1.14.0 has none. With defaults, 4 of 4 writes landed. We got to 0/4 only by passing a
file:...?mode=roURI, which SQLite enforces, not Toolbox. - Both tools, including
list_tables, are markeddestructiveHint:true, so clients may ask for confirmation on every read. - No row cap on
execute_sqlby default: ourSELECT *returned all 2,240 rows.
Who should choose it
Platform teams with mixed or Google Cloud data, and anyone who wants to hand agents curated tools rather than raw SQL. Teams look past it when they want something simpler on a laptop (DBHub) or per-agent keys plus a REST API (Faucet). Vendor-run servers from Snowflake, Oracle and others are covered in every database vendor now ships an MCP server.
2. DBHub — Best for a lightweight local server for coding agents
Best for: developers connecting Claude Code, Cursor or similar to local and staging databases across several SQL engines.
DBHub (Bytebase, MIT, npm @bytebase/dbhub) is a Node.js server for PostgreSQL, MySQL, MariaDB, SQL Server, Oracle and SQLite. It loads two tools by default, execute_sql and search_objects, and keeps everything else opt-in.
Strengths
-
Small and predictable footprint: 2 tools, 1,481 bytes, 347 tokens. With our read-only config it listed one tool in 461 bytes (112 tokens). That matters when an agent juggles many servers; we covered why in the MCP context-window tax.
-
Read-only that held. Seven lines of
dbhub.tomlstopped all four writes, including the CTEDELETE:[[sources]] id = "chinook" dsn = "sqlite:///data/chinook.db" [[tools]] name = "execute_sql" source = "chinook" readonly = trueDBHub’s docs describe two layers: a statement allow-list, then the engine’s own read-only mechanism (for example
PRAGMA query_onlyon SQLite). -
Full set of tool annotations, so clients can tell reads from writes.
-
max_rowsper tool capsSELECTresults and flags truncation.
Things to know
- Auth is off by default. The docs say auth “is off unless you configure”
--auth-token, a shared static bearer token they call “not OAuth.” Our unauthenticatedtools/listreturned 200, and so did the workbench’s/api/sources. - Listens on
0.0.0.0by default in HTTP mode; our run logged it. Pass--host 127.0.0.1or put it behind a proxy. - Writes are allowed until you configure read-only: 4 of 4 landed with defaults. Read-only is set per tool in TOML; the old
--readonlyCLI flag is gone. - Tool list grows per database: two SQLite sources gave 4 tools and 726 tokens.
- No row cap unless you set
max_rows: 2,240 rows came back. - Slowest cold start we measured, 1.512 s median over HTTP.
Who should choose it
Individual developers and small teams running agents against their own databases, on localhost. Teams outgrow DBHub when they need network auth (Faucet, SQL MCP Server, or Toolbox with OAuth) or non-SQL sources (Toolbox). For Postgres-only setups, see PostgreSQL MCP servers compared.
3. SQL MCP Server (Data API builder) — Best for governed CRUD without raw SQL
Best for: teams, especially on Azure, who want agents to work only through declared entities and role rules.
Not tested by us. SQL MCP Server is part of Microsoft’s Data API builder (DAB) from 1.7; Microsoft says to “use the latest 2.0 release,” which was 2.1.5 on 2026-10-16. DAB is MIT licensed and, in Microsoft’s words, “truly free, with no premium tier.” One JSON config serves REST, GraphQL and MCP over SQL Server, Azure SQL, PostgreSQL, MySQL, Cosmos DB and Azure Synapse dedicated SQL pools.
Strengths
- No NL2SQL and no DDL, by design. Agents get seven DML tools (
describe_entities,create_record,read_records,update_record,delete_record,execute_entity,aggregate_records) over the entities you expose. - Per-entity role permissions with field include and exclude, applied identically across REST, GraphQL and MCP.
- Identity providers: Microsoft Entra ID, custom JWT (Okta, Auth0, Keycloak) and App Service EasyAuth.
- Auto configuration on SQL Server: an
autoentitiessection (ordab auto-config) exposes every table matching a pattern without per-entity declarations.
Things to know
- The default auth provider is Unauthenticated, which assumes a trusted front end handles identity.
- No API-key security in Microsoft’s feature table; you need an identity provider (stdio mode uses the simulator).
- No SQLite or Oracle.
aggregate_records, stored procedures as tools and custom tools are unsupported on PostgreSQL and MySQL, as are some types such as PostgreSQLtimestamptz. - Auto configuration is SQL Server only. On PostgreSQL and MySQL you declare each entity, which is safer and slower to set up than introspection.
Who should choose it
Azure and Microsoft-identity shops building agent features on a known set of tables. If you’d rather hand each agent an API key than run an identity provider, Faucet is the closer fit. Our SQL Server MCP servers comparison covers DAB on its home engine.
4. Faucet — Best for shared HTTP access with per-key roles
Best for: teams where several agents or apps reach the same databases over the network, each with its own key and permissions, and who also want a REST API.
Faucet (MIT, single Go binary) connects seven SQL engines and serves an MCP endpoint at /mcp, a REST API with an OpenAPI 3.1 spec, and an admin UI on one port. This is the setup we tested:
export FAUCET_ADMIN_EMAIL=you@example.com FAUCET_ADMIN_PASSWORD='use-a-long-password'
faucet db add --name chinook --driver sqlite --path chinook.db
faucet role create --name readonly --verbs GET
faucet key create --role readonly
faucet serve --host 127.0.0.1
claude mcp add --transport http faucet http://localhost:8080/mcp --header 'X-API-Key: <key>'
Strengths
- The MCP and data endpoints need a key. With no credentials, the data API,
/mcpand the per-service OpenAPI document all returned 401. - Per-key read-only from the CLI. The GET-only key above blocked 9 of 9 write attempts across REST and MCP, with errors like
Forbidden: Role "readonly" does not permit .... Roles can be scoped per database and per table; see the RBAC docs. - A read-only service that even admins can’t bypass. With the service set to
read_only, 0 of 9 writes landed over HTTP as admin with raw SQL enabled, and 0 of 6 over stdio. - Raw SQL is off by default.
faucet_raw_sqlwas refused even for admin until it is enabled per service. - Row cap by default: queries return 25 rows unless asked for more, and a
limitof 5,000 was clamped to 1,000. - Fixed tool list: two databases listed the same 8 tools as one.
- Fast cold start: 0.051 s median to the first MCP query over HTTP.
Things to know
- A newer project, still pre-1.0, so it has a shorter track record than Toolbox or DBHub.
- SQL engines only: REST and MCP for seven SQL databases, no NoSQL or Google Cloud sources.
- API-key auth. Agents authenticate with an
X-API-Keyheader; give each agent its own key. - Largest tool list by size of the four: 8 tools, 1,400 tokens, because it exposes structured CRUD and schema tools rather than a single
execute_sql. The list stays the same as you add databases. - Telemetry: release binaries send anonymous usage telemetry unless
FAUCET_TELEMETRY=0is set (see TELEMETRY.md); our source build had it off.
Who should choose it
Teams that want agents and apps to share one governed path to several SQL databases, with a key per agent. Client setup is in the guide to connecting Claude to your database and the Faucet MCP server docs. For the REST side on specific engines, see the PostgreSQL REST API and SQL Server REST API guides.
5. FreePeak db-mcp-server — Best for per-database tools with engine-level read-only
Best for: developers connecting several databases at once who want each one exposed as its own named set of tools.
Not tested by us. FreePeak’s db-mcp-server is an MIT-licensed Go server for MySQL, PostgreSQL, SQLite and Oracle, with extra tools for PostgreSQL databases that have the TimescaleDB extension. It is actively released (v1.14.0 on 2026-10-13).
Strengths
- Tools per database: each configured database gets
query_<id>,execute_<id>,transaction_<id>,schema_<id>,performance_<id>and more. A--unified-toolsflag collapses them into tools that take adatabaseparameter. - Read-only per database with
"read_only": true; the README says Postgres, TimescaleDB and MySQL enforce it at the engine and SQLite opens inmode=ro. - HTTP refuses to start without a key. Its experimental Streamable HTTP transport requires
DB_MCP_API_KEY, and that key grants onlydb:readunless you adddb:writetoDB_MCP_API_SCOPES. OIDC is optional. - Data protection built in: column masking (
masking_rules), PII redaction (mask_pii) andmax_rows.
Things to know
- Streamable HTTP is labeled experimental; stdio is recommended.
- The legacy SSE transport is off by default for the binary and, per the README, doesn’t apply the API key. The published Docker image is described as a development artifact and includes the insecure SSE behavior.
- For Oracle, read-only relies on a statement classifier plus database privileges.
- Per-database tools multiply the tool list as you add databases, which is what
--unified-toolsis for.
Who should choose it
Developers who want explicit per-database tools, engine-level read-only and masked results, over stdio or behind a proxy.
6. ExecuteAutomation database-server — Best for existing local setups only
Best for: people already running it locally over stdio; we wouldn’t start a new project on it.
@executeautomation/database-server (MIT) is a stdio server for SQLite, SQL Server, PostgreSQL and MySQL with ten tools, including read_query, write_query, table DDL tools and CSV/JSON export. It takes one database per process.
Strengths
- Simple npm setup;
drop_tablerequires an explicitconfirmflag. - In our run,
read_queryrefused all four non-SELECT statements, including the CTEDELETE.
Things to know
- No read-only mode.
write_querylet 3 of 3 writes through, and nothing turns it off. - Unpatched advisory. OSV lists CVE-2025-59333 (high, CVSS 8.1) as affecting versions through 1.1.0:
read_query’s SELECT-prefix check can be bypassed with chained statements or side-effect functions. 1.1.0 (May 2025) is still the latest npm release, and the repo’s last commit was on 2025-08-27. We didn’t test the chained-statement case. - No tool annotations, no row cap (2,240 rows returned) and stdio only.
Who should choose it
Only existing users who can’t move yet. If that’s you, connect it with a database account that has no write privileges; our guide to giving an AI agent read-only database access shows how per engine.
DBHub vs MCP Toolbox
On the same SQLite file:
- Footprint: Toolbox’s SQLite config was smaller (207 against 347 tokens), but DBHub’s read-only config shrank to 112. Toolbox’s Postgres config carries many more tools.
- Several databases: DBHub adds tools per
[[sources]]block automatically; Toolbox needs a tool defined per source. - Startup: 0.114 s for Toolbox, 1.512 s for DBHub.
- Read-only: DBHub’s per-tool switch blocked 4 of 4 writes. Toolbox’s SQLite source has no switch; a read-only URI worked, enforced by SQLite.
- Network auth: neither requires it by default. DBHub offers a static bearer token and listens on
0.0.0.0; Toolbox offers OAuth 2.1 and binds to127.0.0.1. - Coverage: six SQL engines for DBHub; Toolbox adds NoSQL and Google Cloud.
Choose DBHub for a small local SQL server; Toolbox for breadth, curated tools or OAuth.
Bottom line
For breadth, start with MCP Toolbox. For a light local server, DBHub. For governed CRUD with an identity provider, SQL MCP Server. For network access with a key per agent, Faucet was the one tested server that required credentials by default; FreePeak documents the same for its experimental HTTP mode. Whatever you choose, turn on read-only and use a database account that can’t write: with defaults, DBHub, Toolbox and ExecuteAutomation all took writes. Our database MCP server security checklist walks through the rest.
To try Faucet against your own database, the getting started guide takes a few minutes.
Frequently asked questions
What is Google MCP Toolbox for Databases?
MCP Toolbox for Databases is Google's open-source (Apache-2.0) MCP server for databases. It runs as a single binary or through npx. Prebuilt configs such as --prebuilt=postgres or --prebuilt=sqlite give agents ready-made tools, and tools.yaml lets you define fixed, parameterized SQL tools. Its sources include PostgreSQL, MySQL, SQL Server, Oracle, SQLite, Snowflake, MongoDB, Redis and Google Cloud databases.
Is MCP Toolbox the same as genai-toolbox?
Yes. Google renamed the GitHub repository from googleapis/genai-toolbox to googleapis/mcp-toolbox, and the README says so. Docs now live at mcp-toolbox.dev and the npm launcher is @toolbox-sdk/server. Older tutorials and configs that mention genai-toolbox describe the same project, so check that the version they use is still current (1.14.0 on 2026-10-16).
DBHub vs MCP Toolbox: which is better?
It depends on the job. DBHub is lighter to configure for local coding agents: two default tools, per-tool read-only in dbhub.toml, and six SQL engines. MCP Toolbox covers far more sources, including NoSQL and Google Cloud, starts faster in our test (0.114 s against 1.512 s), and supports opt-in OAuth 2.1 on its MCP endpoint. Both allowed writes with default settings.
Which open-source MCP server supports the most databases?
Of the servers in this comparison, Google MCP Toolbox lists the most sources: relational databases, NoSQL stores such as MongoDB, Redis and Elasticsearch, and Google Cloud services such as BigQuery and Spanner. Faucet covers seven SQL engines (MariaDB through its MySQL driver), DBHub six, Microsoft's SQL MCP Server five including Cosmos DB, and FreePeak and ExecuteAutomation four each.
Can one open-source MCP server connect to Postgres and MySQL at the same time?
Yes. DBHub takes several [[sources]] in dbhub.toml, Toolbox takes several sources in tools.yaml, Faucet adds one service per database, FreePeak connects several databases concurrently, and Data API builder supports multiple data sources. ExecuteAutomation takes one database per process. We tested two databases at once with SQLite files only; mixed engines are documented by each project but weren't part of our run.
Does DBHub support authentication?
Only as an option. DBHub's docs say auth is off unless you pass --auth-token, which checks a shared static bearer token on the HTTP transport and is described as "not OAuth." In our test, an unauthenticated tools/list call to DBHub 1.5.0 returned 200, and the server listened on 0.0.0.0. Use --host 127.0.0.1 or a proxy.
Which database MCP server uses the fewest tokens?
Counting the tools/list JSON with the o200k tokenizer, MCP Toolbox's prebuilt SQLite config was smallest at 207 tokens, then DBHub at 347, ExecuteAutomation at 404 and Faucet at 1,400. Claude's tokenizer gives different counts. Why it matters for agents: the MCP context-window tax.
Sources
- Chinook database v1.4.5 release (test fixture) (checked )
- Google MCP Toolbox for Databases repository (checked )
- MCP Toolbox releases (checked )
- MCP Toolbox docs: Read-only mode (checked )
- MCP Toolbox docs: Toolbox with MCP Authorization (checked )
- Google Cloud blog: managed MCP servers for Google Cloud databases (checked )
- DBHub repository and README (checked )
- DBHub releases (checked )
- DBHub docs: command-line options (--host, --auth-token) (checked )
- DBHub docs: execute_sql (read-only and max_rows) (checked )
- Microsoft Learn: SQL MCP Server overview (checked )
- Microsoft Learn: What is Data API builder? (checked )
- Microsoft Learn: Data API builder feature availability (checked )
- Microsoft Learn: Data API builder autoentities configuration (checked )
- Data API builder releases (checked )
- FreePeak db-mcp-server repository and README (checked )
- FreePeak db-mcp-server releases (checked )
- ExecuteAutomation mcp-database-server repository (checked )
- ExecuteAutomation mcp-database-server commit history (checked )
- @executeautomation/database-server on npm (registry metadata) (checked )
- OSV: CVE-2025-59333 (GHSA-65hm-pwj5-73pw) (checked )
- Bytebase docs: Model Context Protocol (MCP) (checked )
- mcp-alchemy repository (checked )
- CentralMind Gateway repository (checked )
- Faucet source code (faucetdb/faucet) (checked )
- Faucet telemetry policy (TELEMETRY.md) (checked )
Last reviewed