Tag: intelligent search

Implement full-text search (DP-800 Exam Prep)

This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Implement AI capabilities in database solutions (25–30%)
   --> Design and implement intelligent search
      --> Implement full-text search


Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

Full-text search is one of the foundational search technologies available in Microsoft SQL Server and Azure SQL Managed Instance. Unlike traditional SQL searches that rely on exact text matching through operators such as LIKE, full-text search provides a much more efficient and intelligent mechanism for searching large collections of textual data.

For the DP-800: Developing AI-Enabled Database Solutions exam, you should understand:

  • What full-text search is
  • When it should be used
  • How it works internally
  • Full-text indexes and catalogs
  • Supported query predicates and functions
  • Language-aware searching
  • Stoplists and thesaurus files
  • Ranking search results
  • Performance considerations
  • When to choose full-text search instead of vector or hybrid search

Although AI-powered semantic search is becoming increasingly popular, full-text search remains an important technology for applications that require fast keyword-based retrieval.


What Is Full-Text Search?

Full-text search is a SQL Server feature that enables efficient searching of large text columns.

Unlike:

WHERE Description LIKE '%backup%'

full-text search creates a specialized index that understands words rather than simple character sequences.

It supports searching within:

  • CHAR
  • VARCHAR
  • NCHAR
  • NVARCHAR
  • TEXT (legacy)
  • NTEXT (legacy)
  • XML
  • FILESTREAM documents through filters

Instead of scanning every row, SQL Server searches an optimized full-text index.


Why Traditional LIKE Queries Are Limited

Many developers initially use:

SELECT *
FROM Articles
WHERE Content LIKE '%security%'

Although this works, it has several disadvantages:

  • Table scans on large datasets
  • Poor performance
  • Cannot rank results
  • No language awareness
  • No stemming
  • No synonym support
  • Limited search capabilities

For enterprise search applications, LIKE queries do not scale effectively.


Benefits of Full-Text Search

Full-text search provides:

  • Fast keyword searches
  • Phrase searching
  • Prefix matching
  • Inflectional searches
  • Linguistic processing
  • Word breaking
  • Ranking of results
  • Stop word removal
  • Efficient indexing
  • Large-scale text retrieval

Full-Text Search Architecture

Several components work together.

Source Tables

Contain text data.

Example:

Articles
Products
KnowledgeBase
SupportTickets
Policies

Full-Text Index

Instead of indexing every character, SQL Server stores:

  • Tokens
  • Word positions
  • Language metadata

This dramatically speeds searches.


Full-Text Catalog

A full-text catalog is a logical container for one or more full-text indexes.

Modern SQL Server versions automatically manage catalogs, but understanding the concept remains important for the DP-800 exam.


Word Breakers

SQL Server separates text into words using language-specific rules.

Example:

SQL Server enables intelligent search.

becomes

SQL
Server
enables
intelligent
search

Different languages use different tokenization rules.


Stemmers

Stemmers recognize grammatical variations.

Searching:

run

may also find

  • running
  • runs
  • ran

depending on the configured language.


Enabling Full-Text Search

Before using full-text search:

  1. Install Full-Text Search feature.
  2. Create a unique key index.
  3. Create a full-text catalog (optional in newer versions).
  4. Create a full-text index.

Example:

CREATE FULLTEXT INDEX
ON Articles(Content)
KEY INDEX PK_Articles;

The index is then populated.


Full-Text Predicates

The DP-800 exam expects familiarity with common predicates.


CONTAINS()

Searches for precise words or phrases.

Example:

SELECT *
FROM Articles
WHERE CONTAINS(Content,'Azure');

Phrase Search

CONTAINS(Content,'"Azure SQL"')

Returns only rows containing the complete phrase.


Boolean Operators

Supports:

AND
OR
AND NOT

Example:

CONTAINS(Content,'"Azure" AND "Backup"')

Prefix Search

CONTAINS(Content,'"cloud*"')

Matches

  • cloud
  • clouds
  • cloud-based
  • clouding

Proximity Search

Finds words located near each other.

Example:

database NEAR backup

Useful when context matters.


FREETEXT()

Unlike CONTAINS(), FREETEXT searches for the meaning of words rather than exact expressions.

Example:

SELECT *
FROM Articles
WHERE FREETEXT(Content,'database recovery');

SQL Server automatically considers:

  • synonyms
  • stemming
  • inflectional forms

It is more natural-language oriented than CONTAINS().


Ranking Results

Often multiple documents match.

SQL Server can assign relevance rankings.

Functions include:

CONTAINSTABLE()
FREETEXTTABLE()

Example:

SELECT *
FROM CONTAINSTABLE
(
Articles,
Content,
'Azure'
)

Returns:

  • KEY
  • RANK

Applications can sort using the ranking score.


Stoplists

Certain words appear so frequently that indexing them offers little value.

Examples:

  • the
  • is
  • and
  • a
  • of

These are called stop words.

Stoplists improve:

  • Index size
  • Query performance
  • Search quality

Custom stoplists may also be created.


Thesaurus Files

SQL Server supports synonym expansion through thesaurus XML files.

Example:

Searching:

car

may automatically include

automobile
vehicle

This improves keyword searches without requiring embeddings.


Supported Languages

Full-text search supports dozens of languages.

Language-specific processing includes:

  • tokenization
  • stemming
  • stop words
  • word breakers

Examples include:

  • English
  • French
  • German
  • Spanish
  • Japanese
  • Chinese

Each language has its own linguistic rules.


Maintaining Full-Text Indexes

Indexes require updates when data changes.

Population modes include:

Full Population

Rebuilds the entire index.

Suitable for:

  • initial creation
  • major updates

Automatic Change Tracking

Automatically updates the index after data modifications.

Recommended for most OLTP workloads.


Manual Population

Administrators trigger updates manually.

Useful when:

  • large batch loads occur
  • maintenance windows exist

Performance Considerations

Full-text search is highly optimized but requires planning.

Consider:

  • index storage
  • population time
  • update frequency
  • large document sizes
  • language configuration
  • stoplists

For massive document repositories, automatic population should be monitored to avoid excessive resource usage.


When to Use Full-Text Search

Choose full-text search when users search by:

  • keywords
  • phrases
  • document titles
  • product names
  • legal terminology
  • technical documentation

Examples:

  • Knowledge bases
  • Product catalogs
  • Documentation portals
  • Legal document repositories
  • Medical reference systems

When NOT to Use Full-Text Search

Full-text search is not ideal when users expect semantic understanding.

Example:

User searches:

“recover my account”

Stored document:

“reset your password”

These phrases contain different words.

Full-text search may not match them effectively.

Semantic vector search would perform much better.


Full-Text Search vs LIKE

FeatureLIKEFull-Text Search
PerformancePoor on large tablesExcellent
Uses indexesLimitedSpecialized full-text indexes
Phrase searchLimitedYes
Word stemmingNoYes
Stop wordsNoYes
RankingNoYes
Prefix searchLimitedYes
Language awarenessNoYes

Full-Text Search vs Semantic Vector Search

FeatureFull-TextVector Search
Keyword matchingExcellentLimited
Semantic understandingNoExcellent
Embeddings requiredNoYes
Natural languageLimitedExcellent
Synonym understandingLimitedExcellent
AI chatbot supportModerateExcellent
RAG supportModerateExcellent
ComplexityLowMedium

Common DP-800 Scenarios

Scenario 1

A legal team searches contracts using exact legal terminology.

Best solution: Full-text search.


Scenario 2

A documentation portal searches millions of technical articles.

Best solution: Full-text search.


Scenario 3

An AI assistant answers questions using company documentation.

Best solution: Hybrid search (full-text + vector search).


Scenario 4

A recommendation engine finds similar documents.

Best solution: Vector search.


Best Practices

  • Use full-text indexes instead of LIKE for large text searches.
  • Configure the correct language for linguistic processing.
  • Enable automatic change tracking for frequently updated data.
  • Use stoplists to reduce index size and improve relevance.
  • Use CONTAINS() for precise searches and FREETEXT() for natural-language style queries.
  • Use CONTAINSTABLE() or FREETEXTTABLE() when relevance ranking is required.
  • Consider hybrid search when applications require both keyword precision and semantic understanding.
  • Monitor full-text index population and maintenance in production environments.

DP-800 Exam Tips

  • Know the differences between CONTAINS(), FREETEXT(), CONTAINSTABLE(), and FREETEXTTABLE().
  • Understand how full-text indexes differ from traditional SQL indexes.
  • Remember that full-text search is keyword-based, while vector search is meaning-based.
  • Understand the purpose of stoplists, word breakers, stemmers, and thesaurus files.
  • Expect scenario-based questions asking you to choose between LIKE queries, full-text search, vector search, and hybrid search based on application requirements.
  • Know when full-text search is sufficient and when semantic search or hybrid search provides a better user experience.

Practice Exam Questions


Question 1

A company stores millions of technical articles in an Azure SQL Database. Users frequently search for exact product names and technical terms. Developers currently use the following query:

SELECT *
FROM Articles
WHERE Content LIKE '%Azure SQL%'

The search is becoming increasingly slow as the table grows.

Which feature should you recommend?

A. Full-text search
B. Columnstore indexes
C. Semantic vector search
D. Table partitioning

Correct Answer: A

Explanation

Full-text search is specifically designed for efficient searching of large text columns. It creates specialized indexes that support keyword searches, phrase matching, ranking, and linguistic analysis. While table partitioning and columnstore indexes improve other workloads, they do not replace full-text search functionality.


Question 2

Which SQL Server function searches for exact words, phrases, Boolean expressions, and prefix terms?

A. FREETEXT()
B. CONTAINS()
C. PATINDEX()
D. CHARINDEX()

Correct Answer: B

Explanation

CONTAINS() supports advanced search expressions including:

  • Exact words
  • Exact phrases
  • Boolean operators (AND, OR, AND NOT)
  • Prefix searches
  • Proximity searches

FREETEXT() is intended for natural-language searching rather than precise keyword expressions.


Question 3

A developer wants search results to include different grammatical forms of the word run, such as:

  • running
  • runs
  • ran

Which SQL Server component provides this capability?

A. Stoplists

B. Full-text catalogs

C. Stemmers

D. Clustered indexes

Correct Answer: C

Explanation

Stemmers recognize different inflectional forms of words based on language-specific rules. This allows a search for “run” to also return documents containing “running,” “runs,” or “ran.”


Question 4

Which statement best describes a full-text catalog?

A. It stores database backups.

B. It replaces clustered indexes.

C. It is a logical container that organizes one or more full-text indexes.

D. It stores vector embeddings.

Correct Answer: C

Explanation

A full-text catalog is a logical container for full-text indexes. While SQL Server automatically manages catalogs in newer versions, understanding their role remains important for administration and exam scenarios.


Question 5

Which function is most appropriate when users enter natural-language search phrases rather than precise keywords?

A. CONTAINS()

B. LIKE

C. FREETEXT()

D. PATINDEX()

Correct Answer: C

Explanation

FREETEXT() performs natural-language searches by considering linguistic analysis, stemming, and synonyms. It is designed for less structured search input compared to CONTAINS().


Question 6

Which full-text search feature helps reduce index size by excluding commonly occurring words such as the, is, and and?

A. Word breakers

B. Stoplists

C. Stemmers

D. Ranking tables

Correct Answer: B

Explanation

Stoplists contain common words, known as stop words, that are ignored during indexing and searching. This improves both index efficiency and search relevance.


Question 7

