DBX Packs 50-Database Support, AI Assistant, and MCP Server into a 15 MB Native App
The other day I was browsing GitHub and came across a project called DBX. At first I didn't think much of it—just another database management tool, I figured. The space is already crowded with DBeaver, Navicat, DataGrip, and the rest; one more wouldn't make a difference.
Then I saw the number. The installer is 15 MB, and it comes with AI features—which, of course, is what I care about most these days. How can a tool even be viable now without AI?
I had to double-check. Was I reading that right?
DBeaver takes up hundreds of megabytes after installation and requires a Java runtime. Navicat Premium isn't much better. And here was a client that claims to manage 50+ databases at just 15 MB, with AI built in?
Honestly, I was stunned.
I've been developing for years, and my machine always has several database clients open for different services—one for MySQL, one for Oracle, a separate GUI for Redis, and occasionally something for MongoDB. Switching between them is annoying, and each client eats up memory. Open too many and the machine grinds to a halt.
So my first reaction to DBX's size wasn't "holy crap, that's awesome"—it was "does this thing actually work?"
Then I checked its website, its docs, and dug through the code repository on GitHub.
GitHub address: github.com/t8y2/dbx
It's already at 7.5k stars.
Official site: dbxio.com/cn
So I downloaded a copy to try it out. It supports Windows, Linux, and macOS.
Interested folks can grab the version they need from GitHub: https://github.com/t8y2/dbx/releases or the official site https://dbxio.com/cn.
Of course, thoughtful Xiaofan also downloaded a copy and put it on cloud storage for direct access. Link: https://pan.quark.cn/s/0500eba0bd2a Passcode: Jpv5
It really works, and it's surprisingly smooth to use.
Small footprint
First, let's talk about how it achieves such a small size.
The tech stack is Tauri 2 with a Rust backend, and the frontend uses Vue 3 and TypeScript.
Tauri differs from Electron in that it doesn't bundle a Chromium browser. Instead, it directly calls the operating system's native WebView to render the interface.
So the packaged app is naturally an order of magnitude smaller than an Electron app.
The entire backend is written in Rust, with native drivers connecting directly to various databases. It doesn't rely on heavyweight runtimes like JDBC.
That's one of the core reasons it can be just 15 MB.
No Java, no Python venv, no Node.js runtime—just a clean, native application.
Which databases does it support?
It currently supports managing over 50 types of databases, covering basically every database you're likely to encounter.
Relational databases include the usual suspects: MySQL, PostgreSQL, SQLite, SQL Server, Oracle, MariaDB.
Support for Chinese domestic databases is also extensive: OceanBase, TiDB, Dameng DM, KingBase, GoldenDB, openGauss, PolarDB, GreatSQL, GaussDB, Vastbase, YashanDB—all present.
On the NoSQL side, Redis is natively supported, and MongoDB, Elasticsearch, Neo4j, and Cassandra can all be connected.
Vector databases like Milvus, Qdrant, and Weaviate are supported too.
There's also DuckDB, ClickHouse, StarRocks, TDengine, Doris, Snowflake, BigQuery—analytical and cloud databases. It can even manage message queues like Pulsar, and configuration centers like Nacos, ZooKeeper, and Etcd.
I counted—it covers essentially every database type you might encounter in your daily work.
And if your database isn't on the list, it also supports connecting via a generic JDBC driver, meaning the number of connectable databases is theoretically far more than 50.
Let's look at the interface
① DBX light mode: connection management on the left, SQL editor in the center, data grid on the right
②DBX dark mode, easier on the eyes at night
The left side is a connection manager where you can organize your database connections into groups.
The center is the SQL editor, built on CodeMirror 6, supporting metadata-aware autocompletion.
That means when you type a table name, it automatically suggests column names; when you type a column name, it knows the column's data type.
This experience should be familiar to anyone who has used DataGrip, but finding this capability in a 15 MB lightweight tool was a bit surprising.
Data Grid
ER diagram feature: table relationships at a glance
Data grid, supporting virtual scrolling, inline editing, and export
The data grid supports virtual scrolling, so it doesn't lag even when handling large result sets with hundreds of thousands of rows.
When inline editing, it previews the SQL to be executed before committing—a nice safety-conscious design.
Export formats include CSV, JSON, Markdown, Excel, and INSERT statements, which covers most daily data extraction needs.
The schema tools are also fairly complete: ER diagrams, Schema Diff comparison, Explain Plan visualization, and column lineage analysis are all there.
These features are quite practical for database design reviews or troubleshooting slow queries.
Additionally, it supports importing connection configurations from DBeaver or Navicat, making the migration cost nearly zero.
AI Features
But what really made me think "this thing is interesting" wasn't its size or the number of databases it supports.
It was the built-in AI assistant.
This AI assistant isn't some superficial plugin integration; it's genuinely embedded into the product's workflow.
And it supports multiple AI model backends. Claude, OpenAI—both work. Running Ollama locally with open-source models works too. Any OpenAI-compatible API can be plugged in.
We just need to configure the corresponding model's API Key. Here, I configured DeepSeek.
Once the AI is configured, you can describe your needs in natural language while writing SQL—for example, "query employee income ranking"—and the AI will generate the corresponding SELECT statement for you.
The generated SQL also undergoes a built-in safety check before execution, preventing you from accidentally wiping out your production environment with a slip of the hand.
For example, if we mistakenly type:
delete table dept
I think this feature is especially useful for two types of people.
One is product managers or analysts who aren't very familiar with SQL syntax. The other is people like me who frequently switch between different databases.
Each database's SQL dialect has some differences. Having an AI assistant helps save a lot of time flipping through documentation.
Charting Feature
After executing an SQL statement, you can convert the result set into corresponding charts. Currently supports bar charts, line charts, and pie charts.
MCP Protocol Support
Speaking of which, there's another feature I feel I must mention: MCP support.
MCP stands for Model Context Protocol. Simply put, it's a protocol that allows AI agents to directly connect to external tools and data sources.
DBX provides an MCP Server, meaning you can let AI directly query the databases you've already configured in DBX from within AI agents like Claude Code, Cursor, Windsurf, or WorkBuddy.
The coolest part is that it's nearly zero-configuration.
Because the MCP Server reads the connection information saved by DBX itself, including passwords from the system keychain. You don't need to manually copy-paste connection strings into some JSON config file. As long as DBX is installed on your computer and connections are configured, the AI can use them directly.
There are two installation methods: global install or run directly:
# Global install
npm install -g @dbx-app/mcp-server
# Or run directly, suitable for a quick trial
npx @dbx-app/mcp-server
:⚠️ Note: It requires Node.js 22.13.0 or higher, otherwise it will error. The screenshot below indicates successful installation.
Here's an example using WorkBuddy. It's very simple; the configuration is as follows:
{
"mcpServers": {
"dbx": {
"command": "dbx-mcp-server"
}
}
}
The screenshot below shows it's configured and ready to use.
The AI will automatically call the corresponding tools via the MCP Server to query the connections in DBX and return the results to you. It supports 9 tools:
| Tool | Description |
|---|---|
dbx_list_connections |
List all connections |
dbx_add_connection |
Add a new connection |
dbx_remove_connection |
Remove a connection |
dbx_list_tables |
List tables and views |
dbx_describe_table |
View table structure |
dbx_get_schema_context |
Get context suitable for AI to write SQL |
dbx_execute_query |
Execute SQL (returns up to 100 rows) |
dbx_execute_redis_command |
Execute a Redis command |
dbx_open_table |
Open a specified table in the DBX desktop app |
Among these, the dbx_get_schema_context tool is particularly practical. It organizes table and column information into a compact context for the AI to use when writing SQL. This way, you don't have to paste the table structure to the AI every time; it can understand field names and types on its own.
Once configured, you can just speak plain language in WorkBuddy:
We input the natural language query "query the number of employees in each department".
Databases like PostgreSQL, MySQL, SQLite, Doris, StarRocks, and Redshift can be queried directly through the MCP Server without opening the DBX desktop app.
About SQL Security
Using AI to operate databases—many people might worry about safety. Will it drop tables and run away?
Xiaofan personally tested it.
The answer is no, it won't. DBX has put considerable design effort into SQL security.
By default, regular write operations are allowed. INSERT, UPDATE, DELETE ... WHERE ... can be executed directly without extra settings. But dangerous statements like DROP, TRUNCATE, ALTER are blocked by default.
If you want the MCP session to be read-only, you can set:
DBX_MCP_ALLOW_WRITES=0
If you genuinely need to execute dangerous statements, you can set:
DBX_MCP_ALLOW_DANGEROUS_SQL=1
Redis security rules are similar: write commands follow DBX_MCP_ALLOW_WRITES, while dangerous commands like KEYS, FLUSHALL, EVAL require DBX_MCP_ALLOW_DANGEROUS_SQL=1 to be allowed.
:🍎 We can use it with peace of mind.
CLI Tool Available
In addition to AI coding agent use, DBX also provides a dedicated CLI tool, suitable for terminals, scripts, and Codex workflows.
Installation command:
npm install -g @dbx-app/cli
Once installed, you can directly operate DBX connections in the terminal. For example, listing all connections:
dbx connections list --json
Or directly execute SQL on a specific connection:
dbx query local "select * from dept" --json
Here, local is the name of your connection. If you have multiple connections, like local-pg, scott, redis-cache, you can switch the execution target by name.
DBX's Shortcomings
So, does DBX have any shortcomings?
Frankly speaking, as a relatively young open-source project (currently at version 0.5.x), it still lags behind veteran tools like DBeaver in terms of feature maturity and ecosystem completeness.
Some advanced features may still be iterating, and the community size is still growing. However, the project updates quite frequently. On GitHub, it already has 2500+ commits, 74+ contributors, and 7100+ Stars—activity is quite good.
Moreover, it's fully open-source under the Apache 2.0 license and does not collect telemetry data, which is important for those who care about privacy.
DBX, this AI-powered database management tool, is truly worth a try.
Project address: github.com/t8y2/dbx
Official site: dbxio.com/cn