AI-200 practice: Store and retrieve embeddings and execute vector similarity search for semantic retrieval

Question 1

You store 1536-dimension embeddings for several million documents in an Azure Cosmos DB for NoSQL container. You need the lowest possible query latency and RU cost at this scale, and you are willing to accept a small amount of approximation to get there.

Which vector index type should you configure in the container's indexing policy?

Accepted Answer

diskANN, an approximate nearest-neighbor index optimized for large-scale, high-dimensional search with lower latency and RU cost at scale

Answer

flat, which performs an exact brute-force vector comparison and is recommended mainly for smaller embedding collections with modest query volume

Answer

quantizedFlat, which balances accuracy and cost by quantizing vectors and suits moderate-sized datasets better than a full diskANN index

Answer

None — omit a vector index and compute cosine similarity in the application after a full container scan returns candidate documents

Question 2

You are configuring a vector index for a RAG container storing 1536-dimension OpenAI embeddings, prioritizing low memory footprint at the cost of some recall, for a container expected to hold 50 million vectors.
```json
{
  "vectorEmbeddingPolicy": {
    "vectorEmbeddings": [
      {
        "path": "/embedding",
        "dataType": "float32",
        "dimensions": 1536,
        "distanceFunction": "cosine"
      }
    ]
  },
  "indexingPolicy": {
    "vectorIndexes": [
      {
        "path": "/embedding",
        "type": "???"
      }
    ]
  }
}
```
Given the scale (50 million vectors) and the priority on low memory footprint, which vector index type should replace "???"?

Accepted Answer

diskANN — an approximate nearest-neighbor graph index designed specifically for very large vector datasets, offering strong recall with lower memory footprint (index data can reside on disk) at very large scale, making it the best fit for 50 million vectors prioritizing memory efficiency.

Answer

flat — flat indexes always have the lowest memory footprint regardless of scale.

Answer

quantizedFlat — reduces memory via vector quantization while remaining an exhaustive/near-exhaustive index, but this still scales poorly to 50 million vectors for latency.

Answer

Vector indexes are not required in Cosmos DB; queries always perform full brute-force scans regardless of index type.

Question 3

You write a hybrid RAG retrieval query combining vector similarity with a metadata filter restricting results to a specific tenant and document type, returning the top 5 most similar chunks:
```python
query = """
SELECT TOP 5 c.id, c.text, c.metadata,
VectorDistance(c.embedding, @queryVector) AS score
FROM c
WHERE c.tenantId = @tenantId AND c.docType = @docType
ORDER BY VectorDistance(c.embedding, @queryVector)
"""
items = list(container.query_items(
    query=query,
    parameters=[
        {"name": "@queryVector", "value": query_embedding},
        {"name": "@tenantId", "value": "tenant-42"},
        {"name": "@docType", "value": "policy"}
    ],
    partition_key="tenant-42"
))
```
This query fails at runtime with an ordering-related error. What is wrong?

Accepted Answer

The ORDER BY VectorDistance(...) clause must specify a sort direction — for similarity search you must explicitly add ASC (lower cosine distance = more similar) since Cosmos DB does not infer directionality for vector distance ordering by default.

Answer

VectorDistance() cannot be used in both the SELECT clause and the ORDER BY clause in the same query.

Answer

TOP 5 cannot be combined with ORDER BY in Cosmos DB SQL.

Answer

partition_key cannot be combined with a WHERE clause that also filters on the partition key field.

Question 4

You configure a vector embedding policy using int8 quantized embeddings to reduce storage cost, migrating from float32.
```json
{
  "vectorEmbeddingPolicy": {
    "vectorEmbeddings": [
      {
        "path": "/embedding",
        "dataType": "int8",
        "dimensions": 1536,
        "distanceFunction": "cosine"
      }
    ]
  }
}
```
Application code:
```python
container.upsert_item({
    "id": "chunk1",
    "embedding": embedding_vector, # list of 1536 floats from OpenAI, e.g. [0.0123, -0.045, ...]
    "text": "..."
})
```
The upsert fails validation. Why?

Accepted Answer

int8 embeddings require the stored array values to actually be 8-bit integers (typically in range -128 to 127) that have already been quantized by the application; raw float32 embeddings from an embeddings API cannot be inserted directly into an int8-typed vector path without an explicit quantization step first.

Answer

int8 is not a valid dataType value; only float32 is supported for dimensions: 1536.

Answer

cosine distance function is incompatible with int8 data type; only dotproduct works with quantized types.

Answer