Your application must display search results ordered from the most relevant document to the least relevant.

Which functions are specifically designed for this purpose?

A. CONTAINS() and FREETEXT()

B. LIKE and PATINDEX()

C. CONTAINSTABLE() and FREETEXTTABLE()

D. CHARINDEX() and STRING_SPLIT()

Correct Answer: C

Explanation

CONTAINSTABLE() and FREETEXTTABLE() return a RANK value that indicates the relevance of each result, allowing applications to sort documents by search quality.


Question 8

Which scenario is the best use case for traditional full-text search?

A. Finding semantically similar customer support tickets

B. Building a Retrieval-Augmented Generation (RAG) chatbot

C. Recommending similar research papers based on meaning

D. Searching legal documents using exact legal terminology

Correct Answer: D

Explanation

Full-text search excels when users search using precise words and phrases, making it well suited for legal, compliance, technical documentation, and product catalog scenarios. Semantic vector search is generally preferred for AI assistants and recommendation systems.


Question 9

Which component is responsible for separating text into searchable words based on language-specific rules?

A. Word breakers

B. Stoplists

C. Embedding models

D. Full-text catalogs

Correct Answer: A

Explanation

Word breakers tokenize text into individual searchable terms according to the linguistic rules of the configured language. Proper tokenization is essential for accurate indexing and querying.


Question 10

A company is building an AI-powered knowledge assistant. Users expect searches such as:

“recover my account”

to return documents titled:

“reset your password”

Which recommendation is most appropriate?

A. Continue using LIKE queries

B. Use only full-text search

C. Replace all searches with clustered indexes

D. Combine full-text search with semantic vector search using hybrid search

Correct Answer: D

Explanation

Full-text search primarily matches keywords and phrases, while semantic vector search retrieves documents based on meaning. Hybrid search combines both approaches, producing more accurate results for AI-powered applications such as RAG systems and enterprise knowledge assistants.


DP-800 Exam Tips

  • Use full-text search when exact keywords, phrases, and language-aware matching are required.
  • Understand the differences between CONTAINS(), FREETEXT(), CONTAINSTABLE(), and FREETEXTTABLE().
  • Remember that word breakers tokenize text, stemmers recognize grammatical variations, and stoplists remove common words to improve search efficiency.
  • Use ranking functions when applications need to order search results by relevance.
  • Recognize that LIKE queries are not appropriate for large-scale enterprise text search.
  • Know that full-text search is keyword-based, while vector search is meaning-based; hybrid search combines the strengths of both and is often the preferred approach for AI-enabled search solutions.

Go to the DP-800 Exam Prep Hub main page

Design for vector data, including vector data type, vector indexes, and size (DP-800 Exam Prep)

This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Implement AI capabilities in database solutions (25–30%)
   --> Design and implement intelligent search
      --> Design for vector data, including vector data type, vector indexes, and size


Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

Modern AI-enabled applications increasingly rely on vector data to represent the meaning of text, images, audio, and other unstructured information. Instead of matching exact words, vector-based search enables applications to find content based on semantic similarity.

Microsoft SQL Server 2025, Azure SQL Database, and Azure SQL Managed Instance introduce native support for vector data, allowing databases to store embeddings directly alongside relational data. Combined with AI models and vector indexes, SQL databases become powerful platforms for semantic search, Retrieval-Augmented Generation (RAG), recommendation engines, document similarity, and AI assistants.

For the DP-800 exam, candidates should understand how to:

  • Design schemas that store vector embeddings
  • Choose appropriate vector dimensions
  • Understand vector data types
  • Create and maintain vector indexes
  • Balance storage, performance, and accuracy
  • Select index types appropriate for AI workloads
  • Understand how vector size affects database performance

What Is Vector Data?

A vector is a numerical representation of data generated by an embedding model.

Instead of storing text directly, the model converts text into hundreds or thousands of floating-point numbers.

Example:

Original text:

“Azure SQL supports AI-powered search.”

Embedding:

[0.012,
-0.553,
0.441,
...
0.318]

This numerical representation captures semantic meaning.

Documents discussing:

  • AI databases
  • Azure SQL
  • semantic search

will produce vectors located close together within vector space.


Why Store Vectors in SQL?

Traditionally, embeddings were stored in external vector databases.

Modern SQL databases now support vectors directly, allowing organizations to:

  • Keep structured and unstructured data together
  • Simplify architecture
  • Reduce synchronization complexity
  • Improve transactional consistency
  • Query relational and vector data simultaneously

Example table:

ProductIDNameCategoryDescriptionDescriptionEmbedding
101LaptopElectronicsPortable computerVector

This allows applications to perform:

  • SQL filtering
  • joins
  • semantic search

within one query.


Understanding the Vector Data Type

The new VECTOR data type stores embeddings efficiently inside SQL tables.

Example:

VECTOR(1536)

The number specifies the vector dimensions.

Examples:

VECTOR(768)
VECTOR(1024)
VECTOR(1536)
VECTOR(3072)

The dimension must exactly match the embedding model.


What Are Vector Dimensions?

Each embedding model outputs a fixed number of values.

Examples:

ModelTypical Dimensions
Small embedding model768
text-embedding-3-small1536
text-embedding-3-large3072

If an embedding model generates 1536 values:

VECTOR(1536)

must be used.

Using the wrong size causes insert failures.


Choosing the Correct Vector Size

Higher dimensions provide richer semantic meaning.

However they also require:

  • more storage
  • larger indexes
  • slower searches
  • additional memory

Example comparison:

DimensionsCharacteristics
256Very small, fast, lower accuracy
768Good balance
1024Higher quality
1536Excellent semantic understanding
3072Highest quality but larger storage

Choosing unnecessarily large vectors wastes storage.


How Embedding Size Affects Storage

Each dimension stores a floating-point number.

Example:

1536 dimensions

≈1536 floating point values

Across one million rows:

1,000,000 vectors
×
1536 dimensions

This becomes a significant storage requirement.

Large AI applications should estimate storage before deployment.


Designing Tables for Vector Data

Common design:

Documents
------------
DocumentID
Title
Category
Content
Embedding

The embedding column stores semantic meaning.

Other columns remain relational.

This design enables hybrid queries.


Separating Embeddings from Business Data

Many organizations separate embeddings into another table.

Example:

Documents
DocumentID
Title
Content
DocumentEmbeddings
DocumentID
Embedding
ModelVersion
CreatedDate

Benefits:

  • easier regeneration
  • reduced locking
  • independent maintenance
  • multiple embedding versions

Versioning Embeddings

Embedding models evolve.

Example:

Version 1:

text-embedding-3-small

Later:

text-embedding-3-large

A model change usually requires regenerating all vectors.

Many databases store:

  • Model Name
  • Version
  • Generation Date

This allows safe migrations.


One Embedding or Multiple?

Some applications store several embeddings.

Example:

Products

  • Title embedding
  • Description embedding
  • Review embedding

Different searches can target different meanings.


Designing for Chunk-Level Embeddings

Large documents are usually divided into chunks.

Instead of:

Entire PDF
One vector

Applications store:

Document
Paragraphs
One vector per paragraph

Benefits include:

  • higher search precision
  • better RAG responses
  • smaller embeddings
  • improved relevance

Vector Search vs Traditional Search

Traditional search matches keywords.

Example:

Search:

vehicle

Document:

car

Keyword search may miss it.

Vector search recognizes semantic similarity.

It understands:

  • automobile
  • vehicle
  • car
  • SUV

are closely related.


Combining SQL Filters with Vector Search

One major benefit of SQL databases is combining structured filters with AI search.

Example:

Category = Electronics
AND
Vector similarity

Only electronics are searched semantically.

This improves both performance and relevance.


Exact Search vs Approximate Search

Vector searches generally use two approaches.

Exact Search

Compares every vector.

Advantages:

  • highest accuracy

Disadvantages:

  • slower
  • expensive for large datasets

Approximate Search

Uses specialized indexes.

Advantages:

  • much faster
  • scalable

Tradeoff:

  • slight reduction in accuracy

Most production AI systems use approximate search.


Understanding Vector Indexes

Without indexes:

Every vector must be compared.

1 million vectors
1 million comparisons

Vector indexes dramatically reduce work.

They organize vectors based on similarity.

This enables very fast nearest-neighbor searches.


Approximate Nearest Neighbor (ANN)

Modern vector databases commonly use ANN indexing.

Instead of checking every vector:

Search
Relevant region
Nearby vectors
Best matches

Response times become milliseconds instead of seconds.


Why Vector Indexes Matter

Benefits include:

  • faster semantic search
  • reduced CPU usage
  • scalable AI applications
  • improved RAG performance
  • lower query latency

Large AI systems depend heavily on vector indexing.


Choosing Whether to Create a Vector Index

Small datasets:

A vector index may not provide significant benefit.

Large datasets:

Vector indexes become essential.

Typical guidance:

RowsRecommendation
ThousandsOptional
Hundreds of thousandsRecommended
MillionsEssential

Best Practices

  • Use the embedding dimensions required by the selected model.
  • Store vectors in dedicated VECTOR columns.
  • Keep relational data alongside embeddings whenever practical.
  • Separate embeddings into dedicated tables when frequent regeneration is expected.
  • Track embedding model versions.
  • Chunk large documents before generating embeddings.
  • Choose the smallest embedding model that delivers acceptable quality.
  • Create vector indexes for large datasets.
  • Combine relational filtering with semantic search.
  • Monitor storage growth as embeddings increase.

Common Exam Tips

  • Know that VECTOR stores embedding data.
  • Understand that vector dimensions must match the embedding model.
  • Remember that larger vectors increase storage and memory requirements.
  • Recognize that vector indexes accelerate semantic similarity searches.
  • Understand the difference between exact and approximate nearest-neighbor searches.
  • Know that chunking improves retrieval quality for large documents.
  • Understand that multiple embeddings may exist for a single record.
  • Remember that embedding model upgrades usually require regenerating vectors.
  • Understand that relational filtering and vector search can be combined.
  • Expect scenario-based questions involving storage, indexing, scalability, and AI search architecture.

Practice Exam Questions


Question 1

A company is building a Retrieval-Augmented Generation (RAG) application using Azure SQL Database. They plan to store embeddings generated by the text-embedding-3-small model.

Which VECTOR data type should be used for the embedding column?

A. VECTOR(768)
B. VECTOR(1024)
C. VECTOR(1536)
D. VECTOR(3072)

Correct Answer: C

Explanation:
The text-embedding-3-small model generates 1,536-dimensional embeddings. The VECTOR column must match the number of dimensions produced by the embedding model. Using any other dimension would prevent embeddings from being stored correctly.


Question 2

A database contains 12 million product embeddings. Semantic searches are becoming increasingly slow because every query compares all vectors.

What should the database developer implement?

A. A clustered index on the VECTOR column
B. A vector index that supports Approximate Nearest Neighbor (ANN) searches
C. A nonclustered index on the product name
D. A filtered index on the category column

Correct Answer: B

Explanation:
Vector indexes using Approximate Nearest Neighbor algorithms dramatically reduce the number of comparisons required during similarity searches. Traditional SQL indexes cannot optimize vector similarity calculations.


Question 3

A developer must choose between a 768-dimensional embedding model and a 3,072-dimensional embedding model.

What is generally true about the larger embedding model?

A. It always performs searches faster.
B. It requires fewer storage resources.
C. It typically captures more semantic detail but requires additional storage and memory.
D. It cannot be indexed.

Correct Answer: C

