Redis Vector Search: Real-Time Similarity Search Guide

Setup: Redis Stack & FT.CREATE Vector Index

Run Redis Stack with Docker and create a vector index using the raw Redis commands.

# Run Redis Stack locally (includes RediSearch + vector search)
# docker run -d -p 6379:6379 redis/redis-stack

pip install redis openai redisvl

import redis
import struct
import json

r = redis.Redis(host="localhost", port=6379, decode_responses=False)

# Create HNSW vector index on Hash documents
# Fields: embedding (vector), category (tag), year (numeric), content (text)
r.execute_command(
    "FT.CREATE", "idx:articles",
    "ON", "HASH",
    "PREFIX", "1", "article:",
    "SCHEMA",
        "content",   "TEXT",
        "category",  "TAG",
        "year",      "NUMERIC", "SORTABLE",
        "embedding", "VECTOR", "HNSW", "6",
            "TYPE",      "FLOAT32",
            "DIM",       "1536",
            "DISTANCE_METRIC", "COSINE"
)

# FLAT (brute-force) index for small datasets / exact search
r.execute_command(
    "FT.CREATE", "idx:small_docs",
    "ON", "HASH",
    "PREFIX", "1", "doc:",
    "SCHEMA",
        "embedding", "VECTOR", "FLAT", "6",
            "TYPE", "FLOAT32",
            "DIM",  "1536",
            "DISTANCE_METRIC", "COSINE"
)

Insert Vectors & FT.SEARCH KNN Query

Store documents as Redis Hashes and query with FT.SEARCH KNN syntax including metadata filters.

import openai

oa = openai.OpenAI()

def embed(text: str) -> bytes:
    vec = oa.embeddings.create(
        model="text-embedding-3-small", input=text
    ).data[0].embedding
    # Convert float list to bytes for Redis storage
    return struct.pack(f"{len(vec)}f", *vec)

# Insert documents as Redis Hashes
docs = [
    {"id": "1", "content": "RAG systems improve LLM accuracy", "category": "ai",  "year": 2024},
    {"id": "2", "content": "Redis supports real-time vector search", "category": "db", "year": 2024},
    {"id": "3", "content": "HNSW index for fast ANN search",       "category": "db", "year": 2023},
]
for doc in docs:
    r.hset(f"article:{doc['id']}", mapping={
        "content":   doc["content"],
        "category":  doc["category"],
        "year":      doc["year"],
        "embedding": embed(doc["content"])
    })

# KNN search with metadata pre-filter
query_bytes = embed("how does retrieval augmented generation work")

# Filter: category=ai, year >= 2024, then KNN top-3
results = r.execute_command(
    "FT.SEARCH", "idx:articles",
    "(@category:{ai} @year:[2024 +inf])=>[KNN 3 @embedding $query_vec AS score]",
    "PARAMS", "2", "query_vec", query_bytes,
    "RETURN", "3", "content", "category", "score",
    "SORTBY", "score",
    "DIALECT", "2"
)

# Parse results (format: [count, key, [field, val, ...], ...])
count = results[0]
print(f"Found {count} results:")
for i in range(1, len(results), 2):
    key = results[i].decode()
    fields = dict(zip(results[i+1][::2], results[i+1][1::2]))
    print(f"  {key} | score={float(fields[b'score']):.4f} | {fields[b'content'].decode()}")

redisvl: High-Level Python Library

redisvl abstracts FT.CREATE and FT.SEARCH into a clean Pythonic API with schema definitions and embedding functions.

from redisvl.index import SearchIndex
from redisvl.query import VectorQuery
from redisvl.utils.vectorize import OpenAITextVectorizer

# Define schema
schema = {
    "index": {"name": "articles", "prefix": "article"},
    "fields": [
        {"name": "content",   "type": "text"},
        {"name": "category",  "type": "tag"},
        {"name": "year",      "type": "numeric"},
        {
            "name": "embedding",
            "type": "vector",
            "attrs": {
                "dims": 1536,
                "distance_metric": "cosine",
                "algorithm": "hnsw",
                "datatype": "float32"
            }
        }
    ]
}

vectorizer = OpenAITextVectorizer(model="text-embedding-3-small")

index = SearchIndex.from_dict(schema)
index.connect("redis://localhost:6379")
index.create(overwrite=True)

# Load documents — redisvl auto-generates embeddings
data = [
    {"content": "RAG systems improve LLM accuracy", "category": "ai", "year": 2024},
]
embeddings = vectorizer.embed_many([d["content"] for d in data])
for d, emb in zip(data, embeddings):
    d["embedding"] = emb
index.load(data)

# Query
query_emb = vectorizer.embed("retrieval augmented generation")
query = VectorQuery(
    vector=query_emb,
    vector_field_name="embedding",
    return_fields=["content", "category", "year"],
    num_results=3,
    filter_expression="@category:{ai}"
)
results = index.query(query)
for r in results:
    print(r)

Redis Vector Search vs Dedicated Vector Databases