platypus-db
OfficialProvides agent access to saved ClickHouse connections for running SQL queries, browsing data, and inspecting schemas, subject to the connection's configured read-only or read/write permissions.
Provides agent access to saved Databricks connections for querying data, browsing tables, and inspecting schemas through PlatypusDB's saved connections.
Provides agent access to saved DuckDB connections for querying analytical data, browsing tables, and inspecting schemas under configured access permissions.
Provides agent access to saved Elasticsearch connections for querying and browsing indexed data under configured access permissions.
Provides agent access to saved MariaDB connections for running SQL queries, browsing and editing data, and inspecting schemas, with write changes awaiting confirmation.
Provides agent access to saved MongoDB connections for querying and browsing collection data under configured access permissions.
Provides agent access to saved MySQL connections for running SQL queries, browsing and editing data, and inspecting schemas, with write changes awaiting confirmation.
Provides agent access to saved PostgreSQL connections for running SQL queries, browsing and editing data, and inspecting schemas, with write changes awaiting confirmation.
Provides agent access to saved Redis connections for querying keys and browsing Redis data under configured access permissions.
Provides agent access to saved Snowflake connections for running SQL queries, browsing data, and inspecting schemas under configured access permissions.
Provides agent access to saved SQLite connections for running SQL queries, browsing and editing data, and inspecting schemas, with write changes awaiting confirmation.
Provides agent access to saved Trino connections for running SQL queries, browsing data, and inspecting schemas under configured access permissions.
PlatypusDB™ is a desktop SQL client for developers, DBAs and analysts who work with several databases in a day. One small app runs queries, browses and edits data, designs tables, explains slow statements and documents schemas, and keeps production connections clearly apart from the others. A Rust core with a Tauri 2 + React interface: an installer of about 20 MB, a window ready in under a second, and a results grid that scrolls through millions of rows.