Explanation:
Higher-dimensional embeddings generally preserve more semantic information, improving search quality. However, they increase storage requirements, memory consumption, and indexing costs.


Question 4

A database stores customer information together with vector embeddings representing customer support conversations.

Which design provides the greatest flexibility for regenerating embeddings after switching to a new embedding model?

A. Store embeddings in a separate table linked by the primary key.
B. Store embeddings inside a JSON document.
C. Store embeddings inside XML columns.
D. Store embeddings inside temporary tables.

Correct Answer: A

Explanation:
Separating embeddings into their own table simplifies regeneration, maintenance, versioning, and model migration while keeping business data unchanged.


Question 5

A development team wants to search only engineering documents while using semantic similarity.

Which approach best meets this requirement?

A. Perform only vector similarity searches across every document.
B. Filter documents by department using SQL, then perform vector similarity searches.
C. Disable relational filtering.
D. Store engineering documents in a separate SQL Server instance.

Correct Answer: B

Explanation:
One advantage of SQL databases is combining structured filtering with vector similarity search. Restricting the dataset before similarity comparisons improves both performance and relevance.


Question 6

A company stores embeddings for technical manuals that average 400 pages each.

What is the recommended design approach?

A. Generate one embedding for the entire manual.
B. Store only the title as an embedding.
C. Divide manuals into logical chunks and generate embeddings for each chunk.
D. Generate embeddings only for images.

Correct Answer: C

Explanation:
Chunking improves semantic retrieval accuracy by allowing searches to return only the most relevant portions of large documents rather than entire documents.


Question 7

A developer upgrades from one embedding model to another that produces vectors with a different number of dimensions.

What should the developer expect?

A. Existing vectors automatically resize.
B. Existing vectors remain compatible without changes.
C. SQL Server automatically converts vector dimensions.
D. Existing embeddings must be regenerated to match the new model dimensions.

Correct Answer: D

Explanation:
Embedding dimensions are fixed for each model. Changing models often changes vector size, requiring regeneration of all stored embeddings.


Question 8

An application contains approximately 3,000 embedded documents.

Which statement is most accurate regarding vector indexes?

A. Vector indexes are mandatory regardless of database size.
B. Vector indexes cannot be created until at least one million vectors exist.
C. A vector index may provide limited benefit for a very small dataset.
D. Vector indexes only work with GraphQL.

Correct Answer: C

Explanation:
Small datasets often perform adequately without vector indexes. The performance gains become much more significant as the number of vectors increases.


Question 9

A developer wants to support semantic search over product descriptions while maintaining product categories, prices, and inventory information in the same database.

Which database design best supports this objective?

A. Store embeddings in a VECTOR column while keeping relational attributes in standard SQL columns.
B. Store all relational data inside embedding vectors.
C. Replace relational tables with JSON files.
D. Store embeddings only in application memory.

Correct Answer: A

Explanation:
Keeping embeddings alongside relational data enables hybrid queries that combine SQL filtering with semantic similarity search, one of the major strengths of AI-enabled SQL databases.


Question 10

Which factor has the greatest impact on the storage requirements of vector data?

A. Database collation
B. Number of database users
C. Recovery model
D. Number of dimensions in each embedding

Correct Answer: D

Explanation:
Each embedding stores one numeric value per dimension. As the number of dimensions increases, the storage required for each vector grows proportionally, affecting table size, indexes, backups, and memory usage.


Final Exam Tips

  • Ensure the VECTOR column dimension exactly matches the embedding model.
  • Larger embeddings generally improve semantic quality but increase storage and computational costs.
  • Use vector indexes (ANN) for large datasets to improve search performance.
  • Combine relational SQL filtering with vector similarity searches for efficient hybrid queries.
  • Chunk large documents before generating embeddings to improve retrieval quality.
  • Store embedding model metadata and versions to simplify future migrations.
  • Separate embeddings from business data when frequent regeneration is expected.
  • Expect scenario-based questions comparing performance, storage, indexing strategies, and search architectures.

Go to the DP-800 Exam Prep Hub main page

Evaluate vector index types and metrics (DP-800 Exam Prep)

This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Implement AI capabilities in database solutions (25–30%)
   --> Design and implement intelligent search
      --> Evaluate vector index types and metrics


Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

Understanding vector indexes and similarity metrics is essential when building AI-enabled database applications that perform semantic search, retrieval-augmented generation (RAG), recommendation engines, and AI-powered document retrieval. Selecting the correct vector index type and similarity metric has a major impact on search accuracy, scalability, latency, and infrastructure costs.

Traditional database indexes are designed to efficiently locate exact values or values within a range.

Examples include:

  • Primary key indexes
  • Clustered indexes
  • Nonclustered indexes
  • Full-text indexes

These indexes perform extremely well for queries such as:

WHERE CustomerID = 123

or

WHERE LastName LIKE 'Smith%'

However, AI applications frequently need to answer questions based on meaning rather than exact text.

For example:

User query:

“Hotels close to the beach with great seafood.”

Documents may contain:

“Oceanfront resort featuring fresh local cuisine.”

There are no matching keywords, yet both sentences describe the same concept.

This is where vector search becomes essential.


What Is a Vector?

A vector is a numerical representation of text, images, audio, or other data generated by an embedding model.

Instead of storing text as characters, AI models convert information into hundreds or thousands of numeric dimensions.

Example:

"The cat sat on the mat."
[0.183,
-0.442,
0.913,
...
1536 dimensions]

Documents discussing similar concepts produce vectors that are mathematically close together.


Why Vector Indexes Are Needed

Suppose a database contains 10 million document embeddings.

Without an index:

  • every query compares against every vector
  • search complexity becomes enormous
  • latency may reach several seconds

Vector indexes organize vectors to reduce the number of comparisons dramatically while preserving high search quality.


Exact vs Approximate Search

Vector search generally falls into two categories.

Exact Search

Also known as:

  • Brute-force search
  • Exhaustive search

Process:

  1. Compare query vector to every stored vector.
  2. Calculate similarity score.
  3. Sort results.
  4. Return best matches.

Advantages:

  • 100% accurate
  • Always finds nearest neighbor
  • Simple implementation

Disadvantages:

  • Slow
  • Poor scalability
  • High CPU usage

Best for:

  • Small datasets
  • Testing
  • Benchmarking

Approximate Nearest Neighbor (ANN)

ANN algorithms search intelligently instead of comparing every vector.

Advantages:

  • Extremely fast
  • Scales to millions or billions of vectors
  • Lower resource consumption

Tradeoff:

  • Results are extremely close to optimal but not always mathematically perfect.

Most enterprise AI systems use ANN indexes.


Common Vector Index Types

1. Flat Index (Brute Force)

Every vector is scanned.

Query
Compare with Vector 1
Compare with Vector 2
Compare with Vector 3
...
Best Match

Advantages

  • Perfect accuracy
  • No preprocessing
  • Easy to maintain

Disadvantages

  • Slow
  • Doesn’t scale well

Best for

  • Small datasets
  • Testing

2. HNSW (Hierarchical Navigable Small World)

One of the most popular ANN indexes.

Rather than checking every vector, HNSW creates multiple graph layers.

High-level layers:

A
B
C

Lower layers:

A — D — E — F
\ |
G — H

The search begins at higher levels and progressively narrows the search.

Advantages

  • Extremely high recall
  • Very low latency
  • Excellent scalability

Disadvantages

  • More memory required
  • Longer index creation time

Commonly used in:

  • Azure SQL vector search
  • AI search engines
  • Modern vector databases

3. IVF (Inverted File Index)

Vectors are grouped into clusters.

Cluster A
Cluster B
Cluster C
Cluster D

Instead of searching every cluster:

  1. Identify closest cluster.
  2. Search only that cluster.

Advantages

  • Very fast
  • Efficient memory usage

Disadvantages

  • Search quality depends on clustering accuracy.

4. Product Quantization (PQ)

PQ compresses vectors into compact representations.

Instead of storing:

1536 floating-point numbers

it stores compressed codes.

Advantages

  • Huge storage savings
  • Faster searches
  • Lower memory usage

Disadvantages

  • Slight loss of precision

Often combined with IVF.


5. Disk-Based Indexes

Some systems keep indexes primarily on disk instead of RAM.

Advantages

  • Supports enormous datasets

Disadvantages

  • Higher latency

Useful when memory is limited.


Comparing Index Types

IndexAccuracySpeedMemoryTypical Use
FlatHighestSlowMediumSmall datasets
HNSWVery HighVery FastHighEnterprise RAG
IVFHighFastMediumLarge datasets
IVF + PQModerate-HighVery FastLowMassive collections
Disk-basedHighModerateLow RAMVery large databases

Understanding Similarity Metrics

A vector index determines how vectors are organized.

A similarity metric determines how closeness is measured.

Choosing the wrong metric can significantly reduce search quality.


Cosine Similarity

The most widely used similarity metric.

Measures the angle between vectors.

Formula (conceptually):

Similarity = cos(angle)

Identical direction:

1.0

Perpendicular:

0

Opposite direction:

-1

Advantages

  • Ignores vector magnitude
  • Excellent for semantic search
  • Very common in embedding models

Typical uses

  • Document search
  • Chatbots
  • RAG
  • Azure OpenAI embeddings

Euclidean Distance

Measures straight-line distance.

Distance = √((x₂−x₁)²...)

Smaller distance means greater similarity.

Advantages

  • Easy to understand
  • Works well for spatial data

Disadvantages

  • Sensitive to vector magnitude

Dot Product

Calculates the mathematical product of vectors.

Useful when embedding magnitude carries meaning.

Often used by recommendation systems.

Advantages

  • Computationally efficient
  • Good with normalized embeddings

Manhattan Distance

Also called:

L1 distance

Measures movement along axes.

|x1-x2| + |y1-y2|

Less common in vector databases.


Hamming Distance

Used for binary vectors.

Measures the number of differing bits.

Common in binary embeddings.


Choosing the Right Similarity Metric

MetricBest For
Cosine SimilaritySemantic search
Euclidean DistanceSpatial similarity
Dot ProductRecommendation systems
Manhattan DistanceGrid-based comparisons
Hamming DistanceBinary vectors

Matching Metrics to Embedding Models

Many embedding models are trained assuming a particular similarity metric.

Examples:

  • OpenAI embeddings → Cosine similarity
  • Azure OpenAI embeddings → Cosine similarity
  • Sentence Transformer models → Cosine similarity (commonly)
  • Some recommendation models → Dot product

Using the incorrect metric can reduce retrieval quality.


Tradeoffs When Evaluating Vector Indexes

Database developers evaluate multiple characteristics.

Search Accuracy

Higher recall produces better retrieval quality.

Higher accuracy often requires:

  • more memory
  • more CPU
  • larger indexes

Query Latency

AI chat applications typically require responses within milliseconds.

Approximate indexes dramatically reduce latency.


Recall

Recall measures how many true nearest neighbors are returned.

Example:

Actual nearest neighbors:

A
B
C
D
E

Returned:

A
B
C
X
Y

Recall:

3/5 = 60%

Higher recall improves RAG quality.


Memory Usage

HNSW indexes often consume substantial memory.

Compressed indexes require much less.


Build Time

Some indexes build quickly.

Others may require extensive preprocessing.

Large enterprise indexes may take hours to create.


Update Performance

Questions to evaluate:

  • How quickly can vectors be inserted?
  • Can vectors be deleted efficiently?
  • Is index rebuilding required?

Applications with frequent updates may favor indexes that support incremental maintenance.


Vector Index Selection Guidelines

