title: Redis CLI

summary: Overview of redis-cli, the Redis command line interface

title: Overview

text:
In interactive mode, `redis-cli` has basic line editing capabilities to provide a familiar typing experience.

To launch the program in special modes, you can use several options, including:

* Simulate a replica and print the replication stream it receives from the primary.
* Check the latency of a Redis server and display statistics.
* Request ASCII-art spectrogram of latency samples and frequencies.

This topic covers the different aspects of `redis-cli`, starting from the simplest and ending with the more advanced features.

title: Install `redis-cli`

role: setup

text:
You have several options for installing or using `redis-cli`.

- [Install Redis Open Source](). The `redis-cli` utility is installed as part of each installation method.
- [Build Redis from source](). Instead of building everything, you can just run the following command:

    `$ make redis-cli`.

    The `redis-cli` utility will be built in the `/path/to/redis-source/src` directory as `/path/to/redis-source/src/redis-cli`.

If you prefer not to install Redis, you can also run `redis-cli` in Docker. See the [Run `redis-cli` using Docker]() page for instructions.

title: Command line usage

role: syntax

text:
To run a Redis command and return a standard output at the terminal, include the command to execute as separate arguments of `redis-cli`:

    $ redis-cli INCR mycounter
    (integer) 7

The reply of the command is "7". Since Redis replies are typed (strings, arrays, integers, nil, errors, etc.), you see the type of the reply between parentheses. This additional information may not be ideal when the output of `redis-cli` must be used as input of another command or redirected into a file.

`redis-cli` only shows additional information for human readability when it detects the standard output is a tty, or terminal. For all other outputs it will auto-enable the *raw output mode*, as in the following example:

    $ redis-cli INCR mycounter > /tmp/output.txt
    $ cat /tmp/output.txt
    8

Note that `(integer)` is omitted from the output because `redis-cli` detects
the output is no longer written to the terminal. You can force raw output
even on the terminal with the `--raw` option:

    $ redis-cli --raw INCR mycounter
    9

You can force human readable output when writing to a file or in
pipe to other commands by using `--no-raw`.

For complete command line usage, see [below](#usage).

title: String quoting and escaping

text:
When `redis-cli` parses a command, whitespace characters automatically delimit the arguments.
In interactive mode, a newline sends the command for parsing and execution.
To input string values that contain whitespaces or non-printable characters, you can use quoted and escaped strings.

Quoted string values are enclosed in double (`"`) or single (`'`) quotation marks.
Escape sequences are used to put nonprintable characters in character and string literals.

An escape sequence contains a backslash (`\`) symbol followed by one of the escape sequence characters.

Doubly-quoted strings support the following escape sequences:

* `\"` - double-quote
* `\n` - newline
* `\r` - carriage return
* `\t` - horizontal tab
* `\b` - backspace
* `\a` - alert
* `\\` - backslash
* `\xhh` - any ASCII character represented by a hexadecimal number (_hh_)

Single quotes assume the string is literal, and allow only the following escape sequences:
* `\'` - single quote
* `\\` - backslash

For example, to return `Hello World` on two lines:

[code example]

When you input strings that contain single or double quotes, as you might in passwords, for example, escape the string, like so:

[code example]

title: Host, port, password, and database

text:
By default, `redis-cli` connects to the server at the address 127.0.0.1 with port 6379.
You can change the port using several command line options. To specify a different host name or an IP address, use the `-h` option. In order to set a different port, use `-p`.

    $ redis-cli -h redis15.localnet.org -p 6390 PING
    PONG

If your instance is password protected, the `-a <password>` option will
perform authentication saving the need of explicitly using the [`AUTH`]() command:

    $ redis-cli -a myUnguessablePazzzzzword123 PING
    PONG

**NOTE:** For security reasons, provide the password to `redis-cli` automatically via the
`REDISCLI_AUTH` environment variable.

Finally, it's possible to send a command that operates on a database number
other than the default number zero by using the `-n <dbnum>` option:

    $ redis-cli FLUSHALL
    OK
    $ redis-cli -n 1 INCR a
    (integer) 1
    $ redis-cli -n 1 INCR a
    (integer) 2
    $ redis-cli -n 2 INCR a
    (integer) 1

Some or all of this information can also be provided by using the `-u <uri>`
option and the URI pattern `redis://user:password@host:port/dbnum`:

    $ redis-cli -u redis://LJenkins:p%40ssw0rd@redis-16379.hosted.com:16379/0 PING
    PONG

**NOTE:**
User, password and dbnum are optional.
For authentication without a username, use username `default`.
For TLS, use the scheme `rediss`.

You can use the `-4` or `-6` argument to set a preference for IPv4 or IPv6, respectively, for DNS lookups.

title: SSL/TLS

text:
By default, `redis-cli` uses a plain TCP connection to connect to Redis.
You may enable SSL/TLS using the `--tls` option, along with `--cacert` or
`--cacertdir` to configure a trusted root certificate bundle or directory.

If the target server requires authentication using a client side certificate,
you can specify a certificate and a corresponding private key using `--cert` and
`--key`.

title: Get input from other programs

text:
There are two ways you can use `redis-cli` in order to receive input from other
commands via the standard input. One is to use the target payload as the last argument
from *stdin*. For example, in order to set the Redis key `net_services`
to the content of the file `/etc/services` from a local file system, use the `-x`
option:

    $ redis-cli -x SET net_services < /etc/services
    OK
    $ redis-cli GETRANGE net_services 0 50
    "#\n# Network services, Internet style\n#\n# Note that "

In the first line of the above session, `redis-cli` was executed with the `-x` option and a file was redirected to the CLI's
standard input as the value to satisfy the `SET net_services` command phrase. This is useful for scripting.

A different approach is to feed `redis-cli` a sequence of commands written in a
text file:

    $ cat /tmp/commands.txt
    SET item:3374 100
    INCR item:3374
    APPEND item:3374 xxx
    GET item:3374
    $ cat /tmp/commands.txt | redis-cli
    OK
    (integer) 101
    (integer) 6
    "101xxx"

All the commands in `commands.txt` are executed consecutively by
`redis-cli` as if they were typed by the user in interactive mode. Strings can be
quoted inside the file if needed, so that it's possible to have single
arguments with spaces, newlines, or other special characters:

    $ cat /tmp/commands.txt
    SET arg_example "This is a single argument"
    STRLEN arg_example
    $ cat /tmp/commands.txt | redis-cli
    OK
    (integer) 25

title: Continuously run the same command

text:
It is possible to execute a single command a specified number of times
with a user-selected pause between executions. This is useful in
different contexts - for example when we want to continuously monitor some
key content or [`INFO`]() field output, or when we want to simulate some
recurring write event, such as pushing a new item into a list every 5 seconds.

This feature is controlled by two options: `-r <count>` and `-i <delay>`.
The `-r` option states how many times to run a command and `-i` sets
the delay between the different command calls in seconds (with the ability
to specify values such as 0.1 to represent 100 milliseconds).

By default the interval (or delay) is set to 0, so commands are just executed
ASAP:

    $ redis-cli -r 5 INCR counter_value
    (integer) 1
    (integer) 2
    (integer) 3
    (integer) 4
    (integer) 5

To run the same command indefinitely, use `-1` as the count value.
To monitor over time the RSS memory size it's possible to use the following command:

    $ redis-cli -r -1 -i 1 INFO | grep rss_human
    used_memory_rss_human:2.71M
    used_memory_rss_human:2.73M
    used_memory_rss_human:2.73M
    used_memory_rss_human:2.73M
    ... a new line will be printed each second ...

title: Mass insertion of data using `redis-cli`

text:
Mass insertion using `redis-cli` is covered in a separate page as it is a
worthwhile topic itself. Please refer to our [mass insertion guide]().

title: CSV output

text:
A CSV (Comma Separated Values) output feature exists within `redis-cli` to export data from Redis to an external program.

    $ redis-cli LPUSH mylist a b c d
    (integer) 4
    $ redis-cli --csv LRANGE mylist 0 -1
    "d","c","b","a"

Note that the `--csv` flag will only work on a single command, not the entirety of a DB as an export.

title: Run Lua scripts

text:
The `redis-cli` has extensive support for using the debugging facility
of Lua scripting, available with Redis 3.2 onwards. For this feature, refer to the [Redis Lua debugger documentation]().

Even without using the debugger, `redis-cli` can be used to
run scripts from a file as an argument:

    $ cat /tmp/script.lua
    return redis.call('SET',KEYS[1],ARGV[1])
    $ redis-cli --eval /tmp/script.lua location:hastings:temp , 23
    OK

The Redis [`EVAL`]() command takes the list of keys the script uses, and the
other non key arguments, as different arrays. When calling [`EVAL`]() you
provide the number of keys as a number.

When calling `redis-cli` with the `--eval` option above, there is no need to specify the number of keys
explicitly. Instead it uses the convention of separating keys and arguments
with a comma. This is why in the above call you see `location:hastings:temp , 23` as arguments.

So `location:hastings:temp` will populate the [`KEYS`]() array, and `23` the `ARGV` array.

The `--eval` option is useful when writing simple scripts. For more
complex work, the Lua debugger is recommended. It is possible to mix the two approaches, since the debugger can also execute scripts from an external file.

title: Interactive mode

text:
We have explored how to use the Redis CLI as a command line program.
This is useful for scripts and certain types of testing, however most
people will spend the majority of time in `redis-cli` using its interactive
mode.

In interactive mode the user types Redis commands at the prompt. The command
is sent to the server, processed, and the reply is parsed back and rendered
into a simpler form to read.

Nothing special is needed for running the `redis-cli` in interactive mode -
just execute it without any arguments

    $ redis-cli
    127.0.0.1:6379> PING
    PONG

The string `127.0.0.1:6379>` is the prompt. It displays the connected Redis server instance's hostname and port.

The prompt updates as the connected server changes or when operating on a database different from the database number zero:

    127.0.0.1:6379> SELECT 2
    OK
    127.0.0.1:6379[2]> DBSIZE
    (integer) 1
    127.0.0.1:6379[2]> SELECT 0
    OK
    127.0.0.1:6379> DBSIZE
    (integer) 503

title: Handle connections and reconnections

text:
Using the `CONNECT` command in interactive mode makes it possible to connect
to a different instance, by specifying the *hostname* and *port* we want
to connect to:

    127.0.0.1:6379> CONNECT metal 6379
    metal:6379> PING
    PONG

As you can see the prompt changes accordingly when connecting to a different server instance.
If a connection is attempted to an instance that is unreachable, the `redis-cli` goes into disconnected
mode and attempts to reconnect with each new command:

    127.0.0.1:6379> CONNECT 127.0.0.1 9999
    Could not connect to Redis at 127.0.0.1:9999: Connection refused
    not connected> PING
    Could not connect to Redis at 127.0.0.1:9999: Connection refused
    not connected> PING
    Could not connect to Redis at 127.0.0.1:9999: Connection refused

Generally after a disconnection is detected, `redis-cli` always attempts to
reconnect transparently; if the attempt fails, it shows the error and
enters the disconnected state. The following is an example of disconnection
and reconnection:

    127.0.0.1:6379> INFO SERVER
    Could not connect to Redis at 127.0.0.1:6379: Connection refused
    not connected> PING
    PONG
    127.0.0.1:6379>
    (now we are connected again)

When a reconnection is performed, `redis-cli` automatically re-selects the
last database number selected. However, all other states about the
connection is lost, such as within a MULTI/EXEC transaction:

    $ redis-cli
    127.0.0.1:6379> MULTI
    OK
    127.0.0.1:6379> PING
    QUEUED

    ( here the server is manually restarted )

    127.0.0.1:6379> EXEC
    (error) ERR EXEC without MULTI

This is usually not an issue when using the `redis-cli` in interactive mode for
testing, but this limitation should be known.

Use the `-t <timeout>` option to specify server timeout in seconds.

title: Editing, history, completion and hints

text:
Because `redis-cli` uses the
[linenoise line editing library](http://github.com/antirez/linenoise), it
always has line editing capabilities, without depending on `libreadline` or
other optional libraries.

Command execution history can be accessed in order to avoid retyping commands by pressing the arrow keys (up and down).
The history is preserved between restarts of the CLI, in a file named
`.rediscli_history` inside the user home directory, as specified
by the `HOME` environment variable. It is possible to use a different
history filename by setting the `REDISCLI_HISTFILE` environment variable,
and disable it by setting it to `/dev/null`.

The `redis-cli` client is also able to perform command-name completion by pressing the TAB
key, as in the following example:

    127.0.0.1:6379> Z<TAB>
    127.0.0.1:6379> ZADD<TAB>
    127.0.0.1:6379> ZCARD<TAB>

Once Redis command name has been entered at the prompt, the `redis-cli` will display
syntax hints. Like command history, this behavior can be turned on and off via the `redis-cli` preferences.

Reverse history searches, such as `CTRL-R` in terminals, is supported.

title: Preferences

text:
There are two ways to customize `redis-cli` behavior. The file `.redisclirc`
in the home directory is loaded by the CLI on startup. You can override the
file's default location by setting the `REDISCLI_RCFILE` environment variable to
an alternative path. Preferences can also be set during a CLI session, in which
case they will last only the duration of the session.

To set preferences, use the special `:set` command. The following preferences
can be set, either by typing the command in the CLI or adding it to the
`.redisclirc` file:

* `:set hints` - enables syntax hints
* `:set nohints` - disables syntax hints

title: Run the same command N times

text:
It is possible to run the same command multiple times in interactive mode by prefixing the command
name by a number:

    127.0.0.1:6379> 5 INCR mycounter
    (integer) 1
    (integer) 2
    (integer) 3
    (integer) 4
    (integer) 5

title: Show online help for Redis commands

text:
`redis-cli` provides online help for most Redis [commands](), using the `HELP` command. The command can be used
in two forms:

* `HELP @<category>` shows all the commands about a given category. The
categories are:
    - `@generic`
    - `@string`
    - `@list`
    - `@set`
    - `@sorted_set`
    - `@hash`
    - `@pubsub`
    - `@transactions`
    - `@connection`
    - `@server`
    - `@scripting`
    - `@hyperloglog`
    - `@cluster`
    - `@geo`
    - `@stream`
* `HELP <commandname>` shows specific help for the command given as argument.

For example in order to show help for the [`PFADD`]() command, use:

    127.0.0.1:6379> HELP PFADD

    PFADD key element [element ...]
    summary: Adds the specified elements to the specified HyperLogLog.
    since: 2.8.9

Note that `HELP` supports TAB completion as well.

title: Clear the terminal screen

text: Using the `CLEAR` command in interactive mode clears the terminal's screen.

title: Special modes of operation

text:
So far we saw two main modes of `redis-cli`.

* Command line execution of Redis commands.
* Interactive "REPL" usage.

The CLI performs other auxiliary tasks related to Redis that
are explained in the next sections:

* Monitoring tool to show continuous stats about a Redis server.
* Scanning a Redis database for very large keys.
* Key space scanner with pattern matching.
* Acting as a [Pub/Sub]() client to subscribe to channels.
* Monitoring the commands executed into a Redis instance.
* Checking the [latency]() of a Redis server in different ways.
* Checking the scheduler latency of the local computer.
* Transferring RDB backups from a remote Redis server locally.
* Acting as a Redis replica for showing what a replica receives.
* Simulating [LRU]() workloads for showing stats about keys hits.
* A client for the Lua debugger.

title: Continuous stats mode

text:
Continuous stats mode is probably one of the lesser known yet very useful features of `redis-cli` to monitor Redis instances in real time. To enable this mode, the `--stat` option is used.
The output is very clear about the behavior of the CLI in this mode:

    $ redis-cli --stat
    ------- data ------ --------------------- load -------------------- - child -
    keys       mem      clients blocked requests            connections
    506        1015.00K 1       0       24 (+0)             7
    506        1015.00K 1       0       25 (+1)             7
    506        3.40M    51      0       60461 (+60436)      57
    506        3.40M    51      0       146425 (+85964)     107
    507        3.40M    51      0       233844 (+87419)     157
    507        3.40M    51      0       321715 (+87871)     207
    508        3.40M    51      0       408642 (+86927)     257
    508        3.40M    51      0       497038 (+88396)     257

In this mode a new line is printed every second with useful information and differences of request values between old data points. Memory usage, client connection counts, and various other statistics about the connected Redis database can be easily understood with this auxiliary `redis-cli` tool.

The `-i <interval>` option in this case works as a modifier in order to
change the frequency at which new lines are emitted. The default is one
second.

title: Scan for big keys and memory usage

title: Big keys

text:
In this special mode, `redis-cli` works as a key space analyzer. It scans the
dataset for big keys, but also provides information about the data types
that the data set consists of. This mode is enabled with the `--bigkeys` option,
and produces verbose output:

[code example]

In the first part of the output, each new key larger than the previous larger
key (of the same type) encountered is reported. The summary section
provides general stats about the data inside the Redis instance.

The program uses the [`SCAN`]() command, so it can be executed against a busy
server without impacting the operations, however the `-i` option can be
used in order to throttle the scanning process of the specified fraction
of second for each [`SCAN`]() command.

For example, `-i 0.01` will slow down the program execution considerably, but will also reduce the load on the server
to a negligible amount.

Note that the summary also reports in a cleaner form the biggest keys found
for each time. The initial output is just to provide some interesting info
ASAP if running against a very large data set.

The `--bigkeys` option now works on cluster replicas.

title: Memory usage

text:
Similar to the `--bigkeys` option, `--memkeys` allows you to scan the entire keyspace to find biggest keys as well as
the average sizes per key type.

[code example]

The `--memkeys` option now works on cluster replicas.

title: Combine `--bigkeys` and `--memkeys`

text:
You can use the `--keystats` and `--keystats-samples` options to combine `--memkeys` and `--bigkeys` with additional distribution data.

[code example]

title: Get a list of keys

text:
It is also possible to scan the key space, again in a way that does not
block the Redis server (which does happen when you use a command
like `KEYS *`), and print all the key names, or filter them for specific
patterns. This mode, like the `--bigkeys` option, uses the [`SCAN`]() command,
so keys may be reported multiple times if the dataset is changing, but no
key would ever be missing, if that key was present since the start of the
iteration. Because of the command that it uses this option is called `--scan`.

    $ redis-cli --scan | head -10
    key-419
    key-71
    key-236
    key-50
    key-38
    key-458
    key-453
    key-499
    key-446
    key-371

Note that `head -10` is used in order to print only the first ten lines of the
output.

Scanning is able to use the underlying pattern matching capability of
the [`SCAN`]() command with the `--pattern` option.

    $ redis-cli --scan --pattern '*-11*'
    key-114
    key-117
    key-118
    key-113
    key-115
    key-112
    key-119
    key-11
    key-111
    key-110
    key-116

Piping the output through the `wc` command can be used to count specific
kind of objects, by key name:

    $ redis-cli --scan --pattern 'user:*' | wc -l
    3829433

You can use `-i 0.01` to add a delay between calls to the [`SCAN`]() command.
This will make the command slower but will significantly reduce load on the server.

title: Pub/sub mode

text:
The CLI is able to publish messages in Redis Pub/Sub channels using
the [`PUBLISH`]() command. Subscribing to channels in order to receive
messages is different - the terminal is blocked and waits for
messages, so this is implemented as a special mode in `redis-cli`. Unlike
other special modes this mode is not enabled by using a special option,
but simply by using the [`SUBSCRIBE`]() or [`PSUBSCRIBE`]() command, which are available in
interactive or command mode:

    $ redis-cli PSUBSCRIBE '*'
    Reading messages... (press Ctrl-C to quit)
    1) "PSUBSCRIBE"
    2) "*"
    3) (integer) 1

