Open-Source MCP Servers for Multiple Databases: 6 Compared

Six open-source MCP servers for several databases, four of them run on the same SQLite file: writes, read-only, auth, tool tokens and cold start.

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 to 127.0.0.1 by 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

ToolBest forLicense / pricing modelRuntimeDatabasesSeveral DBs in one processLatest release (2026-10-16)Managed optionTested by us?
Google MCP ToolboxWidest coverage, Google CloudApache-2.0, freeGo binary (or npx)Relational, NoSQL (MongoDB, Redis, Elasticsearch, Firestore and more), Google CloudYes, sources in tools.yaml1.14.0Google runs managed MCP servers for its own databasesYes (SQLite)
DBHubLight local server for coding agentsMIT, freeNode.js 22.5+PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, SQLiteYes, [[sources]] in dbhub.toml; tools per source1.5.0NoneYes (SQLite)
SQL MCP Server (DAB)Governed CRUD, Entra IDMIT, “truly free, with no premium tier”.NETSQL Server, Azure SQL, PostgreSQL, MySQL, Cosmos DB, Synapse dedicated SQL poolYes, multiple data sources2.1.5None (self-hosted, including on Azure)No (docs)
FaucetShared HTTP access with per-key rolesMIT, freeSingle Go binaryPostgreSQL, MySQL, MariaDB (MySQL driver), SQL Server, Oracle, Snowflake, SQLiteYes, one service per DB; same toolsv0.1.15 (pre-1.0)NoneYes (SQLite; source build)
FreePeak db-mcp-serverPer-database toolsMIT, freeGoMySQL, PostgreSQL (plus TimescaleDB extension), SQLite, OracleYes; tools per DB unless --unified-toolsv1.14.0NoneNo (docs)
ExecuteAutomationExisting local setupsMIT, freeNode.jsSQLite, SQL Server, PostgreSQL, MySQLNo, one DB per process1.1.0 (May 2025)NoneYes (SQLite)

Security defaults and extras:

ToolTransportsHTTP auth by defaultRead-only controlMasking / auditREST API too?
Google MCP Toolboxstdio, Streamable HTTPNone (opt-in OAuth 2.1 resource server); binds 127.0.0.1Setting on some sources (Cloud SQL, AlloyDB; BigQuery write mode); none for SQLiteNot built inNo table REST API
DBHubstdio, HTTPNone (opt-in static bearer token); listened on 0.0.0.0Per tool in dbhub.toml, enforced by the engine tooNot built inNo
SQL MCP Server (DAB)stdio, Streamable HTTPDefault provider is Unauthenticated (expects a trusted front end)Per-entity role permissions; no raw SQLField include/exclude per role; Application Insights and Log AnalyticsYes, plus GraphQL
Faucetstdio, Streamable HTTPAPI key required (X-API-Key)GET-only role per key, or a read-only service— †Yes, with OpenAPI 3.1
FreePeak db-mcp-serverstdio; legacy SSE; experimental Streamable HTTPHTTP won’t start without an API key, which is read-scope by default; SSE has noneread_only per database; max_rowsColumn masking and PII redactionNo
ExecuteAutomationstdion/a (stdio only)None (SELECT-prefix check on read_query)NoneNo

† 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 INSERT and UPDATE on Artist and a DELETE on InvoiceLine, sent through every write path. Raw-SQL tools also got WITH x AS (SELECT 1) DELETE ..., which is valid SQLite but doesn’t start with DELETE. 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/list result, and tokens from tiktoken’s o200k_base encoding (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

FaucetDBHub 1.5.0MCP Toolbox 1.14.0ExecuteAutomation 1.1.0
Tools / bytes / o200k tokens in tools/list8 / 6,285 / 1,4002 / 1,481 / 3472 / 917 / 20710 / 1,842 / 404
Same, at 5 and 50 tablesUnchangedUnchangedUnchangedUnchanged
Same, with a second database8 / 6,285 / 1,4004 / 3,019 / 726Depends on the tools you defineNeeds a second process
Tool annotations— †Full set of hintsreadOnlyHint:false, destructiveHint:true on both tools, including list_tablesNone
Writes landed with defaults— † (raw SQL refused: off by default)4/4, CTE DELETE included4/43/3 via write_query; read_query refused 4/4
Writes landed in read-only setup0/9 with a GET-only key (REST and MCP); 0/9 with a read-only service, even as admin0/4 (readonly = true)0/4 (SQLite mode=ro URI)No read-only mode
Unauthenticated MCP request401200200stdio only
Rows from SELECT * FROM InvoiceLine25 by default, 1,000 max2,2402,2402,240
Cold start, median0.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.yaml replace 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 (an authService with mcpEnabled: true), validating JWTs from your OIDC provider, and it serves protected-resource metadata.
  • Binds to 127.0.0.1 by 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 /mcp unless you configure it. Our unauthenticated tools/list returned 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=ro URI, which SQLite enforces, not Toolbox.
  • Both tools, including list_tables, are marked destructiveHint:true, so clients may ask for confirmation on every read.
  • No row cap on execute_sql by default: our SELECT * 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.toml stopped all four writes, including the CTE DELETE:

    [[sources]]
    id = "chinook"
    dsn = "sqlite:///data/chinook.db"
    
    [[tools]]
    name = "execute_sql"
    source = "chinook"
    readonly = true

    DBHub’s docs describe two layers: a statement allow-list, then the engine’s own read-only mechanism (for example PRAGMA query_only on SQLite).

  • Full set of tool annotations, so clients can tell reads from writes.

  • max_rows per tool caps SELECT results 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 unauthenticated tools/list returned 200, and so did the workbench’s /api/sources.
  • Listens on 0.0.0.0 by default in HTTP mode; our run logged it. Pass --host 127.0.0.1 or 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 --readonly CLI 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 autoentities section (or dab 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 PostgreSQL timestamptz.
  • 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, /mcp and 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_sql was refused even for admin until it is enabled per service.
  • Row cap by default: queries return 25 rows unless asked for more, and a limit of 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-Key header; 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=0 is 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-tools flag collapses them into tools that take a database parameter.
  • Read-only per database with "read_only": true; the README says Postgres, TimescaleDB and MySQL enforce it at the engine and SQLite opens in mode=ro.
  • HTTP refuses to start without a key. Its experimental Streamable HTTP transport requires DB_MCP_API_KEY, and that key grants only db:read unless you add db:write to DB_MCP_API_SCOPES. OIDC is optional.
  • Data protection built in: column masking (masking_rules), PII redaction (mask_pii) and max_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-tools is 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_table requires an explicit confirm flag.
  • In our run, read_query refused all four non-SELECT statements, including the CTE DELETE.

Things to know

  • No read-only mode. write_query let 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 to 127.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

Last reviewed