redisvl writes its dependency floors into comments

One excluded version, and the reason is in a comment

Most packaging files list version ranges. This one explains them. The runtime dependencies are `numpy>=1.26.0,<3`, `pyyaml>=5.4,<7.0`, `pydantic>=2,<3`, `tenacity>=8.2.2`, `ml-dtypes>=0.4.0,<1.0.0`, `python-ulid>=3.0.0` and `jsonpath-ng>=1.5.0`, and the interesting line is the Redis client:

`redis>=6.3.0,!=8.0.0,<9.0`

The comment above it says that 6.3.0 is the first release to accept SVS-VAMANA, and that redis-py 8.0.0 returns empty RESP3 search results, citing the upstream issue. Because of that, 8.1.0 is stated as the supported floor within the 8.x line.

This is worth reading before any upgrade. An empty result set from a vector query is not an error, so the failure mode is a search that silently returns nothing rather than one that raises. A library that pins itself away from a broken client release, and explains why in the file, has done the part of the work most libraries leave to you.

The schema is a document, not a pile of constructor calls

An index starts as a schema describing your data with Redis's indexable field types: text, tags, numerics, geo and vectors. The schema can come from a YAML file or from a Python dictionary, and both paths go through `IndexSchema`. The YAML form is worth reading because it shows what a field actually carries:

index:
  name: user-idx
  prefix: user
  storage_type: json

fields:
  - name: user
    type: tag
  - name: job_title
    type: text
    attrs:
      sortable: true
      no_index: false  # Index for search (default)
      unf: false       # Normalize case for sorting (default)
  - name: embedding
    type: vector
    attrs:
      algorithm: flat
      dims: 4
      distance_metric: cosine
      datatype: float32

Three details do real work. `no_index` decides whether a text field is searchable at all. `unf` controls case normalisation, which matters because sorting is case sensitive without it. And the vector field fixes the index algorithm, the dimension count, the distance metric and the datatype in one place, so a mismatch between the embedding width and the declared `dims` becomes a schema problem rather than a query problem.

Loading it from a file is two lines:

from redisvl.schema import IndexSchema

schema = IndexSchema.from_yaml("schemas/schema.yaml")

SearchIndex takes the schema and a redis_url

Once the schema exists, the index object is where the work happens. It handles both admin operations and queries against the index in Redis:

from redis import Redis
from redisvl.index import SearchIndex

# Define the index
index = SearchIndex(schema, redis_url="redis://localhost:6379")

# Create the index in Redis
index.create()

Documents are loaded and fetched through the same object, with an id field identifying each record. What sits on top of that is the part the README spends its table on: similarity search with metadata filters, multiple filter types combined, and hybrid search that combines semantic and full-text signals.

There is an async-compatible class alongside the synchronous one, `AsyncSearchIndex`, and the async story is treated as a first-class capability rather than an afterthought, covering both indexing and search.

Beyond retrieval, the client ships the pieces an agent needs around the index: semantic caching to cut repeated LLM calls, LLM memory for context management, semantic routing for query classification, and embedding caching so the same text is not embedded twice.

Five deployment shapes, two of them one Docker command

The library is agnostic about where Redis runs, and the options are laid out with what each one is for. Redis Cloud is a managed service with a free tier. Redis Enterprise is the commercial self-hosted build. Azure Managed Redis is the managed version of that on Azure. Redis Sentinel is for high availability with automatic failover, configured through a URL of this shape:

# Connect via Sentinel
redis_url="redis+sentinel://sentinel1:26379,sentinel2:26379/mymaster"

The local option is a single command, and the image tag matters here:

docker run -d --name redis -p 6379:6379 redis:latest

That runs Redis 8 or later with vector search built in, so there is no sidecar index service to start. Worth noting that the Makefile pins the same container to `redis:8.4` for local development, while the README uses the floating `latest` tag. For development against a specific Redis release the pinned tag is the one to use.

The extras follow providers, and one follows a protocol

