Verified MCP server: Redis
The short answer
Last verified 2026-08-03
The Redis MCP server lets an AI assistant talk to a Redis instance you already run: read and write keys, work with hashes, lists, sets, sorted sets, streams and JSON, run vector and hybrid search over an index, and read server stats. It is the official one, published by Redis, Inc. as the Python package redis-mcp-server, it runs on your own Mac over stdio, and against a local unauthenticated instance it needs no account, no API key and no sign-up. We did not take the README's word for any of that. We started it against a real redis-server on localhost:6379, spoke the protocol to it, enumerated all 47 tools, wrote a throwaway key, read it back and deleted it again, and kept the raw output. That run also caught something the README does not tell you: the exact command it prints crashes today, and one extra flag fixes it. The crash, the fix and every other error are below. [3][1][2]
Verification
Method
We started a real redis-server on this Mac at localhost:6379, spawned the MCP server with uvx over stdio pointed at redis://localhost:6379/0, completed the MCP initialize handshake, called tools/list, and then ran real tool calls: set wrote a throwaway key with a 60 second expiry, get read it back, delete removed it again. No credential of any kind was used, read or banked: the instance is local and unauthenticated. Four more sessions were started on purpose to fail, and that is where the troubleshooting section comes from. The command printed in the README crashed before the handshake on this Mac, so every session ran uvx --with the Python MCP SDK pinned below 2, which resolved SDK 1.29.0. The Mac ran Python 3.14.3 and uv 0.10.11. Node appears in the strip above only because our test client is a Node process; this server does not need it. On a warm uv cache the server prints nothing at all on stdout or stderr, so the banner below is the raw one-line initialize response as it came off the wire.
Startup banner
{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-06-18","capabilities":{"experimental":{},"prompts":{"listChanged":false},"resources":{"subscribe":false,"listChanged":false},"tools":{"listChanged":false}},"serverInfo":{"name":"Redis MCP Server","version":"1.29.0"}}}One real tool call
tools/call set {"key": "mcp-verify-2026", "value": "getroutines-live-check", "expiration": 60}Successfully set mcp-verify-2026 with expiration 60 seconds
Real lines from the captured result: enough to prove the call answered.
Tools
The server answered tools/list with 47 tools on 2026-08-03. The names, descriptions and parameters below are its own words, copied from that response and never edited.
| Tool | What it does |
|---|---|
| hsetname*key*value*expire_seconds | Set a field in a hash stored at key with an optional expiration time. Args: name: The Redis hash key. key: The field name inside the hash. value: The value to set. expire_seconds: Optional; time in seconds after which the key should expire. Returns: A success message or an error message. |
| hgetname*key* | Get the value of a field in a Redis hash. Args: name: The Redis hash key. key: The field name inside the hash. Returns: The field value or an error message. |
| hdelname*key* | Delete a field from a Redis hash. Args: name: The Redis hash key. key: The field name inside the hash. Returns: A success message or an error message. |
| hgetallname* | Get all fields and values from a Redis hash. Args: name: The Redis hash key. Returns: A dictionary of field-value pairs or an error message. |
| hexistsname*key* | Check if a field exists in a Redis hash. Args: name: The Redis hash key. key: The field name inside the hash. Returns: True if the field exists, False otherwise. |
| set_vector_in_hashname*vector*vector_field | Store a vector as a field in a Redis hash. Args: name: The Redis hash key. vector_field: The field name inside the hash. Unless specifically required, use the default field name vector: The vector (list of numbers) to store in the hash. Returns: True if the vector was successfully stored, False otherwise. |
| get_vector_from_hashname*vector_field | Retrieve a vector from a Redis hash and convert it back from binary blob. Args: name: The Redis hash key. vector_field: The field name inside the hash. Unless specifically required, use the default field name Returns: The vector as a list of floats, or an error message if retrieval fails. |
| json_setname*path*value*expire_seconds | Set a JSON value in Redis at a given path with an optional expiration time. Args: name: The Redis key where the JSON document is stored. path: The JSON path where the value should be set. value: The JSON value to store (as JSON string, or will be auto-converted). expire_seconds: Optional; time in seconds after which the key should expire. Returns: A success message or an error message. |
| json_getname*path | Retrieve a JSON value from Redis at a given path. Args: name: The Redis key where the JSON document is stored. path: The JSON path to retrieve (default: root '$'). Returns: The retrieved JSON value or an error message. |
| json_delname*path | Delete a JSON value from Redis at a given path. Args: name: The Redis key where the JSON document is stored. path: The JSON path to delete (default: root '$'). Returns: A success message or an error message. |
| lpushname*value*expire | Push a value onto the left of a Redis list and optionally set an expiration time. |
| rpushname*value*expire | Push a value onto the right of a Redis list and optionally set an expiration time. |
| lpopname* | Remove and return the first element from a Redis list. |
| rpopname* | Remove and return the last element from a Redis list. |
| lrangename*start*stop* | Get elements from a Redis list within a specific range. Returns: str: A JSON string containing the list of elements or an error message. |
| llenname* | Get the length of a Redis list. |
| lremname*count*element* | Remove elements from a Redis list. Args: name: The name of the list count: Number of elements to remove (0 = all, positive = from head, negative = from tail) element: The element value to remove Returns: A string indicating the number of elements removed. |
| deletekey* | Delete a Redis key. Args: key (str): The key to delete. Returns: str: Confirmation message or an error message. |
| typekey* | Returns the string representation of the type of the value stored at key Args: key (str): The key to check. Returns: str: The type of key, or none when key doesn't exist |
| expirename*expire_seconds* | Set an expiration time for a Redis key. Args: name: The Redis key. expire_seconds: Time in seconds after which the key should expire. Returns: A success message or an error message. |
| renameold_key*new_key* | Renames a Redis key from old_key to new_key. Args: old_key (str): The current name of the Redis key to rename. new_key (str): The new name to assign to the key. Returns: Dict[str, Any]: A dictionary containing the result of the operation. On success: {"status": "success", "message": "..."} On error: {"error": "..."} |
| scan_keyspatterncountcursor | Scan keys in the Redis database using the SCAN command (non-blocking, production-safe). ⚠️ IMPORTANT: This returns PARTIAL results from one iteration. Use scan_all_keys() to get ALL matching keys, or call this function multiple times with the returned cursor until cursor becomes 0. The SCAN command iterates through the keyspace in small chunks, making it safe to use on large databases without blocking other operations. Args: pattern: Pattern to match keys against (default is "*" for all keys). Common patterns: "user:*", "cache:*", "*:123", etc. count: Hint for the number of keys to return per iteration (default 100). Redis may return more or fewer keys than this hint. cursor: The cursor position to start scanning from (0 to start from beginning). To continue scanning, use the cursor value returned from previous call. Returns: A dictionary containing: - 'cursor': Next cursor position (0 means scan is complete) - 'keys': List of keys found in this iteration (PARTIAL RESULTS) - 'total_scanned': Number of keys returned in this batch - 'scan_complete': Boolean indicating if scan is finished Or an error message if something goes wrong. Example usage: First call: scan_keys("user:*") -> returns cursor=1234, keys=[...], scan_complete=False Next call: scan_keys("user:*", cursor=1234) -> continues from where it left off Final call: returns cursor=0, scan_complete=True when done |
| scan_all_keyspatternbatch_size | Scan and return ALL keys matching a pattern using multiple SCAN iterations. This function automatically handles the SCAN cursor iteration to collect all matching keys. It's safer than KEYS * for large databases but will still collect all results in memory. ⚠️ WARNING: With very large datasets (millions of keys), this may consume significant memory. For large-scale operations, consider using scan_keys() with manual iteration instead. Args: pattern: Pattern to match keys against (default is "*" for all keys). batch_size: Number of keys to scan per iteration (default 100). Returns: A list of all keys matching the pattern or an error message. |
| search_redis_documentsquestion* | Search Redis documentation and knowledge base to learn about Redis concepts and use cases. This tool exposes updated and curated documentation, and must be invoked every time the user wants to learn more in areas including: **Common Use Cases:** - Session Management: User session storage and management - Caching: Application-level and database query caching - Rate Limiting: API throttling and request limiting - Leaderboards: Gaming and ranking systems - Semantic Search: AI-powered similarity search - Agentic Workflows: AI agent state and memory management - RAG (Retrieval-Augmented Generation): Vector storage for AI applications - Real-time Analytics: Counters, metrics, and time-series data - Message Queues: Task queues and job processing - Geospatial: Location-based queries and proximity search Args: question: The question about Redis concepts, data structures, features, or use cases Returns: Union[List[Dict[str, Any]], Dict[str, Any]]: A list of documentation results from the API, or a dict with an error message. |
| publishchannel*message* | Publish a message to a Redis channel. Args: channel: The Redis channel to publish to. message: The message to send. Returns: A success message or an error message. |
| subscribechannel* | Subscribe to a Redis channel. Args: channel: The Redis channel to subscribe to. Returns: A success message or an error message. |
| unsubscribechannel* | Unsubscribe from a Redis channel. Args: channel: The Redis channel to unsubscribe from. Returns: A success message or an error message. |
| get_indexes | List of indexes in the Redis database Returns: str: A JSON string containing the list of indexes or an error message. |
| get_index_infoindex_name* | Retrieve schema and information about a specific Redis index using FT.INFO. Args: index_name (str): The name of the index to retrieve information about. Returns: str: Information about the specified index or an error message. |
| get_indexed_keys_numberindex_name* | Retrieve the number of indexed keys by the index Args: index_name (str): The name of the index to retrieve information about. Returns: str: Number of indexed keys as a string |
| create_vector_index_hashindex_nameprefixvector_fielddimdistance_metric | Create a Redis 8 vector similarity index using HNSW on a Redis hash. This function sets up a Redis index for approximate nearest neighbor (ANN) search using the HNSW algorithm and float32 vector embeddings. Args: index_name: The name of the Redis index to create. Unless specifically required, use the default name for the index. prefix: The key prefix used to identify documents to index (e.g., 'doc:'). Unless specifically required, use the default prefix. vector_field: The name of the vector field to be indexed for similarity search. Unless specifically required, use the default field name dim: The dimensionality of the vectors stored under the vector_field. distance_metric: The distance function to use (e.g., 'COSINE', 'L2', 'IP'). Returns: A string indicating whether the index was created successfully or an error message. |
| vector_search_hashquery_vector*index_namevector_fieldkreturn_fields | Perform a KNN vector similarity search using Redis 8 or later version on vectors stored in hash data structures. Args: query_vector: List of floats to use as the query vector. index_name: Name of the Redis index. Unless specifically specified, use the default index name. vector_field: Name of the indexed vector field. Unless specifically required, use the default field name k: Number of nearest neighbors to return. return_fields: List of fields to return (optional). Returns: A list of matched documents or an error message. |
| hybrid_searchquery_vector*filter_expressionindex_namevector_fieldkreturn_fields | Perform a hybrid search combining a Redis filter expression with KNN vector similarity. Hybrid search pre-filters documents by metadata before ranking by vector similarity — the standard pattern for production RAG and semantic search pipelines. Filter expression examples: "*" → no filter, pure vector search (same as vector_search_hash) "@category:{news}" → tag filter "@year:[2020 2024]" → numeric range "@lang:{en} @year:[2022 +inf]" → combined tag + range "@title:redis" → full-text match on a text field Full filter syntax: https://redis.io/docs/latest/develop/interact/search-and-query/query/ Args: query_vector: List of floats to use as the query vector. filter_expression: Redis filter expression to restrict candidates before KNN ranking. Defaults to '*' (no filter). index_name: Name of the Redis index (default: 'vector_index'). vector_field: Name of the indexed vector field (default: 'vector'). k: Number of nearest neighbors to return. return_fields: Additional fields to include in results (optional). Returns: A list of matched documents with their similarity score, or an error message. |
| dbsize | Get the number of keys stored in the Redis database |
| infosection | Get Redis server information and statistics. Args: section: The section of the info command (default, memory, cpu, etc.). Returns: A dictionary of server information or an error message. |
| client_list | Get a list of connected clients to the Redis server. |
| saddname*value*expire_seconds | Add a value to a Redis set with an optional expiration time. Args: name: The Redis set key. value: The value to add to the set. expire_seconds: Optional; time in seconds after which the set should expire. Returns: A success message or an error message. |
| sremname*value* | Remove a value from a Redis set. Args: name: The Redis set key. value: The value to remove from the set. Returns: A success message or an error message. |
| smembersname* | Get all members of a Redis set. Args: name: The Redis set key. Returns: A list of values in the set or an error message. |
| zaddkey*score*member*expiration | Add a member to a Redis sorted set with an optional expiration time. Args: key (str): The sorted set key. score (float): The score of the member. member (str): The member to add. expiration (int, optional): Expiration time in seconds. Returns: str: Confirmation message or an error message. |
| zrangekey*start*end*with_scores | Retrieve a range of members from a Redis sorted set. Args: key (str): The sorted set key. start (int): The starting index. end (int): The ending index. with_scores (bool, optional): Whether to include scores in the result. Returns: str: The sorted set members in the given range or an error message. |
| zremkey*member* | Remove a member from a Redis sorted set. Args: key (str): The sorted set key. member (str): The member to remove. Returns: str: Confirmation message or an error message. |
| xaddkey*fields*expiration | Add an entry to a Redis stream with an optional expiration time. Args: key (str): The stream key. fields (dict): The fields and values for the stream entry. expiration (int, optional): Expiration time in seconds. Returns: str: The ID of the added entry or an error message. |
| xrangekey*count | Read entries from a Redis stream. Args: key (str): The stream key. count (int, optional): Number of entries to retrieve. Returns: str: The retrieved stream entries or an error message. |
| xdelkey*entry_id* | Delete an entry from a Redis stream. Args: key (str): The stream key. entry_id (str): The ID of the entry to delete. Returns: str: Confirmation message or an error message. |
| setkey*value*expiration | Set a Redis string value with an optional expiration time. Args: key (str): The key to set. value (str, bytes, int, float, dict): The value to store. expiration (int, optional): Expiration time in seconds. Returns: str: Confirmation message or an error message. |
| getkey* | Get a Redis string value. Args: key (str): The key to retrieve. Returns: str, bytes: The stored value or an error message. |
Parameters marked with * are required.
Setup
Copy the block for the app you use. Each one is the configuration this server was verified with.
Open the file ~/Library/Application Support/Claude/claude_desktop_config.json (in Claude Desktop: Settings, then Developer, then Edit Config) and add:
{
"mcpServers": {
"redis": {
"type": "stdio",
"command": "/opt/homebrew/bin/uvx",
"args": [
"--from",
"redis-mcp-server@latest",
"--with",
"mcp<2",
"redis-mcp-server",
"--url",
"redis://localhost:6379/0"
]
}
}
}Use the full path to uvx, as the README does: a Mac app launched from the Dock does not see the same PATH your terminal does, and /opt/homebrew/bin/uvx is where Homebrew puts it. The --with and mcp<2 pair is our addition, not the README's: without it the server crashes on start today, which is the first entry in troubleshooting below. Swap the URL for your own instance, then quit and reopen Claude Desktop. [2][12][7]
One command in your terminal:
claude mcp add --transport stdio redis -- uvx --from redis-mcp-server@latest --with 'mcp<2' redis-mcp-server --url redis://localhost:6379/0
Everything after the double dash is the exact command Claude Code will run. Keep the single quotes around mcp<2: unquoted, your shell reads the less-than sign as a file redirect and the command breaks before Claude Code ever sees it. Add --env KEY=value pairs before the server name if your Redis needs a password. [13][2]
Add to ~/.cursor/mcp.json for every project, or to .cursor/mcp.json inside one project:
{
"mcpServers": {
"redis": {
"command": "uvx",
"args": [
"--from",
"redis-mcp-server@latest",
"--with",
"mcp<2",
"redis-mcp-server",
"--url",
"redis://localhost:6379/0"
]
}
}
}Cursor picks the file up on restart. Cursor needs no type key for a stdio server, only command, args and an optional env block. If Cursor reports that it cannot find uvx, write the full path /opt/homebrew/bin/uvx instead. [14]
No JSON file and no terminal. In Routines: Settings, then Assistant, then Connections, then Add MCP Server. Switch the form to Command (stdio) and enter:
Name Redis Command /opt/homebrew/bin/uvx Arguments --from redis-mcp-server@latest --with mcp<2 redis-mcp-server --url redis://localhost:6379/0 Environment Variables (leave empty for a local instance with no password)
The Arguments field splits on spaces and needs no quoting, so mcp<2 goes in as written. Leave Environment Variables empty for a local unauthenticated Redis. If yours has a password, either put it in the URL as redis://default:yourpassword@host:6379/0 or add REDIS_PWD as an environment variable and keep it out of Arguments. Click Test Connection first: a working server answers with its tool count, forty-seven for this one. [15][2]
No terminal needed
If you have never opened Terminal and never want to, this is your path. Routines is a Mac app that runs MCP servers for you: fill in two fields once, and this server's tools are available to your AI in chat and in scheduled routines. The one thing you have to bring is a Redis instance and its address.
01
Download the app from getroutines.ai/download, drag it to Applications, and sign in.
02
For a Redis running on the same Mac, the address is redis://localhost:6379/0 and nothing else is needed. For a hosted one, your provider gives you a full connection string in the form redis://username:password@host:port/0, or rediss:// with two s letters when the connection is encrypted. Have it in your clipboard before the next step.
03
Click your account at the bottom of the sidebar and choose Settings. Open the Assistant section, then the Connections tab, scroll to MCP Servers, and click Add MCP Server.
04
The form opens in URL (SSE/HTTP) mode. Switch it to Command (stdio): this server is a command, not a web address. Name: Redis. Command: /opt/homebrew/bin/uvx, written in full, because an app launched from the Dock does not search the same folders your terminal does.
05
Arguments: --from redis-mcp-server@latest --with mcp<2 redis-mcp-server --url followed by your address. Leave Environment Variables empty unless your Redis needs a password. Click Test Connection: Routines starts the server without saving it and reports how many tools it found, forty-seven for this one. Then click Add Server.
06
The tools work in chat right away: ask how many keys are in the database, or what a given key holds. To let a scheduled routine use them, open the routine, find the Tools & connections card, and tick the server under Apps.
Routine ideas
Once the server is connected, a scheduled routine can use its tools while you are away. Copy a prompt, paste it into Routines, and pick a time.
Every weekday at 8:00, check my Redis instance: how many keys it holds, how much memory it is using, and how many clients are connected. Compare it with yesterday and write a five-line note to redis-health.md in my Notes folder, flagging anything that moved more than 20 percent.
Every hour between 9:00 and 18:00 on weekdays, read the length of my job queue list in Redis. If it is above 500 items, write a line with the time and the count to queue-backlog.md and tell me; if it is below, do nothing.
Every Monday at 10:00, scan my Redis instance for keys matching session:* and cache:*, list the ones with no expiry set, and write them to redis-no-ttl.md with a short note on which prefixes are growing. Do not delete anything.
Troubleshooting
Real errors captured during the verification run, printed exactly as the server returned them.
What you see
Traceback (most recent call last):
File "/Users/[REDACTED]/.cache/uv/archive-v0/UNWlYJnHWlVcsoPONbhvR/bin/redis-mcp-server", line 6, in <module>
from src.main import cli
File "/Users/[REDACTED]/.cache/uv/archive-v0/UNWlYJnHWlVcsoPONbhvR/lib/python3.14/site-packages/src/main.py", line 11, in <module>
from src.common.server import mcp
File "/Users/[REDACTED]/.cache/uv/archive-v0/UNWlYJnHWlVcsoPONbhvR/lib/python3.14/site-packages/src/common/server.py", line 3, in <module>
from mcp.server.fastmcp import FastMCP
ModuleNotFoundError: No module named 'mcp.server.fastmcp'The fix
This is what we got on 2026-08-03 from the exact command the README prints, and it is not your fault. The published 0.5.0 package asks for the Python MCP SDK with no upper limit, so uv installs the newest one, and SDK 2.0.0 moved the module this server imports. Add --with and mcp<2 straight after the package name, as every config on this page does, and it starts. The project already fixed the limit on its main branch, so a future release will drop the need for the flag.
What you see
Error retrieving key mcp-verify-2026: Error 61 connecting to localhost:6399. Connection refused.
The fix
The server starts and describes all 47 tools even when nothing is listening, because it only opens the connection when a tool actually runs. So a green Test Connection proves the server works, not that your Redis is reachable. We triggered this on purpose by pointing it at port 6399 with nothing there. Check the host, port and database number in your URL, and that the instance is running.
What you see
Error executing tool set: 1 validation error for setArguments
value
Field required [type=missing, input_value={'key': 'mcp-verify-2026'}, input_type=dict]
For further information visit https://errors.pydantic.dev/2.13/v/missingThe fix
A required argument was missing, here a set with a key but no value. The message names the tool, the field and what it received, so it is usually enough to hand straight back to the assistant. The tool table above lists which arguments each tool requires.
What you see
Unknown tool: gett
The fix
A typo or an invented name. The server answers with this line and logs a warning rather than crashing, so the session continues. Point the assistant at the tool table above, which is the exact list the running server reports.
What you see
× No solution found when resolving tool dependencies:
╰─▶ Because redis-mcp-servr was not found in the package registry and you
require redis-mcp-servr, we can conclude that your requirements are
unsatisfiable.The fix
A misspelled package name, ours here on purpose. The name is redis-mcp-server, singular, with server spelled in full, and it lives on PyPI, not on npm. If you copied a config from somewhere and it names an npm package instead, see the FAQ below on which package is the real one.
The fix
The uvx command belongs to uv, the Python package runner. If uv is not installed on your Mac, every client on this page fails at the spawn step before the server can say anything. Install it from astral.sh/uv, then use the full path /opt/homebrew/bin/uvx in your config, because desktop apps do not search the same folders your terminal does. This server needs no Node.js at all; Node appears in our receipt strip only because our test client is written in it.
FAQ
It is a small program that sits between an AI assistant and a Redis instance and speaks the Model Context Protocol. Once connected, an assistant such as Claude can read and write keys, work with hashes, lists, sets, sorted sets, streams and JSON documents, run vector and hybrid search over a Redis index, and read server statistics. It is published by Redis, Inc. itself, it runs as a local process on your Mac, and it talks to your AI app over stdio. [1][2]
The running server exposes 47 tools. Strings and keys (set, get, delete, type, expire, rename, scan_keys, scan_all_keys), hashes (hset, hget, hdel, hgetall, hexists), lists (lpush, rpush, lpop, rpop, lrange, llen, lrem), sets and sorted sets (sadd, srem, smembers, zadd, zrange, zrem), streams (xadd, xrange, xdel), JSON (json_set, json_get, json_del), pub/sub (publish, subscribe, unsubscribe), vectors and search (set_vector_in_hash, get_vector_from_hash, create_vector_index_hash, vector_search_hash, hybrid_search, get_indexes, get_index_info, get_indexed_keys_number), server info (dbsize, info, client_list), and one documentation lookup (search_redis_documents). The table above is the live tools/list output, word for word.
The code is open under the MIT license and the connection never leaves your machine unless your Redis address points somewhere else. The real question is scope, because this server is not read-only: delete, hdel, json_del, lrem, srem, zrem, xdel and rename all change data, and set overwrites a key without warning. Point it at a development instance first, or at a database number you keep for the assistant, and give it a Redis user with only the permissions it needs before you let it near production data. [1]
No. For a local instance with no password there is nothing to sign up for and no credential to paste: our whole verification run used none. If your Redis does have a password, it goes in the connection URL or in the REDIS_PWD environment variable, and there is an optional Microsoft Entra ID flow for Azure Managed Redis that a local setup never touches. The uvx command downloads the package from PyPI on first run, so the very first start needs an internet connection; after that it is cached on your Mac. [2][3]
No, and this is the trap. There is no official npm package for talking to your Redis data. The npm name @modelcontextprotocol/server-redis is an old reference server that npm marks deprecated, with the message that the package is no longer supported; its last release is dated 2025-04-25 and its source sits in the archived reference repository. It still pulled 1,594 downloads in the week ending 2026-08-01, so plenty of people are still installing a dead package. The maintained one is the PyPI package on this page. Watch out for one more name too: redis/mcp-redis-cloud is also from Redis, but it manages Redis Cloud subscriptions rather than the data in a running instance. [8][9][10][11]
Both numbers are real and we captured both. PyPI publishes the package as 0.5.0, dated 2026-03-16. Over MCP the running server reports the name Redis MCP Server and the version 1.29.0, which is the version of the Python MCP SDK underneath it: this server passes no version of its own to the SDK, and the SDK we ran falls back to reporting its own package version when a server leaves it unset. Same code, two numbers, neither of them wrong. [3][6]
Any MCP client that can launch a local stdio server: Claude Desktop, Claude Code, Cursor and Routines all can, and the exact config for each is above. VS Code with GitHub Copilot takes the same shape. There is no hosted or remote endpoint to point a URL at, because the server supports stdio only today; the README says streamable HTTP is planned but not shipped. [2][13][14][15]
Sources
Anything on this page we did not observe in the run is linked here, with the date we read it. The run itself is the receipt for the rest.
[1]
The official Redis, Inc. repository. 556 stars, MIT licensed, not archived, last push 2026-07-31, per the GitHub API.
[2]
The uvx invocation, the Claude Desktop and VS Code config shapes, the environment variable table, the Entra ID section, and the statement that only stdio is supported today.
[3]
Latest version 0.5.0, uploaded 2026-03-16, requiring the Python MCP SDK as mcp[cli]>=1.9.4 with no upper limit.
[4]
4,576 downloads in the last week, 13,809 in the last month.
[5]
License MIT, requires-python >=3.10, entry point redis-mcp-server, and the SDK limit already tightened on main to mcp[cli]>=1.26.0,<2.
[6]
Tag 0.5.0, published 2026-03-16, so main carries commits ahead of the last tagged release.
[7]
Version 2.0.0 published 2026-07-28, the release that moves the module the published server imports.
[8]
Latest version 2025.4.25, published 2025-04-25, flagged deprecated: Package no longer supported.
[9]
1,594 downloads for the week ending 2026-08-01, on a package marked no longer supported.
[10]
Archived repository described as reference MCP servers that are no longer maintained, the former home of the npm Redis server.
[11]
A second official Redis server, for the Redis Cloud control plane rather than the data in a running instance. 40 stars, last push 2025-05-05.
[12]
The official Claude Desktop quickstart and the config file location.
[13]
The claude mcp add syntax for local stdio servers, and the --env flag.
[14]
The mcp.json shape and file locations, and the command, args and env fields for a stdio server.
[15]
How Routines runs one-click OAuth connectors and any MCP server.
This page describes Redis as it behaved in one dated run on one Mac. Versions move: if something here no longer matches what you see, the capture date at the top says how old the reading is.
Behind this directory
Routines, the app behind this directory, runs MCP servers like this one without a terminal: see how connectors work. The reports it writes stay markdown files on your Mac, there is no cloud bill, and it works offline. Download Routines