Model or dataset
redis/mcp-redis avatar
redis/mcp-redis

Redis MCP Server: eight data-type tool families, one transport, and an image that installs dev dependencies

The official Redis MCP Server is a natural language interface designed for agentic applications to manage and search data in Redis efficiently

642 stars125 forksPythonMIT

At a glance

What is it?
The official Redis MCP Server gives an agent a natural-language surface over Redis, with a tool family per data type and three extras for documentation search, vector indexes and server information. The packaging details are the interesting part: a protocol dependency capped below its next major, a transport that is standard input only, and a container image that syncs the development dependency group.
Who is it for?
Redis MCP Server suits an application that already keeps state in Redis and wants an agent to manage and search it without writing client code. Before you deploy it, decide on the transport, because it speaks standard input and output only, and anything expecting a network transport is not supported yet.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 4 days ago.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • redis/mcp-redis642 ★ · +22
Star history
Repository2026-09-112026-11-15
redis/mcp-redis620642

22 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Eight data types, one tool family each, plus three extras

The tool surface is organised by Redis data type rather than by task, which is the right shape for an agent that already knows the structure of its data. Strings cover values with an expiration, which is the session and cache case. Hashes store field and value pairs in one key and can hold vector embeddings, so the vector use case does not need a separate store. Lists append and pop, for queues and recent-activity lists. Sets add, remove, list and intersect. Sorted sets carry scores, for leaderboards and priority queues. Publish and subscribe can create stateful channel or pattern subscriptions and read queued messages through handles the tool returns, which is the part that matters for an agent doing more than one-shot publishes. Streams add, read, delete, create and destroy consumer groups and acknowledge entries. JSON documents are stored and manipulated with path-based access. Three tools sit outside that taxonomy: documentation search, vector index management, and a server information call.

The docs tool calls an HTTP endpoint the example file never mentions

One of the extra tools is a natural-language search over Redis documentation, tutorials and best practices, and it is not local. It is backed by an HTTP endpoint configured through a dedicated environment variable, so the tool's usefulness depends on a service URL the operator has to supply and keep current. That variable does not appear in the example environment file, which is otherwise entirely about connecting to Redis: a host, a port, a logical database, a username and password, a boolean for transport security, six separate certificate-related variables and a cluster-mode flag. So the file reads as a connection reference rather than a feature reference, and the one setting a non-Redis feature needs is missing from it. Anyone enabling the documentation tool from the example file will have to discover the variable name from the tool's own documentation.

One transport today, a second one promised

The integration story is stated in one sentence and it constrains deployment. The server supports the standard input and output transport, and support for the streamable HTTP transport will be added in the future. In practice that means the server is designed to be launched by an MCP client as a child process and to talk over pipes, which is the easiest possible arrangement for a local desktop agent and the easiest to secure, since there is no port to bind. It also means the server cannot yet be run as a shared service for several clients at once, and a client that only supports network transports cannot use it. The readme's own installation examples reflect the pipe model: a client configuration that launches a package runner with a set of arguments and a connection URL, with no host and no port for the server itself:

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

The documented client config has stray escaping in its URL argument

The recommended installation is a client configuration block that launches the package through a runner, which downloads it on demand, builds a temporary environment and runs it. The shape is right and the connection string follows the registered schemes, with the logical database number after the slash and a separate scheme for an encrypted connection. Certificate verification is configurable: a path to a certificate authority bundle to verify the server's identity, and a setting that can be turned off entirely for an unverified connection. One detail will bite anyone copying the block. The URL argument in the example is wrapped in escaped quotation marks inside the argument array, so a client that takes the value literally will try to connect to a URL that begins with a quote character. Drop the inner quotes and it works; leave them and the connection fails with an unhelpful message.

The container syncs the development group, not a runtime-only install

The published Dockerfile is nine lines and does something worth knowing about. It starts from a slim Python 3.14 base, installs the package runner, copies the entire repository into the working directory including the tests and the tooling configuration, and then runs a full sync against the lockfile with a build cache mounted for the package cache. The command it ends with runs the server through the same runner, from the repository's own source layout. Two consequences follow. Because the whole tree is copied and the sync is not restricted to the runtime group, the image contains the development dependency group, which for this project means the test runner, the coverage tool, the type checker, the formatter and a security linter. And because the base interpreter is two major versions ahead of the declared floor, the image exercises a different combination from the one most users will install from the package index.

The protocol dependency is capped below its next major

The runtime dependency list is short and each entry says something about the project's shape. The protocol library is the only dependency with an upper bound, pinned below its next major release, which is a deliberate constraint on a package whose whole purpose is to speak someone else's protocol. The Redis client has a floor at a major version of its own, which matters because the tool families are named after commands that have moved between versions. A Microsoft identity package handles the Azure managed service authentication that the features list calls out as native support. Everything else is infrastructure: an array library for vector work, an async HTTP client, a terminal argument parser and the environment file reader. The development group is where the project's engineering standards live, and it includes a security linter with its own configuration, including a rule skipped globally with a comment saying it can be enabled if needed.

Two deployment homes and two agent ecosystems

The repository carries configuration for several places it can live. There is a deployment descriptor for one application hosting platform, a container build, a package on the Python index, and a registry manifest that names the server so it can be discovered by the protocol's own registry. There is also a descriptor for a specific coding agent's extension format, sitting next to an instruction file for that agent, which is why the tree looks like it belongs to more than one project at once. One example script sits alongside the tests. On releases, the cadence is uneven: a patch in November 2025, a minor in March 2026, and a patch in August 2026, with the default branch receiving commits as recently as the day this was read. So the package you install and the source you read may differ by more than a release note, which is normal for a repository that is actively worked on but worth remembering before you pin a version.

Editorial conclusion

Redis MCP Server suits an application that already keeps state in Redis and wants an agent to manage and search it without writing client code. Before you deploy it, decide on the transport, because it speaks standard input and output only, and anything expecting a network transport is not supported yet. Configure the documentation search endpoint explicitly if you want that tool, since it calls an external service and the example environment file does not mention it. And if you build a container from the published Dockerfile, check what the sync step installs, because it is a full sync rather than a runtime-only install.

Frequently asked questions

What is a MCP data server?

A server that exposes a data system to agentic clients as tools. This one gives an agent natural-language access to Redis across strings, hashes, lists, sets, sorted sets, publish and subscribe, streams and JSON documents.

Which transports does the Redis MCP Server support?

Standard input and output only. The readme says streamable HTTP support will be added in the future, so it is launched as a child process by the client rather than run as a shared network service.

How does the Redis MCP Server search vector data?

Its query engine tools manage vector indexes and perform vector search, and hashes are documented as able to store vector embeddings directly.

What does the Redis MCP Server need to configure documentation search?

An HTTP endpoint supplied through a dedicated environment variable, which the tool calls with natural-language questions. That variable is not present in the example environment file, which only lists Redis connection and TLS settings.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. redis/mcp-redis on GitHub
  5. Releases
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/redis-mcp-redis.svg)](https://hysenlabs.com/projects/redis-mcp-redis)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/redis-mcp-redis.svg)](https://hysenlabs.com/projects/redis-mcp-redis)

Was this useful?