Small Collections (<100K vectors)

Recommended:

  • Flat index

Reason:

  • Simplicity
  • Maximum accuracy

Medium Collections (100K–10M)

Recommended:

  • HNSW

Reason:

  • Excellent speed
  • Excellent recall

Massive Collections (100M+)

Recommended:

  • IVF
  • IVF + PQ

Reason:

  • Reduced storage
  • Excellent scalability

Memory-Constrained Systems

Recommended:

  • Product Quantization
  • Disk-based indexes

Vector Indexes in SQL-Based AI Solutions

Modern SQL platforms increasingly support vector capabilities.

Examples include:

  • SQL databases with vector data types
  • Vector indexes
  • Embedding storage
  • Similarity search functions

These capabilities enable developers to combine structured SQL queries with semantic AI search within a single database solution.


Best Practices

  • Match the similarity metric to the embedding model.
  • Use cosine similarity for most semantic search workloads.
  • Prefer ANN indexes for production systems.
  • Benchmark recall, latency, and throughput before deployment.
  • Monitor index performance as datasets grow.
  • Rebuild or optimize indexes when fragmentation or large-scale updates reduce efficiency.
  • Evaluate memory consumption alongside query performance.
  • Test retrieval quality using realistic user queries.

DP-800 Exam Tips

Remember these key points for the exam:

  • Vector indexes optimize similarity search rather than exact matching.
  • ANN indexes trade a small amount of accuracy for significant performance gains.
  • HNSW is a leading ANN algorithm due to its high recall and low latency.
  • IVF clusters vectors before searching.
  • Product Quantization reduces storage requirements.
  • Cosine similarity is the preferred metric for most semantic search scenarios.
  • Choosing the appropriate similarity metric is just as important as choosing the index type.
  • Retrieval quality depends on embeddings, similarity metrics, and index configuration working together.

Practice Exam Questions

Question 1

A development team is building a Retrieval-Augmented Generation (RAG) solution containing over 15 million document embeddings. The application requires low query latency while maintaining high retrieval accuracy.

Which vector index type is the most appropriate?

A. Flat index

B. HNSW

C. Clustered index

D. Full-text index

Answer: B

Explanation:
HNSW is designed for Approximate Nearest Neighbor (ANN) search and offers excellent recall with very low latency, making it a common choice for large-scale RAG implementations. Flat indexes become too slow at this scale, while clustered and full-text indexes are not vector indexes.


Question 2

Which similarity metric is most commonly used with modern text embedding models for semantic search?

A. Manhattan Distance

B. Euclidean Distance

C. Cosine Similarity

D. Hamming Distance

Answer: C

Explanation:
Cosine similarity compares the angle between vectors rather than their magnitude, making it ideal for semantic search. Many embedding models, including Azure OpenAI embeddings, are designed to work effectively with cosine similarity.


Question 3

A database developer wants mathematically perfect nearest-neighbor results regardless of execution time.

Which search method should be selected?

A. Approximate Nearest Neighbor

B. Product Quantization

C. Exhaustive (Flat) Search

D. IVF

Answer: C

Explanation:
Exhaustive or flat search compares the query against every stored vector, guaranteeing the exact nearest neighbors. This approach is computationally expensive but provides maximum accuracy.


Question 4

What is the primary purpose of Product Quantization (PQ)?

A. Improve SQL joins

B. Increase transaction throughput

C. Normalize embeddings

D. Reduce storage and memory requirements

Answer: D

Explanation:
Product Quantization compresses vectors into compact representations, reducing storage and memory usage while enabling efficient searches. The tradeoff is a small reduction in precision.


Question 5

Which statement best describes Approximate Nearest Neighbor (ANN) indexing?

A. It guarantees perfect search accuracy.

B. It searches every vector sequentially.

C. It balances retrieval accuracy with search performance.

D. It only supports binary vectors.

Answer: C

Explanation:
ANN algorithms reduce search time by avoiding exhaustive comparisons. They provide high-quality results with much better performance than exact search, making them suitable for production AI systems.


Question 6

A team notices that their semantic search results have degraded after switching from cosine similarity to Euclidean distance while using the same embedding model.

What is the most likely cause?

A. The embedding model was trained assuming cosine similarity.

B. Euclidean distance always produces identical results.

C. Vector indexes require clustered tables.

D. SQL Server does not support vectors.

Answer: A

Explanation:
Embedding models are often optimized for specific similarity metrics. Using a different metric than the one assumed during training can reduce retrieval quality even if the vectors themselves remain unchanged.


Question 7

Why do vector indexes improve search performance?

A. They reduce the dimensionality of every embedding.

B. They organize vectors so fewer comparisons are needed.

C. They convert vectors into relational tables.

D. They eliminate the need for embeddings.

Answer: B

Explanation:
Vector indexes structure embeddings so that searches examine only promising candidates instead of every stored vector, significantly reducing query latency.


Question 8

A company has a small proof-of-concept application containing 25,000 document embeddings. Search accuracy is more important than performance.

Which index is the best choice?

A. IVF + PQ

B. HNSW

C. Flat index

D. Disk-based ANN index

Answer: C

Explanation:
For relatively small datasets where absolute accuracy is the priority, a flat index is often the simplest and most accurate solution. Performance remains acceptable because the collection size is limited.


Question 9

Which evaluation metric indicates how many true nearest neighbors are successfully returned during a vector search?

A. Latency

B. Precision

C. Throughput

D. Recall

Answer: D

Explanation:
Recall measures the proportion of actual nearest neighbors that are retrieved by the search algorithm. Higher recall generally leads to better retrieval quality in semantic search and RAG systems.


Question 10

When evaluating different vector index types for a production AI solution, which combination of factors is most important?

A. File size and backup frequency

B. Number of SQL tables and views

C. Search latency, recall, memory usage, and index maintenance

D. Number of stored procedures and triggers

Answer: C

Explanation:
Production vector indexes should be evaluated based on their ability to deliver fast queries, high recall, efficient memory utilization, and manageable maintenance as data volumes grow. These characteristics directly affect the performance and scalability of AI-enabled database solutions.


Go to the DP-800 Exam Prep Hub main page

Implement vector search (DP-800 Exam Prep)

This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Implement AI capabilities in database solutions (25–30%)
   --> Design and implement intelligent search
      --> Implement vector search


Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

Implementing vector search is one of the foundational skills for building modern AI-enabled database applications. Vector search enables databases to retrieve information based on semantic meaning rather than exact keyword matches, making it essential for Retrieval-Augmented Generation (RAG), AI assistants, recommendation engines, semantic document search, knowledge management systems, and intelligent enterprise applications.


What Is Vector Search?

Traditional SQL queries search for exact values.

For example:

SELECT *
FROM Products
WHERE ProductName = 'Laptop';

or

WHERE Description LIKE '%wireless%'

These approaches rely on exact text matching.

However, AI applications often need to answer questions like:

“Find documents about reducing cloud costs.”

Relevant documents might contain:

  • Lower Azure spending
  • Optimize infrastructure expenses
  • Cloud cost optimization
  • Reduce operational costs

Although these documents contain different words, they share the same meaning.

Vector search enables databases to find these semantically related documents.


How Vector Search Works

Vector search consists of several stages.

User Query
Embedding Model
Query Vector
Vector Similarity Search
Nearest Neighbor Documents
(Optional)
Large Language Model (LLM)

Instead of comparing text directly, the database compares numeric vector representations generated by an embedding model.


What Is a Vector?

A vector is a high-dimensional numerical representation of data.

Example:

"Azure SQL Database"
[-0.134,
0.281,
0.998,
...
1536 dimensions]

Every document stored in the database has its own embedding vector.

When a user submits a query, the query is also converted into a vector.

The database then compares vectors mathematically to identify the most similar results.


Components of a Vector Search Solution

A complete vector search implementation includes several components.

1. Source Data

Examples include:

  • PDF files
  • Product catalogs
  • Emails
  • Knowledge articles
  • Web pages
  • Support tickets
  • SQL records

2. Embedding Model

The embedding model converts text into vectors.

Popular examples include:

  • Azure OpenAI Embeddings
  • OpenAI text embedding models
  • Sentence Transformers
  • Other compatible embedding models

The embedding model should remain consistent for both indexing and querying.


3. Vector Storage

Embeddings are stored inside the database.

Example table:

DocumentIDContentEmbedding
101Product Manual[1536 values]
102FAQ[1536 values]
103Warranty Guide[1536 values]

Modern SQL databases increasingly support dedicated vector data types.


4. Vector Index

Searching millions of vectors without an index would require comparing every vector.

Vector indexes organize embeddings for efficient similarity searches.

Common vector indexes include:

  • Flat (Exact Search)
  • HNSW
  • IVF
  • IVF + Product Quantization (PQ)

Approximate Nearest Neighbor (ANN) indexes are commonly used in production systems because they significantly reduce search latency while maintaining high recall.


5. Similarity Function

The database determines which vectors are closest.

Common similarity metrics include:

  • Cosine similarity
  • Euclidean distance
  • Dot product

Cosine similarity is the most common metric for semantic search.


Exact Search vs Approximate Search

Exact (Brute Force) Search

The database compares the query vector against every stored vector.

Advantages:

  • Perfect accuracy
  • Guaranteed nearest neighbors

Disadvantages:

  • Slow
  • Poor scalability

Best suited for:

  • Small datasets
  • Testing
  • Validation

Approximate Nearest Neighbor (ANN)

ANN indexes intelligently reduce the search space.

Advantages:

  • Extremely fast
  • Scales to millions or billions of vectors
  • Lower CPU utilization

Tradeoff:

Results are highly accurate but not mathematically perfect.

Most enterprise AI applications use ANN search.


Implementing Vector Search

A typical implementation follows these steps.

Step 1. Prepare Data

Collect the documents.

Examples:

  • Product manuals
  • Policies
  • Emails
  • Support articles

Clean the text by removing unnecessary formatting and duplicate content.


Step 2. Generate Embeddings

Use an embedding model to create vectors.

Example workflow:

Document
Embedding Model
1536-Dimensional Vector

Each document receives one or more embeddings.


Step 3. Store Embeddings

Store:

  • Original text
  • Metadata
  • Embedding vector

Example:

DocumentIDCategoryContentEmbedding
501HRVacation PolicyVector
502ITVPN SetupVector

Metadata enables additional filtering during searches.


Step 4. Create a Vector Index

The vector index accelerates similarity searches.

Without an index:

Query
Compare to every vector

With an ANN index:

Query
Index
Small candidate set
Best matches

Step 5. Convert User Query

The user’s search query is embedded using the same embedding model.

Example:

"How do I connect remotely?"
Embedding Model
Query Vector

Consistency is critical. Using a different embedding model for queries than for indexed documents can significantly reduce search quality.


Step 6. Perform Similarity Search

The database compares the query vector with stored vectors.

Example SQL pseudocode:

SELECT TOP 5
DocumentID,
SimilarityScore
FROM Documents
ORDER BY VECTOR_DISTANCE(Embedding, @QueryVector);

The exact syntax varies depending on the database platform and vector search implementation.


Step 7. Return Results

The application retrieves the closest documents.

Example:

RankDocument
1VPN Configuration Guide
2Remote Access FAQ
3Employee Network Policy

Vector Search Workflow

Documents
Generate Embeddings
Store Vectors
Create Vector Index
User Query
Generate Query Embedding
Similarity Search
Top Matching Documents

Filtering Vector Search Results

Many applications combine vector search with traditional SQL filtering.

Example:

Semantic Search
+
WHERE Department = 'Finance'
+
ORDER BY Similarity

This approach is often called hybrid filtering, allowing organizations to limit searches by structured metadata while still leveraging semantic similarity.

Examples of filters include:

  • Department
  • Date
  • Customer
  • Region
  • Security classification
  • Language

Hybrid Search

Hybrid search combines:

  • Keyword search
  • Full-text search
  • Vector search

Example:

Keyword Search
+
Vector Search
Combined Ranking
Final Results

Benefits include:

  • Higher relevance
  • Better handling of synonyms
  • Stronger ranking
  • Improved user satisfaction

Many enterprise AI search systems use hybrid search instead of vector search alone.


Using Vector Search in RAG

Retrieval-Augmented Generation relies heavily on vector search.

Workflow:

User Question
Embedding
Vector Search
Relevant Documents
LLM
Grounded Response

Instead of relying solely on the LLM’s training data, the model uses retrieved documents as grounding data.

Benefits:

  • More accurate responses
  • Reduced hallucinations
  • Access to current organizational knowledge

Common Vector Search Scenarios

Enterprise Knowledge Search

Users ask natural language questions.

Example:

“How do I reset my VPN password?”

The database retrieves the most semantically relevant documentation.


Customer Support

Support engineers search:

“Printer won’t connect.”

Relevant troubleshooting documents are retrieved even if they use different wording.


Product Recommendation

Customers searching for:

“Comfortable running shoes”

may receive products described as:

  • Lightweight trainers
  • Cushioned athletic footwear
  • Marathon shoes

Legal Document Search

Law firms search by legal concepts rather than exact wording.


Healthcare Knowledge Bases

Clinicians retrieve similar cases based on symptoms rather than identical terminology.


Performance Considerations

Database developers should evaluate:

Search Latency

Users expect responses within milliseconds.

ANN indexes dramatically reduce latency.


Recall

Recall measures how many of the true nearest neighbors are returned.

Higher recall generally improves RAG quality.


Index Size

Larger indexes often improve retrieval quality but require more memory.


Memory Consumption

HNSW indexes typically consume more RAM than compressed indexes.


Index Build Time

Large vector indexes may require significant time to build.

Plan for maintenance windows when rebuilding indexes.


Update Frequency

Applications with frequent inserts and deletes should use index types that efficiently support incremental updates.


Common Implementation Mistakes

Using Different Embedding Models

Documents embedded with one model should not be searched using vectors generated by a different model.


Using the Wrong Similarity Metric

Many embedding models assume cosine similarity.

Using Euclidean distance or dot product incorrectly may reduce search accuracy.


Not Creating a Vector Index

Searching without an index performs poorly on large datasets.


Ignoring Metadata

Metadata filtering significantly improves result quality.


Returning Too Many Documents

Retrieving excessive documents increases latency and may overwhelm downstream LLMs in RAG systems.


Best Practices

  • Use the same embedding model for indexing and querying.
  • Choose a similarity metric recommended for the embedding model.
  • Use ANN indexes for production environments.
  • Combine vector search with metadata filters when appropriate.
  • Consider hybrid search for the highest-quality results.
  • Benchmark recall, latency, and throughput using realistic workloads.
  • Monitor index growth and rebuild or optimize indexes when necessary.
  • Store both embeddings and the original source content.

DP-800 Exam Tips

Remember these key points for the exam:

  • Vector search retrieves data based on semantic similarity rather than exact text.
  • Embeddings are numerical representations generated by AI models.
  • The same embedding model should be used for both indexing and querying.
  • Vector indexes improve search performance by reducing the number of vector comparisons.
  • Approximate Nearest Neighbor (ANN) indexes provide fast searches with high recall.
  • Cosine similarity is the most commonly used metric for semantic search.
  • Hybrid search combines keyword search with vector search to improve relevance.
  • Vector search is a core component of Retrieval-Augmented Generation (RAG).

Practice Exam Questions

Question 1

A company is building a chatbot that answers employee questions using internal policy documents. The solution converts both documents and user queries into embeddings before searching for relevant information.

What is the primary purpose of generating embeddings?

A. To compress documents for storage

B. To represent text numerically so semantic similarity can be measured

C. To encrypt sensitive information

D. To improve SQL transaction performance

Answer: B

Explanation:
Embeddings convert text into high-dimensional numerical vectors that capture semantic meaning. These vectors enable similarity comparisons that go beyond exact keyword matching.


Question 2

A developer plans to implement vector search against a database containing 30 million document embeddings.

Which approach provides the best balance between scalability and query performance?

A. Sequentially compare every vector

B. Use a clustered index

C. Use an Approximate Nearest Neighbor (ANN) vector index

D. Create additional foreign keys

Answer: C

Explanation:
ANN indexes are specifically designed to support efficient vector similarity searches across very large datasets while maintaining high recall and low latency.


Question 3

A user searches for:

“Affordable cloud storage”

The returned documents discuss:

  • Cost-effective cloud backup
  • Low-cost online storage
  • Budget-friendly data storage

Why were these documents returned?

A. SQL wildcard matching

B. Lexical keyword matching

C. Primary key lookup

D. Semantic similarity using vector search

Answer: D

Explanation:
Vector search retrieves content based on semantic meaning rather than identical words, enabling related concepts and synonyms to be found.


Question 4

Which statement best describes hybrid search?

A. It combines vector search with keyword or full-text search.

B. It stores vectors in multiple databases.

C. It replaces embeddings with SQL indexes.

D. It searches only relational columns.

Answer: A

Explanation:
Hybrid search combines traditional lexical search with semantic vector search, often producing more relevant and comprehensive search results.


Question 5

Why should the same embedding model be used for both document indexing and query generation?

A. It reduces storage costs.

B. It eliminates the need for vector indexes.

C. It ensures vectors exist in the same semantic space for meaningful comparisons.

D. It automatically creates SQL indexes.

Answer: C

Explanation:
Embeddings generated by different models may occupy different vector spaces, making similarity calculations unreliable and reducing retrieval quality.


Question 6

What is the primary function of a vector index?

A. Encrypt embedding vectors

B. Reduce the number of vector comparisons during searches

C. Compress relational tables

D. Replace SQL indexes

Answer: B

Explanation:
Vector indexes organize embeddings so the search engine evaluates only the most promising candidates instead of comparing every stored vector.


Question 7

A Retrieval-Augmented Generation (RAG) application performs vector search before sending retrieved documents to a large language model.

Why is this retrieval step important?

A. It reduces SQL storage requirements.

B. It converts SQL tables into vectors.

C. It grounds the model with relevant information, improving response accuracy.

D. It eliminates the need for embeddings.

Answer: C

Explanation:
RAG retrieves relevant documents that provide context to the LLM, helping produce accurate, current, and evidence-based responses while reducing hallucinations.


Question 8

Which SQL capability is most commonly combined with vector search to narrow search results to specific business data?

A. Metadata filtering using WHERE clauses

B. ALTER TABLE statements

C. Transaction logging

D. Foreign key constraints

Answer: A

Explanation:
Combining vector search with structured SQL filters allows applications to restrict results by attributes such as department, region, or document type while maintaining semantic relevance.


Question 9

A developer performs vector similarity searches without creating a vector index.

What is the most likely consequence?

A. Embeddings become corrupted.

B. Query performance decreases significantly as the dataset grows.

C. SQL transactions stop working.

D. Documents cannot be embedded.

Answer: B

Explanation:
Without a vector index, the system typically performs an exhaustive comparison against every stored vector, resulting in much slower query performance on large datasets.


Question 10

Which statement best summarizes the role of vector search in AI-enabled database applications?

A. It replaces relational databases.

B. It removes the need for SQL queries.

C. It automatically generates embeddings.

D. It enables retrieval of information based on semantic meaning instead of exact text matching.

Answer: D

Explanation:
Vector search is designed to retrieve semantically similar information by comparing embedding vectors, making it a foundational capability for intelligent search, recommendation systems, and RAG-based applications.


Go to the DP-800 Exam Prep Hub main page

Implement hybrid search (DP-800 Exam Prep)

This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Implement AI capabilities in database solutions (25–30%)
   --> Design and implement intelligent search
      --> Implement hybrid search


Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

Hybrid search is a core capability for modern AI-enabled database solutions because it combines the strengths of traditional keyword search and vector (semantic) search. By leveraging both lexical and semantic matching techniques, hybrid search delivers more accurate, relevant, and context-aware search results than either approach alone. Hybrid search is widely used in Retrieval-Augmented Generation (RAG) applications, enterprise knowledge bases, AI assistants, recommendation systems, and intelligent search platforms.


What Is Hybrid Search?

Hybrid search combines multiple search techniques into a single query, typically including:

  • Keyword search
  • Full-text search
  • Vector (semantic) search

Instead of relying on only one search method, hybrid search retrieves candidates from multiple search engines and combines the results using a ranking algorithm.

For example, consider a user searching for:

“How do I reduce Azure storage costs?”

A keyword search might find documents containing the exact terms:

  • Azure
  • Storage
  • Costs

A vector search might retrieve documents discussing:

  • Lower cloud expenses
  • Optimize storage spending
  • Reduce infrastructure costs

Hybrid search combines both result sets and ranks the most relevant documents at the top.


Why Hybrid Search Is Important

Neither keyword search nor vector search is perfect by itself.

Keyword Search Strengths

Keyword search excels at finding:

  • Exact product names
  • Error codes
  • File names
  • Database object names
  • Technical terminology

Example:

SQL72014

A keyword search finds documents containing that exact error code.


Keyword Search Weaknesses

Keyword search struggles with:

  • Synonyms
  • Different wording
  • Natural language
  • Conceptual relationships

Example:

Search:

“Vacation policy”

Document:

“Paid time off guidelines”

Although both describe the same concept, keyword search may not find the document.


Vector Search Strengths

Vector search understands meaning.

Example:

Search:

“Improve application speed”

Documents discussing:

  • Performance optimization
  • Query tuning
  • Faster database execution

can all be returned because their embeddings are semantically similar.


Vector Search Weaknesses

Vector search may struggle with:

  • Product IDs
  • Version numbers
  • Error codes
  • Exact names
  • Highly specialized terminology

Example:

Searching for:

SQL71561

works better with keyword search.


Hybrid Search Combines Both Approaches

User Query
Keyword Search
+
Vector Search
Combined Results
Ranking
Top Results

This allows users to benefit from both lexical precision and semantic understanding.


How Hybrid Search Works

A hybrid search implementation generally follows these steps.

Step 1. User Submits a Query

Example:

“How do I configure Azure SQL backups?”


Step 2. Keyword Search Executes

The database searches for:

  • Azure
  • SQL
  • Backups
  • Configure

using:

  • Full-text indexes
  • SQL predicates
  • Traditional search indexes

Step 3. Vector Search Executes

The same query is converted into an embedding.

Query
Embedding Model
Vector

The vector is compared against stored document embeddings.


Step 4. Merge Results

Suppose keyword search returns:

DocumentScore
Backup Overview95
SQL Backup Guide90

Vector search returns:

DocumentScore
Disaster Recovery93
Data Protection88

The system merges these candidate sets.


Step 5. Rank Results

The ranking engine evaluates:

  • Keyword relevance
  • Semantic similarity
  • Metadata
  • Popularity
  • Freshness
  • Business rules

The highest-ranking documents are returned.


Components of a Hybrid Search Solution

Source Documents

Examples include:

  • PDFs
  • Product documentation
  • Knowledge articles
  • Support tickets
  • Policies
  • Emails
  • SQL records

