Redis Vector Library

The AI-native Redis Python client

Redis Vector Library (RedisVL) is the production-ready Python client for AI applications built on Redis. Lightning-fast vector search meets enterprise-grade reliability.

Perfect for building RAG pipelines with real-time retrieval, AI agents with memory and semantic routing, and recommendation systems with fast search and reranking.

Install redisvl into your Python (>=3.10) environment using pip:

pip install redisvl

Install the MCP server extra when you want to expose an existing Redis index through MCP:

pip install redisvl[mcp]

For more detailed instructions, visit the installation guide. For MCP concepts and setup, see the RedisVL MCP docs and the MCP how-to guide.

Choose from multiple Redis deployment options:

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

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

💡 Tip: Enhance your experience and observability with the free Redis Insight GUI.

1. Design a schema for your use case that models your dataset with built-in Redis indexable fields (e.g. text, tags, numerics, geo, and vectors).

   Load schema from YAML file

   index:
     name: user-idx
     prefix: user
     storage_type: json
   
   fields:
     - name: user
       type: tag
     - name: credit_score
       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

   from redisvl.schema import IndexSchema
   
   schema = IndexSchema.from_yaml("schemas/schema.yaml")

   Load schema from Python dictionary

   from redisvl.schema import IndexSchema
   
   schema = IndexSchema.from_dict({
       "index": {
           "name": "user-idx",
           "prefix": "user",
           "storage_type": "json"
       },
       "fields": [
           {"name": "user", "type": "tag"},
           {"name": "credit_score", "type": "tag"},
           {
               "name": "job_title",
               "type": "text",
               "attrs": {
                   "sortable": True,
                   "no_index": False,  # Index for search
                   "unf": False        # Normalize case for sorting
               }
           },
           {
               "name": "embedding",
               "type": "vector",
               "attrs": {
                   "algorithm": "flat",
                   "datatype": "float32",
                   "dims": 4,
                   "distance_metric": "cosine"
               }
           }
       ]
   })

   📚 Learn more about schema design and schema creation.

2. Create a SearchIndex class with an input schema to perform admin and search operations on your 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()

   An async-compatible index class also available: AsyncSearchIndex.

3. Load and fetch data to/from your Redis instance:

   data = {"user": "john", "credit_score": "high", "embedding": [0.23, 0.49, -0.18, 0.95]}
   
   # load list of dictionaries, specify the "id" field
   index.load([data], id_field="user")
   
   # fetch by "id"
   john = index.fetch("john")

Define queries and perform advanced searches over your indices, including vector search, complex filtering, and hybrid search combining semantic and full-text signals.

• VectorQuery - Flexible vector queries with customizable filters enabling semantic search:

  from redisvl.query import VectorQuery
  
  query = VectorQuery(
    vector=[0.16, -0.34, 0.98, 0.23],
    vector_field_name="embedding",
    num_results=3,
    # Optional: tune search performance with runtime parameters
    ef_runtime=100  # HNSW: higher for better recall
  )
  # run the vector search query against the embedding field
  results = index.query(query)

• RangeQuery - Vector search within a defined range paired with customizable filters

Build complex filtering queries by combining multiple filter types (tags, numerics, text, geo, timestamps) using logical operators:

```python
from redisvl.query import VectorQuery
from redisvl.query.filter import Tag, Num

# Combine multiple filter types
tag_filter = Tag("user") == "john"
price_filter = Num("price") >= 100

# Create complex filtering query with combined filters
query = VectorQuery(
    vector=[0.16, -0.34, 0.98, 0.23],
    vector_field_name="embedding",
    filter_expression=tag_filter & price_filter,
    num_results=10
)
results = index.query(query)
```

• FilterQuery - Standard search using filters and full-text search
• CountQuery - Count the number of indexed records given attributes
• TextQuery - Full-text search with support for field weighting and BM25 scoring

Learn more about building complex filtering queries.