The *reading messages* message shows that we entered Pub/Sub mode.
When another client publishes some message in some channel, such as with the command `redis-cli PUBLISH mychannel mymessage`, the CLI in Pub/Sub mode will show something such as:

    1) "pmessage"
    2) "*"
    3) "mychannel"
    4) "mymessage"

This is very useful for debugging Pub/Sub issues.
To exit the Pub/Sub mode just process `CTRL-C`.

title: Monitor commands executed in Redis

text:
Similarly to the Pub/Sub mode, the monitoring mode is entered automatically
once you use the [`MONITOR`]() command. All commands received by the active Redis instance will be printed to the standard output:

    $ redis-cli MONITOR
    OK
    1460100081.165665 [0 127.0.0.1:51706] "set" "shipment:8000736522714:status" "sorting"
    1460100083.053365 [0 127.0.0.1:51707] "get" "shipment:8000736522714:status"

Note that it is possible to pipe the output, so you can monitor
for specific patterns using tools such as `grep`.

title: Monitor the latency of Redis instances

text:
Redis is often used in contexts where latency is very critical. Latency
involves multiple moving parts within the application, from the client library
to the network stack, to the Redis instance itself.

The `redis-cli` has multiple facilities for studying the latency of a Redis
instance and understanding the latency's maximum, average and distribution.

The basic latency-checking tool is the `--latency` option. Using this
option the CLI runs a loop where the [`PING`]() command is sent to the Redis
instance and the time to receive a reply is measured. This happens 100
times per second, and stats are updated in a real time in the console:

    $ redis-cli --latency
    min: 0, max: 1, avg: 0.19 (427 samples)

The stats are provided in milliseconds. Usually, the average latency of
a very fast instance tends to be overestimated a bit because of the
latency due to the kernel scheduler of the system running `redis-cli`
itself, so the average latency of 0.19 above may easily be 0.01 or less.
However this is usually not a big problem, since most developers are interested in
events of a few milliseconds or more.

Sometimes it is useful to study how the maximum and average latencies
evolve during time. The `--latency-history` option is used for that
purpose: it works exactly like `--latency`, but every 15 seconds (by
default) a new sampling session is started from scratch:

    $ redis-cli --latency-history
    min: 0, max: 1, avg: 0.14 (1314 samples) -- 15.01 seconds range
    min: 0, max: 1, avg: 0.18 (1299 samples) -- 15.00 seconds range
    min: 0, max: 1, avg: 0.20 (113 samples)^C

Sampling sessions' length can be changed with the `-i <interval>` option.