Full-Text Index

Supports traditional keyword searching.

Optimized for:

  • Exact phrases
  • Words
  • Wildcards
  • Boolean searches

Embedding Model

Generates vector representations for documents and queries.

Examples:

  • Azure OpenAI Embeddings
  • OpenAI embedding models
  • Sentence Transformers

The same embedding model should be used during indexing and querying.


Vector Index

Stores embeddings for efficient semantic search.

Examples:

  • HNSW
  • IVF
  • Flat index
  • Product Quantization (PQ)

Ranking Engine

Combines multiple signals into a single relevance score.


Search Pipeline

User Query
Keyword Search
\
\
Ranking Engine
/
/
Vector Search
Combined Results

Both searches occur independently before the results are combined.


Ranking in Hybrid Search

Hybrid search is more than simply combining two result lists.

Each result receives a relevance score based on multiple factors.

Typical ranking signals include:

  • Keyword score
  • Vector similarity score
  • Document freshness
  • Popularity
  • User permissions
  • Metadata
  • Business importance

The ranking algorithm determines the final ordering.


Metadata Filtering

Hybrid search often includes structured SQL filters.

Example:

WHERE Department = 'Finance'

or

WHERE DocumentType = 'Policy'

The search becomes:

Keyword Search
+
Vector Search
+
Metadata Filters
Ranking

Filtering improves both relevance and performance.


Hybrid Search in RAG

Hybrid search is commonly used in Retrieval-Augmented Generation.

Workflow:

User Question
Hybrid Search
Relevant Documents
Large Language Model
Grounded Response

Benefits include:

  • Higher-quality context
  • Reduced hallucinations
  • More complete retrieval
  • Better factual accuracy

Example Scenario

Suppose an employee asks:

“How do I access my benefits after changing jobs?”

Keyword search retrieves:

  • Benefits
  • Jobs

Vector search retrieves:

  • Employee transition
  • HR onboarding
  • Employment status changes

Hybrid search combines both sets, increasing the likelihood of returning the most relevant documents.


Hybrid Search vs Keyword Search

FeatureKeyword SearchHybrid Search
Exact termsExcellentExcellent
SynonymsPoorExcellent
Natural languageLimitedExcellent
Error codesExcellentExcellent
Semantic understandingNoneExcellent
AI applicationsLimitedExcellent

Hybrid Search vs Vector Search

FeatureVector SearchHybrid Search
Semantic understandingExcellentExcellent
Exact identifiersModerateExcellent
Error codesModerateExcellent
Product namesModerateExcellent
Natural languageExcellentExcellent
Overall relevanceHighVery High

Benefits of Hybrid Search

Better Relevance

Combines multiple search signals.


Handles Synonyms

Users don’t need exact wording.


Supports Technical Queries

Keyword search finds:

  • Error codes
  • File names
  • Product names

Supports Natural Language

Vector search understands concepts.


Improved User Satisfaction

Users receive better search results.


Better RAG Responses

The LLM receives more relevant context.


Challenges

Increased Complexity

Two search systems must be maintained.


Higher Resource Usage

Both keyword and vector searches execute.


Ranking Tuning

Determining the correct weighting between keyword and semantic scores may require experimentation.


Embedding Maintenance

Embeddings should be regenerated when source content changes significantly or when migrating to a new embedding model.


Common Hybrid Search Scenarios

Enterprise Knowledge Bases

Employees search documentation using natural language.


Customer Support

Support agents retrieve troubleshooting articles using both error codes and descriptive questions.


Product Catalogs

Customers search using product names, descriptions, or intent.


Healthcare

Clinicians search using symptoms while also matching standardized medical terminology.


Legal Research

Lawyers search using statutes, case numbers, and legal concepts.


Financial Services

Analysts search reports using account identifiers and descriptive business questions.


Best Practices

  • Combine full-text and vector search for production AI applications.
  • Use the same embedding model during indexing and querying.
  • Create appropriate full-text and vector indexes.
  • Apply metadata filters whenever possible.
  • Tune ranking weights using representative user queries.
  • Evaluate both precision and recall during testing.
  • Continuously monitor search quality and user feedback.
  • Refresh embeddings when source documents change significantly.
  • Secure search results using role-based access controls and document permissions.

DP-800 Exam Tips

Remember these key points for the exam:

  • Hybrid search combines traditional keyword search with vector search.
  • Keyword search excels at exact terms, identifiers, and technical strings.
  • Vector search excels at semantic meaning and natural language.
  • Hybrid search generally provides better relevance than either approach alone.
  • Ranking combines multiple signals, including lexical relevance, semantic similarity, and metadata.
  • Metadata filtering improves both performance and result quality.
  • Hybrid search is commonly used in Retrieval-Augmented Generation (RAG) systems.
  • The same embedding model should be used for both indexing and querying to ensure meaningful vector comparisons.

Practice Exam Questions

Question 1

A company is building an AI-powered knowledge base that must support searches for both exact error codes and natural language questions.

Which search approach is most appropriate?

A. Hybrid search

B. Keyword search only

C. Vector search only

D. Relational indexing only

Answer: A

Explanation:
Hybrid search combines keyword and vector search, enabling both exact matching for error codes and semantic matching for natural language queries.


Question 2

A user searches for:

“Improve database response time”

The system returns documents discussing query tuning, indexing strategies, and SQL optimization, even though those exact words were not used.

Which component enabled this behavior?

A. Full-text search

B. Vector search

C. Clustered indexes

D. Foreign key constraints

Answer: B

Explanation:
Vector search compares embeddings that capture semantic meaning, allowing conceptually related documents to be retrieved even when different wording is used.


Question 3

What is the primary purpose of the ranking engine in a hybrid search solution?

A. Generate document embeddings

B. Create vector indexes

C. Combine and order results from multiple search methods

D. Encrypt search results

Answer: C

Explanation:
The ranking engine merges results from keyword and vector searches and orders them using relevance signals such as lexical score, semantic similarity, freshness, and metadata.


Question 4

Which type of query is generally handled most effectively by keyword search?

A. “How can I reduce cloud expenses?”

B. “Best practices for disaster recovery”

C. “Ways to improve SQL performance”

D. “SQL71561”

Answer: D

Explanation:
Exact identifiers such as error codes, product names, and version numbers are best handled using keyword or full-text search.


Question 5

Why is hybrid search commonly used in Retrieval-Augmented Generation (RAG) applications?

A. It eliminates the need for embeddings.

B. It improves retrieval quality by combining lexical and semantic matching.

C. It replaces large language models.

D. It removes the need for vector indexes.

Answer: B

Explanation:
Hybrid search retrieves more comprehensive and relevant information than either keyword or vector search alone, providing higher-quality context to the LLM.


Question 6

A search solution first performs keyword search, then vector similarity search, and finally combines both result sets.

Which step typically follows next?

A. Delete duplicate documents from the database.

B. Recreate all vector indexes.

C. Rank the combined results using relevance signals.

D. Generate new embeddings for every document.

Answer: C

Explanation:
After gathering candidate documents, the ranking engine evaluates multiple relevance signals to determine the final ordering presented to the user.


Question 7

Which statement best describes metadata filtering in hybrid search?

A. It replaces vector search.

B. It restricts search results using structured attributes such as department or document type.

C. It converts SQL tables into embeddings.

D. It automatically updates document embeddings.

Answer: B

Explanation:
Metadata filters narrow the search scope using structured data while still allowing semantic and keyword search within the filtered dataset.


Question 8

A developer configures hybrid search using one embedding model for indexing documents and a different embedding model for processing user queries.

What is the most likely result?

A. Improved semantic accuracy.

B. Reduced index size.

C. Faster query execution.

D. Lower-quality semantic matches because vectors occupy different embedding spaces.

Answer: D

Explanation:
Embeddings produced by different models are generally not directly comparable, leading to poorer semantic similarity calculations and less relevant search results.


Question 9

Which advantage does hybrid search have over vector search alone?

A. It supports exact matching for identifiers while preserving semantic search capabilities.

B. It eliminates the need for full-text indexes.

C. It guarantees mathematically perfect search results.

D. It removes the need for metadata.

Answer: A

Explanation:
Hybrid search enhances vector search by adding lexical matching, making it more effective for exact terms such as product names, file names, and error codes.


Question 10

Which best practice should a database developer follow when implementing hybrid search?

A. Use different embedding models for documents and queries.

B. Disable metadata filtering to improve semantic search.

C. Combine full-text search, vector search, and structured filtering to improve relevance.

D. Use exhaustive vector search for every production workload regardless of size.

Answer: C

Explanation:
A well-designed hybrid search solution combines lexical search, semantic search, and structured metadata filtering to maximize relevance, scalability, and user satisfaction in AI-enabled database applications.


Go to the DP-800 Exam Prep Hub main page

Implement reciprocal rank fusion (RRF) (DP-800 Exam Prep)

This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Implement AI capabilities in database solutions (25–30%)
   --> Design and implement intelligent search
      --> Implement reciprocal rank fusion (RRF)


Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

Reciprocal Rank Fusion (RRF) is an important ranking technique used in modern hybrid search systems. It enables AI-enabled database solutions to combine results from multiple search algorithms—such as full-text search and vector search—into a single ranked result set. RRF is widely used in Retrieval-Augmented Generation (RAG), enterprise search, Azure AI Search, recommendation systems, and intelligent database applications because it consistently produces high-quality search results without requiring complex score normalization.


What Is Reciprocal Rank Fusion (RRF)?

Reciprocal Rank Fusion (RRF) is a rank aggregation algorithm that combines multiple independently ranked result lists into one unified ranking.

Instead of comparing the actual relevance scores produced by different search algorithms, RRF considers only the position (rank) of each document within each result list.

This makes RRF particularly effective when combining search methods that produce different types of scores.

For example:

  • Full-text search may produce BM25 relevance scores.
  • Vector search may produce cosine similarity scores.
  • Semantic rerankers may produce AI-generated relevance scores.

Because these scoring systems are different and often not directly comparable, RRF combines rankings instead of raw scores.


Why Is RRF Needed?

Modern AI search systems often execute multiple searches simultaneously.

Example:

User query:

“How do I secure Azure SQL backups?”

The search system performs:

  • Full-text search
  • Vector search
  • Metadata filtering
  • Optional semantic reranking

Each search returns different documents with different scoring methods.

Without RRF, combining these results would be difficult because:

  • BM25 scores are not directly comparable to cosine similarity scores.
  • Different algorithms have different score ranges.
  • Some algorithms produce probabilities.
  • Others produce similarity values.

RRF eliminates this problem by using document rankings instead of score values.


Traditional Score Combination Problems

Suppose two searches return:

Keyword Search

RankDocumentBM25 Score
1Doc A98
2Doc B91
3Doc C88

Vector Search

RankDocumentCosine Similarity
1Doc C0.95
2Doc D0.94
3Doc A0.92

Notice:

  • BM25 scores range around 90–100.
  • Cosine similarity ranges between approximately -1 and 1 (typically 0–1 for normalized embeddings).

Adding these scores directly would not produce meaningful results.


How RRF Works

RRF ignores the raw scores.

Instead, it assigns each document a score based on its ranking position.

Conceptually:

RRF Score = Σ 1 / (k + rank)

Where:

  • rank = the document’s position in each result list.
  • k = a constant (commonly 60) that reduces the impact of very high rankings and smooths the score distribution.

The exact value of k is implementation-specific, but many search platforms—including Azure AI Search—use a default value of 60.