Installing the client is `pip install redisvl` into a Python environment of 3.10 or newer. Everything beyond that is an extra, and the shape of the list tells you what is core and what is optional.

Vectorizers cover eight or more embedding provider integrations, and each provider has its own extra: `mistralai>=1.0.0,<2`, `openai>=1.1.0` and `cohere>=4.44` are named explicitly, with a video extra behind the truncation point. Rerankers are a separate feature from vectorizers, which is the right split, since reranking operates on results rather than on queries.

The MCP extra is the one with a comment worth reading. It pulls `fastmcp>=2.0.0,<4` and `pydantic-settings>=2.0,<3`, and the upper bound is deliberate: the MCP protocol revision is chosen by the dependency rather than by RedisVL, the SDK's LATEST_PROTOCOL_VERSION is the ceiling a server can negotiate, and the 2026-07-28 revision is a breaking stateless redesign of the protocol core. Supporting that revision is described as its own piece of work.

So when you see an MCP client negotiate an unexpected protocol version, the cap in this file is the reason.

The MCP server exposes indexes you already have

One of the listed capabilities is an MCP server, and its framing matters: it exposes one or more existing Redis indexes to MCP clients. It is not a search engine that owns your vectors. It is a surface onto indexes you have already defined with a schema and created.

That distinction determines what you have to build first. The MCP server is the last step, not the first, because there is nothing to expose until a schema exists, an index is created and documents are loaded. The README's own ordering reflects that, walking through index management before it gets to the extensions.

Installation is the extra rather than a separate package:

pip install redisvl[mcp]

Authentication has its own specification in the repository at `mcp-auth-spec.md`, alongside a `.cursor/` directory and a `CLAUDE.md` at the root, which tells you something about which tools this codebase is developed against.

The Python ceiling is in pyproject, not in the README

The Getting Started section says to install into a Python 3.10 or newer environment. The packaging metadata is narrower: `requires-python = ">=3.10,<3.15"`, with classifiers for 3.10, 3.11, 3.12, 3.13 and 3.14.

The gap is small and only matters at the top end, but it is the kind of thing worth knowing before a build fails on a 3.15 interpreter. Nothing in the quick start mentions an upper bound, so a reader who only reads the README will discover it at install time.

The project is Redis Inc's own client, with the author recorded as Redis Inc and the description in the metadata reading as a Python client library and CLI for using Redis as a vector database. The version, 0.27.2, carries a note that the release workflow increments it automatically and it should not be adjusted by hand, which is why the recent tags move in small steps rather than in planned jumps.

make redis-start pins 8.4 while the README says latest

Development runs through uv and a Makefile, and the targets show how the project expects to be worked on. `install` runs `uv sync --all-extras`, `redis-start` starts the container and then queries the server version back out, and `redis-stop` tears the container down.

docker run -d --name redis -p 6379:6379 redis:8.4

Quality gates are separate targets rather than one command. Formatting runs isort with the black profile and black itself against Python 3.11 as the target, linting runs pylint with `.pylintrc`, and types are checked with mypy. `lint` chains format and the type check. Tests run under pytest with `-n auto` and extra arguments can be passed through, so an opt-in API test is a matter of passing a flag rather than editing a config.

The repository root holds the pieces that make this repeatable: `.pylintrc`, `.pre-commit-config.yaml`, a `uv.lock` for reproducible installs, `doctests/`, and a `schemas/` directory that matches the schema loading shown earlier.

Editorial conclusion

Adopt redisvl if your vectors already live in Redis, or you want them there, because the value is the schema layer and the query helpers rather than a new store. Do not adopt it to escape Redis, since every index, cache and memory structure here is a Redis key. Verify two things first. Read the version floor in the dependencies, because redis-py 8.0.0 is excluded by an explicit inequality and a client upgrade can break search results in a way that looks like an empty index. Then decide whether you need the MCP extra, whose upper bound is capped because the protocol revision is chosen by the SDK dependency rather than by this library.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. redis/redis-vl-python on GitHub
5. Releases