---
title: "Redis MCP Server: Official Setup for Claude and VS Code"
url: "https://mcpshelf.co/servers/redis"
description: "Redis's own MCP server lets an assistant read and write strings, hashes, lists, streams and JSON, and run vector search. The right uvx config and ACL tips."
updated: "2026-11-10"
site: "MCP Shelf"
---

# Redis MCP Server

> Redis's own server: keys, hashes, streams, JSON and vector search in plain English.

Source: https://mcpshelf.co/servers/redis  
Markdown: https://mcpshelf.co/servers/redis.md  
Generated: 2026-11-22T13:57:57.635Z

## Facts

- **Name:** Redis MCP Server
- **Tagline:** Redis's own server: keys, hashes, streams, JSON and vector search in plain English.
- **Description:** Redis MCP Server is Redis's official server that lets an AI assistant read and write Redis data types, from strings and hashes to streams and JSON, and run vector search on Redis 8.
- **Repository:** https://github.com/redis/mcp-redis
- **Package:** redis-mcp-server 0.5.1 (PyPI)
- **Install:** `claude mcp add redis -- uvx --from redis-mcp-server@latest redis-mcp-server --url redis://localhost:6379/0`
- **Transport:** stdio (local)
- **Auth:** No required keys or settings listed
- **Tools exposed:** 53: `hset`, `hget`, `hdel`, `hgetall`, `hexists`, `set_vector_in_hash`, `get_vector_from_hash`, `json_set`, `json_get`, `json_del`, `lpush`, `rpush`, `lpop`, `rpop`, `lrange`, `llen`, `lrem`, `delete`, `type`, `expire`, `rename`, `scan_keys`, `scan_all_keys`, `search_redis_documents`, `publish`, `subscribe`, `psubscribe`, `read_messages`, `unsubscribe`, `get_indexes`, `get_index_info`, `get_indexed_keys_number`, `create_vector_index_hash`, `vector_search_hash`, `hybrid_search`, `dbsize`, `info`, `client_list`, `sadd`, `srem`, `smembers`, `zadd`, `zrange`, `zrem`, `xadd`, `xrange`, `xdel`, `xgroup_create`, `xgroup_destroy`, `xreadgroup`, `xack`, `set`, `get`
- **Category:** Databases and data (https://mcpshelf.co/categories/databases)
- **Stats:** 641 GitHub stars, 11 downloads a week, last commit 26 Oct 2026, 0 upvotes on MCP Shelf
- **Install check:** Needs your setup first
- **Listed:** 2026-11-10
- **Page updated:** 2026-11-10

## Full description

### What is Redis MCP Server?

**Redis MCP Server is Redis's official server that lets an AI assistant read and write Redis data types, from strings and hashes to streams and JSON, and run vector search on Redis 8.**

Redis maintains this server, which gives an assistant around fifty tools covering the main Redis data types: strings with expiry, hashes, lists, sets, sorted sets, streams with consumer groups, JSON documents and pub/sub. It can also build a vector index on hashes and run a KNN or hybrid search, scan keys without blocking the server, and search the Redis documentation.

Most of its tools write, and the server has no read-only switch of its own. The README points to Redis ACLs instead: connect as a user that only has the @read commands and every write fails at the database, whatever the model tries.

|  |  |
| --- | --- |
| Made by | Redis (redis/mcp-redis) |
| GitHub | https://github.com/redis/mcp-redis |
| Licence | MIT |
| PyPI package | [redis-mcp-server](https://pypi.org/project/redis-mcp-server/) 0.5.1 (5 Aug 2026) |
| GitHub stars | 641 |
| Downloads | 11 a week |
| Last commit | 26 Oct 2026 |
| Tools | 53 |
| Runs on | Your computer |
| Install check | Needs your setup first |
| Category | [Databases and data](https://mcpshelf.co/categories/databases) |
| Works with | Claude Code, Cursor, Claude Desktop, VS Code, Codex, Windsurf |
| Setup checked | 10 Nov 2026 |
| Page updated | 10 Nov 2026 |

**Our check:** It needs something our Linux test machine does not have (an account, a desktop app, a Mac or a running service), so on 10 Nov 2026 we read its tools from the source code instead of running this config. The npm package "mcp-redis" in the shared database is not from Redis. Redis publishes this server on PyPI as redis-mcp-server, and its README starts it with uvx --from redis-mcp-server@latest, which is the config here.

#### Try asking Redis MCP Server

- "Show me the keys that start with session: and when they expire."
- "Store this user profile as a hash under user:42."
- "Find the five documents most similar to this query in my vector index."

#### MCP Shelf take

> Redis needs something our Linux test machine does not have (an account, an app or a service), so on 10 Nov 2026 we read its source and counted 53 tools. 27 of the 53 only read; the other 26 can change things. Other directories point at a package with the same name that belongs to someone else; the config on this page installs the real one. It sits 10th of 10 in its category on our shelf by GitHub stars (641, with 11 downloads a week).

— MCP Shelf tests (numbers from our own runs), tested on 10 Nov 2026

### What tools does Redis MCP Server have?

We listed 53 tools on 10 Nov 2026. 27 only read; the rest can change things or run commands.

| Tool | Kind | What it is for |
| --- | --- | --- |
| `hset` | changes | Sets one field in a hash, with an optional expiry on the key. |
| `hget` | reads | Reads one field from a hash. |
| `hdel` | changes | Removes a field from a hash. |
| `hgetall` | reads | Reads every field and value in a hash. |
| `hexists` | reads | Checks whether a hash has a field. |
| `set_vector_in_hash` | changes | Stores a list of numbers as a binary vector field in a hash. |
| `get_vector_from_hash` | reads | Reads a vector field back from a hash as numbers. |
| `json_set` | changes | Writes a JSON value at a path in a document. |
| `json_get` | reads | Reads the JSON at a path. |
| `json_del` | changes | Deletes the JSON at a path. |
| `lpush` | changes | Adds a value to the start of a list. |
| `rpush` | changes | Adds a value to the end of a list. |
| `lpop` | changes | Takes the first value off a list. |
| `rpop` | changes | Takes the last value off a list. |
| `lrange` | reads | Reads a range of a list. |
| `llen` | reads | Counts the items in a list. |
| `lrem` | changes | Removes matching values from a list. |
| `delete` | changes | Deletes a key. |
| `type` | reads | Says what type of value a key holds. |
| `expire` | changes | Sets a key to expire after a number of seconds. |
| `rename` | changes | Renames a key. |
| `scan_keys` | reads | Lists keys matching a pattern a page at a time, without blocking the server. |
| `scan_all_keys` | reads | Keeps scanning until it has every matching key. |
| `search_redis_documents` | reads | Searches the Redis documentation and tutorials with a plain-English question. |
| `publish` | changes | Sends a message to a pub/sub channel. |
| `subscribe` | reads | Subscribes to a channel and returns a handle for reading later. |
| `psubscribe` | reads | Subscribes to every channel that matches a pattern. |
| `read_messages` | reads | Reads the messages waiting on a subscription handle. |
| `unsubscribe` | reads | Closes a subscription. |
| `get_indexes` | reads | Lists the search indexes in the database. |
| `get_index_info` | reads | Shows an index's schema and stats (FT.INFO). |
| `get_indexed_keys_number` | reads | Counts the keys an index covers. |
| `create_vector_index_hash` | changes | Builds an HNSW vector index over hashes. |
| `vector_search_hash` | reads | Finds the nearest vectors to a query vector (KNN). |
| `hybrid_search` | reads | Combines a filter expression with a KNN vector search. |
| `dbsize` | reads | Counts the keys in the database. |
| `info` | reads | Returns server information and statistics, optionally one section. |
| `client_list` | reads | Lists the clients connected to the server. |
| `sadd` | changes | Adds a member to a set. |
| `srem` | changes | Removes a member from a set. |
| `smembers` | reads | Lists a set's members. |
| `zadd` | changes | Adds a member with a score to a sorted set. |
| `zrange` | reads | Reads a range of a sorted set, optionally with scores. |
| `zrem` | changes | Removes a member from a sorted set. |
| `xadd` | changes | Appends an entry to a stream. |
| `xrange` | reads | Reads entries from a stream. |
| `xdel` | changes | Deletes an entry from a stream. |
| `xgroup_create` | changes | Creates a consumer group on a stream. |
| `xgroup_destroy` | changes | Deletes a consumer group. |
| `xreadgroup` | changes | Reads new entries for a consumer in a group. |
| `xack` | changes | Marks entries as processed by a group. |
| `set` | changes | Sets a string value, with an optional expiry. |
| `get` | reads | Reads a string value. |

#### Tool groups

| Group | Covers |
| --- | --- |
| `Data types` | Strings, hashes, lists, sets, sorted sets, streams with consumer groups, and JSON documents, each with read and write tools. |
| `Pub/sub` | Publish, subscribe by channel or pattern, read queued messages and unsubscribe. |
| `Query engine` | List and inspect indexes, build an HNSW vector index on hashes, and run KNN or hybrid vector search. Needs Redis 8 or Redis Stack. |
| `Keys and server` | Scan, type, expire, rename and delete keys; database size, INFO and the client list; and Redis docs search. |

### How do I install Redis MCP Server?

#### Install steps from the Redis MCP Server README

Copied from the project's [README on GitHub](https://github.com/redis/mcp-redis#readme) on 10 Nov 2026 under its MIT licence.

##### From PyPI (recommended)

Configuring the latest Redis MCP Server version from PyPI, as an example, can be done importing the following JSON configuration in the desired framework or tool.
The `uvx` command will download the server on the fly (if not cached already), create a temporary environment, and then run it.

```
{
  "mcpServers": {
    "RedisMCPServer": {
      "command": "uvx",
      "args": [
        "--from",
        "redis-mcp-server@latest",
        "redis-mcp-server",
        "--url",
        "\"redis://localhost:6379/0\""
      ]
    }
  }
}
```

##### URL specification

The format to specify the `--url` argument follows the [redis](https://www.iana.org/assignments/uri-schemes/prov/redis) and [rediss](https://www.iana.org/assignments/uri-schemes/prov/rediss) schemes:

```
redis://user:secret@localhost:6379/0?foo=bar&qux=baz
```

As an example, you can easily connect to a localhost server with:

```
redis://localhost:6379/0
```

Where `0` is the [logical database](https://redis.io/docs/latest/commands/select/) you'd like to connect to.

For an encrypted connection to the database (e.g., connecting to a [Redis Cloud](https://redis.io/cloud/) database), you'd use the `rediss` scheme.

```
rediss://user:secret@localhost:6379/0?foo=bar&qux=baz
```

To verify the server's identity, specify `ssl_ca_certs`.

```
rediss://user:secret@hostname:port?ssl_cert_reqs=required&ssl_ca_certs=path_to_the_certificate
```

For an unverified connection, set `ssl_cert_reqs` to `none`

```
rediss://user:secret@hostname:port?ssl_cert_reqs=none
```

Configure your connection using the available options in the section "Available CLI Options".

##### Claude Desktop

The simplest way to configure MCP clients is using `uvx`. Add the following JSON to your `claude_desktop_config.json`, remember to provide the full path to `uvx`.

**Basic Redis connection:**

```
{
  "mcpServers": {
    "redis-mcp-server": {
        "type": "stdio",
        "command": "/Users/mortensi/.local/bin/uvx",
        "args": [
            "--from", "redis-mcp-server@latest",
            "redis-mcp-server",
            "--url", "redis://localhost:6379/0"
        ]
    }
  }
}
```

**Azure Managed Redis with EntraID authentication:**

```
{
  "mcpServers": {
    "redis-mcp-server": {
        "type": "stdio",
        "command": "/Users/mortensi/.local/bin/uvx",
        "args": [
            "--from", "redis-mcp-server@latest",
            "redis-mcp-server",
            "--url", "redis://your-azure-redis.redis.cache.windows.net:6379"
        ],
        "env": {
            "REDIS_ENTRAID_AUTH_FLOW": "default_credential",
            "REDIS_ENTRAID_SCOPES": "https://redis.azure.com/.default"
        }
    }
  }
}
```

##### VS Code with GitHub Copilot

To use the Redis MCP Server with VS Code, you must nable the [agent mode](https://code.visualstudio.com/docs/copilot/chat/chat-agent-mode) tools. Add the following to your `settings.json`:

```
{
  "chat.agent.enabled": true
}
```

You can start the GitHub desired version of the Redis MCP server using `uvx` by adding the following JSON to your `mcp.json` file:

```
"servers": {
  "redis": {
    "type": "stdio",
    "command": "uvx",
    "args": [
      "--from", "redis-mcp-server@latest",
      "redis-mcp-server",
      "--url", "redis://localhost:6379/0"
    ]
  },
}
```

##### Suppressing uvx Installation Messages

If you want to suppress uvx installation messages that may appear as warnings in MCP client logs, use the `-qq` flag:

```
"servers": {
  "redis": {
    "type": "stdio",
    "command": "uvx",
    "args": [
      "-qq",
      "--from", "redis-mcp-server@latest",
      "redis-mcp-server",
      "--url", "redis://localhost:6379/0"
    ]
  },
}
```

The `-qq` flag enables silent mode, which suppresses "Installed X packages" messages that uvx writes to stderr during package installation.

Alternatively, you can start the server using `uv` and configure your `mcp.json`. This is usually desired for development.

```
// mcp.json
{
  "servers": {
    "redis": {
      "type": "stdio",
      "command": "<full_path_uv_command>",
      "args": [
        "--directory",
        "<your_mcp_server_directory>",
        "run",
        "src/main.py"
      ],
      "env": {
        "REDIS_HOST": "<your_redis_database_hostname>",
        "REDIS_PORT": "<your_redis_database_port>",
        "REDIS_USERNAME": "<your_redis_database_username>",
        "REDIS_PWD": "<your_redis_database_password>",
      }
    }
  }
}
```

For more information, see the [VS Code documentation](https://code.visualstudio.com/docs/copilot/chat/mcp-servers).

> **Tip:** You can prompt Copilot chat to use the Redis MCP tools by including `#redis` in your message.

> **Note:** Starting with [VS Code v1.102](https://code.visualstudio.com/updates/v1_102),
> MCP servers are now stored in a dedicated `mcp.json` file instead of `settings.json`.

#### What you need first

- uv (for uvx)
- A Redis server or Redis Cloud database you can reach, and its URL

#### Claude Code

Where: Your terminal, in the project folder

```bash
claude mcp add redis -- uvx --from redis-mcp-server@latest redis-mcp-server --url redis://localhost:6379/0
```

#### Cursor

Where: ~/.cursor/mcp.json, or .cursor/mcp.json in a project

```json
{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": [
        "--from",
        "redis-mcp-server@latest",
        "redis-mcp-server",
        "--url",
        "redis://localhost:6379/0"
      ]
    }
  }
}
```

#### Claude Desktop

Where: claude_desktop_config.json (Settings → Developer → Edit Config)

```json
{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": [
        "--from",
        "redis-mcp-server@latest",
        "redis-mcp-server",
        "--url",
        "redis://localhost:6379/0"
      ]
    }
  }
}
```

Use the full path to uvx in command, as Redis's own example does, and restart Claude Desktop after saving.

#### VS Code

Where: .vscode/mcp.json in your project

```json
{
  "servers": {
    "redis": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "--from",
        "redis-mcp-server@latest",
        "redis-mcp-server",
        "--url",
        "redis://localhost:6379/0"
      ]
    }
  }
}
```

Turn on agent mode (chat.agent.enabled), then mention #redis in a chat to point Copilot at these tools.

#### Codex

Where: ~/.codex/config.toml, shared by the Codex CLI, IDE extension and ChatGPT desktop app

```
[mcp_servers.redis]
command = "uvx"
args = ["--from", "redis-mcp-server@latest", "redis-mcp-server", "--url", "redis://localhost:6379/0"]
```

Or run: `codex mcp add redis -- uvx --from redis-mcp-server@latest redis-mcp-server --url redis://localhost:6379/0`

#### Windsurf

Where: ~/.codeium/windsurf/mcp_config.json

```json
{
  "mcpServers": {
    "redis": {
      "command": "uvx",
      "args": [
        "--from",
        "redis-mcp-server@latest",
        "redis-mcp-server",
        "--url",
        "redis://localhost:6379/0"
      ]
    }
  }
}
```

#### ChatGPT

Where: Not supported

ChatGPT on the web only connects to servers by URL. This one runs on your computer: the ChatGPT desktop app can start it from its MCP servers settings, with the same config as the Codex tab.

Change the URL to your own database: rediss:// for TLS, with the user and password in it. For a safer start, create a read-only ACL user and connect as that.

Checked against the project's own install docs on 10 Nov 2026: https://github.com/redis/mcp-redis#readme, https://pypi.org/project/redis-mcp-server/

### How do I configure Redis MCP Server?

| Setting | Kind | Required | What it does |
| --- | --- | --- | --- |
| `--url` | flag | no | The database to connect to, as a redis:// or rediss:// (TLS) URL with an optional user, password and database number. Example: `rediss://user:secret@redis.example.com:6379/0` |
| `--host, --port, --db, --username, --password` | flag | no | The same connection as separate flags. Defaults are 127.0.0.1, 6379 and database 0. |
| `--ssl and --ssl-ca-certs` | flag | no | Turn on TLS and name the CA bundle to check the server against. --ssl-cert-reqs none skips the check, which you should not do in production. |
| `--cluster-mode` | flag | no | Connect to a Redis Cluster rather than a single node. |
| `REDIS_HOST, REDIS_PORT, REDIS_USERNAME, REDIS_PWD` | env | no | The connection through environment variables instead of flags. Flags win when both are set. |
| `REDIS_ENTRAID_AUTH_FLOW` | env | no | Signs in to Azure Managed Redis with Entra ID: service_principal, managed_identity or default_credential. Tokens renew on their own. Example: `default_credential` |
| `MCP_REDIS_LOG_LEVEL` | env | no | How much the server logs to stderr. WARNING by default. Example: `INFO` |

### What can Redis MCP Server read and change?

**It can read**

- Any key and value the Redis user can read
- Server statistics and the list of connected clients
- The Redis documentation, through the docs search tool

**It can change**

- Keys and values of every type, including deletes, renames and expiry times
- Search indexes and stream consumer groups

**Safer setup:** The server has no read-only switch. Create a Redis ACL user with only read commands, for example ACL SETUSER readonlyuser on >password ~* +@read -@write, and connect as that user.

### Good for

- Inspecting what is actually in a cache or session store while debugging
- Prototyping agent memory with streams, hashes or JSON documents
- Trying vector search on Redis 8 without writing the index commands yourself

### Redis MCP Server not working? Common fixes

**Claude Desktop says it cannot find uvx**
Give the full path to uvx in the command field, as the README's Claude Desktop example does (which uvx shows it).

**Install messages from uvx show up as warnings in the client log**
Add -qq as the first argument, before --from, to make uvx silent.

**Connection refused**
Check that Redis is running and reachable at the URL. For Redis Cloud or any TLS endpoint, use rediss:// rather than redis://.

**Vector index or search commands fail**
The query engine tools need the search module, which is built into Redis 8 and Redis Stack but not into older plain Redis.

### What are the alternatives to Redis MCP Server?

| Server | What it does | Tools | Runs on | Licence | Stars |
| --- | --- | --- | --- | --- | --- |
| [Redis MCP Server](https://mcpshelf.co/servers/redis) | Redis's own server: keys, hashes, streams, JSON and vector search in plain English. | 53 | Your computer | MIT | 641 |
| [Postgres MCP Pro](https://mcpshelf.co/servers/postgres-mcp-pro) | SQL, query plans, health checks and index advice for Postgres. | 9 | Your computer | MIT | 3.4K |
| [Supabase](https://mcpshelf.co/servers/supabase) | Manage Supabase projects, tables, migrations, logs and Edge Functions. | 29 | Hosted | Apache-2.0 | 3K |
| [MCP Toolbox for Databases](https://mcpshelf.co/servers/mcp-toolbox-for-databases) | Google's toolbox for Postgres, MySQL, BigQuery, Spanner and other databases. | 29 | Your computer | Apache-2.0 | 16.7K |
| [Qdrant](https://mcpshelf.co/servers/qdrant) | Store notes and find them by meaning in a Qdrant vector collection. | 2 | Your computer | Apache-2.0 | 1.6K |
| [Excel MCP Server](https://mcpshelf.co/servers/excel) | Create, edit, format and chart .xlsx files, no Excel needed. | 46 | Your computer | MIT | 4.3K |

### Redis MCP Server FAQ

#### Is the Redis MCP Server official?

Yes. Redis maintains it in the redis organisation on GitHub and publishes it to PyPI as redis-mcp-server, under the MIT licence.

#### How do I install the Redis MCP Server?

With uv installed, add a server that runs uvx --from redis-mcp-server@latest redis-mcp-server --url followed by your database URL. uvx downloads and runs it on demand, so there is nothing else to install.

#### Can I make it read-only?

Not with a flag. Use Redis ACLs instead: create a user that only has the @read commands and connect as that user, and every write is refused by Redis itself.

#### Does it work with Redis Cloud and Azure Managed Redis?

Yes. Use a rediss:// URL with your Redis Cloud user and password. For Azure Managed Redis it can also sign in with Entra ID through a service principal, a managed identity or your Azure CLI login.

#### Can it do vector search?

Yes, on Redis 8 or Redis Stack. It can store embeddings in hashes, build an HNSW index over them and run nearest-neighbour or hybrid searches, which makes it handy for agent memory experiments.

#### Why not npx mcp-redis?

That npm name is not published by Redis. The official server is a Python package on PyPI, redis-mcp-server, and the README runs it with uvx.

#### Does it support remote or HTTP clients?

Not yet. It talks to clients over stdio, and the README says streamable HTTP will come later. The Redis database itself can be anywhere you can reach.

#### What does it cost?

The server is free and open source. You pay only for the Redis you run it against, and Redis Cloud has a free database to start with.

#### How do I add Redis MCP Server to Cursor?

In ~/.cursor/mcp.json, or .cursor/mcp.json for one project, add an entry named redis that runs uvx --from redis-mcp-server@latest redis-mcp-server --url redis://localhost:6379/0. Save, and the tools show up in Agent chat.

#### Can I use Redis MCP Server in VS Code?

Yes, through GitHub Copilot. In .vscode/mcp.json, add a server named redis with type stdio that runs uvx --from redis-mcp-server@latest redis-mcp-server --url redis://localhost:6379/0. Turn on agent mode (chat.agent.enabled), then mention #redis in a chat to point Copilot at these tools.

#### Does Redis MCP Server work with Codex?

Yes. Run codex mcp add redis -- uvx --from redis-mcp-server@latest redis-mcp-server --url redis://localhost:6379/0 in a terminal, or add an [mcp_servers.redis] table to ~/.codex/config.toml, which the Codex CLI and IDE extension share.

Full docs on GitHub: https://github.com/redis/mcp-redis

## Notes for agents

Fetch these instead of parsing the HTML page:

- llms.txt: https://mcpshelf.co/llms.txt
- llms-full.txt: https://mcpshelf.co/llms-full.txt
- ai.txt: https://mcpshelf.co/ai.txt
- Full catalog (.md): https://mcpshelf.co/catalog.md
- API spec: https://mcpshelf.co/openapi.json
- MCP server: https://mcpshelf.co/mcp
- MCP manifest: https://mcpshelf.co/.well-known/mcp.json
- Developer docs: https://mcpshelf.co/developers

MCP endpoint (Streamable HTTP, no key): https://mcpshelf.co/mcp. REST API: https://mcpshelf.co/api/v1.