Combine semantic (vector) search with full-text (BM25) search signals for improved search quality:

• HybridQuery - Native hybrid search combining text and vector similarity (Redis 8.4.0+):

  from redisvl.query import HybridQuery
  
  hybrid_query = HybridQuery(
      text="running shoes",
      text_field_name="description",
      vector=[0.1, 0.2, 0.3],
      vector_field_name="embedding",
      combination_method="LINEAR",  # or "RRF"
      num_results=10
  )
  results = index.query(hybrid_query)

• AggregateHybridQuery - Hybrid search using aggregation (compatible with earlier Redis versions)

Learn more about hybrid search.

Integrate with popular embedding providers to greatly simplify the process of vectorizing unstructured data for your index and queries.

from redisvl.utils.vectorize import CohereTextVectorizer

# set COHERE_API_KEY in your environment
co = CohereTextVectorizer()

embedding = co.embed(
    text="What is the capital city of France?",
    input_type="search_query"
)

embeddings = co.embed_many(
    texts=["my document chunk content", "my other document chunk content"],
    input_type="search_document"
)

Learn more about using vectorizers in your embedding workflows.

Integrate with popular reranking providers to improve the relevancy of the initial search results from Redis

RedisVL Extensions provide production-ready modules implementing best practices and design patterns for working with LLM memory and agents. These extensions encapsulate learnings from our user community and enterprise customers.

💡 Have an idea for another extension? Open a PR or reach out to us at applied.ai@redis.com. We're always open to feedback.

Increase application throughput and reduce the cost of using LLM models in production by leveraging previously generated knowledge with the SemanticCache.

from redisvl.extensions.cache.llm import SemanticCache

# init cache with TTL and semantic distance threshold
llmcache = SemanticCache(
    name="llmcache",
    ttl=360,
    redis_url="redis://localhost:6379",
    distance_threshold=0.1  # Redis COSINE distance [0-2], lower is stricter
)

# store user queries and LLM responses in the semantic cache
llmcache.store(
    prompt="What is the capital city of France?",
    response="Paris"
)

# quickly check the cache with a slightly different prompt (before invoking an LLM)
response = llmcache.check(prompt="What is France's capital city?")
print(response[0]["response"])

>>> Paris

Learn more about semantic caching for LLMs.

Reduce computational costs and improve performance by caching embedding vectors with their associated text and metadata using the EmbeddingsCache.

from redisvl.extensions.cache.embeddings import EmbeddingsCache
from redisvl.utils.vectorize import HFTextVectorizer

# Initialize embedding cache
embed_cache = EmbeddingsCache(
    name="embed_cache",
    redis_url="redis://localhost:6379",
    ttl=3600  # 1 hour TTL
)

# Initialize vectorizer with cache
vectorizer = HFTextVectorizer(
    model="sentence-transformers/all-MiniLM-L6-v2",
    cache=embed_cache
)

# First call computes and caches the embedding
embedding = vectorizer.embed("What is machine learning?")

# Subsequent calls retrieve from cache (much faster!)
cached_embedding = vectorizer.embed("What is machine learning?")

>>> Cache hit! Retrieved from Redis in <1ms

Learn more about embedding caching for improved performance.

Improve personalization and accuracy of LLM responses by providing user conversation context. Manage access to memory data using recency or relevancy, powered by vector search with the MessageHistory.

from redisvl.extensions.message_history import SemanticMessageHistory

history = SemanticMessageHistory(
    name="my-session",
    redis_url="redis://localhost:6379",
    distance_threshold=0.7
)

# Supports roles: system, user, llm, tool
# Optional metadata field for additional context
history.add_messages([
    {"role": "user", "content": "hello, how are you?"},
    {"role": "llm", "content": "I'm doing fine, thanks."},
    {"role": "user", "content": "what is the weather going to be today?"},
    {"role": "llm", "content": "I don't know", "metadata": {"model": "gpt-4"}}
])

