How Many Databases Does dbx Support? A Complete Guide to All 62 Supported Database Types

dbx supports 62 distinct database types, ranging from traditional relational databases like PostgreSQL and MySQL to modern vector databases like Milvus and Qdrant, as defined in the DBX_CONNECTION_TYPE_DESCRIPTION constant in the MCP server source code.

The open-source dbx project (repository t8y2/dbx) provides a unified database connector that abstracts interactions across dozens of database engines. Understanding the full scope of supported databases helps developers determine if dbx covers their specific data infrastructure requirements.

The Complete List of 62 Supported Databases

According to the source code in packages/mcp-server/src/index.ts, the DBX_CONNECTION_TYPE_DESCRIPTION constant explicitly enumerates every supported database type:

export const DBX_CONNECTION_TYPE_DESCRIPTION =
  "Database type: postgres, mysql, sqlite, rqlite, redis, duckdb, clickhouse, sqlserver, mongodb, oracle, elasticsearch, etcd, doris, starrocks, manticoresearch, milvus, qdrant, weaviate, chromadb, redshift, dameng, kingbase, highgo, vastbase, goldendb, databend, gaussdb, kwdb, yashandb, databricks, saphana, teradata, vertica, firebird, exasol, opengauss, oceanbase-oracle, questdb, gbase, h2, snowflake, trino, prestosql, hive, spark, db2, informix, influxdb, iris, neo4j, cassandra, bigquery, kylin, sundb, oscar, tdengine, iotdb, xugu, zookeeper, jdbc, access, mq";

Parsing this comma-separated list yields 62 unique database identifiers:

• Relational Databases: postgres, mysql, sqlite, sqlserver, oracle, db2, informix, firebird, h2, access, dameng, kingbase, highgo, vastbase, goldendb, gaussdb, opengauss, oceanbase-oracle, gbase, oscar, xugu, sundb, kylin, teradata, vertica, saphana, exasol, redshift, databricks, snowflake, trino, prestosql, hive, spark, yashandb
• MySQL-Compatible: doris, starrocks, manticoresearch
• Embedded/Distributed: rqlite, etcd, zookeeper
• NoSQL/Document: mongodb, redis, cassandra, neo4j, elasticsearch
• Vector/AI: milvus, qdrant, weaviate, chromadb
• Time-Series: influxdb, questdb, kwdb, tdengine, iotdb, iris
• Cloud/Data Warehouses: bigquery, clickhouse, databend
• Connectivity: jdbc, mq

How Database Support Is Implemented in dbx

The dbx codebase organizes database support through several key constants that define capabilities and query types.

Primary Database Enumeration

The DBX_CONNECTION_TYPE_DESCRIPTION constant in packages/mcp-server/src/index.ts (lines 70-71) serves as the canonical registry of supported databases. This string is used for validation and help text generation throughout the application.

Direct Query Capabilities

A subset of databases supports direct SQL queries without intermediate translation. The DIRECT_QUERY_TYPES array in packages/node-core/src/diagnostics.ts (lines 1-12) lists these engines:

export const DIRECT_QUERY_TYPES = [
  "postgres",
  "redshift",
  "mysql",
  "doris",
  "starrocks",
  "manticoresearch",
  "sqlite",
  "rqlite",
  "kwdb",
  "questdb",
];

File-Based Connection Support

Certain databases support file-based imports and connections. The FILE_CAPABLE_CONNECTION_TYPES Set in packages/mcp-server/src/index.ts (line 72) identifies these:

const FILE_CAPABLE_CONNECTION_TYPES = new Set(["sqlite", "duckdb", "access", "h2"]);

Categorizing dbx Supported Database Types

To better understand the 62 supported databases, they can be grouped by architectural patterns and use cases.

Relational and OLTP Databases

dbx provides comprehensive support for traditional relational databases including PostgreSQL, MySQL, Oracle, SQL Server, and DB2. The platform also covers emerging Chinese relational databases like Dameng, Kingbase, HighGo, Vastbase, GoldenDB, GaussDB, OpenGauss, OceanBase, GBase, Oscar, Xugu, and SunDB.

Data Warehouses and Analytics Engines

For analytical workloads, dbx supports Snowflake, Databricks, Redshift, BigQuery, ClickHouse, Apache Hive, Apache Spark, Trino, PrestoSQL, Teradata, Vertica, Exasol, SAP HANA, Kylin, and Databend.

Vector Databases and AI Infrastructure

Modern AI applications requiring vector search capabilities are supported through Milvus, Qdrant, Weaviate, and ChromaDB. These integrate with dbx's connection pooling and query execution systems.

Time-Series and Specialized Stores

Time-series databases including InfluxDB, QuestDB, TDengine, IoTDB, Iris, and KWDB are supported alongside specialized engines like Elasticsearch, Cassandra, Neo4j, and MongoDB.

Practical Implementation: Checking Database Support

Developers can programmatically verify database support using the dbx SDK. The following example demonstrates how to access the supported database list and check specific capabilities:

import { DBX_CONNECTION_TYPE_DESCRIPTION } from "@dbx/mcp-server";

// Extract and count supported databases
const databaseList = DBX_CONNECTION_TYPE_DESCRIPTION
  .replace("Database type: ", "")
  .split(", ")
  .map(s => s.trim());

console.log(`Total supported databases: ${databaseList.length}`); // Outputs: 62

// Check if a specific database is supported
const targetDb = "postgres";
const isSupported = databaseList.includes(targetDb);
console.log(`${targetDb} support: ${isSupported}`);

For capability-specific checks, import the capability sets:

import { DIRECT_QUERY_TYPES } from "@dbx/node-core";

// Check direct query support
const supportsDirectQuery = DIRECT_QUERY_TYPES.includes("postgres"); // true

Summary

• dbx supports 62 distinct database types as enumerated in the DBX_CONNECTION_TYPE_DESCRIPTION constant.
• The canonical list resides in packages/mcp-server/src/index.ts (lines 70-71).
• Direct query capabilities are limited to 10 databases defined in packages/node-core/src/diagnostics.ts.
• File-based connections are supported for SQLite, DuckDB, Access, and H2.
• The supported range covers relational, NoSQL, vector, time-series, and specialized databases.

Frequently Asked Questions

How many databases does dbx support in total?

dbx supports exactly 62 database types according to the source code constant DBX_CONNECTION_TYPE_DESCRIPTION in packages/mcp-server/src/index.ts. This count includes relational databases, NoSQL stores, vector databases, time-series engines, and specialized connection types like JDBC and message queues.

Where is the list of supported databases defined in the dbx source code?

The definitive list is defined in the string constant DBX_CONNECTION_TYPE_DESCRIPTION located at lines 70-71 of packages/mcp-server/src/index.ts. This constant provides a comma-separated enumeration of all supported database identifiers used throughout the application for validation and documentation purposes.

Does dbx support file-based database connections?

Yes, but only for a specific subset. The FILE_CAPABLE_CONNECTION_TYPES Set in packages/mcp-server/src/index.ts (line 72) restricts file-based connections to SQLite, DuckDB, Microsoft Access, and H2 databases. Other database types require network-based connections.

Which databases support direct SQL queries without translation in dbx?

The DIRECT_QUERY_TYPES array in packages/node-core/src/diagnostics.ts identifies 10 databases that support direct SQL queries: PostgreSQL, Redshift, MySQL, Doris, StarRocks, ManticoreSearch, SQLite, RQLite, KWDB, and QuestDB. These engines bypass intermediate query translation layers for improved performance.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}