The most advanced latency study tool, but also the most complex to
interpret for non-experienced users, is the ability to use color terminals
to show a spectrum of latencies. You'll see a colored output that indicates the
different percentages of samples, and different ASCII characters that indicate
different latency figures. This mode is enabled using the `--latency-dist`
option:

    $ redis-cli --latency-dist
    (output not displayed, requires a color terminal, try it!)

There is another pretty unusual latency tool implemented inside `redis-cli`.
It does not check the latency of a Redis instance, but the latency of the
computer running `redis-cli`. This latency is intrinsic to the kernel scheduler,
the hypervisor in case of virtualized instances, and so forth.

Redis calls it *intrinsic latency* because it's mostly opaque to the programmer.
If the Redis instance has high latency regardless of all the obvious things
that may be the source cause, it's worth to check what's the best your system
can do by running `redis-cli` in this special mode directly in the system you
are running Redis servers on.

By measuring the intrinsic latency, you know that this is the baseline,
and Redis cannot outdo your system. In order to run the CLI
in this mode, use the `--intrinsic-latency <test-time>`. Note that the test time is in seconds and dictates how long the test should run.

    $ ./redis-cli --intrinsic-latency 5
    Max latency so far: 1 microseconds.
    Max latency so far: 7 microseconds.
    Max latency so far: 9 microseconds.
    Max latency so far: 11 microseconds.
    Max latency so far: 13 microseconds.
    Max latency so far: 15 microseconds.
    Max latency so far: 34 microseconds.
    Max latency so far: 82 microseconds.
    Max latency so far: 586 microseconds.
    Max latency so far: 739 microseconds.

    65433042 total runs (avg latency: 0.0764 microseconds / 764.14 nanoseconds per run).
    Worst run took 9671x longer than the average latency.

IMPORTANT: this command must be executed on the computer that runs the Redis server instance, not on a different host. It does not connect to a Redis instance and performs the test locally.

In the above case, the system cannot do better than 739 microseconds of worst
case latency, so one can expect certain queries to occasionally run less than 1 millisecond.

title: Remote backups of RDB files

text:
During a Redis replication's first synchronization, the primary and the replica
exchange the whole data set in the form of an RDB file. This feature is exploited
by `redis-cli` in order to provide a remote backup facility that allows a
transfer of an RDB file from any Redis instance to the local computer running
`redis-cli`. To use this mode, call the CLI with the `--rdb <dest-filename>`
option:

    $ redis-cli --rdb /tmp/dump.rdb
    SYNC sent to master, writing 13256 bytes to '/tmp/dump.rdb'
    Transfer finished with success.

This is a simple but effective way to ensure disaster recovery
RDB backups exist of your Redis instance. When using this options in
scripts or `cron` jobs, make sure to check the return value of the command.
If it is non zero, an error occurred as in the following example:

    $ redis-cli --rdb /tmp/dump.rdb
    SYNC with master failed: -ERR Can't SYNC while not connected with my master
    $ echo $?
    1

title: Replica mode

text:
The replica mode of the CLI is an advanced feature useful for
Redis developers and for debugging operations.
It allows for the inspection of the content a primary sends to its replicas in the replication
stream in order to propagate the writes to its replicas. The option
name is simply `--replica`. The following is a working example:

    $ redis-cli --replica
    SYNC with master, discarding 13256 bytes of bulk transfer...
    SYNC done. Logging commands from master.
    "PING"
    "SELECT","0"
    "SET","last_name","Enigk"
    "PING"
    "INCR","mycounter"

The command begins by discarding the RDB file of the first synchronization
and then logs each command received in CSV format.

If you think some of the commands are not replicated correctly in your replicas
this is a good way to check what's happening, and also useful information
in order to improve the bug report.

title: Perform an LRU simulation

text:
Redis is often used as a cache with [LRU eviction]().
Depending on the number of keys and the amount of memory allocated for the
cache (specified via the `maxmemory` directive), the amount of cache hits
and misses will change. Sometimes, simulating the rate of hits is very
useful to correctly provision your cache.

The `redis-cli` has a special mode where it performs a simulation of GET and SET
operations, using an 80-20% power law distribution in the requests pattern.
This means that 20% of keys will be requested 80% of times, which is a
common distribution in caching scenarios.

Theoretically, given the distribution of the requests and the Redis memory
overhead, it should be possible to compute the hit rate analytically
with a mathematical formula. However, Redis can be configured with
different LRU settings (number of samples) and LRU's implementation, which
is approximated in Redis, changes a lot between different versions. Similarly
the amount of memory per key may change between versions. That is why this
tool was built: its main motivation was for testing the quality of Redis' LRU
implementation, but now is also useful for testing how a given version
behaves with the settings originally intended for deployment.

To use this mode, specify the amount of keys in the test and configure a sensible `maxmemory` setting as a first attempt.

IMPORTANT NOTE: Configuring the `maxmemory` setting in the Redis configuration
is crucial: if there is no cap to the maximum memory usage, the hit will
eventually be 100% since all the keys can be stored in memory. If too many keys are specified with maximum memory, eventually all of the computer RAM will be used. It is also needed to configure an appropriate
*maxmemory policy*; most of the time `allkeys-lru` is selected.

In the following example there is a configured a memory limit of 100MB and an LRU
simulation using 10 million keys.

WARNING: the test uses pipelining and will stress the server, don't use it
with production instances.

    $ ./redis-cli --lru-test 10000000
    156000 Gets/sec | Hits: 4552 (2.92%) | Misses: 151448 (97.08%)
    153750 Gets/sec | Hits: 12906 (8.39%) | Misses: 140844 (91.61%)
    159250 Gets/sec | Hits: 21811 (13.70%) | Misses: 137439 (86.30%)
    151000 Gets/sec | Hits: 27615 (18.29%) | Misses: 123385 (81.71%)
    145000 Gets/sec | Hits: 32791 (22.61%) | Misses: 112209 (77.39%)
    157750 Gets/sec | Hits: 42178 (26.74%) | Misses: 115572 (73.26%)
    154500 Gets/sec | Hits: 47418 (30.69%) | Misses: 107082 (69.31%)
    151250 Gets/sec | Hits: 51636 (34.14%) | Misses: 99614 (65.86%)

The program shows stats every second. In the first seconds the cache starts to be populated. The misses rate later stabilizes into the actual figure that can be expected:

    120750 Gets/sec | Hits: 48774 (40.39%) | Misses: 71976 (59.61%)
    122500 Gets/sec | Hits: 49052 (40.04%) | Misses: 73448 (59.96%)
    127000 Gets/sec | Hits: 50870 (40.06%) | Misses: 76130 (59.94%)
    124250 Gets/sec | Hits: 50147 (40.36%) | Misses: 74103 (59.64%)

A miss rate of 59% may not be acceptable for certain use cases therefor
100MB of memory is not enough. Observe an example using a half gigabyte of memory. After several
minutes the output stabilizes to the following figures:

    140000 Gets/sec | Hits: 135376 (96.70%) | Misses: 4624 (3.30%)
    141250 Gets/sec | Hits: 136523 (96.65%) | Misses: 4727 (3.35%)
    140250 Gets/sec | Hits: 135457 (96.58%) | Misses: 4793 (3.42%)
    140500 Gets/sec | Hits: 135947 (96.76%) | Misses: 4553 (3.24%)

With 500MB there is sufficient space for the key quantity (10 million) and distribution (80-20 style).

title: Usage

text: [code example]

code:
127.0.0.1:6379> SET mykey "Hello\nWorld"
OK
127.0.0.1:6379> GET mykey
Hello
World

section_id: string-quoting-and-escaping

code:
$ redis-cli --bigkeys

# Scanning the entire keyspace to find biggest keys as well as
# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
# per 100 SCAN commands (not usually needed).

100.00% ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Keys sampled: 55

-------- summary -------

Total key length in bytes is 495 (avg len 9.00)

Biggest   list found "bikes:finished" has 1 items
Biggest string found "all_bikes" has 36 bytes
Biggest   hash found "bike:1:stats" has 3 fields
Biggest stream found "race:france" has 4 entries
Biggest    set found "bikes:racing:france" has 3 members
Biggest   zset found "racer_scores" has 8 members

1 lists with 1 items (01.82% of keys, avg size 1.00)
16 strings with 149 bytes (29.09% of keys, avg size 9.31)
1 MBbloomCFs with 0 ? (01.82% of keys, avg size 0.00)
1 hashs with 3 fields (01.82% of keys, avg size 3.00)
3 streams with 8 entries (05.45% of keys, avg size 2.67)
2 TDIS-TYPEs with 0 ? (03.64% of keys, avg size 0.00)
1 TopK-TYPEs with 0 ? (01.82% of keys, avg size 0.00)
2 sets with 5 members (03.64% of keys, avg size 2.50)
1 CMSk-TYPEs with 0 ? (01.82% of keys, avg size 0.00)
2 zsets with 11 members (03.64% of keys, avg size 5.50)
25 ReJSON-RLs with 0 ? (45.45% of keys, avg size 0.00)

section_id: big-keys

code:
$ redis-cli --memkeys

# Scanning the entire keyspace to find biggest keys as well as
# average sizes per key type.  You can use -i 0.1 to sleep 0.1 sec
# per 100 SCAN commands (not usually needed).

100.00% ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Keys sampled: 55

-------- summary -------

Total key length in bytes is 495 (avg len 9.00)

Biggest   list found "bikes:finished" has 104 bytes
Biggest string found "all_bikes" has 120 bytes
Biggest MBbloomCF found "bikes:models" has 1048680 bytes
Biggest   hash found "bike:1:stats" has 104 bytes
Biggest stream found "race:italy" has 7172 bytes
Biggest TDIS-TYPE found "bikes:sales" has 9832 bytes
Biggest TopK-TYPE found "bikes:keywords" has 114256 bytes
Biggest    set found "bikes:racing:france" has 120 bytes
Biggest CMSk-TYPE found "bikes:profit" has 144056 bytes
Biggest   zset found "racer_scores" has 168 bytes
Biggest ReJSON-RL found "bikes:inventory" has 4865 bytes

1 lists with 104 bytes (01.82% of keys, avg size 104.00)
16 strings with 1360 bytes (29.09% of keys, avg size 85.00)
1 MBbloomCFs with 1048680 bytes (01.82% of keys, avg size 1048680.00)
1 hashs with 104 bytes (01.82% of keys, avg size 104.00)
3 streams with 16960 bytes (05.45% of keys, avg size 5653.33)
2 TDIS-TYPEs with 19648 bytes (03.64% of keys, avg size 9824.00)
1 TopK-TYPEs with 114256 bytes (01.82% of keys, avg size 114256.00)
2 sets with 208 bytes (03.64% of keys, avg size 104.00)
1 CMSk-TYPEs with 144056 bytes (01.82% of keys, avg size 144056.00)
2 zsets with 304 bytes (03.64% of keys, avg size 152.00)
25 ReJSON-RLs with 15748 bytes (45.45% of keys, avg size 629.92)

section_id: memory-usage

code:
$ redis-cli --keystats

# Scanning the entire keyspace to find the biggest keys and distribution information.
# Use -i 0.1 to sleep 0.1 sec per 100 SCAN commands (not usually needed).
# Use --cursor <n> to start the scan at the cursor <n> (usually after a Ctrl-C).
# Use --top <n> to display <n> top key sizes (default is 10).
# Ctrl-C to stop the scan.