# Get recent chat history
history.get_recent(top_k=1)
# >>> [{"role": "llm", "content": "I don't know", "metadata": {"model": "gpt-4"}}]

# Get relevant chat history (powered by vector search)
history.get_relevant("weather", top_k=1)
# >>> [{"role": "user", "content": "what is the weather going to be today?"}]

# Filter messages by role
history.get_recent(role="user")  # Get only user messages
history.get_recent(role=["user", "system"])  # Or multiple roles

Learn more about LLM memory.

Build fast decision models that run directly in Redis and route user queries to the nearest "route" or "topic".

from redisvl.extensions.router import Route, SemanticRouter

routes = [
    Route(
        name="greeting",
        references=["hello", "hi"],
        metadata={"type": "greeting"},
        distance_threshold=0.3,
    ),
    Route(
        name="farewell",
        references=["bye", "goodbye"],
        metadata={"type": "farewell"},
        distance_threshold=0.3,
    ),
]

# build semantic router from routes
router = SemanticRouter(
    name="topic-router",
    routes=routes,
    redis_url="redis://localhost:6379",
)

router("Hi, good morning")
# >>> RouteMatch(name='greeting', distance=0.273891836405)

Learn more about semantic routing.

Create, destroy, and manage Redis index configurations from a purpose-built CLI interface: rvl.

$ rvl -h

usage: rvl <command> [<args>]

Commands:
        index       Index manipulation (create, delete, etc.)
        mcp         Run the RedisVL MCP server
        version     Obtain the version of RedisVL
        stats       Obtain statistics about an index

Run the MCP server over stdio (default):

uvx --from redisvl[mcp] rvl mcp --config /path/to/mcp.yaml

Or over Streamable HTTP for remote MCP clients:

uvx --from redisvl[mcp] rvl mcp --config /path/to/mcp.yaml --transport streamable-http --host 0.0.0.0 --port 8000

Or over SSE:

uvx --from redisvl[mcp] rvl mcp --config /path/to/mcp.yaml --transport sse --host 0.0.0.0 --port 9000

Use --read-only to expose search without upsert.

Read more about using the CLI and running RedisVL MCP.

RedisVL includes an MCP server that lets MCP-compatible clients search or upsert data in an existing Redis index through a small, stable tool contract.

The server:

• connects to one existing Redis Search index
• reconstructs the schema from Redis at startup
• uses the configured vectorizer for query embedding and optional upsert embedding
• exposes search-records and, unless read-only mode is enabled, upsert-records
• supports stdio (default), Streamable HTTP, and SSE transports

Run it over stdio (default):

uvx --from redisvl[mcp] rvl mcp --config /path/to/mcp.yaml

Run it over Streamable HTTP for remote clients:

uvx --from redisvl[mcp] rvl mcp --config /path/to/mcp.yaml --transport streamable-http --host 0.0.0.0 --port 8000

Use --read-only when clients should only search:

uvx --from redisvl[mcp] rvl mcp --config /path/to/mcp.yaml --read-only

For configuration details, tool arguments, and examples, see the RedisVL MCP docs and the MCP how-to guide.

Redis is a proven, high-performance database that excels at real-time workloads. With RedisVL, you get a production-ready Python client that makes Redis's vector search, caching, and session management capabilities easily accessible for AI applications.

Built on the Redis Python client, RedisVL provides an intuitive interface for vector search, LLM caching, and conversational AI memory - all the core components needed for modern AI workloads.

For additional help, check out the following resources:

• Getting Started Guide
• RedisVL MCP
• API Reference
• Redis AI Recipes

Please help us by contributing PRs, opening GitHub issues for bugs or new feature ideas, improving documentation, or increasing test coverage. Read more about how to contribute!

This project is supported by Redis, Inc on a good faith effort basis. To report bugs, request features, or receive assistance, please file an issue.