The important DP-800 exam concept is that RRF combines rankings rather than raw relevance scores.


Example of RRF

Suppose two searches return:

Keyword Search

RankDocument
1A
2B
3C

Vector Search

RankDocument
1C
2A
3D

RRF rewards documents appearing in both lists.

Document A:

  • Rank 1 in keyword search
  • Rank 2 in vector search

Document C:

  • Rank 3 in keyword search
  • Rank 1 in vector search

Both receive relatively high RRF scores because they rank well in multiple searches.

Documents appearing in only one list receive lower combined scores.


RRF Search Pipeline

User Query
Keyword Search
\
\
\
RRF
/
/
Vector Search
Combined Ranked Results

Each search executes independently.

RRF merges the rankings.


Why Ranking Is Better Than Combining Scores

Consider two scoring systems.

Keyword search:

95
82
79

Vector search:

0.97
0.94
0.92

These values represent different measurements.

Instead of trying to normalize them, RRF simply uses:

Rank 1
Rank 2
Rank 3

This approach is:

  • Simpler
  • More stable
  • More reliable
  • Independent of score scales

RRF in Hybrid Search

Hybrid search commonly executes:

  • Keyword search
  • Full-text search
  • Vector search

Each produces candidate documents.

RRF combines them into one ranked list.

Example:

Keyword Results
RRF
Vector Results
Final Results

This is one of the most common implementations in enterprise AI search systems.


RRF in Retrieval-Augmented Generation (RAG)

RAG applications depend on retrieving the most relevant documents.

Workflow:

User Question
Hybrid Search
RRF Ranking
Top Documents
Large Language Model
Grounded Response

Benefits include:

  • Better retrieval quality
  • Better grounding
  • More complete context
  • Reduced hallucinations

Advantages of RRF

Simple

No complex score normalization is required.


Algorithm Independent

Works with:

  • BM25
  • Vector similarity
  • AI ranking
  • Other retrieval algorithms

Better Retrieval Quality

Documents consistently ranked highly across multiple search methods naturally rise to the top.


Robust

Minor score differences between search algorithms do not significantly affect results.


Easy to Scale

Additional search algorithms can be incorporated into the fusion process without redesigning the ranking approach.


Example Enterprise Scenario

Suppose an employee searches:

“Configure disaster recovery”

Keyword search returns:

  • Disaster Recovery Guide
  • Backup Documentation

Vector search returns:

  • Business Continuity Planning
  • Disaster Recovery Guide
  • Failover Procedures

RRF recognizes that Disaster Recovery Guide appears near the top of both lists and promotes it in the final ranking.


RRF Compared to Score Averaging

Score Averaging

Requires:

  • Score normalization
  • Matching score scales
  • Additional tuning

Problems:

  • Different algorithms use different scoring methods.
  • Difficult to compare heterogeneous scores.

Reciprocal Rank Fusion

Uses:

  • Ranking positions only

Benefits:

  • Simpler
  • More reliable
  • Independent of scoring scales
  • Common in production AI search systems

RRF Compared to Semantic Reranking

These concepts are related but different.

Reciprocal Rank FusionSemantic Reranking
Combines multiple ranked listsReorders documents using an AI model
Uses document positionsUses semantic understanding
Doesn’t read document contentEvaluates document meaning
Runs before semantic reranking in many architecturesOften runs after candidate retrieval

Many enterprise AI search solutions use both techniques:

  1. Keyword search
  2. Vector search
  3. RRF
  4. Semantic reranking
  5. Return results

RRF in AI-Enabled Database Solutions

Modern AI-enabled SQL solutions increasingly combine:

  • SQL filtering
  • Full-text search
  • Vector search
  • Hybrid search
  • RRF
  • Retrieval-Augmented Generation

These capabilities enable intelligent applications to retrieve highly relevant information while leveraging existing relational database technologies.


Performance Considerations

Multiple Searches

Hybrid search requires multiple searches to execute.

This increases computational work compared to using only one search method.


Improved Relevance

The additional processing typically results in significantly better retrieval quality.


Candidate List Size

Most systems apply RRF to the top-ranked candidates from each search rather than the entire dataset.


Low Computational Overhead

RRF calculations are lightweight because they operate on rankings instead of comparing vector values or processing document contents.


Best Practices

  • Use RRF when combining keyword and vector search results.
  • Avoid directly comparing raw scores from different retrieval algorithms.
  • Retrieve an appropriate number of candidate documents from each search before applying RRF.
  • Combine RRF with metadata filtering when appropriate.
  • Use semantic reranking after RRF if supported by the platform.
  • Evaluate retrieval quality using representative business queries.
  • Monitor precision and recall when tuning hybrid search solutions.

DP-800 Exam Tips

Remember these key points for the exam:

  • Reciprocal Rank Fusion (RRF) combines ranked search results, not raw relevance scores.
  • RRF is commonly used in hybrid search systems.
  • RRF works well because keyword search scores and vector similarity scores are not directly comparable.
  • Documents ranked highly by multiple search algorithms receive higher final rankings.
  • RRF is lightweight, scalable, and independent of the underlying retrieval algorithms.
  • RRF is frequently used in Retrieval-Augmented Generation (RAG) to improve document retrieval before passing context to an LLM.
  • Semantic reranking and RRF are complementary techniques; RRF typically merges candidate lists before optional semantic reranking.

Practice Exam Questions

Question 1

A developer is combining results from a keyword search and a vector similarity search. The two searches produce different scoring scales.

Which ranking technique is specifically designed to combine these results without comparing the raw scores?

A. Reciprocal Rank Fusion (RRF)

B. Euclidean Distance

C. Product Quantization

D. HNSW

Answer: A

Explanation:
RRF combines ranked result lists instead of raw relevance scores, making it ideal for merging results from search algorithms that use different scoring methods.


Question 2

What information does Reciprocal Rank Fusion primarily use when calculating a document’s combined relevance?

A. The document’s embedding values

B. The raw BM25 score

C. The document’s position (rank) in each result list

D. The number of words in the document

Answer: C

Explanation:
RRF uses the ranking position of documents in each search result list rather than their raw scores, allowing it to combine heterogeneous search results effectively.


Question 3

Why is RRF commonly used in hybrid search?

A. It generates embeddings automatically.

B. It combines keyword and vector search results using document rankings.

C. It replaces vector indexes.

D. It eliminates full-text search.

Answer: B

Explanation:
Hybrid search often combines keyword and vector searches. RRF merges the ranked results without requiring score normalization.


Question 4

A document appears near the top of both keyword search and vector search results.

How will RRF typically treat this document?

A. It will remove it as a duplicate.

B. It will assign it a lower ranking because it appears twice.

C. It will ignore the vector search ranking.

D. It will rank the document higher in the final results.

Answer: D

Explanation:
Documents that consistently rank highly across multiple search methods receive higher combined RRF scores and are promoted in the final ranking.


Question 5

Which challenge does RRF help solve?

A. Encrypting document embeddings

B. Creating vector indexes

C. Combining search algorithms that produce different relevance score scales

D. Compressing embedding vectors

Answer: C

Explanation:
Because keyword search, vector search, and semantic search often use different scoring systems, RRF combines rankings instead of attempting to compare incompatible scores.


Question 6

Which statement best describes Reciprocal Rank Fusion?

A. It performs semantic reranking by analyzing document content.

B. It combines ranked search results from multiple retrieval methods.

C. It generates vector embeddings.

D. It creates Approximate Nearest Neighbor indexes.

Answer: B

Explanation:
RRF is a rank aggregation algorithm that merges multiple ranked lists into a single ordered result set.


Question 7

In a Retrieval-Augmented Generation (RAG) solution, where is RRF typically applied?

A. After the large language model generates its response

B. Before document retrieval begins

C. During the combination of candidate search results before providing context to the LLM

D. During embedding generation

Answer: C

Explanation:
RRF is used after multiple retrieval methods return candidate documents and before the final context is passed to the LLM.


Question 8

Which statement accurately compares RRF and semantic reranking?

A. They perform the same function.

B. RRF replaces semantic reranking.

C. Semantic reranking combines ranked lists using reciprocal values.

D. RRF merges ranked results, while semantic reranking uses AI to evaluate document meaning.

Answer: D

Explanation:
RRF aggregates ranked lists from multiple search methods, whereas semantic reranking analyzes document content and query meaning to reorder results.


Question 9

What is a key advantage of using RRF instead of averaging raw search scores?

A. It requires complex score normalization.

B. It is independent of the underlying scoring scales used by different search algorithms.

C. It eliminates the need for vector search.

D. It always returns mathematically exact nearest neighbors.

Answer: B

Explanation:
RRF avoids the complexities of comparing different scoring systems by relying solely on ranking positions.


Question 10

A database developer is implementing hybrid search in an AI-enabled SQL solution.

Which sequence best reflects a common enterprise retrieval pipeline?

A. Generate embeddings → LLM → Vector search → Keyword search

B. Semantic reranking → Embedding generation → Keyword search

C. Keyword search → Vector search → Reciprocal Rank Fusion → Optional semantic reranking → Return results

D. Product Quantization → SQL backup → Semantic reranking

Answer: C

Explanation:
A common enterprise hybrid search workflow retrieves candidate documents using keyword and vector search, combines them using RRF, optionally applies semantic reranking, and then returns the highest-quality results for use in applications such as RAG.


Go to the DP-800 Exam Prep Hub main page

Evaluate performance of vector and hybrid search (DP-800 Exam Prep)

This post is a part of the DP-800: Developing AI-Enabled Database Solutions Exam Prep Hub.
This topic falls under these sections:
Implement AI capabilities in database solutions (25–30%)
   --> Design and implement intelligent search
      --> Evaluate performance of vector and hybrid search


Note that there are 10 practice questions (with answers) at the end of each section to help you solidify your knowledge of the material. Also, there are 4 practice tests with 30 questions each available from the hub's main page below the exam topics section.

Introduction

Evaluating the performance of vector and hybrid search solutions is a critical responsibility when developing AI-enabled database applications. While implementing vector search is important, ensuring that the search solution consistently returns accurate, relevant, fast, and scalable results is equally essential. Database developers must understand how to measure search quality, optimize retrieval performance, balance latency with accuracy, and monitor search systems over time.

This knowledge is especially important for applications such as:

  • Retrieval-Augmented Generation (RAG)
  • Enterprise knowledge search
  • AI-powered chatbots
  • Document retrieval
  • Recommendation systems
  • Intelligent search applications

Why Performance Evaluation Matters

Unlike traditional SQL queries that typically return deterministic results, vector and hybrid search systems retrieve documents based on statistical similarity.

This means there is always a balance between:

  • Search speed
  • Search accuracy
  • Resource consumption
  • Scalability

A search system that responds instantly but returns irrelevant documents is not useful.

Likewise, a system that returns perfect results but requires several seconds per query may not satisfy user expectations.

The goal is to optimize the entire search experience.


Key Performance Metrics

Several metrics are commonly used to evaluate vector and hybrid search.

Query Latency

Latency measures how long a search takes to return results.

Example:

User Query
120 ms
Results Returned

Lower latency improves user experience.

Typical enterprise AI search systems aim for response times measured in milliseconds.

Factors affecting latency include:

  • Index type
  • Dataset size
  • Hardware resources
  • Number of search algorithms executed
  • Network latency
  • Number of retrieved documents

Throughput

Throughput measures the number of search requests a system can process within a given time.

Examples:

  • Searches per second
  • Queries per minute