Why PlatypusDB
Light. A 20 MB installer on Windows and a 30 MB download on Linux, against 122 MB for DBeaver, 346 MB for Beekeeper Studio and about 1 GB for DataGrip; a window in under a second.
Safe with production. Connection types color the window frame, risky statements ask first, production opens in manual commit, and every save of edited rows leaves an undo script.
Many databases, one app. PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, ClickHouse, SQLite, DuckDB, MongoDB, Redis, Elasticsearch, Cassandra, Snowflake, BigQuery and more, with the same editor and grid.
Ready for agents. Claude Code, Codex, Cursor and other MCP clients use your saved connections with the access you give each one, and their changes wait for your OK.
Open source. AGPL-3.0, no account, no telemetry.
Related MCP server: CentralMind/Gateway
Install
Download the installer for your system from the
releases page: .exe/.msi for
Windows, .dmg for macOS, .AppImage/.deb/.rpm for Linux. The app updates itself.
Open PlatypusDB and click New connection, or paste a connection URL (
postgres://…,mysql://…, a JDBC URL or an ADO.NET string).No database at hand? Try the sample database on the welcome screen: a SQLite field survey of platypuses, with linked tables, a view and saved scripts.
Press
Ctrl+Kfor the command palette: every action, connection and table is a few letters away.
Portable copy: put the executable in a folder with an empty data folder beside it.
Connections, settings, history and scripts then live in data, and the folder can move to
another machine or a USB stick (more).
The user guide goes on from here, task by task: getting started, connecting, queries, safety, troubleshooting.
Databases
PostgreSQL, MySQL, MariaDB, SQL Server, Oracle, ClickHouse, SQLite, DuckDB, libSQL, MongoDB, Redis, Elasticsearch, Cassandra, Snowflake, BigQuery, Databricks, Trino, IBM Db2, ODBC and the databases that speak the PostgreSQL protocol. How each one connects, its oldest supported version and what works on it are in the databases guide.
Features
Write SQL | Edit data safely |
|
|
Find slow steps | Browse the data |
|
|
Design tables | Find anything |
|
|
Connections over SSH, proxies and cloud sign-in; a SQL editor with completion; a data viewer and editor; charts and notebooks; table design, ER diagrams and schema comparison; query plans; server activity; import, export and transfer; projects and seven languages. Every feature, area by area: docs/user/FEATURES.md. Task by task: the user guide. Keyboard shortcuts: docs/user/SHORTCUTS.md.
Agents (MCP) and the CLI
Claude Code, Codex, Cursor and other MCP clients can use your saved connections, with the access
you give each one: none, read only (the default) or read and write. A change an agent wants to
run opens a dialog in the app first. Setup, tools, limits and the platypus CLI:
docs/user/AGENTS.md.
Performance
PlatypusDB 0.6.0 on Windows 11 (Ryzen 7 9700X, 32 GB):
PlatypusDB 0.6.0 | |
Start, until the window has finished drawing | 0.7 s (0.8 s the first time) |
Memory at rest, the app and its web view | 170 MB |
A million rows from SQLite | first page in 0.3 s, the rest 0.3 s later; the window never stalls |
Windows installer | 20 MiB |
Next to DBeaver on the same machine, both started five times without a connection, DBeaver on a profile already set up:
PlatypusDB 0.6.1 | DBeaver CE 26.2.3 | |
Start, until the window has finished drawing | 0.7 s | 5.2 s |
Memory at rest | 170 MB | 488 MB |
Next to other SQL clients, by the size of their official Linux downloads:
PlatypusDB 0.6.0 | DBeaver CE 26.2.3 | DataGrip 2026.2.6 | TablePlus 2.2.0 | Beekeeper Studio 6.2.0 | |
Runtime | Rust and the system's web view | Java, JRE bundled | Java, JetBrains Runtime bundled | Native (GTK) | Electron |
Download | 30 MiB ( | 122 MiB | 1,047 MiB | 60 MiB | 346 MiB |
On disk | 68 MiB, plus the system's WebKitGTK | 206 MiB | not published | 180 MiB | 1,105 MiB |
License | AGPL-3.0 | Apache 2.0 | Proprietary | Proprietary | GPLv3 |
How each number is taken, the scale tests and the Linux measurements: docs/dev/BENCHMARKS.md.
Development
Build, test, project layout and the dev databases: docs/dev/DEVELOPMENT.md. What comes next is in docs/dev/ROADMAP.md (in Italian); every document is listed in docs/README.md, and the changes of each release in CHANGELOG.md.
Contributing
Bug reports, ideas and pull requests are welcome: open an issue first for anything larger than a small fix. CONTRIBUTING.md explains how to build, test and submit a change. Everyone taking part follows the Code of Conduct.
Security
Please report vulnerabilities privately, not in a public issue: see SECURITY.md.
License
PlatypusDB is licensed under the GNU Affero General Public License v3.0 or later (AGPL-3.0-or-later). You can use, study, change and share it freely; if you distribute it, or run a changed version as a service for others, you must release your source code under the same license. Third-party code and assets keep their own licenses: see THIRD-PARTY-NOTICES.md.
The name and the logo are not part of that license. PlatypusDB™ and the PlatypusDB logo are trademarks of the PlatypusDB maintainers: as AGPL section 7(e) allows, no rights are granted under trademark law, and the logo and icon files listed in NOTICE are © 2026 PlatypusDB maintainers, all rights reserved. You can name the project, link to it and redistribute the official builds unchanged; a fork must ship under its own name and icons. The details are in TRADEMARKS.md.
Available Tools
24 toolscompare_schemasA
Compares two schemas, of one connection or of two connections of the same kind of database, as the PlatypusDB schema compare does: the differences (tables, columns, indexes, foreign keys and constraints added, dropped or changed) and the migration script that makes other_schema like schema, as text. Nothing runs: the script reaches the user only through propose_sql. A script too long for max_bytes (default 32768) is left out whole and the answer says so: it is never cut.
Inputs: schema (required), connection (required), other_schema (required), max_bytes, +2 more.
describe_tableA
Describes a table or view: columns (type, nullable, default, primary key, comment, enum values), indexes, foreign keys, other constraints and the foreign keys of other tables that point at it. Also the notes, tags and sensitive marks the user set in PlatypusDB (note, tags, sensitive: true or false, never values), when there are any.
Inputs: table (required), schema (required), connection (required).
estimate_changeA
Dry run of a change: returns, without running anything, what the confirmation dialog would show the user for one SQL statement: the rows the database expects to change (estimated_rows) and its plan, the Safety checks that would ask or refuse (safety_checks), and whether the user is asked in the app (asks_the_user) and the change would run (would_run). A statement the connection's access refuses answers outcome=refused with the reason; one that changes nothing answers outcome=not_a_change. A database without plans answers with no estimate and says so. Use it to correct a statement before run_query asks the user.
Inputs: sql (required), connection (required).
explainA
Returns the plan of one SQL statement: its steps as an indented tree with cost, estimated rows and, with analyze=true, actual rows and times (or JSON with format=json), then index suggestions for filtered full scans of large tables. Without analyze the statement does not run. With analyze it runs and what it changes is rolled back; on read_only connections only statements that change nothing are explained, and analyze needs PostgreSQL, MySQL, MariaDB or SQLite. max_bytes (default 32768) and timeout_seconds (default 30) work as in run_query.
Inputs: sql (required), connection (required), format, analyze, +2 more.
get_ddlB
Returns the CREATE statement of a table, view, function, trigger or other object.
Inputs: name (required), schema (required), connection (required), kind.
get_er_diagramA
Returns a Mermaid erDiagram of a schema's tables (columns, primary keys) and the foreign keys between them, as text. Without tables the whole schema; with tables, those and the tables within depth foreign-key hops of them (default 1, at most 3). A diagram too long for one answer is cut with a note: pass tables to choose. With format: "svg" the answer is the SVG image PlatypusDB draws for its own export (it needs the app open, asks the user nothing, and is refused rather than cut when it is over the byte limit); the default mermaid works without the app.
Inputs: schema (required), connection (required), depth, format, +1 more.
get_user_contextA
Asks the user to share what they are looking at in the PlatypusDB app: the text of the active editor tab (editor), the part they selected (selection) and the result their grid shows (result: columns and rows). Use it when the user refers to something on their screen: "this query", "what I selected", "the result I see". Nothing is shared unless the user allows it in the app, each time or for your whole session; they can refuse, with a reason you get. parts limits what you ask for (all three by default). Answers connection, tab (its title) and the parts shared; the editor and selection are cut at 64 KiB, the result at 100 rows and 32 KiB (truncated says so). A tab on a connection that is not open to agents is not shared. Needs the app open; read-only: nothing runs.
Inputs: parts.
list_connectionsA
Lists the database connections saved in PlatypusDB that agents may use: name, id, driver, type (dev, test, prod), database and agent_access (read_only or read_write). Never shows hosts, users or passwords.
Inputs: no named parameters.
list_objectsA
Lists the tables, views, sequences, functions, procedures, triggers and types of a schema, with their kind, comment and estimated rows: a list of up to 500 objects (limit raises it to 2000). A schema with more returns {objects, truncated: true, total, offset, next_offset}: call again with offset=next_offset for the next page, or use search_objects to find names.
Inputs: schema (required), connection (required), limit, offset.
list_open_sessionsA
Lists the sessions open in the PlatypusDB app, when it is open: their connection, the database when it is not the connection's own, purpose (main for the session the connection's editor tabs and navigator share, side for one a dialog opened), whether it runs in manual-commit mode and whether a transaction is open in it. Your statements run on sessions of your own, never on these: use it to know what the user is working on.
Inputs: no named parameters.
list_schemasA
Lists the schemas of a connection (databases in MySQL and MariaDB, main and attached databases in SQLite), with current for the one unqualified names resolve to and system for catalog schemas.
Inputs: connection (required).
list_scriptsA
Lists the SQL scripts the user saved in PlatypusDB: path (relative to the project, with /), whether it is a folder, and the name of the connection a script opens on, if it is linked to one. project is the project's name as the app shows it; left out, the scripts of All connections. Scripts linked to a connection agents may not use are not listed. Read-only: use read_script for a script's text.
Inputs: project.
next_pageA
Reads the next rows of a result that run_query cut at max_rows or max_bytes, from the cursor it returned, instead of running the statement again: the pages come from the rows read with the first one (up to 10000 more rows, 4 MB or 250 ms of reading; the answer says when the result has more than that), so they do not change if the data does. Same format, max_rows (default 100) and max_bytes as run_query, with the connection's limits and calls per minute; sensitive columns stay masked as in the first page. A cursor is kept 5 minutes after its last use and belongs to this session; an unknown, expired or another session's cursor is refused.
Inputs: cursor (required), format, max_rows, max_bytes.
profile_tableA
Profiles the columns of a table or view from a sample of its rows (the first sample_rows, default 10000, up to 100000; no order is implied): per column NULLs, distinct values, empty texts, minimum and maximum, the most frequent values, patterns (emails, dates, numbers stored as text...) and, for numbers, their spread. Sensitive columns (as in results) give counts only: no value of any kind. Read-only, within the connection's limits; max_bytes and timeout_seconds work as in run_query.
Inputs: table (required), schema (required), connection (required), max_bytes, +2 more.
propose_editsA
Proposes rows to change in a table: PlatypusDB opens the table's data viewer with them as pending edits (new rows, changed cells, rows marked for deletion) that the user reviews, saves or discards (now if the app is open, else when it starts). Nothing is written here, whatever the connection's agent access. inserts: objects of column to value. updates: {key, set}, key naming a row by exactly the columns of a primary or unique key. deletes: objects naming rows by such a key. A value is a string, number, boolean or null (no arrays or objects); at most 500 rows and 1 MiB in all. The table needs a primary or unique key. On MongoDB the table is a collection (not a view) and the key is _id alone, read by the type of the collection's _id: an ObjectId as its 24 hex digits. Redis, Elasticsearch and Cassandra, read-only connections and those that forbid editing data are refused. title names the tab.
Inputs: table (required), schema (required), connection (required), title, +3 more.
propose_sqlA
Proposes SQL to the user: PlatypusDB opens it in a new editor tab on the connection (now if the app is open, else when it starts), where the user reviews, edits and runs it by hand. Nothing runs here, whatever the connection's agent access: use it for changes the user should check, or that read_only access does not allow. title names the tab.
Inputs: sql (required), connection (required), title.
query_across_databasesA
Runs one read-only DuckDB statement over tables of several connections: each source (connection, schema, table, optional name) is copied, up to source_rows rows (default 10000, up to 100000) and within that connection's limits, into a DuckDB of this call, where the statement joins them by name. Every connection must be open to agents; the statement runs only on the copies, cannot write to a source and reads no file nor URL. Values of sensitive columns are masked before they are copied (unless the user shows them for that connection): all values of such a column are equal, so do not join on one. A source copied in part is said so. Use DuckDB's SQL. Same result format and limits as run_query.
Inputs: sql (required), sources (required), format, max_rows, +3 more.
read_scriptA
Returns the text of a script the user saved in PlatypusDB, by the path list_scripts shows, with the connection it is linked to. At most 256 KiB: a longer script is cut, and the answer says so (truncated). A script linked to a connection agents may not use is refused. Read-only: nothing is run or changed.
Inputs: path (required), project.
run_queryA
Runs one SQL statement on a connection and returns its rows as an aligned text table (or JSON with format=json, where integers beyond 2^53 are strings so that no JSON parser rounds them), saying when rows or long values were left out. In the text table SQL NULL is NULL, and a text that reads NULL shows quoted, 'NULL'. Defaults: 100 rows, 32768 bytes, 30 s timeout; max_rows, max_bytes and timeout_seconds raise them up to 10000 rows, 1048576 bytes and 300 s. On read_only connections only statements that change nothing run, in a read-only transaction; on read_write connections changes commit at once, and UPDATE or DELETE without WHERE is refused unless the user's safety settings allow it. Use the database's own SQL dialect. A result cut by max_rows or max_bytes returns a cursor (the cursor field in JSON) for next_page to read the rest.
Inputs: sql (required), connection (required), format, max_rows, +2 more.
sample_rowsA
Returns the first rows of a table, view, MongoDB collection or search index (default 20 rows), as run_query returns them: an aligned text table, or JSON with format=json. max_rows, max_bytes and timeout_seconds work as in run_query. The rows come in the order the database reads them: no order is implied.
Inputs: table (required), schema (required), connection (required), format, +3 more.
search_historyA
Searches the history of statements run in PlatypusDB, newest first, on the connections agents may use: connection, sql, started_at (UTC, RFC 3339), duration_ms, rows, status (ok, error or cancelled), error and origin (app for what the user ran, else the agent's name). connection limits it to one connection, text to statements containing it (ignoring case), origin to app or agent. 50 entries by default, up to 500 with limit. Use it to see how the user queries the data.
Inputs: text, limit, origin, connection.
search_objectsA
Finds objects of a connection whose name contains a text, ignoring case; where the database supports it, also objects with such a column or in whose source the text appears; also objects whose comment or the user's notes contain it (matched comment or note), and #tag finds the objects the user tagged. At most 200 matches.
Inputs: text (required), connection (required).
server_activityA
What the database server is doing now: its sessions (user, database, client, state, the statement running and for how long, what it waits for and the sessions blocking it) and the locks held or waited for, as in the PlatypusDB admin tab; sessions that wait or run first, 50 by default (limit, up to 200). The statements are other people's: credentials and the values of sensitive columns are masked, and long ones cut at 500 characters. PostgreSQL, MySQL, MariaDB and SQL Server; read-only: nothing is cancelled or ended. A missing privilege is said so.
Inputs: connection (required), limit.
top_queriesA
The statements that took the server most time, the costliest first, from its own statistics (pg_stat_statements, performance_schema, Query Store): the statement with its values replaced as the server writes them, calls, total, mean and max seconds, rows, user and database. 20 by default (limit, up to 100). Credentials and the values of sensitive columns are masked, long statements cut at 500 characters. PostgreSQL, MySQL, MariaDB and SQL Server; read-only. Says so when the statistics are not enabled (pg_stat_statements not installed) or the user may not read them.
Inputs: connection (required), limit.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 24 tools
Most tools target clearly distinct resources or actions, and the descriptions draw sharp boundaries between similar-sounding tools such as explain vs. estimate_change and run_query vs. sample_rows. A few pairs still require careful reading, but an agent can generally select correctly.
The set is overwhelmingly snake_case with a verb_noun pattern (list_objects, describe_table, propose_sql, search_history). Minor deviations like top_queries, next_page, server_activity, and explain are readable but break the pattern slightly.
At 24 tools, the surface is heavy for a database MCP server and sits at the upper end of the borderline range. Each tool appears purposeful, but the breadth of schema, query, admin, scripting, and proposal features makes the set large enough to feel burdensome.
The tool set covers connection discovery, schema and object introspection, querying, pagination, explain/estimate, profiling, sampling, cross-database queries, SQL and row-edit proposals, scripts, history, sessions, server activity, and schema comparison. No obvious lifecycle or workflow gap remains for the stated database-assistant purpose.
Maintenance
Related MCP Connectors
Hosted SQL Server MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
PostgreSQL, MySQL, and SQL Server in one session. 26 read-only MCP tools for AI agents.
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Hosted PostgreSQL MCP server for Claude, ChatGPT and Cursor, with each action switched per account.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceThe Multi DB MCP Server is a high-performance implementation of the Database Model Context Protocol designed to revolutionize how AI agents interact with databases. Currently supporting MySQL and PostgreSQL databases.480MIT
- AlicenseNot gradedqualityDmaintenanceMCP-Server from your Database optimized for LLMs and AI-Agents. Supports PostgreSQL, MySQL, ClickHouse, Snowflake, MSSQL, BigQuery, Oracle Database, SQLite, ElasticSearch, DuckDB550Apache 2.0
- AlicenseAqualityBmaintenanceOne config, one CLI that turns your databases (Postgres, MySQL, SQLite, MongoDB) into MCP servers for Claude, GPT, Cursor, and any MCP-compatible agent.31MIT
- AlicenseAqualityBmaintenanceZero-config MCP server that empowers AI agents to safely query SQL and NoSQL databases like PostgreSQL, MySQL, SQLite, MongoDB, and Redis.547 npm1MIT





