Redis 8.4 Hybrid Search — Combining Full-Text and Vector Search for AI

# Add a vector to a set
VADD product-vectors "laptop-001" VALUES 768 0.12 -0.34 0.56 ...
    SETATTR '{"category":"electronics","price":1299}'

# Find the 5 most similar vectors
VSIM product-vectors VALUES 768 0.11 -0.33 0.55 ... COUNT 5

# Find with attribute filters
VSIM product-vectors VALUES 768 0.11 -0.33 0.55 ... COUNT 5
    FILTER '.category == "electronics" && .price < 2000'

# Update attributes
VSETATTR product-vectors "laptop-001"
    '{"category":"electronics","price":1199,"on_sale":true}'

FT.HYBRID index
  SEARCH query
    [SCORER scorer]
    [YIELD_SCORE_AS name]
  VSIM vector_field $vector_param
    [KNN count K k [EF_RUNTIME ef]]
    [RANGE count RADIUS radius [EPSILON epsilon]]
    [YIELD_SCORE_AS name]
    [FILTER filter]
  [COMBINE RRF count [CONSTANT c] [WINDOW w] [YIELD_SCORE_AS name]]
  [COMBINE LINEAR count [ALPHA a] [BETA b] [WINDOW w] [YIELD_SCORE_AS name]]
  [LIMIT offset num]
  [SORTBY count field [ASC | DESC]]
  [LOAD count field ...]
  [GROUPBY ... REDUCE ...]
  [APPLY expression AS name]
  PARAMS nargs vector_param vector_blob [name value ...]
  [TIMEOUT timeout]

# RRF formula for each document d:
RRF_score(d) = 1/(rank_text(d) + k) + 1/(rank_vector(d) + k)

# Where k = CONSTANT (default 60)
# rank_text(d) = position of d in the full-text results
# rank_vector(d) = position of d in the vector results

# Example: RRF with window = 40 and constant = 80
FT.HYBRID products-idx
  SEARCH "@category:electronics laptop"
  SCORER 4 BM25 1.5 0.8
  YIELD_SCORE_AS text_score
  VSIM @embedding $query_vec
  KNN 4 K 20 EF_RUNTIME 200
  YIELD_SCORE_AS vector_score
  COMBINE RRF 4 WINDOW 40 CONSTANT 80
  YIELD_SCORE_AS hybrid_score
  LOAD 3 @title @price @category
  LIMIT 0 10
  PARAMS 2 query_vec "\x00\x01..."

# Formula:
Linear_score(d) = alpha * normalized_text_score(d) + beta * normalized_vector_score(d)

# Example: prioritize semantic search (70% vector, 30% text)
FT.HYBRID docs-idx
  SEARCH "machine learning optimization"
  VSIM @content_vector $query_vec
  KNN 2 K 15
  COMBINE LINEAR 4 ALPHA 0.3 BETA 0.7
  LOAD *
  PARAMS 2 query_vec "\x00\x01..."

# Create an index supporting both full-text and vector search
FT.CREATE docs-idx ON HASH PREFIX 1 doc:
  SCHEMA
    title TEXT WEIGHT 2.0
    content TEXT
    category TAG
    created_at NUMERIC SORTABLE
    embedding VECTOR HNSW 6
      TYPE FLOAT32
      DIM 768
      DISTANCE_METRIC COSINE

import redis
from openai import OpenAI
import numpy as np

client = OpenAI()
r = redis.Redis(host='localhost', port=6379)

def index_document(doc_id, title, content, category):
    # Generate embedding
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=f"{title} {content}"
    )
    embedding = np.array(response.data[0].embedding, dtype=np.float32)

    # Store in a Redis Hash
    r.hset(f"doc:{doc_id}", mapping={
        "title": title,
        "content": content,
        "category": category,
        "created_at": int(time.time()),
        "embedding": embedding.tobytes()
    })

def hybrid_search(query, top_k=5):
    # Generate query embedding
    response = client.embeddings.create(
        model="text-embedding-3-small",
        input=query
    )
    query_vec = np.array(
        response.data[0].embedding, dtype=np.float32
    ).tobytes()

    # FT.HYBRID — combine BM25 + vector similarity
    result = r.execute_command(
        "FT.HYBRID", "docs-idx",
        "SEARCH", query,
        "SCORER", "4", "BM25", "1.2", "0.75",
        "YIELD_SCORE_AS", "text_score",
        "VSIM", "@embedding", "$query_vec",
        "KNN", "2", "K", str(top_k * 3),
        "YIELD_SCORE_AS", "vector_score",
        "COMBINE", "RRF", "4",
        "WINDOW", "30", "CONSTANT", "60",
        "YIELD_SCORE_AS", "hybrid_score",
        "LOAD", "4", "@title", "@content",
        "@text_score", "@vector_score",
        "LIMIT", "0", str(top_k),
        "PARAMS", "2", "query_vec", query_vec
    )
    return parse_results(result)

import anthropic

client_ai = anthropic.Anthropic()

def rag_answer(question):
    # Hybrid retrieval
    docs = hybrid_search(question, top_k=5)

    # Build context
    context = "\n---\n".join(
        f"[{d['title']}] {d['content']}" for d in docs
    )

    # Call Claude with the context
    response = client_ai.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=2048,
        messages=[{
            "role": "user",
            "content": f"""Based on the following documents, answer the question.

Documents:
{context}

Question: {question}"""
        }]
    )
    return response.content[0].text

# Combine hybrid search + time-based sorting
FT.HYBRID docs-idx
  SEARCH "kubernetes deployment strategy"
  VSIM @embedding $query_vec
  KNN 2 K 20
  COMBINE RRF 2 WINDOW 30
  SORTBY 2 created_at DESC
  LOAD 3 @title @created_at @category
  LIMIT 0 10
  PARAMS 2 query_vec "\x00\x01..."

# Hybrid search + geo filter for location-based apps
FT.HYBRID places-idx
  SEARCH "quiet cafe with wifi"
  VSIM @description_vec $query_vec
  KNN 2 K 15
  FILTER "@location:[106.6 10.7 5 km]"
  COMBINE LINEAR 4 ALPHA 0.4 BETA 0.6
  LOAD 4 @name @address @rating @distance
  PARAMS 2 query_vec "\x00\x01..."

# Find both typos and semantically similar terms
FT.HYBRID products-idx
  SEARCH "%%samsuung%% %%gallaxy%% ~phone ~smartphone"
  VSIM @features_vec $query_vec
  KNN 2 K 10
  COMBINE RRF 2 WINDOW 20
  LOAD *
  PARAMS 2 query_vec "\x00\x01..."

# %%word%% = fuzzy matching (Levenshtein distance)
# ~word = optional term (boost if matched, not excluded otherwise)

# FILTER inside VSIM narrows the vector space BEFORE search
# → significantly reduces compute time
FT.HYBRID products-idx
  SEARCH "gaming laptop RTX"
  VSIM @features_vec $query_vec
  KNN 2 K 20
  FILTER "@category:{electronics} @price:[500 3000]"
  COMBINE RRF 2 WINDOW 30
  LOAD 3 @title @price @rating
  LIMIT 0 10
  PARAMS 2 query_vec "\x00\x01..."

# Two pre-filter policies:
# ADHOC_BF — brute-force scan, good for selective filters (<10% data)
# BATCHES — batch processing, good for less-selective filters