AI-200 practice: Implement vector indexing to enable similarity search

Question 1

You are configuring vector search in Azure Managed Redis for a recommendation feature that needs approximate nearest-neighbor search with strong query throughput on a large, frequently updated dataset, using cosine similarity between embeddings.

What should you configure?

Accepted Answer

An HNSW index with the COSINE distance metric for approximate nearest-neighbor search suited to large, frequently updated embedding datasets

Answer

A FLAT index with the L2 distance metric, assuming exact search is always faster than approximate search for large, frequently updated embedding collections

Answer

A Redis Sorted Set that stores precomputed dot-product scores as member scores and rebuilds those scores on every embedding write operation

Answer

A Redis Hash holding raw embedding vectors with no index, using SCAN plus client-side cosine similarity for each recommendation query

Question 2

You create a Redis vector index for RAG chunk retrieval using redis-py against Azure Managed Redis (Redis Stack-compatible):
```python
import redis
from redis.commands.search.field import VectorField, TextField
from redis.commands.search.indexDefinition import IndexDefinition, IndexType

r = redis.Redis(host=host, port=10000, password=key, ssl=True)
schema = (
    TextField("text"),
    VectorField(
        "embedding",
        "HNSW",
        {
            "TYPE": "FLOAT32",
            "DIM": 1536,
            "DISTANCE_METRIC": "COSINE"
        }
    )
)
r.ft("idx:chunks").create_index(
    schema,
    definition=IndexDefinition(prefix=["chunk:"], index_type=IndexType.HASH)
)

r.hset("chunk:1", mapping={
    "text": "Azure Kubernetes Service overview",
    "embedding": embedding_list # a Python list of 1536 floats
})
```
Documents are stored like this, but FT.SEARCH returns zero results for a valid KNN query. What is the bug?

Accepted Answer

The embedding field must be stored as raw bytes (e.g., numpy.array(embedding_list, dtype=numpy.float32).tobytes()), not as a native Python list — HSET with a list value is invalid for a Redis VECTOR field.

Answer

HNSW is not a valid algorithm for VectorField; only FLAT is supported in Azure Managed Redis.

Answer

The index prefix "chunk:" doesn't match; it should be "chunk*" with a wildcard.

Answer

DISTANCE_METRIC must be lowercase "cosine", not "COSINE".

Question 3

You need to run a K-nearest-neighbor vector search combined with a metadata filter (category == "networking") against a Redis HASH-based index:
```python
from redis.commands.search.query import Query

q = Query("(@category:{networking})=>[KNN 5 @embedding $vec AS score]") \
    .sort_by("score") \
    .return_fields("text", "score") \
    .dialect(2)

results = r.ft("idx:chunks").search(
    q, query_params={"vec": query_vector_bytes}
)
```
This query returns a syntax error. Assuming category was indexed as a TextField, what is the correct fix?

Accepted Answer

category must be indexed as a TagField, not a TextField, for exact-match filtering with the {value} tag-filter syntax (@category:{networking}) to be valid; TextField requires full-text search syntax instead.

Answer

The KNN clause must come before the filter clause: [KNN 5 @embedding $vec AS score]=>(@category:{networking}).

Answer

dialect(2) is invalid; hybrid filter+KNN queries require dialect(1).

Answer

query_params cannot be used with hybrid queries.

Question 4

Your Redis-backed vector search index for a 2-million-chunk RAG corpus is consuming more memory than expected. You review the index configuration:
```python
VectorField(
    "embedding",
    "FLAT",
    {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE"
    }
)
```
Query latency is also degrading as the corpus grows. Which single change most directly improves both memory usage and query latency at this scale?

Accepted Answer

Switch the algorithm from FLAT to HNSW, which builds an approximate graph-based index providing sub-linear query time and better scaling characteristics as corpus size grows.

Answer

Increase DIM to add padding, which Redis uses internally to improve cache locality and reduce latency.

Answer

Change DISTANCE_METRIC from COSINE to L2; L2 is always faster and uses less memory regardless of index algorithm.

Answer

Switch TYPE from FLOAT32 to FLOAT64 for more precise distance calculations.

Question 5