The dimensions value must be reduced proportionally (e.g., to 384) when switching to int8.

Question 5

You compare vector search algorithm choices for a Cosmos DB container as part of a design review. A teammate claims flat will always give the best recall since it's exhaustive.

Which statement correctly completes the trade-off analysis for choosing between flat, quantizedFlat, and diskANN?

Accepted Answer

flat provides exact (100%) recall since it performs brute-force comparison against every vector, but has the highest memory footprint and worst query latency at scale, making it suitable only for small collections; diskANN trades some recall for dramatically better latency, memory efficiency, and scalability to large collections via approximate search.

Answer

All three algorithms provide identical recall; they differ only in indexing speed, so diskANN should always be chosen for its faster index builds.

Answer

quantizedFlat always has higher recall than flat because quantization improves precision.

Answer

diskANN cannot be used with cosine distance; it only supports euclidean.

Question 6

You implement multi-tenant RAG retrieval where each tenant's vectors must never be visible to another tenant, and queries should be as RU-efficient as possible:
```python
def retrieve(tenant_id, query_embedding, top_k=5):
    query = """
    SELECT TOP @topK c.id, c.text,
    VectorDistance(c.embedding, @qv) AS score
    FROM c
    ORDER BY VectorDistance(c.embedding, @qv)
    """
    return list(container.query_items(
        query=query,
        parameters=[
            {"name": "@topK", "value": top_k},
            {"name": "@qv", "value": query_embedding}
        ],
        enable_cross_partition_query=True
    ))
```
This code is a security and performance problem. What are the two required corrections?

Accepted Answer

Add WHERE c.tenantId = @tenantId to the query (security: prevents cross-tenant data leakage) and pass partition_key=tenant_id instead of enable_cross_partition_query=True (performance: routes the query to a single physical partition, avoiding a fan-out across all partitions).

Answer

Only add WHERE c.tenantId = @tenantId; enable_cross_partition_query=True is required regardless of partitioning and cannot be avoided for vector queries.

Answer

Only change enable_cross_partition_query=True to partition_key=tenant_id; the WHERE clause is unnecessary because partition key routing alone guarantees tenant isolation.

Answer

Add WHERE c.tenantId = @tenantId only; vector index queries always operate correctly within a single partition automatically regardless of settings.

Question 7

You build a hybrid search combining vector similarity with keyword/full-text matching for a document retrieval system:
```sql
SELECT TOP 10 c.id, c.text,
VectorDistance(c.embedding, @qv) AS vectorScore
FROM c
WHERE FullTextContains(c.text, "azure kubernetes service")
ORDER BY RANK RRF(VectorDistance(c.embedding, @qv),
FullTextScore(c.text, ["azure kubernetes service"]))
```
This query requires a specific index configuration to execute without error. What must the container's indexing policy define?

Accepted Answer

Both a vectorIndexes entry for /embedding and a fullTextIndexes entry for /text (along with the corresponding fullTextPolicy defining the path's language), since hybrid RANK RRF() queries combining vector and full-text scoring require both index types to be explicitly configured.

Answer

Only a vectorIndexes entry for /embedding; full-text search in Cosmos DB works without any dedicated index configuration.

Answer

A single compositeIndexes entry covering both /embedding and /text; composite indexes handle both vector and full-text scoring together.

Answer

No index configuration is required; RANK RRF() performs the fusion entirely client-side after two separate unindexed scans.

Question 8

You are designing a RAG system storing 1536-dimension embeddings in Cosmos DB for NoSQL. Query latency for vector similarity search is too high at scale. What should you configure to improve it?

Accepted Answer

Vector index (quantizedFlat/diskANN) on embeddings

Answer

Composite index on every string property path

Answer

Strong consistency to speed similarity search

Answer

Hierarchical keys alone without a vector index

Question 9

To store and retrieve embeddings in Cosmos DB for NoSQL, which container-level configuration must be defined before inserting vector data for it to be queryable via vector search?

Accepted Answer

vectorEmbeddingPolicy plus matching vector index

Answer

Unique key constraint on the embedding property

Answer

JS stored procedure computing cosine each query

Answer

No setup; any array property is vector-searchable

Question 10

You are using the Azure Cosmos DB Python SDK to perform a vector similarity search. Which method/clause is required to execute a vector query against stored embeddings?

Accepted Answer

ORDER BY VectorDistance()

Answer

WHERE VectorDistance() ASC

Answer

SELECT TOP VectorDistance()

Answer

GROUP BY VectorDistance()

13 questions