Higher throughput enables more concurrent users.

Throughput depends on:

  • CPU
  • Memory
  • Index efficiency
  • Parallel processing
  • Database architecture

Recall

Recall measures how many relevant documents are successfully retrieved.

Example:

Relevant documents:

A
B
C
D
E

Returned documents:

A
B
C
X
Y

Recall:

3 / 5 = 60%

Higher recall generally improves RAG quality because more relevant information is available to the large language model.


Precision

Precision measures how many returned documents are actually relevant.

Example:

Returned:

A
B
C
X
Y

Relevant:

A
B
C

Precision:

3 / 5 = 60%

High precision reduces irrelevant search results.


F1 Score

The F1 Score combines precision and recall into a single metric.

It is especially useful when both false positives and false negatives matter.

Higher F1 scores indicate a better overall balance between retrieving relevant documents and avoiding irrelevant ones.


Mean Reciprocal Rank (MRR)

MRR measures how highly the first relevant result appears in the ranked list.

Example:

Relevant document positions:

QueryFirst Relevant Result
Query 1Rank 1
Query 2Rank 2
Query 3Rank 4

Higher MRR indicates users find relevant information more quickly.

MRR is commonly used when evaluating question-answering systems and RAG applications.


Normalized Discounted Cumulative Gain (NDCG)

NDCG measures:

  • Ranking quality
  • Position of relevant documents
  • Graded relevance

Unlike recall, NDCG rewards placing the most relevant documents near the top.

This is especially important because users rarely read beyond the first few search results.


Evaluating Vector Search

When evaluating vector search, developers typically measure:

  • Recall
  • Precision
  • Latency
  • Index build time
  • Memory usage
  • Storage requirements

Index Performance

Questions include:

  • How quickly are searches completed?
  • How much memory does the index require?
  • How long does index creation take?
  • How efficiently are inserts handled?

Search Quality

Evaluate:

  • Are similar documents retrieved?
  • Are unrelated documents excluded?
  • Are synonyms recognized?
  • Does semantic similarity match user expectations?

Evaluating Hybrid Search

Hybrid search combines:

  • Full-text search
  • Vector search
  • Metadata filtering
  • Ranking algorithms such as Reciprocal Rank Fusion (RRF)
  • Optional semantic reranking

Because more components participate, additional evaluation is necessary.


Ranking Quality

Developers evaluate whether:

  • Exact matches appear near the top.
  • Semantically relevant documents are included.
  • Duplicate results are minimized.
  • Ranking is consistent.

Hybrid Relevance

Example query:

“Reduce Azure costs”

Good hybrid results may include:

  • Azure cost optimization
  • Cloud spending reduction
  • Budget management
  • Reserved capacity guidance

Poor hybrid results may include unrelated Azure topics.


Measuring Retrieval Quality

Many organizations create benchmark datasets.

Example:

Question:

“How do I configure VPN access?”

Expected documents:

  • VPN Setup Guide
  • Remote Access Policy
  • Authentication Configuration

The search system is evaluated based on whether these expected documents appear in the returned results.


Human Evaluation

Automated metrics cannot evaluate every aspect of search quality.

Organizations often perform manual reviews.

Experts examine:

  • Relevance
  • Completeness
  • Ranking quality
  • Consistency

Human evaluation is particularly valuable for RAG applications.


Offline Evaluation

Offline testing uses historical datasets.

Advantages:

  • Repeatable
  • Safe
  • Fast
  • No production impact

Developers compare:

  • Multiple embedding models
  • Index types
  • Similarity metrics
  • Ranking algorithms

Online Evaluation

Online evaluation uses live users.

Common techniques include:

A/B Testing

Group A:

Current search system

Group B:

New search implementation

Metrics compared include:

  • Click-through rate
  • User satisfaction
  • Search success
  • Session completion

User Feedback

Collect feedback such as:

  • Helpful
  • Not Helpful

User feedback helps improve future search tuning.


Factors Affecting Vector Search Performance

Embedding Quality

Poor embeddings reduce retrieval quality regardless of index performance.

Always choose embedding models appropriate for the domain.


Similarity Metric

Common choices:

  • Cosine similarity
  • Dot product
  • Euclidean distance

Using the wrong metric can reduce search accuracy.


Vector Index Type

Different index types provide different tradeoffs.

IndexSpeedRecallMemory
FlatSlowHighestModerate
HNSWVery FastVery HighHigh
IVFFastHighModerate
IVF + PQVery FastModerate-HighLow

Candidate Set Size

Returning more candidate documents often increases recall.

However:

  • Latency increases.
  • More data must be reranked.
  • LLM token usage increases in RAG.

Balance is important.


Metadata Filtering

Filtering improves:

  • Precision
  • Latency

Example:

WHERE Department = 'Finance'

Searching fewer documents reduces processing time while improving relevance.


Evaluating Hybrid Search Components

Keyword Search

Evaluate:

  • Exact matches
  • Phrase matching
  • Synonym handling
  • Technical terminology

Vector Search

Evaluate:

  • Semantic understanding
  • Related concepts
  • Context awareness

Reciprocal Rank Fusion (RRF)

Evaluate:

  • Ranking consistency
  • Combined relevance
  • Candidate diversity

Semantic Reranking

Evaluate:

  • Final ranking quality
  • User satisfaction
  • Response accuracy

Common Performance Bottlenecks

Missing Vector Index

Searching every embedding significantly increases latency.


Poor Embeddings

Weak embeddings reduce semantic quality.


Excessive Candidate Retrieval

Retrieving hundreds of documents unnecessarily increases reranking and LLM processing time.


Large Embedding Dimensions

Higher-dimensional embeddings require:

  • More storage
  • More memory
  • More computation

Frequent Index Rebuilds

Rebuilding indexes too frequently can consume unnecessary resources.

Use incremental updates where supported.


Optimization Techniques

Choose the Correct Index

Examples:

  • Small datasets → Flat
  • Medium datasets → HNSW
  • Very large datasets → IVF or IVF + PQ

Tune Candidate Count

Retrieve only the number of documents needed.


Use Metadata Filters

Reduce unnecessary searches.


Optimize Embeddings

Select high-quality embedding models.


Use Hybrid Search

Combining lexical and semantic search generally improves relevance.


Apply Semantic Reranking

Use reranking on a limited candidate set to improve final result quality.


Performance Monitoring

Production systems should monitor:

  • Average latency
  • Peak latency
  • Recall
  • Precision
  • Throughput
  • Memory usage
  • Index size
  • Search failures
  • User satisfaction
  • Search abandonment rate

Monitoring enables proactive tuning as data volumes and usage patterns evolve.


Best Practices

  • Benchmark search quality before deployment.
  • Measure both latency and retrieval quality.
  • Use benchmark datasets with known expected results.
  • Combine automated metrics with human evaluation.
  • Tune candidate retrieval size based on workload.
  • Select the appropriate vector index for dataset size.
  • Monitor production search metrics continuously.
  • Refresh embeddings when source data changes significantly.
  • Evaluate hybrid search using realistic business queries.
  • Test changes in a staging environment before production deployment.

DP-800 Exam Tips

Remember these key points for the exam:

  • Vector search performance should be evaluated using both speed and retrieval quality metrics.
  • Recall measures how many relevant documents are retrieved.
  • Precision measures how many returned documents are relevant.
  • MRR evaluates how quickly users encounter the first relevant result.
  • NDCG evaluates the quality of document ranking.
  • Hybrid search should be evaluated as a complete pipeline, including keyword search, vector search, RRF, and optional semantic reranking.
  • Metadata filtering improves both precision and performance.
  • Human evaluation remains important because automated metrics cannot fully measure search usefulness.
  • Production systems should continuously monitor latency, recall, throughput, and user satisfaction.

Practice Exam Questions

Question 1

A database developer is evaluating a vector search solution. Which metric measures the percentage of retrieved documents that are actually relevant?

A. Recall

B. Latency

C. Precision

D. Throughput

Answer: C

Explanation:
Precision measures the proportion of retrieved documents that are relevant. High precision indicates that the search results contain few irrelevant documents.


Question 2

A Retrieval-Augmented Generation (RAG) application consistently retrieves only three of the five relevant documents for most user queries.

Which performance metric is primarily affected?

A. Recall

B. Mean Reciprocal Rank (MRR)

C. Throughput

D. Query latency

Answer: A

Explanation:
Recall measures how many relevant documents are successfully retrieved. Missing relevant documents lowers the recall score.


Question 3

Which metric evaluates how quickly users encounter the first relevant search result?

A. F1 Score

B. Mean Reciprocal Rank (MRR)

C. Precision

D. Throughput

Answer: B

Explanation:
MRR evaluates the ranking position of the first relevant result, rewarding systems that place useful documents near the top of the results list.


Question 4

A search solution returns highly relevant documents, but users complain that responses take several seconds.

Which performance metric should the development team investigate first?

A. Index build time

B. Storage utilization

C. Embedding dimension

D. Query latency

Answer: D

Explanation:
Query latency measures the time required to return search results. High latency negatively impacts the user experience, even when retrieval quality is good.


Question 5

Which statement best describes hybrid search performance evaluation?

A. Only vector search accuracy needs to be measured.

B. Only keyword search latency matters.

C. Evaluation should include keyword search, vector search, ranking quality, and overall retrieval performance.

D. Performance is determined solely by embedding size.

Answer: C

Explanation:
Hybrid search combines multiple retrieval methods, so developers should evaluate the complete search pipeline rather than a single component.


Question 6

A developer increases the number of candidate documents retrieved before semantic reranking.

What is the most likely tradeoff?

A. Lower latency and reduced memory usage

B. Higher recall but increased latency and reranking costs

C. Reduced recall with faster indexing

D. Elimination of vector indexing requirements

Answer: B

Explanation:
Retrieving more candidate documents increases the likelihood of finding relevant information but also increases processing time, reranking effort, and LLM token usage.


Question 7

Why is human evaluation still valuable when assessing AI-powered search systems?

A. Automated metrics cannot fully measure user relevance and usefulness.

B. Human evaluation eliminates the need for benchmark datasets.

C. Human reviewers create vector indexes.

D. Human evaluation replaces latency testing.

Answer: A

Explanation:
While automated metrics quantify retrieval quality, human reviewers can assess contextual relevance, completeness, and overall usefulness from a user perspective.


Question 8

Which optimization technique can improve both search precision and query performance?

A. Increasing embedding dimensions indefinitely

B. Removing vector indexes

C. Using metadata filtering to narrow the search scope

D. Returning every matching document

Answer: C

Explanation:
Metadata filters reduce the number of candidate documents that must be searched, improving both relevance and performance.


Question 9

Which performance metric evaluates the overall quality of document ranking by giving more credit when highly relevant documents appear near the top of the results?

A. Recall

B. Precision

C. Throughput

D. Normalized Discounted Cumulative Gain (NDCG)

Answer: D

Explanation:
NDCG measures ranking quality by considering both document relevance and the position of documents in the ranked results, rewarding systems that place the most relevant items first.


Question 10

A development team wants to compare two different embedding models before deploying a new search solution.

Which evaluation approach is most appropriate?

A. Online A/B testing only

B. Disable benchmarking and rely on production feedback

C. Conduct repeatable offline testing using benchmark datasets with expected search results

D. Measure only CPU utilization

Answer: C

Explanation:
Offline benchmarking with known datasets enables developers to compare embedding models, similarity metrics, and indexing strategies safely and consistently before deploying changes to production.


Go to the DP-800 Exam Prep Hub main page