You store chunks as Redis JSON documents (not HASH) to preserve nested metadata structures, and need a matching vector index:
```python
r.json().set("chunk:1", "$", {
    "text": "AKS scaling guide",
    "metadata": {"category": "compute", "source": "docs"},
    "embedding": [0.01, 0.02, "..."]
})

schema = (
    VectorField(
        "$.embedding",
        "HNSW",
        {"TYPE": "FLOAT32", "DIM": 1536, "DISTANCE_METRIC": "COSINE"}
    ),
)

r.ft("idx:json_chunks").create_index(
    schema,
    definition=IndexDefinition(prefix=["chunk:"], index_type=IndexType.HASH)
)
```
Index creation succeeds but FT.SEARCH never returns results for chunk:1. What is wrong?

Accepted Answer

IndexDefinition(index_type=IndexType.HASH) must be IndexType.JSON to match the actual storage format used (r.json().set); using HASH when documents are stored as Redis JSON causes the indexer to ignore the JSON documents.

Answer

"$.embedding" is invalid JSONPath syntax; it should be "embedding" without the $. prefix.

Answer

JSON documents cannot be vector-indexed in Redis; only HASH storage supports VectorField.

Answer

The AS alias is required on VectorField when using JSON storage.

Question 6

You need a hybrid Redis query combining vector KNN search with a numeric metadata range filter (documents published in the last 30 days) and a tag filter on department:
```python
q = Query("(@department:{engineering} @publishedTs:[1700000000 +inf])=>[KNN 5 @embedding $vec AS score]") \
    .sort_by("score") \
    .return_fields("text", "score") \
    .dialect(2)
```
Given department is a TagField and publishedTs is a NumericField, is this query syntactically valid, and if not, what's wrong?

Accepted Answer

It is valid: combining a tag filter and a numeric range filter with implicit AND (space-separated) inside the pre-filter expression, followed by =>[KNN ...], is correct RediSearch hybrid query syntax.

Answer

It is invalid: NumericField range filters cannot be combined with TagField filters in the same query.

Answer

It is invalid: numeric ranges require the syntax @publishedTs:[1700000000, +inf] with a comma separator, not a space.

Answer

It is invalid: +inf is not a valid upper bound.

Question 7

You are tuning an HNSW-based Redis vector index for a production RAG system and need to reduce query latency, currently seeing acceptable recall but slower-than-target FT.SEARCH response times under load:
```python
q = Query(
    "(@department:{engineering} @publishedTs:[1700000000 +inf])=>[KNN 10 @embedding $vec AS score]"
).sort_by("score").dialect(2)

VectorField(
    "embedding",
    "HNSW",
    {
        "TYPE": "FLOAT32",
        "DIM": 1536,
        "DISTANCE_METRIC": "COSINE",
        "M": 64,
        "EF_CONSTRUCTION": 500,
        "EF_RUNTIME": 500
    }
)
```
Which single parameter, if reduced, most directly improves per-query latency (at the cost of some recall) without requiring a full index rebuild?

Accepted Answer

EF_RUNTIME — this controls the size of the dynamic candidate list explored at query time; it can be overridden per-query (or via a lower index default) without rebuilding the index, and directly trades recall for latency at search time.

Answer

M — this controls the number of bi-directional links per node in the HNSW graph and can be changed at query time without any rebuild.

Answer

EF_CONSTRUCTION — this controls query-time candidate list size and can be tuned live per search.

Answer

DIM — reducing the vector dimensionality at query time lowers per-query compute without needing a rebuild.

Question 8

Your team wants to use Azure Managed Redis for both caching and low-latency vector similarity search of embeddings within the same cache tier. Which capability should you enable and use?

Accepted Answer

RediSearch vector index (HNSW) on embeddings

Answer

Sorted sets scored only by insertion order

Answer

Pub/Sub channels broadcasting embedding data

Answer

Streams holding vectors without any index

Question 9

An AI solution requires high-performance vector retrieval with sub-millisecond latency using Azure Managed Redis. Which command is used to create an index for vectors stored as Hashes?

Accepted Answer

FT.CREATE

Answer

FT.SEARCH

Answer

FT.ALTER

Answer

FT.INFO

Question 10

Using the Python SDK for Azure Managed Redis, you want to perform a vector search over millions of items where high throughput and recall accuracy are critical. Which search index algorithm is most suitable?

Accepted Answer

HNSW

Answer

FLAT

Answer

IVF

Answer

LSH

10 questions