100.00% ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
Keys sampled: 55
Keys size:    1.30M

--- Top 10 key sizes ---
  1    1.00M MBbloomCF  "bikes:models"
  2  140.68K CMSk-TYPE  "bikes:profit"
  3  111.58K TopK-TYPE  "bikes:keywords"
  4    9.60K TDIS-TYPE  "bikes:sales"
  5    9.59K TDIS-TYPE  "racer_ages"
  6    7.00K stream     "race:italy"
  7    4.92K stream     "race:france"
  8    4.75K ReJSON-RL  "bikes:inventory"
  9    4.64K stream     "race:usa"
 10    1.26K ReJSON-RL  "bicycle:7"

--- Top size per type ---
list       bikes:finished is 104B
string     all_bikes is 120B
MBbloomCF  bikes:models is 1.00M
hash       bike:1:stats is 104B
stream     race:italy is 7.00K
TDIS-TYPE  bikes:sales is 9.60K
TopK-TYPE  bikes:keywords is 111.58K
set        bikes:racing:france is 120B
CMSk-TYPE  bikes:profit is 140.68K
zset       racer_scores is 168B
ReJSON-RL  bikes:inventory is 4.75K

--- Top length and cardinality per type ---
list       bikes:finished has 1 items
string     all_bikes has 36B
hash       bike:1:stats has 3 fields
stream     race:france has 4 entries
set        bikes:racing:france has 3 members
zset       racer_scores has 8 members

Key size Percentile Total keys
-------- ---------- -----------
     64B    0.0000%           3
    239B   50.0000%          28
    763B   75.0000%          42
   4.92K   87.5000%          49
   9.60K   93.7500%          52
 140.69K   96.8750%          54
   1.00M  100.0000%          55
Note: 0.01% size precision, Mean: 24.17K, StdDeviation: 138.12K

Key name length Percentile Total keys
--------------- ---------- -----------
            19B  100.0000%          55
Total key length is 495B (9B avg)

Type        Total keys  Keys % Tot size Avg size  Total length/card Avg ln/card
--------- ------------ ------- -------- -------- ------------------ -----------
list                 1   1.82%     104B     104B            1 items        1.00
string              16  29.09%    1.33K      85B               149B          9B
MBbloomCF            1   1.82%    1.00M    1.00M                 -           -
hash                 1   1.82%     104B     104B           3 fields        3.00
stream               3   5.45%   16.56K    5.52K          8 entries        2.67
TDIS-TYPE            2   3.64%   19.19K    9.59K                 -           -
TopK-TYPE            1   1.82%  111.58K  111.58K                 -           -
set                  2   3.64%     208B     104B          5 members        2.50
CMSk-TYPE            1   1.82%  140.68K  140.68K                 -           -
zset                 2   3.64%     304B     152B         11 members        5.50
ReJSON-RL           25  45.45%   15.38K     629B                 -           -

section_id: combine-bigkeys-and-memkeys

code:
Usage: redis-cli [OPTIONS] [cmd [arg [arg ...]]]
  -h <hostname>      Server hostname (default: 127.0.0.1).
  -p <port>          Server port (default: 6379).
  -t <timeout>       Server connection timeout in seconds (decimals allowed).
                     Default timeout is 0, meaning no limit, depending on the OS.
  -s <socket>        Server socket (overrides hostname and port).
  -a <password>      Password to use when connecting to the server.
                     You can also use the REDISCLI_AUTH environment
                     variable to pass this password more safely
                     (if both are used, this argument takes precedence).
  --user <username>  Used to send ACL style 'AUTH username pass'. Needs -a.
  --pass <password>  Alias of -a for consistency with the new --user option.
  --askpass          Force user to input password with mask from STDIN.
                     If this argument is used, '-a' and REDISCLI_AUTH
                     environment variable will be ignored.
  -u <uri>           Server URI on format redis://user:password@host:port/dbnum
                     User, password and dbnum are optional. For authentication
                     without a username, use username 'default'. For TLS, use
                     the scheme 'rediss'.
  -r <repeat>        Execute specified command N times.
  -i <interval>      When -r is used, waits <interval> seconds per command.
                     It is possible to specify sub-second times like -i 0.1.
                     This interval is also used in --scan and --stat per cycle.
                     and in --bigkeys, --memkeys, --keystats, and --hotkeys per 100 cycles.
  -n <db>            Database number.
  -2                 Start session in RESP2 protocol mode.
  -3                 Start session in RESP3 protocol mode.
  -x                 Read last argument from STDIN (see example below).
  -X                 Read <tag> argument from STDIN (see example below).
  -d <delimiter>     Delimiter between response bulks for raw formatting (default: \n).
  -D <delimiter>     Delimiter between responses for raw formatting (default: \n).
  -c                 Enable cluster mode (follow -ASK and -MOVED redirections).
  -e                 Return exit error code when command execution fails.
  -4                 Prefer IPv4 over IPv6 on DNS lookup.
  -6                 Prefer IPv6 over IPv4 on DNS lookup.
  --raw              Use raw formatting for replies (default when STDOUT is
                     not a tty).
  --no-raw           Force formatted output even when STDOUT is not a tty.
  --quoted-input     Force input to be handled as quoted strings.
  --csv              Output in CSV format.
  --json             Output in JSON format (default RESP3, use -2 if you want to use with RESP2).
  --quoted-json      Same as --json, but produce ASCII-safe quoted strings, not Unicode.
  --show-pushes <yn> Whether to print RESP3 PUSH messages.  Enabled by default when
                     STDOUT is a tty but can be overridden with --show-pushes no.
  --stat             Print rolling stats about server: mem, clients, ...
  --latency          Enter a special mode continuously sampling latency.
                     If you use this mode in an interactive session it runs
                     forever displaying real-time stats. Otherwise if --raw or
                     --csv is specified, or if you redirect the output to a non
                     TTY, it samples the latency for 1 second (you can use
                     -i to change the interval), then produces a single output
                     and exits.
  --latency-history  Like --latency but tracking latency changes over time.
                     Default time interval is 15 sec. Change it using -i.
  --latency-dist     Shows latency as a spectrum, requires xterm 256 colors.
                     Default time interval is 1 sec. Change it using -i.
  --lru-test <keys>  Simulate a cache workload with an 80-20 distribution.
  --replica          Simulate a replica showing commands received from the master.
  --rdb <filename>   Transfer an RDB dump from remote server to local file.
                     Use filename of "-" to write to stdout.
  --functions-rdb <filename> Like --rdb but only get the functions (not the keys)
                     when getting the RDB dump file.
  --pipe             Transfer raw Redis protocol from stdin to server.
  --pipe-timeout <n> In --pipe mode, abort with error if after sending all data.
                     no reply is received within <n> seconds.
                     Default timeout: 30. Use 0 to wait forever.
  --bigkeys          Sample Redis keys looking for keys with many elements (complexity).
  --memkeys          Sample Redis keys looking for keys consuming a lot of memory.
  --memkeys-samples <n> Sample Redis keys looking for keys consuming a lot of memory.
                     And define number of key elements to sample
  --keystats         Sample Redis keys looking for keys memory size and length (combine bigkeys and memkeys).
  --keystats-samples <n> Sample Redis keys looking for keys memory size and length.
                     And define number of key elements to sample (only for memory usage).
  --cursor <n>       Start the scan at the cursor <n> (usually after a Ctrl-C).
                     Optionally used with --keystats and --keystats-samples.
  --top <n>          To display <n> top key sizes (default: 10).
                     Optionally used with --keystats and --keystats-samples.
  --hotkeys          Sample Redis keys looking for hot keys.
                     only works when maxmemory-policy is *lfu.
  --scan             List all keys using the SCAN command.
  --pattern <pat>    Keys pattern when using the --scan, --bigkeys, --memkeys,
                     --keystats or --hotkeys options (default: *).
  --count <count>    Count option when using the --scan, --bigkeys, --memkeys,
                     --keystats or --hotkeys (default: 10).
  --quoted-pattern <pat> Same as --pattern, but the specified string can be
                         quoted, in order to pass an otherwise non binary-safe string.
  --intrinsic-latency <sec> Run a test to measure intrinsic system latency.
                     The test will run for the specified amount of seconds.
  --eval <file>      Send an EVAL command using the Lua script at <file>.
  --ldb              Used with --eval enable the Redis Lua debugger.
  --ldb-sync-mode    Like --ldb but uses the synchronous Lua debugger, in
                     this mode the server is blocked and script changes are
                     not rolled back from the server memory.
  --cluster <command> [args...] [opts...]
                     Cluster Manager command and arguments (see below).
  --verbose          Verbose mode.
  --no-auth-warning  Don't show warning message when using password on command
                     line interface.
  --help             Output this help and exit.
  --version          Output version and exit.

Cluster Manager Commands:
  Use --cluster help to list all available cluster manager commands.

Examples:
  redis-cli -u redis://default:PASSWORD@localhost:6379/0
  cat /etc/passwd | redis-cli -x set mypasswd
  redis-cli -D "" --raw dump key > key.dump && redis-cli -X dump_tag restore key2 0 dump_tag replace < key.dump
  redis-cli -r 100 lpush mylist x
  redis-cli -r 100 -i 1 info | grep used_memory_human:
  redis-cli --quoted-input set '"null-\x00-separated"' value
  redis-cli --eval myscript.lua key1 key2 , arg1 arg2 arg3
  redis-cli --scan --pattern '*:12345*'
  redis-cli --scan --pattern '*:12345*' --count 100

  (Note: when using --eval the comma separates KEYS[] from ARGV[] items)

When no command is given, redis-cli starts in interactive mode.
Type "help" in interactive mode for information on available commands
and settings.

section_id: usage


title: Client tools

summary: Tools to interact with a Redis server

title: Redis CLI

summary: Visualize and optimize Redis data, connect to RDI, and more.

title: Redis Insight

summary: Connect to Redis from Visual Studio Code.

title: Redis for VS Code

page_type: content

title: Overview

role: overview

text:
You can use several tools to connect to a Redis server, to
manage it and interact with the data:

* The [`redis-cli`](#redis-command-line-interface-cli) command line tool
* [Redis Insight](#redis-insight) (a graphical user interface tool)
* The Redis [VSCode extension](#redis-vscode-extension)

title: Redis command line interface (CLI)

role: content

text:
The [Redis command line interface]() (also known as `redis-cli`) is a terminal program that sends commands to and reads replies from the Redis server. It has the following two main modes:

1. An interactive Read Eval Print Loop (REPL) mode where the user types Redis commands and receives replies.
2. A command mode where `redis-cli` is executed with additional arguments, and the reply is printed to the standard output.

title: Redis Insight

text:
[Redis Insight]() combines a graphical user interface with Redis CLI to let you work with any Redis deployment. You can visually browse and interact with data, take advantage of diagnostic tools, learn by example, and much more. Best of all, Redis Insight is free.

[Download Redis Insight](https://redis.io/downloads/#insight).

title: Redis VSCode extension

text:
[Redis for VS Code]()
is an extension that allows you to connect to your Redis databases from within Microsoft Visual Studio Code. After connecting to a database, you can view, add, modify, and delete keys, and interact with your Redis databases using a Redis Insight like UI and also a built-in CLI interface.


title: Redis Copilot FAQ

title: General questions

title: What is Redis Copilot?

text: Redis Copilot is an AI-powered developer assistant that helps you learn about Redis, explore your Redis data, and build search queries in a conversational manner.  It is available in our flagship visual GUI developer tool, Redis Insight, as well as within the Redis public documentation (general chatbot).

title: How does Redis Copilot work?

text: Redis Copilot is powered by the [OpenAI API](https://platform.openai.com/docs/overview) platform. When it needs to provide context-aware assistance, such as within the **my data** chat in Redis Insight, Redis Copilot will use data from your connected database. Some of that data, such as indexing schemas and sample keys, may be transmitted to the Redis Copilot backend and OpenAI for processing.

title: What kind of tasks can Redis Copilot perform?

text:
Currently, Redis Copilot provides two primary features: a general chatbot and a context-aware data chatbot.

**General chatbot**: the knowledge-based chatbot serves as an interactive and dynamic documentation interface to simplify the learning process. You can ask specific questions about Redis commands, concepts, and products, and get responses on the fly. The general chatbot is also available in our public docs.

**My data chatbot**: the context-aware chatbot available in Redis Insight lets you construct search queries using everyday language rather than requiring specific programming syntax. This feature lets you query and explore data easily and interactively without extensive technical knowledge.

title: How do I get started with Redis Copilot in Redis Insight?

text:
The Redis Copilot instance within our public documentation is free for anyone to use and is available now to answer general questions about Redis.

The Redis Copilot instance that is embedded in Redis Insight is gradually being rolled out to the user base. Once you are granted access to Redis Copilot in the app, you need to sign in with your Redis Cloud account before you can start using it. If you don’t have an account with Redis Cloud yet, it will be automatically created when you sign in at no extra cost to you.

title: Data and Privacy

title: What data does Redis Copilot have access to in my database?

text:
Redis Copilot will have access to any relevant data stored in your database to provide context-aware assistance.
However, this only impacts the **my data** chat in Redis Insight.

title: Will OpenAI use my data to train their models?

text: OpenAI states that the data provided via OpenAI API is not used for training. Please see the [OpenAI API data privacy page](https://openai.com/api-data-privacy) for the latest information.

title: What are the Redis Copilot terms?

text: Redis Copilot terms apply to your use of or access to Redis Copilot. They set out what you can expect from Redis Copilot concerning its capabilities and limitations and how Redis Copilot handles your data.

title: Feedback

title: How can I provide feedback or report a bug?

text: Redis Copilot is released as Beta in Redis Insight. We welcome your feedback and bug reports. You can submit them through the feedback form available in the [Redis Insight GitHub repository](https://github.com/RedisInsight/RedisInsight).


title: Redis Insight debugging information

summary: Redis Insight debugging information

title: Overview

text: If you are experiencing errors or other issues when using Redis Insight, follow the steps below to learn more about the errors and to identify root cause.

title: Connection issues

text: If you experience connection issues, try these steps.

title: 1. Launch Redis Insight in debug mode

text:
Run the following command to launch Redis Insight in debug mode to investigate connection issues:

* **Windows**:

    `cmd /C "set DEBUG=ioredis* && ".\Redis Insight.exe""`

* **macOS** (from the Applications folder):

    `DEBUG=ioredis* open "Redis Insight.app"`

* **Linux**:

    `DEBUG=ioredis* "redis insight"`

title: 2. Investigate logs

text:
You can review the Redis Insight log files (files with a `.log` extension) to get detailed information about system issues.
These are the locations on supported platforms:

- **Docker**: In the `/data/logs` directory *inside the container*.
- **macOS**: In the `/Users/<your-username>/.redis-insight` directory.
- **Windows**: In the `C:\Users\<your-username>\.redis-insight` directory.
- **Linux**: In the `/home/<your-username>/.redis-insight` directory.

title: Other issues

title: To debug issues other than connectivity

text:
* **Windows**:

    `cmd /C "set DEBUG=* && ".\Redis Insight.exe""`

* **macOS** (from the Applications folder):

    `DEBUG=* open "Redis Insight.app"`

* **Linux**:

    `DEBUG=* "redis insight"`

title: Get detailed Redis Insight logs

text:
* **Windows**:

    `cmd /C "set STDOUT_LOGGER=true && set LOG_LEVEL=debug && set LOGGER_OMIT_DATA=false && ".\Redis Insight.exe""`

* **macOS** (from the Applications folder):

    `LOG_LEVEL=debug LOGGER_OMIT_DATA=false open "Redis Insight.app"`

* **Linux**:

    `LOG_LEVEL=debug LOGGER_OMIT_DATA=false "redis insight"`

    Note: if you use LOGGER_OMIT_DATA=false, logs may contain sensitive data.

title: To log everything

text:
* **Windows**:

    `cmd /C "set STDOUT_LOGGER=true && set LOG_LEVEL=debug && set LOGGER_OMIT_DATA=false && set DEBUG=* && ".\Redis Insight.exe""`

* **macOS** (from the Applications folder):

    `LOG_LEVEL=debug LOGGER_OMIT_DATA=false DEBUG=* open "Redis Insight.app"`

* **Linux**:

    `LOG_LEVEL=debug LOGGER_OMIT_DATA=false DEBUG=* "redis insight"`

    Note: if you use LOGGER_OMIT_DATA=false or DEBUG=*, logs may contain sensitive data.


title: Redis Insight

title: Redis Copilot FAQ

summary: Connect to RDI from Redis Insight, configure pipelines, and more.

title: RDI in Redis Insight

summary: Learn how to manage streams and consumer groups in Redis Insight

title: Manage streams and consumer groups in Redis Insight

summary: Redis Insight debugging information

title: Redis Insight debugging information

title: Redis Insight release notes

title: Overview

text:
[![Discord](https://img.shields.io/discord/697882427875393627?style=flat-square)](https://discord.gg/QUkjSsk)
[![Github](https://img.shields.io/static/v1?label=&message=repository&color=5961FF&logo=github)](https://github.com/redisinsight/redisinsight/)

Redis Insight is a powerful tool for visualizing and optimizing data in Redis, making real-time application development easier and more fun than ever before. Redis Insight lets you do both GUI- and CLI-based interactions in a fully-featured desktop GUI client.

title: Installation and release notes

title: Overview

title: Connection management

text:
* Automatically discover and add your local Redis databases (that use standalone connection type and do not require authentication).
* Discover your databases in Redis Software Cluster and databases with Flexible plans in Redis Cloud.
* Use a form to enter your connection details and add any Redis database running anywhere (including Redis Open Source cluster or sentinel).
* Connect to a Redis Data Integration (RDI) management plane, create, test, and deploy RDI pipelines, and view RDI statistics.

When you add a Redis database for a particular user using the `username` and `password` fields, that user must be able to run the `INFO` command. See the [access control list (ACL) documentation]() for more information.

title: Connect to Azure Managed Redis with ease

text:
Automatically discover databases across subscriptions and connect using Microsoft Entra ID (OAuth) with passwordless authentication and background token refresh. Redis Insight supports both Azure Managed Redis and Azure Cache for Redis tiers, with:

- Auto-discovery of subscriptions and databases
- One-click import and connection
- Multi-account support for switching between Azure accounts
- Improved, user-friendly error handling

This feature requires Azure-side configuration. Please coordinate with your Azure administrator and follow [the setup guide](https://github.com/redis/RedisInsight/blob/main/docs/azure-setup.md) to configure the necessary permissions.

title: Redis Copilot

text:
Redis Copilot is an AI-powered developer assistant that helps you learn about Redis, explore your Redis data, and build search queries in a conversational manner. It is available in Redis Insight as well as within the Redis public documentation.

Currently, Redis Copilot provides two primary features: a general chatbot and a context-aware data chatbot.

**General chatbot**: the knowledge-based chatbot serves as an interactive and dynamic documentation interface to simplify the learning process. You can ask specific questions about Redis commands, concepts, and products, and get responses on the fly. The general chatbot is also available in our public docs.

**My data chatbot**: the context-aware chatbot available in Redis Insight lets you construct search queries using everyday language rather than requiring specific programming syntax. This feature lets you query and explore data easily and interactively without extensive technical knowledge.

Before you can use Redis Copilot, you must first sign in and accept the terms of use. Click on the Redis Copilot icon in the top right corner of the Redis Insight window to sign in and accept the terms of use.

Here's an example of using Redis Copilot to search data using a simple, natural language prompt.

See the [Redis Insight Copilot FAQ]() for more information.

title: RDI in Redis Insight

text: Redis Insight includes Redis Data Integration (RDI) connectivity, which allows you to connect to an RDI management plane, and create, test, and deploy RDI pipelines. Read more about this feature [here]().

title: Browser

text:
Browse, filter and visualize your key-value Redis data structures.
* [CRUD](https://en.wikipedia.org/wiki/Create,_read,_update_and_delete) support for lists, hashes, strings, sets, sorted sets, and streams.
* CRUD support for [JSON]().
* Group keys according to their namespaces.

* View, validate, and manage your key values in a human-readable format using formatters that prettify and highlight data in different formats (for example, Unicode, JSON, MessagePack, HEX, and ASCII) in the Browser tool.

title: Profiler

text: Analyze every command sent to Redis in real time. To use the profiler, click  **Profiler** at the bottom left of the screen. It should reveal the profiler window, and there you can start the profiler by clicking on **Start Profiler**.

title: CLI

text:
The CLI is accessible at any time within the application. To use the CLI, click  **>_ CLI** at the bottom left of the screen. It should reveal the CLI window, and there you can start typing Redis [commands]().

The CLI includes the following features:

* Employs integrated help to deliver intuitive assistance.
* Use together with a convenient command helper that lets you search and read on Redis commands.

title: Workbench

text:
Workbench is an advanced command line interface with intelligent command auto-complete and complex data visualization support.

* Built-in guides: you can conveniently discover Redis and Redis Open Source features using the built-in guides.
* Command auto-complete support for all features in Redis and Redis Open Source.
* Advanced, schema-aware auto-complete for Redis Search, which provides for faster query building with context-sensitive suggestions that recognize indexes, schemas, and fields based on your current query. Start typing any Redis Search command in to try this feature. See below for an example of an in-progress `FT.SEARCH` command.

Workbench also includes:

* Visualizations of your indexes, queries, and aggregations.
* Visualizations of your [time series]() data.

title: Tools

title: Database analysis

text:
Use the database analysis tool to optimize the performance and memory usage of your Redis database. Check data type distribution and memory allocation and review the summary of key expiration time and memory to be freed over time. Inspect the top keys and namespaces sorted by consumed memory or key length and count of keys, respectively. Capture and track the changes in your database by viewing historical analysis reports. Next figure shows a sample database analysis report.

The database analysis tool will only analyze up to 10,000 keys. If more than 10,000 keys are present, the tool will attempt to use extrapolation in its analysis.

title: Redis Streams support

text:
Create and manage streams by adding, removing, and filtering entries per timestamp. To see and work with new entries, enable and customize the automatic refresh rate.

View and manage the list of consumer groups. See existing consumers in a given consumer name as well as the last messages delivered to them. Inspect the list of pending messages, explicitly acknowledge the processed items, or claim unprocessed messages via Redis Insight.

title: Search features

text: If you're using the indexing, querying, or full-text search features of Redis Open Source, Redis Insight provides UI controls to quickly and conveniently run search queries against a preselected index. You can also create a secondary index of your data in a dedicated pane.

title: Bulk actions

text:
Easily and quickly delete multiple keys of the same type and/or with the same key name pattern in bulk. To do so, in the List or Tree view, set filters per key type or key names and open the Bulk Actions section. The section displays a summary of all the keys with the expected number of keys that will be deleted based on the set filters.

When the bulk deletion is completed, Redis Insight displays the results of this operation with the number of keys processed and the time taken to delete the keys in bulk.
Use bulk deletion to optimize the usage of your database based on the results from the Redis database analysis.

title: Slow Log

text: The Slow Log tool displays the list of logs captured by the SLOWLOG command to analyze all commands that exceed a specified runtime, which helps with troubleshooting performance issues. Specify both the runtime and the maximum length of Slowlog (which are server configurations) to configure the list of commands logged and set the auto-refresh interval to automatically update the list of commands displayed.

title: Plugins

text: With Redis Insight you can now also extend the core functionality by building your own data visualizations. See our [plugin documentation](https://github.com/Redis-Insight/Redis-Insight/wiki/Plugin-Documentation) for more information.

title: Telemetry

text: Redis Insight includes an opt-in telemetry system. This help us improve the developer experience of the app. We value your privacy; all collected data is anonymized.

title: Log files

text:
You can review the Redis Insight log files (files with a `.log` extension) to get detailed information about system issues.
These are the locations on supported platforms:

- **Docker**: In the `/data/logs` directory *inside the container*.
- **Mac**: In the `/Users/<your-username>/.redis-insight` directory.
- **Windows**: In the `C:\Users\<your-username>\.redis-insight` directory.
- **Linux**: In the `/home/<your-username>/.redis-insight` directory.

You can install Redis Insight on operating systems that are not officially supported, but it may not behave as expected.

title: Redis Insight API (only for Docker)

text:
If you are running Redis Insight from [Docker](),
you can access the API from `http://localhost:5540/api/docs`.

title: Feedback

text: To provide your feedback, [open a ticket in our Redis Insight repository](https://github.com/Redis-Insight/Redis-Insight/issues/new).

title: License

text: Redis Insight is licensed under [SSPL](https://github.com/Redis-Insight/Redis-Insight/blob/main/LICENSE) license.


title: Overview

text:
A _stream_ is an append-only log file.
When you add data to it, you cannot change it.
That may seem like a disadvantage; however, a stream serves as a log or single source of truth.
It can also be used as a buffer between processes that work at different speeds and do not need to know about each other.
For more conceptual information about streams, see [Redis Streams]().

In this topic, you will learn how to add and work with streams as well as consumer groups in Redis Insight.

Here's a stream that models temperature and humidity sensors. Processes interacting with the stream perform one of two roles: _consumer_ and _producer_.
The point of a stream is that it's not going to end, so you cannot capture whole datasets and do some processing on them.

In this stream, sensors are considered _producers_, which broadcast data.
A _consumer_ reads from the stream and does some work on it.
For example, if the temperature is above a certain threshold, it puts a message out to turn on the air conditioner in that unit or notify the maintenance.

It is possible to have multiple consumers doing different jobs, one measuring humidity, and another taking temperature measurements over periods of time.
Redis stores a copy of the entire dataset in memory, which is a finite resource.
To avoid runaway data, streams can be trimmed when you add something to them.
When adding to a stream with [`XADD`](), you can optionally specify that the stream should be trimmed to a specific or approximate number of the newest entries, or to only include entries whose ID is higher than the ID specified.
You can also manage the storage required for streaming data using key expiry.  For example, by writing each day's data to its own stream in Redis and expiring each stream's key after a period of time, say a week.
An ID can be any number, but each new entry in the stream must have an ID whose value is higher than the last ID added to the stream.

title: Adding new entries

text:
Use [`XADD`]() with `*` for the ID to have Redis automatically generate a new ID for you consisting of a millisecond precision timestamp, a dash and a sequence number.  For example `1656416957625-0`.  Then supply the field names and values to store in the new stream entry.

There are a couple of ways of retrieving things. You can retrieve entries by time range or you could ask for everything that's happened since a timestamp or ID that you specify. Using a single command you can ask for anything from 10:30 until 11:15 am on a given day.

title: Consumer groups

text:
A more realistic use case would be a system with many temperature sensors whose data Redis puts in a stream, records the time they arrive, and orders them.

On the right side we have two consumers that read the stream. One of them is alerting if the temperature is over a certain number and texting the maintenance crew that they need to do something, and the other is a data warehouse that is taking the data and putting it into a database.

They run independently of each other.
Up in the right, we have another sort of task.
Let's assume that alerting and data warehouse are really fast.
You get a message whether the temperature is larger than a specific value, which might take a millisecond.
And alerting can keep up with the data flow.
One way you can scale consumers is _consumer groups_, which allows multiple instances of the same consumer or same code to work as a team to process the stream.

title: Managing streams in Redis Insight

text:
You can add a stream in Redis Insight in two ways: create a new stream or add to an existing stream.

To create a stream, start by selecting the key type (stream).
You cannot set time to live (TTL) because it cannot be put on a message in a stream; it can only be done on a Redis key. Name the stream _mystream_.
Then, set the *Entry ID* to `*` to default to timestamp.
If you have your own ID generation strategy, enter the next ID from your sequence. Remember that the ID must be higher than the ID of any other entry in the stream.

Then, enter fields and values using + to add more than one (for example, name and location).
Now you have a stream that appears in the **Streams** view and you can continue adding fields and values to it.

Redis Insight runs read commands for you so you can see the stream entries in the **Streams** view.
And the **Consumer Groups** view shows each consumers in a given consumer group and the last time Redis allocated a message, what the ID of it was and how many times that process has happened, and whether a consumer has you have told Redis that you are finished working with that task using the [`XACK`]() command.

title: Monitor temperature and humidity from sensors in Redis Insight

text: This example shows how to bring an existing stream into Redis Insight and work with it.

title: Setup

text:
1. Install [Redis Insight](https://redis.com/redis-enterprise/redis-insight/?_ga=2.48624486.1318387955.1655817244-1963545967.1655260674#insight-form).
2. Download and install [Node.js](https://nodejs.org/en/download/) (LTS version).
3. Install [Redis](). In Docker, check that Redis is running locally on the default port 6379 (with no password set).
4. Clone the [code repository](https://github.com/redis-developer/introducing-redis-talk) for this example.
See the [README](https://github.com/redis-developer/introducing-redis-talk/tree/main/streams) for more information about this example and installation tips.
5. On your command-line, navigate to the folder containing the code repository and install the Node.js package manager (npm).

 npm install

title: Run the producer

text:
To start the producer, which will add a new entry to the stream every few seconds, enter:

npm run producer

> streams@1.0.0 producer
> node producer.js

Starting producer...
Adding reading for location: 62, temperature: 40.3, humidity: 36.5
Added as 1632771056648-0
Adding reading for location: 96, temperature: 15.4, humidity: 70
Added as 1632771059039-0
...

The producer runs indefinitely.
Select `Ctrl+C` to stop it.
You can start multiple instances of the producer if you want to add entries to the stream faster.

title: Run the consumer

text:
To start the consumer, which reads from the stream every few seconds, enter:

npm run consumer

> streams@1.0.0 consumer
> node consumer.js

Starting consumer...
Resuming from ID 1632744741693-0
Reading stream...
Received entry 1632771056648-0:
[ 'location', '62', 'temp', '40.3', 'humidity', '36.5' ]
Finished working with entry 1632771056648-0
Reading stream...
Received entry 1632771059039-0:
[ 'location', '96', 'temp', '15.4', 'humidity', '70' ]

The consumer stores the last entry ID that it read in a Redis string at the key `consumer:lastid`. It uses this string to pick up from where it left off after it is restarted. Try this out by stopping it with `Ctrl+C` and restarting it.

Once the consumer has processed every entry in the stream, it will wait indefinitely for instances of the producer to add more:

Reading stream...
No new entries since entry 1632771060229-0.
Reading stream...
No new entries since entry 1632771060229-0.
Reading stream...

Stop it using `Ctrl+C`.

title: Run a consumer group

text:
A consumer group consists of multiple consumer instances working together. Redis manages allocation of entries read from the stream to members of a consumer group. A consumer in a group will receive a subset of the entries, with the group as a whole receiving all of them. When working in a consumer group, a consumer process must acknowledge receipt/processing of each entry.

Using multiple terminal windows, start three instances of the consumer group consumer, giving each a unique name:

npm run consumergroup consumer1

> streams@1.0.0 consumergroup
> node consumer_group.js -- "consumer1"

Starting consumer consumer1...
Consumer group temphumidity_consumers exists, not created.
Reading stream...
Received entry 1632771059039-0:
[ 'location', '96', 'temp', '15.4', 'humidity', '70' ]
Acknowledged processing of entry 1632771059039-0.
Reading stream...

In a second terminal:

npm run consumergroup consumer2

And in a third:

npm run consumergroup consumer3

The consumers will run indefinitely, waiting for new messages to be added to the stream by a producer instance when they have collectively consumed the entire stream.
Note that in this model, each consumer instance does not receive all of the entries from the stream, but the three members of the group each receive a subset.

title: View the stream in Redis Insight

text:
1. Launch Redis Insight.
2. Select `localhost:6379`
3. Select **STREAM**. Optionally, select full screen from the upper right corner to expand the view.

You can now toggle between **Stream** and **Consumer Groups** views to see your data.
As mentioned earlier in this topic, a stream is an append-only log so you can't modify the contents of an entry, but you can delete an entire entry.
A case when that's useful is in the event of a so-called _poison-pill message_ that can cause consumers to crash. You can physically remove such messages in the **Streams** view or use the [`XDEL`]() command at the command-line interface (CLI).

You can continue interacting with your stream at the CLI. For example, to get the current length of a stream, use the [`XLEN`]() command:

XLEN ingest:temphumidity

Use streams for auditing and processing events in banking, gaming, supply chain, IoT, social media, and so on.

title: Related topics

role: related

text:
- [Redis Streams]()
- [Introducing Redis Streams with Redis Insight, node.js, and Python](https://www.youtube.com/watch?v=q2UOkQmIo9Q) (video)


title: RDI in Redis Insight

title: Overview

text:
Redis Data Integration (RDI) and its [ingest pipeline capability]() is an end-to-end solution for mirroring your application's primary database in Redis. RDI employs a capture data change mechanism and a stream processor to map and transform source data such as relational tables into fast Redis data structures that match your use cases.
You can read more about RDI's ingest architecture [on these pages]().

As of version `2.54.0`, Redis Insight includes RDI connectivity, which allows you to connect to [RDI management planes](#how-rdi-is-deployed), create, test, and deploy [RDI pipelines](), and view RDI statistics.

title: Connect

text:
Open Redis Insight and then click on the **Redis Data Integration** tab, which looks like this:

Next, click on **Let's connect to RDI**, which will open the **Add RDI Endpoint** dialog.

Enter your RDI server details into the dialog and then click **Add Endpoint**. The **RDI Alias** field can be any name you choose and it will be used as the primary name in the **RDI Instances** list view. The **URL** field string needs to begin with "https://", followed by the IP address or hostname of your RDI server. You'll receive notification if your connection is successful.

title: Create, test, and deploy RDI pipelines

text:
Begin by clicking the alias of your newly configured RDI endpoint in the **RDI Instances** view (for example, **Test connection** in the above image), which will reveal the **Pipeline Management** view:

The vertical ellipses ("kebab") menu, which is adjacent to the **Deploy** button, contains the following options:

- **Download deployed pipeline** - Download an existing pipeline from your RDI configuration.
- **Import pipeline from ZIP file** - Upload YAML pipeline files from your local computer in ZIP format.
- **Save pipeline to ZIP file** - Save YAML pipeline files to your local computer in ZIP format.

Redis Insight will automatically download the RDI pipeline content from your server when the connection is opened for the first time.

title: Download a deployed pipeline from your RDI configuration

text: Select the **Download deployed pipeline** option from the kebab menu to download a previously defined pipeline from your RDI configuration. The downloaded pipeline will be displayed in the **Pipeline management** pane. As shown below, each pipeline consists of a configuration file (`config.yaml`) and zero or more `job` YAML files; both shown in the leftmost panel. The configuration file will be displayed in the rightmost editor panel.

title: Import a pipeline from your local machine

text:
Select the **Import pipeline from ZIP file** option from the kebab menu to upload your configuration and job YAML files from your local computer. The files must be stored in a ZIP file that has the following structure.

[code example]

The `config.yaml` file, your configuration YAML file, is required. The `jobs` directory can be empty, as job pipelines are not required, but the empty directory must exist in the ZIP file. Otherwise, the `jobs` folder might contain one or more job YAML files.

title: Create a new configuration file using the built-in editor

text:
If you wish to create a new pipeline from scratch, first delete any existing YAML code from the editor panel. If you're familiar with the structure of a configuration file, you can begin editing. If you're not familiar, you can insert a database template using the **Insert template** button menu, which has the following options:

After you make your selections and click **Apply**, Redis Insight will populate the editor window with an appropriate template.

The **Insert template** menu is only available when the editor panel is empty.

See the [RDI documentation]() for information about required fields.

title: Test your target database connection

text: After you've created your **Target database configuration**, you can test the connection using the **Test Connection** button in the bottom right of the editor pane. A new panel will open to the right containing the test results.

title: Create a new transformation job file using the built-in editor

text:
In the **Pipeline Management** pane, click the `+` next to the **Transform and Validate** folder label and enter a name for the new transformation job.

Next, click the job name you just created. You can either begin manually editing your transformation job or you can select **Insert template**, which will populate a sample, non-functional job template in the editor.

The [RDI documentation]() has several examples of transformation jobs that can help get you started. Note: RDI uses a very specific YAML format for job files. See [here](#job-files) for more information.

title: Use the built-in editors

text:
The Redis Insight pipeline file editors are context-aware. They provide auto-completion, syntax highlighting, and error detection for:

- YAML files in the configuration and job file editors
- JMESPath and SQL function snippets in a dedicated editor. To open the JMESPath and SQL editor, click the **SQL and JMESPathEditor** button as shown below. A new editor panel will open in the lower half of the screen. At the bottom-left of that panel, you select either **SQLite functions** or **JMESPath**.

Here's a [reference]() to the supported JMESPath extension functions and expressions that you can use in your job files.

Any changes you make in the editors will be lost if you exit Redis Insight without saving your work. To save any changes you made to your pipeline files, deploy them to your RDI server (see below) or download the modified files as a ZIP file to your local computer. Redis Insight will prepend a green circle on unsaved/undeployed files. Redis Insight will also show errors (if present) using an exclamation point icon.

title: Dry run transformation job pipelines

text:
After you've created a transformation job pipeline, you can execute a dry run on the RDI server. To do that, click on **Dry Run** in the lower right side of the editor panel. A new **Test transformation logic** panel will open to the side. There are two vertically-stacked panes: **Input** and a lower panel that has two tabs: **Transformation output** and **Job output**. In the **Input** section, enter JSON data that will trigger the transformation and then click **Dry run**. Any results will be displayed in the lower section.

There are two tabs in the lower section:

1. **Transformation output** - this is where you'll see JSON output from your dry run.
1. **Job output** - this is where you'll see the Redis commands that would have been run in a real scenario.

title: Deploy pipelines and add target DB to Redis Insight

text:
If you're satisfied with your configuration and transformation job pipelines, you can deploy them to the RDI management plane. Click the **Deploy** button to proceed.

After your pipelines have been deployed, you can add the RDI target Redis database defined in your `config.yaml` file to Redis Insight.
Doing so will allow you to monitor key creation from your RDI pipeline over time.

title: View RDI analytics

text:
You can view various analytics (statistics) for your RDI deployment. To do so, click  the **Analytics** tab button.

Analytics results are refreshed in an interval of your choosing. You can set the refresh interval by clicking on the arrow to the right of the **Auto refresh** control. You can either set the **Refresh rate** in seconds by clicking on the pencil control, or disable refresh altogether using the **Auto Refresh** slider control.

code:
.
├── config.yaml
└── jobs
    └── bbb.yaml


title: Redis Insight release notes

summary: Redis Insight v3.2.0

title: Redis Insight v3.2.0, February 2026

summary: Redis Insight v3.0.3

title: Redis Insight v3.0.3, February 2026

summary: Redis Insight v3.0.2

title: Redis Insight v3.0.2, January 2026

summary: Redis Insight v3.0.0

title: Redis Insight v3.0.0, November 2025

summary: Redis Insight v2.70.1

title: Redis Insight v2.70.1, July 2025

summary: Redis Insight v2.70

title: Redis Insight v2.70.0, May 2025

summary: Redis Insight v2.68

title: Redis Insight v2.68.0, April 2025

summary: Redis Insight v2.66

title: Redis Insight v2.66.0, January 2025

summary: Redis Insight v2.64.1

title: Redis Insight v2.64.1, December 2024

summary: Redis Insight v2.64

title: Redis Insight v2.64.0, December 2024

summary: Redis Insight v2.62

title: Redis Insight v2.62.0, November 2024

summary: Redis Insight v2.60

title: Redis Insight v2.60.0, October 2024

summary: Redis Insight v2.58

title: Redis Insight v2.58.0, October 2024

summary: Redis Insight v2.56

title: Redis Insight v2.56.0, September 2024

summary: Redis Insight v2.54

title: Redis Insight v2.54.0, August 2024

summary: Redis Insight v2.52

title: Redis Insight v2.52.0, June 2024

summary: Redis Insight v2.50

title: Redis Insight v2.50.0, May 2024

summary: Redis Insight v2.48

title: Redis Insight v2.48.0, April 2024

summary: RedisInsight v2.46

title: RedisInsight v2.46.0, March 2024

summary: RedisInsight v2.44

title: RedisInsight v2.44.0, February 2024

summary: RedisInsight v2.42

title: RedisInsight v2.42.0, January 2024

summary: RedisInsight v2.40

title: RedisInsight v2.40.0, December 2023

summary: RedisInsight v2.38

title: RedisInsight v2.38.0, November 2023

summary: RedisInsight v2.36

title: RedisInsight v2.36.0, October 2023

summary: RedisInsight v2.34

title: RedisInsight v2.34.0, September 2023

summary: RedisInsight v2.32

title: RedisInsight v2.32.0, August 2023

summary: RedisInsight v2.30

title: RedisInsight v2.30.0, July 2023

summary: RedisInsight v2.28

title: RedisInsight v2.28.0, June 2023

summary: RedisInsight v2.26

title: RedisInsight v2.26.0, May 2023

summary: RedisInsight v2.24

title: RedisInsight v2.24.0, April 2023

summary: RedisInsight v2.22.1

title: RedisInsight v2.22.1, March 2023

summary: RedisInsight v2.20.0

title: RedisInsight v2.20.0, February 2023

summary: RedisInsight v2.18.0

title: RedisInsight v2.18.0, January 2023

summary: RedisInsight v2.16.0

title: RedisInsight v2.16.0, December 2022

summary: RedisInsight v2.14.0

title: RedisInsight v2.14.0, November 2022

summary: RedisInsight v2.12.0

title: RedisInsight v2.12.0, October 2022

summary: RedisInsight v1.14.0

title: RedisInsight v1.14, may 2023

summary: RedisInsight v2.10.0

title: RedisInsight v2.10.0, September 2022

summary: RedisInsight v2.8.0

title: RedisInsight v2.8.0, August 2022

summary: RedisInsight v1.13.0

title: RedisInsight v1.13, Aug 2022

summary: RedisInsight v2.6.0

title: RedisInsight v2.6.0, July 2022

summary: RedisInsight v2.4.0

title: RedisInsight v2.4.0, June 2022

summary: RedisInsight v2.2.0

title: RedisInsight v2.2.0, May 2022

summary: RedisInsight v1.12.0

title: RedisInsight v1.12, May 2022

summary: RedisInsight v2.0.2

title: RedisInsight v2.0, Nov 2021

summary: RedisInsight v1.11.0

title: RedisInsight v1.11, Oct 2021

summary: RedisInsight v1.10.0

title: RedisInsight v1.10, March 2021

summary: RedisInsight v1.9.0

title: RedisInsight v1.9, January 2021

summary: RedisInsight v1.8.0

title: RedisInsight v1.8, November 2020

summary: RediSearch 2.0 support and stability improvements

title: RedisInsight v1.7, September 2020

summary: Rootless Docker container, Copy keys in Browser and Stream UX improvements

title: RedisInsight v1.6, June 2020

summary: New tool for RedisGears, Multi-line query builder and improved suppport of Redis 6 ACLs

title: RedisInsight v1.5, May 2020

summary: Redis 6 ACLs support, improved CLI and full screen support in Graph, TimeSeries and RedisSearch

title: RedisInsight v1.4, April 2020

summary: Auto-discovery of Redis Cloud databases, visualising paths in RedisGraph

title: RedisInsight v1.3, March 2020

summary: TLS Client side authentication support and stability improvements

title: RedisInsight v1.2, January 2020

summary: Stability improvements and other fixes

title: RedisInsight v1.1, December 2019

summary: The initial release after Redis acquired RDBTools

title: RedisInsight v1.0, November 2019

title: Content

text: Here are the most recent changes for Redis Insight:


title: RedisInsight v2.14.0, November 2022

summary: RedisInsight v2.14.0

title: 2.14.0 (November 2022)

text: This is the General Availability (GA) release of RedisInsight 2.14.

title: Highlights

text:
- Support for [search capabilities](https://redis.io/docs/stack/search/) in Browser: Create secondary index via dedicated form, run queries and full-text search in Browser or Tree views
- Ability to resize the column width of key values when displaying hashes, lists, and sorted sets
- Command processing time displayed as part of the result in Workbench

title: Details

text:
**Features and improvements**
- [#1345](https://github.com/RedisInsight/RedisInsight/pull/1345), [#1346](https://github.com/RedisInsight/RedisInsight/pull/1346), [#1376](https://github.com/RedisInsight/RedisInsight/pull/1376) Added support for [search capabilities](https://redis.io/docs/stack/search/) in Browser tool. Create secondary index of your data using a dedicated form. Conveniently run your queries and full-text search against the preselected index and display results in Browser or Tree views.
- [#1385](https://github.com/RedisInsight/RedisInsight/pull/1385) Resize the column width of key values when displaying hashes, lists, and sorted sets
- [#1354](https://github.com/RedisInsight/RedisInsight/pull/1407) Do not scroll to the end of results when double-clicking a command output in CLI
- [#1347](https://github.com/RedisInsight/RedisInsight/pull/1347) Display command processing time as part of the result in Workbench (time taken to process the command by both RedisInsight backend and Redis)
- [#1351](https://github.com/RedisInsight/RedisInsight/pull/1351) Display the namespaces section in the Database analysis report when no namespaces were found


title: RedisInsight v2.16.0, December 2022

summary: RedisInsight v2.16.0

title: 2.16.0 (December 2022)

text: This is the General Availability (GA) release of RedisInsight 2.16.

title: Highlights

text:
- Bulk import database connections from a file
- Navigation enhancements for the Tree view
- Pre-populated host, port, and database alias in the form when adding a new Redis database

title: Details

text:
**Features and improvements**
- [#1492](https://github.com/RedisInsight/RedisInsight/pull/1492), [#1497](https://github.com/RedisInsight/RedisInsight/pull/1497), [#1500](https://github.com/RedisInsight/RedisInsight/pull/1500), [#1502](https://github.com/RedisInsight/RedisInsight/pull/1502) Migrate your database connections from other Redis GUIs, including RESP.app, with the new feature to bulk import database connections from a file.
- [#1506](https://github.com/RedisInsight/RedisInsight/pull/1506) Pre-populated host (127.0.0.1), port (6379, or 26379 for [Sentinel](https://redis.io/docs/management/sentinel/) connection type), and database alias in the form when adding a new Redis database
- [#1473](https://github.com/RedisInsight/RedisInsight/pull/1473) **Browser** view is renamed **List** view to avoid confusion with the Browser tool
- [#1464](https://github.com/RedisInsight/RedisInsight/pull/1464) Navigation enhancements for the Tree view, covering cases when filters are applied, the list of keys is refreshed or the view is switched to the Tree view
- [#1481](https://github.com/RedisInsight/RedisInsight/pull/1481), [#1482](https://github.com/RedisInsight/RedisInsight/pull/1482), [#1489](https://github.com/RedisInsight/RedisInsight/pull/1489) Indication of new database connections that have been manually added, auto-discovered or imported, but not opened yet
- [#1499](https://github.com/RedisInsight/RedisInsight/pull/1499) Display values of [JSON](https://redis.io/docs/stack/json/) keys when [JSON.DEBUG MEMORY](https://redis.io/commands/json.debug-memory/) is not available

**Bugs**
- [#1514](https://github.com/RedisInsight/RedisInsight/pull/1514) Scan the database even when the [DBSIZE](https://redis.io/commands/dbsize/) returns 0


title: RedisInsight v2.18.0, January 2023

summary: RedisInsight v2.18.0

title: 2.18.0 (January 2023)

text: This is the General Availability (GA) release of RedisInsight 2.18.

title: Highlights

text:
- Support for SSH tunnel to connect to your Redis database
- Ability to switch between database indexes while connected to your database
- Recommendations on how to optimize the usage of your database

title: Details

text:
**Features and improvements**
- [#1567](https://github.com/RedisInsight/RedisInsight/pull/1567), [#1576](https://github.com/RedisInsight/RedisInsight/pull/1576), [#1577](https://github.com/RedisInsight/RedisInsight/pull/1577) Connect to your Redis database via SSH tunnel using a password or private key in PEM format.
- [#1540](https://github.com/RedisInsight/RedisInsight/pull/1540), [#1608](https://github.com/RedisInsight/RedisInsight/pull/1608) Switch between database indexes while connected to your database in Browser, Workbench, and Database Analysis.
- [#1457](https://github.com/RedisInsight/RedisInsight/pull/1457), [#1465](https://github.com/RedisInsight/RedisInsight/pull/1465), [#1590](https://github.com/RedisInsight/RedisInsight/pull/1590) Run Database Analysis to generate recommendations on how to save memory and optimize the usage of your database. These recommendations are based on industry standards and Redis best practices. Upvote or downvote recommendations in terms of their usefulness.
- [#1598](https://github.com/RedisInsight/RedisInsight/pull/1598) Check and highlight the [JSON](https://redis.io/docs/stack/json/) syntax using new [Monaco Editor](https://microsoft.github.io/monaco-editor/).
- [#1583](https://github.com/RedisInsight/RedisInsight/pull/1583) Click a pencil icon to make changes to database aliases.
- [#1579](https://github.com/RedisInsight/RedisInsight/pull/1579) Increase the database password length limitation to 10,000.


title: RedisInsight v2.20.0, February 2023

summary: RedisInsight v2.20.0

title: 2.20.0 (February 2023)

text: This is the General Availability (GA) release of RedisInsight 2.20.

title: Highlights

text:
- Visualizations of [search](https://redis.io/docs/stack/search/) and [graph](https://redis.io/docs/stack/graph/) execution plans in Workbench
- Guided walkthrough of RedisInsight tools and capabilities for new users
- Bulk export database connections to a file
- Upload values of [RedisJSON](https://redis.io/docs/stack/json/) from a file for new keys in Browser
- Visualizations of [CLIENT LIST](https://redis.io/commands/client-list/) in Workbench
- See filters previously used in Browser

title: Details

text:
**Features and improvements**
- [#1629](https://github.com/RedisInsight/RedisInsight/pull/1629), [#1739](https://github.com/RedisInsight/RedisInsight/pull/1739), [#1740](https://github.com/RedisInsight/RedisInsight/pull/1740), [#1781](https://github.com/RedisInsight/RedisInsight/pull/1781) Investigate and optimize your [search](https://redis.io/docs/stack/search/) and [graph](https://redis.io/docs/stack/graph/) queries with new visualizations of execution plans in Workbench. Visualizations are supported for [FT.EXPLAIN](https://redis.io/commands/ft.explain/),[FT.PROFILE](https://redis.io/commands/ft.profile/), [GRAPH.EXPLAIN](https://redis.io/commands/graph.explain/), and [GRAPH.PROFILE](https://redis.io/commands/graph.profile/).
- [#1698](https://github.com/RedisInsight/RedisInsight/pull/1698) Explore RedisInsight's tools and capabilities with a new walkthrough when you start RedisInsight for the first time.
- [#1631](https://github.com/RedisInsight/RedisInsight/pull/1631), [#1632](https://github.com/RedisInsight/RedisInsight/pull/1632) Migrate your database connections to another RedisInsight instance by performing a bulk export of database connections to a file.
- [#1741](https://github.com/RedisInsight/RedisInsight/pull/1741) Upload [RedisJSON](https://redis.io/docs/stack/json/) values from a file for new keys in Browser.
- [#1653](https://github.com/RedisInsight/RedisInsight/pull/1653) Analyze client connections using new Workbench visualizations for [CLIENT LIST](https://redis.io/commands/client-list/).
- [#1625](https://github.com/RedisInsight/RedisInsight/pull/1625) Quickly set filters previously used in Browser by selecting them from the list of recently used filters.
- [#1713](https://github.com/RedisInsight/RedisInsight/pull/1713) See your new Redis keys added in Browser without a need to refresh the list of keys.
- [#1681](https://github.com/RedisInsight/RedisInsight/pull/1681), [#1692](https://github.com/RedisInsight/RedisInsight/pull/1692), [#1693](https://github.com/RedisInsight/RedisInsight/pull/1693) Avoid the timeout connection errors by configuring the connection timeout for databases added manually via host and port.
- [#1696](https://github.com/RedisInsight/RedisInsight/pull/1696), [#1703](https://github.com/RedisInsight/RedisInsight/pull/1703) Test the database connection before adding the database.
- [#1689](https://github.com/RedisInsight/RedisInsight/pull/1689) Update the port of an existing database connection instead of adding a new one.
- [#1731](https://github.com/RedisInsight/RedisInsight/pull/1731) Use database indexes based on [INFO keyspace](https://redis.io/commands/info/).

**Bugs**
- [#1678](https://github.com/RedisInsight/RedisInsight/pull/1678) Prevent crashes when SSH is set up on Linux.
- [#1697](https://github.com/RedisInsight/RedisInsight/pull/1697) Prevent crashes when working with [Redis streams](https://redis.io/docs/data-types/streams) with large IDs.


title: RedisInsight v2.22.1, March 2023

summary: RedisInsight v2.22.1

title: 2.22.1 (March 2023)

text: This is the General Availability (GA) release of RedisInsight 2.22.

title: Highlights

text:
- Share your Redis expertise with your team and the wider community by building custom RedisInsight tutorials. Use our [instructions](https://github.com/RedisInsight/Tutorials) to describe your implementations of Redis for other users to follow and interact with in the context of a connected Redis database
- Take a quick tour of RedisInsight to discover how it can enhance your development experience when building with Redis or Redis Stack
- Select from a list of supported decompression formats to view your data in a human-readable format

title: Details

text:
**Features and improvements**
- [#1782](https://github.com/RedisInsight/RedisInsight/pull/1782), [#1813](https://github.com/RedisInsight/RedisInsight/pull/1813) Share your Redis expertise with your team and the wider community by building custom RedisInsight tutorials. The tutorials use markdown and are easy to write. They are an ideal way to describe practical implementations of Redis so users can follow and interact with commands in the context of an already connected Redis database. Check out these [instructions](https://github.com/RedisInsight/Tutorials) to start creating your own tutorials. Let the community discover your content by labeling your GitHub repository with [redis-tutorials](https://github.com/topics/redis-tutorials)
- [#1834](https://github.com/RedisInsight/RedisInsight/pull/1834) Take a quick tour of RedisInsight to discover how it can enhance your development experience. To start the tour, in the left-side navigation, open the Help Center (above the Settings icon), reset the onboarding and open the Browser page
- [#1742](https://github.com/RedisInsight/RedisInsight/pull/1742), [#1753](https://github.com/RedisInsight/RedisInsight/pull/1753), [#1755](https://github.com/RedisInsight/RedisInsight/pull/1755), [#1762](https://github.com/RedisInsight/RedisInsight/pull/1762) Configure one of the following data decompression formats when adding a database connection to view your data in a human-readable format: GZIP, LZ4, ZSTD, SNAPPY
- [#1787](https://github.com/RedisInsight/RedisInsight/pull/1787) Added UX improvements to the search by values of keys feature in Browser: Enable the search box after the index is selected

**Bugs**
- [#1808](https://github.com/RedisInsight/RedisInsight/pull/1808) Prevent errors when running Docker RedisInsight on Safari Version 16.2
- [#1835](https://github.com/RedisInsight/RedisInsight/pull/1835) Display total memory and total keys for replicas in Sentinel