Introduction
A step-by-step guide to help you connect to Redis and use every Redis screen in NoSqlStudio — a first-class DBA surface for Redis, sitting next to the MongoDB tooling without replacing any of it. Follow from Step 1 to the end, in order. Each step tells you what to do and what you will see.
Concept
Enterprise plan
Redis support (Cloud + on-prem) is part of the Enterprise subscription.
How to read this manual
Each step has:
- Do — the exact action (click, type, run such-and-such command).
- See — what should happen on screen. This is your “pass / fail”.
- Why — extra context, only when it helps (skip it if you're in a hurry).
Before you start
Concept
What the Redis support is
NoSqlStudio talks to Redis over RESP (the wire protocol), not over MongoDB. It supports on-prem Redis OSS / Valkey, Sentinel and Cluster topologies, Redis Enterprise and Redis Cloud. The whole data-plane — keyspace, pub/sub, monitor, diagnostics, maintenance — runs against any reachable Redis. The control-plane (Redis Cloud / Enterprise REST) is a separate screen covered in Stage 8.
Heads-up
Dangerous commands are gated
Every command is classified by a 3-tier safety gate: HIDDEN (never exposed — SHUTDOWN, FLUSHSLOTS, blind REPLICAOF…), CONFIRM (typed double-confirm + a diff + an audit entry — FLUSHALL, CONFIG SET, CLIENT KILL, ACL SETUSER…) and SOFT-GUARD (allowed, but capped / re-routed / cancellable — a bulk KEYS * is rerouted to SCAN). You will meet this gate on the destructive steps.
You will need:
- 1A reachable Redis server — e.g. Redis OSS 7.x over a local port or an SSH tunnel. The data-plane in this manual was validated live against Redis OSS 7.4.9 standalone.
- 2Its connection string in
redis://(orrediss://for TLS) form, plus the password / ACL credentials if the server requires auth. - 3Optionally,
redis-clion the same machine (through the tunnel) to seed a few typed test keys for Stage 2, and a Redis Cloud API key/secret (or a Redis Enterprise cluster) if you want to validate Stage 8.
Estimated time for the full walkthrough: ~25 minutes.
Connect to Redis
Add a Redis connection, pick its topology, test it, and confirm the sidebar switches to the Redis shape.
Open the connection form and pick Redis
Open the connection manager (File → Connect…, or the Connect button) and click + Add new connection. At the top of the form, set Type: Redis (the segmented control next to MongoDB).
The form swaps the Mongo auth fields for the Redis block: a scheme (redis / rediss), a topology selector, host/port, auth and TLS fields.
The connection form is multi-engine. Choosing Redis serializes the connection as a redis:// string with Redis-specific app-params, tagged savedConnectionType: redis, so it reopens as Redis without sniffing.
Choose the topology
Pick the topology that matches your server: Standalone, Sentinel (give the master name + the list of sentinels) or Cluster (give the seed nodes).
Concept
One form, every Redis shape
The same form covers on-prem OSS / Valkey, Sentinel, Cluster, Redis Enterprise and Redis Cloud. Standalone shows a SELECT 0..15 database index; Cluster hides it (one logical keyspace across slots); Sentinel connects to the master that the sentinels resolve.
Enter the host, auth and TLS
Type the host as a redis:// URL — for example redis://:<password>@127.0.0.1:6379. For auth, choose none, requirepass (password only) or ACL (user + password). For TLS use the rediss scheme and, if needed, attach the CA / client cert+key.
The form accepts the URL. The password is held in your local secret store, never echoed back into the connection string shown in the header.
The password is resolved by the app's main process at connect time and passed to the driver as a password / username option — the saved redis:// URI itself stays credential-free.
Test, then Connect
Click Test. Then click Connect.
Test returns a green line like “Connected — Redis 7.4.9 · standalone · oss”. Connect closes the modal and the connection goes connected, with a green dot in the sidebar.
On connect the app probes topology — INFO server / INFO replication, CLUSTER INFO, MODULE LIST, ACL WHOAMI — to detect version, role, vendor and modules. That probe is what fills the green status line.
Confirm the sidebar is Redis-shaped
In the sidebar, expand the Redis connection (click the ▸).
Under the Redis connection you get 🔑 Keyspace Browser (with a “navigate the keyspace…” note) — not Mongo's Details / Users & Roles. Expand a MongoDB connection to confirm it still shows Databases / Details / Users & Roles as before — no regression.
The sidebar is gated by connection kind at every call site, so Redis and Mongo connections render their own trees side by side. ✅
Keyspace browser
Browse keys without blocking the server, view and edit every Redis data type, manage TTL, and run raw commands in the RESP console.
Open the Keyspace Browser
Click 🔑 Keyspace Browser in the sidebar.
The Redis Keyspace tab opens, focused on this connection. Its header reads something like ● Redis · oss · v7.4.9 · standalone · role:master · DBSIZE: 5000.
Scan the keyspace
Click SCAN (with no MATCH). Then click Load more · cursor N to fetch the next page.
About 200 keys load instantly, each with a type icon. Load more advances the cursor and appends the next batch; when the cursor returns to 0 you see end of scan.
Concept
It never blocks the server
Browsing uses iterative `SCAN` (cursor-paged, non-blocking) — never the blocking KEYS *, which is O(N) and would stall Redis's single command thread. A batch can even come back empty with a non-zero cursor; the browser keeps going until the cursor is 0.
Filter with a MATCH pattern
Type a glob in the SCAN MATCH field — for example k:1* — and click SCAN.
Only the keys matching the pattern come back. Clear the field and SCAN again to browse everything.
View a key with its typed viewer
Click a key (for example k:3610).
The right-hand panel shows the value (v3610), a string type badge, the TTL state (e.g. no TTL) and the memory per key.
Selecting a key runs TYPE, the type-appropriate read (GET / HGETALL-equivalent paged read / LRANGE window …), TTL and a sampled MEMORY USAGE — only on select, never during the scan.
Seed typed keys for the other viewers
If your keyspace is strings-only, create one key of each type with redis-cli (through the tunnel), then *SCAN MATCH `test:`** in the app and click each one:
redis-cli -u redis://:<password>@127.0.0.1:6379 <<'CMDS'
SET test:str "hello world"
HSET test:hash name "Marcos" plan "corporate" age 30
RPUSH test:list a b c d
SADD test:set x y z
ZADD test:zset 100 alice 200 bob 150 carol
XADD test:stream * type created order 8821
CMDSEach type gets its own viewer: hash → a field/value table; list → an index/value table; set → a member list; zset → a member/score table; stream → entries plus stream info. Strings auto-detect JSON into a structured editor; numbers get a stepper.
Concept
Modules need module support
JSON / TimeSeries / Search keys (RedisJSON, RediSearch, RedisTimeSeries) need the matching modules loaded. A pure-OSS Redis has none, so those commands fail there — use a redis-stack server to exercise the module viewers.
Edit a string value (keeping its TTL)
Select a throwaway key such as k:101. Its value becomes an editable textarea — change the text (e.g. test-value) and click Save (SET KEEPTTL).
The viewer reopens showing the new value, and any existing TTL is preserved.
Edits use SET … KEEPTTL on purpose: a plain SET would silently drop the key's TTL. The editor always preserves it.
Set and clear a TTL
In the TTL s field type 60 and click EXPIRE. Then click PERSIST.
After EXPIRE the badge becomes TTL 60s and the list shows 60s next to the key. After PERSIST the badge returns to no TTL.
Delete a key with UNLINK
With k:101 selected, click UNLINK. A confirmation modal appears — click Confirm.
The key disappears from the list and DBSIZE drops by 1.
Heads-up
Destructive commands are typed-confirm gated
Delete uses `UNLINK` (asynchronous, non-blocking) rather than DEL, and it is gated: the confirmation modal is the CONFIRM tier of the safety gate. The same gate guards FLUSHDB / RENAME (overwrite) / LTRIM / XTRIM.
Flip to read-only
Click the 🔓 Editable → 🔒 Read-only toggle, then select a key.
The editable textarea and the EXPIRE / PERSIST / UNLINK buttons disappear — the key is view-only. Flip back to 🔓 to re-enable editing.
Read-only mode defaults on for prod-tagged connections, so you can't fat-finger a write on production while browsing.
Run raw commands in the RESP console
Open the RESP console and run a couple of raw commands:
TYPE test:hash
HGETALL test:hash
OBJECT ENCODING test:zset
MEMORY USAGE test:list SAMPLES 5Each command's reply renders in the console. Destructive commands typed here still pass through the same safety gate — KEYS * is rerouted to SCAN, and FLUSHALL demands a typed confirm.
Real-Time monitor
A live INFO-driven dashboard of how the instance is behaving right now.
Open the Real-Time dashboard
From the Redis monitoring menu (or the connection's context menu → Open Real-Time), open the Real-Time Dashboard.
A live dashboard starts polling, with sparklines that fill in over the next few ticks.
The dashboard polls INFO on a timer and parses every section. Cumulative counters are turned into rates (delta ÷ time); gauges and status fields are read as-is.
Read the live tiles
Watch the tiles while something is writing to Redis (your redis-cli loop or normal traffic).
- Ops/sec and network in/out as live rates.
- Hit-ratio gauge computed over the delta (not the lifetime).
- Memory used vs
maxmemorywith a utilisation %, plus fragmentation ratio (warns above 1.5, critical above 2.0, and below 1.0 = swapping = critical). - Evictions / expirations, connected / blocked clients, replication offset-lag and
master_link_status, persistence status chips, CPU and the last fork time.
Counters move as rates, and a gauge changes colour by value — so a memory-util or fragmentation problem is visible at a glance.
Survive a restart cleanly
If the server restarts or you run CONFIG RESETSTAT, the dashboard notices the run_id change / uptime drop, discards that delta and re-baselines instead of drawing a fake spike. You don't have to do anything — the rates just stay honest.
Slowlog & Latency (Diagnostics)
Find the slow commands, see what Redis itself blames for latency, and inspect or kill client connections.
Open the Slowlog viewer
Open the Slowlog pane (Diagnostics). It tails `SLOWLOG GET`.
An append-only table fills with the slowest commands — each row shows the duration, the command and its args — with a “N new” marker and a top-command rollup. Click a row to drill into the full args.
Entries are de-duplicated by slowlog id, so re-polling appends only genuinely new slow commands.
Read the Latency doctor
Open the Latency pane. It runs `LATENCY LATEST` / `LATENCY HISTORY` and `LATENCY DOCTOR`.
Per-event cards (fork, aof-fsync, expire, eviction, defrag…) with a spike timeline, plus the DOCTOR verdict in plain language.
Concept
What latency spikes mean
Redis runs commands on a single thread, so a spike is usually a blocking event behind that thread: a slow fork for a save, an AOF fsync stall, mass key expiry/eviction, or active defrag. The event name on the spike points you straight at the cause.
Inspect and kill clients
Open the Clients pane. It snapshots `CLIENT LIST`. Filter the table, then (if needed) select a connection and click Kill.
A virtualised table of connections — address, name, age, idle time, flags, db, output-buffer memory, user and client library. Kill asks for a typed confirm first.
CLIENT KILL is a CONFIRM-tier command, so killing a connection takes a deliberate confirmation — no accidental disconnects.
Maintenance & Ops
Read and change configuration, analyse memory, trigger background saves, and manage ACL users — all behind the safety gate.
Edit configuration
Open the Config pane. It shows *`CONFIG GET ** grouped by area, with a **dirty vs persisted** indicator. Change a parameter and apply it (**CONFIG SET`), then click REWRITE** to persist it to the config file.
A typed double-confirm appears showing the old → new diff before the change applies; afterwards the audit log records it and REWRITE clears the dirty marker.
Heads-up
Ops route through the 3-tier safety gate
Maintenance commands are classified: CONFIRM = typed double-confirm + a diff + an audit entry (CONFIG SET/REWRITE, CLIENT KILL, ACL SETUSER/DELUSER, MEMORY PURGE); SOFT-GUARD = allowed but capped / cancellable (a big-key scan budgets its total MEMORY USAGE calls). On managed Redis (Cloud) some CONFIG keys are blocked and the pane switches to the REST control-plane.
Analyse memory and find big keys
Open the Memory pane. Read the `MEMORY DOCTOR` verdict and the dataset-vs-overhead breakdown, then run the big-keys finder.
The DOCTOR verdict, fragmentation ratios, and a big-key table (key, type, encoding, cardinality, memory) that fills in with a progress bar you can cancel.
The big-key finder is clean-room: it SCANs and samples `MEMORY USAGE … SAMPLES 5` per key (never a full O(N) sweep), budgeting the total number of calls so it never overruns the server.
Trigger persistence
Open the Persistence pane. It shows INFO persistence, LASTSAVE and DBSIZE. Click BGSAVE (RDB snapshot) or BGREWRITEAOF (compact the AOF).
The background save / rewrite starts and the pane reflects the new LASTSAVE / AOF state when it finishes.
Concept
Background, not blocking
`BGSAVE` and `BGREWRITEAOF` fork a child so the main thread keeps serving. The blocking SAVE and DEBUG RELOAD are HIDDEN by the gate. On OSS, restoring from a backup is advisory (file + restart) — Cloud/Enterprise do it via REST.
Manage ACL users
Open the ACL pane. It runs `ACL LIST` / `ACL GETUSER` / `ACL CAT` / `ACL WHOAMI`. Create or edit a user (`ACL SETUSER`) or delete one (`ACL DELUSER`).
The user list with each user's rules; create/edit/delete each ask for a typed confirm, and the audit entry redacts any >password / #hash so secrets never land in the log.
The pane renders by capability — buttons grey out where your own ACL denies the action or the command has been renamed — so you only see what you can actually do.
DBA · RCA (root-cause)
The DBA hero screen: one click runs a full health sweep and hands you ranked findings with evidence and a recommended action — and, optionally, an AI explanation.
Run a health sweep
Open the DBA · RCA screen and click the one-click health sweep.
A single pass collects across memory, latency, persistence, cluster and replication, then returns a list of ranked findings.
Instead of you opening five panes and correlating them by hand, the sweep gathers the signals once and ranks what is actually wrong.
Read a finding's evidence and action
Click the top finding to expand it.
Each finding carries its evidence (the metrics / log lines that triggered it) and a recommended action, with the root cause placed on a live timeline so you can see correlations across memory / latency / persistence / cluster / replication.
Optionally ask the AI to explain it
If you have a model configured, click AI analysis on the finding.
A plain-language explanation and remediation summary appears, built from the same evidence.
Concept
Bring-your-own LLM, cheapest model
AI analysis is optional and uses your own configured LLM (BYO-LLM). It automatically picks the cheapest capable model, so the explanation costs as little as possible — and nothing leaves your setup if you don't enable it.
Pub/Sub
Tail channels and patterns live, and publish test messages from an embedded publisher to see them arrive.
Subscribe to a channel
Open the Pub/Sub pane. Discover active channels (it uses PUBSUB CHANNELS), then subscribe to one with `SUBSCRIBE`, or to a pattern with `PSUBSCRIBE` (e.g. news.*).
A live tail starts — incoming messages stream into a scrolling buffer, newest first.
The tail runs on a dedicated subscriber connection (a duplicate of the data connection), because a subscribed socket only accepts subscribe/ping commands. Your browsing connection is never tied up.
Publish a test message
In the embedded publisher, send a message to the channel you're tailing:
PUBLISH news.sports "hello from NoSqlStudio"The message appears at the top of the live tail within a moment. The buffer is capped (oldest dropped) and you can pause / auto-stop it so it never grows without bound.
Redis Cloud & Enterprise (control-plane)
Connect the REST control-plane to manage subscriptions and databases — and jump straight back into the data-plane with a generated connection string.
Connect the REST control-plane
Open the Redis Cloud screen. For Redis Cloud, enter your account API key and secret key (against api.redislabs.com). For Redis Enterprise, point it at the cluster's REST endpoint on port `:9443` with its credentials.
The control-plane authenticates and lists your account's subscriptions × databases.
Heads-up
This stage needs real Cloud / Enterprise infra
The whole data-plane (Stages 1–7) was validated live against Redis OSS 7.4.9. The control-plane is built and packaged but can only be validated with a real Redis Cloud account (API key/secret) or a Redis Enterprise cluster. With a pure OSS server there is nothing for this screen to connect to. The secret key is held main-side only and is never sent to the UI.
Explore subscriptions, databases and modules
Drill from a subscription into its databases. Open a database to see its modules, and any Active-Active (CRDB) geo-distribution.
Per-database details — memory, eviction, persistence, modules, replication — plus, for an Active-Active database, the participating clusters and regions. Active-Active is control-plane-only: a single data connection only reaches one region.
One-click into the data-plane
On a cloud database, click Connect this database.
A redis:// (here rediss://) connection string is generated and the connection form pre-fills with vendor redis-cloud — connect it to land in the Keyspace Browser from Stage 2 against that database.
This bridges the two planes: discover databases over REST, then jump into the live data-plane of any of them without copying connection details by hand. ✅
Cleanup (when you're done)
Drop the test keys you created, then close the Redis tabs. From the RESP console or redis-cli:
UNLINK k:101
UNLINK test:str test:hash test:list test:set test:zset test:streamThe test keys are gone and DBSIZE drops accordingly.
Concept
Your Redis connection and its secrets (passwords, Cloud API keys) live in your local profile — closing the tabs doesn't delete them. Remove the saved connection from the connection manager if you want them gone.
Summary of what you validated
| Screen | What you can do |
|---|---|
| 1 | Connect to Redis (Standalone / Sentinel / Cluster, TLS, auth) and get a Redis-shaped sidebar |
| 2 | Keyspace Browser: non-blocking SCAN, typed viewers + editors, TTL, memory per key, UNLINK, RESP console |
| 3 | Real-Time monitor: live INFO dashboard with rates, gauges and alerts |
| 4 | Diagnostics: Slowlog, Latency DOCTOR, and client inspect/kill |
| 5 | Maintenance & Ops: CONFIG GET/SET/REWRITE, memory + big-keys, BGSAVE/BGREWRITEAOF, ACL — all gated |
| 6 | DBA · RCA: one-click health sweep, ranked findings with evidence, optional BYO-LLM analysis |
| 7 | Pub/Sub: live tail of channels & patterns with an embedded publisher |
| 8 | Redis Cloud & Enterprise control-plane: subscriptions × databases, modules, one-click connect |