Features

From first connect to production work

Eleven chapters, in the order you actually meet them. Everything here is in the app today — no roadmap asterisks.

01 First connection

Connect to something real

Host, port, done. The sidebar fills with what is actually on the server — databases, collections, tables — and opening one writes the first query for you.

MongoDB, PostgreSQL, SQL Server, Aerospike, ClickHouse and Elasticsearch from the same dialog
Optional SSH tunnel with password or private-key auth
Tag a connection production, colour it, or make it read-only — a write on production asks first, a write on read-only never runs

02 Result views

Read the result three ways

The same rows as a typed table, as raw JSON, or as an expandable tree — switch views without re-running anything.

Virtualized table that stays smooth on very wide, very long results
Tree view for deeply nested documents, JSON view for copy-paste fidelity
Background row counts and paging instead of a frozen window

03 Query Builder

Query without writing syntax

Filter, projection, sort, skip and limit as plain fields. Switch back to the shell and the query is already written — the Builder is a starting point, not a walled garden.

Available for MongoDB and Aerospike, right beside the shell
Round-trips both ways: shell to fields, fields to shell
Same executor and same results grid as a hand-written query

04 IntelliShell

Let the editor know your schema

IntelliShell autocompletes from your live connection — collections, tables, columns, fields, operators and the keywords of the dialect you are actually in.

One Monaco editor, six dialects: Mongo shell JavaScript, PostgreSQL, T-SQL, AQL, ClickHouse SQL, Query DSL
Field suggestions sampled from the collection in front of you
Cursor-aware: chaining, operators and engine keywords all follow context

05 Selection & clipboard

Get the data back out

Select rows and columns like a spreadsheet, then copy exactly the shape the next tool needs.

TSV or CSV for Excel, JSON, SQL INSERT or IN lists, Markdown tables — or a file, in the shape you set once
Sort any column, filter by a cell value, open a row as its own query
Diff two rows side by side to see what actually differs

06 History & snippets

Nothing you ran is lost

Every run is kept with its connection, status and duration. Pull an old one back into a tab, and turn the ones you keep re-typing into snippets.

Searchable history across connections, with the error text when a run failed
Open any entry back into its own tab instead of retyping it
Snippets carry tags and drop in at the cursor from the editor toolbar

07 AI query

Describe it, then read what it wrote

Say what you need in plain language and get a query in the dialect you are actually in — as editable text in your editor, never executed behind your back.

Bring your own key: OpenAI, Google Gemini or Anthropic Claude
Point it at Azure OpenAI or your company gateway instead of the provider directly
Nothing leaves the machine until you press Generate, and the switch turns the whole thing off
The result lands in the editor as a normal query you can read and change

08 Indexes

Indexes without leaving the tree

Indexes hang under the collection that owns them. Expand to read them, right-click to add one — no DDL, no separate tool.

Every index shows its key spelled out, per engine
Create, edit and drop from the same context menu as everything else
Views, functions, sequences and column types live in the tree too

09 Delete recovery

Delete it anyway — you can get it back

Records are journaled locally before a delete runs. When the filter was wider than you thought, the changelog puts them back exactly as they were.

MongoDB and Aerospike deletes, from the shell as well as the context menu
Edits and deletes from the grid generate an editable script you approve first
Where nothing can be journaled — a drop, a TRUNCATE, any SQL delete — you get told what is about to go instead

10 SSH tunnel

Databases that only exist behind a jump host

Production rarely listens on the open internet. The tunnel is part of the connection — set it up once and connecting brings it up with you.

Password or private-key auth, passphrase optional
Host keys are pinned on first connect; a changed fingerprint raises a native dialog instead of a silent reconnect
Works the same for all six engines — the tunnel does not care what is on the other end

11 MCP access

Let an AI agent read your database — on your terms

Sutido can serve your databases to Claude Code, Cursor, VS Code, Codex or anything else that speaks MCP. Off until you turn it on, and turning it on grants nothing: you pick what it reaches, down to a single column. Part of Pro, and of the 14-day trial.

Grant per connection, database, table or column — including "everything here except this one"
Reads are proved, not assumed; writes need a grant and a person, with the row count shown before you decide
Every request recorded, refusals included, each with the rule that refused it

12 Six engines

Six engines, one window

A Mongo shell, a Postgres session, a T-SQL batch, an AQL query, a ClickHouse scan and an Elasticsearch request — side by side, in tabs, with the workspace restored exactly as you left it.

Each engine gets its own executor and its own quirks handled, not a shared SQL box
Tabs, queries and layout survive restarts and updates
Per-engine result limits and response guards so one runaway tab cannot stall the rest

Engines

What each engine actually gets

Five executors, five dialects, five sets of quirks handled — instead of a lowest-common-denominator SQL box with five icons.

MongoDB

The real shell experience — JavaScript, cursors, ObjectId and ISODate literals.

Runs mongo-shell style scripts, not just single queries
Dual driver reaches legacy servers 3.6 and 4.0 automatically
Preview scripts for insert, edit and delete actions

PostgreSQL

Multi-statement SQL scripts on a single pinned session.

Session state (SET, temp tables) survives across statements in a run
Abort cancels the query on the server, not just the socket
Browse tables, views, functions, sequences and materialized views

SQL Server

T-SQL with proper GO batch handling and Windows authentication.

GO batches are sent whole, the way SSMS does it
Windows integrated auth alongside SQL logins
Schema browsing through information_schema

Aerospike

An AQL shell for namespaces, sets and records.

SELECT, INSERT and DELETE over AQL
Namespace and set browsing in the sidebar
Isolated native driver — a crash never takes the app down

ClickHouse

Native ClickHouse SQL over HTTP, built for very large tables.

Abort issues KILL QUERY server-side — runaway scans actually stop
Sensible default row limits so SELECT * stays browsable
DESCRIBE TABLE schema view from the sidebar

Elasticsearch

Kibana Console syntax, and an index addressed by name alone.

Two levels, not three — indices sit directly under the connection
Field names come from the mapping, so the list is complete
A single-document delete is recoverable, under the same id

And then some

The rest of the box

Smaller things that did not need their own chapter but would be missed if they were gone.

Encrypted secrets

Passwords, SSH keys and API keys are stored with OS-level encryption, and legacy Credential Manager entries are imported once on first start.

Workspaces that come back

Tabs, queries and layout are restored exactly as you left them — through restarts and through updates.

Sane default limits

Queries default to 50 rows unless you say otherwise, a statement timeout is yours to set, and oversized responses are truncated with an honest note rather than a hang.

Nine themes

From a quiet dark slate to high-contrast light — including a kawaii one, because someone asked and it turned out great.

See it on your own data.

Free for everyday work — download and connect in the next five minutes.

Download for Windows View pricing