Embedding models for semantic search in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Embedding Vectors

Which statement best describes what an embedding vector represents in semantic search?

A A one-hot encoded vector indicating the presence of specific keywords

B A numeric representation capturing the meaning of text in a multi-dimensional space

C A binary vector representing the frequency of words in a document

D A sequence of characters representing the original text

💡 Hint

Think about how semantic similarity is measured between texts.

Embedding vectors convert text into numbers that capture meaning, allowing comparison by distance in space.

❓ Predict Output

intermediate

Output of Cosine Similarity Calculation

What is the output of this Python code calculating cosine similarity between two embedding vectors?

Agentic AI

import numpy as np

def cosine_similarity(vec1, vec2):
    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))

vec_a = np.array([1, 2, 3])
vec_b = np.array([4, 5, 6])
result = cosine_similarity(vec_a, vec_b)
print(round(result, 2))

A 0.77

B 0.67

C 0.97

D 0.87

💡 Hint

Recall the cosine similarity formula and calculate dot product and norms.

Cosine similarity between [1,2,3] and [4,5,6] is approximately 0.97 after rounding to two decimals.

❓ Model Choice

advanced

Choosing an Embedding Model for Semantic Search

You want to build a semantic search system for short product descriptions. Which embedding model is best suited?

A A pretrained sentence-transformer model fine-tuned on product descriptions

B A large transformer-based model trained on general web text

C A small word2vec model trained on product reviews

D A bag-of-words model with TF-IDF weighting

💡 Hint

Consider model size, training data relevance, and ability to capture sentence meaning.

Fine-tuned sentence-transformer models capture sentence-level semantics well and adapt to domain-specific data.

❓ Hyperparameter

advanced

Effect of Embedding Dimension Size

What is a likely effect of increasing the embedding vector dimension size in a semantic search model?

A Always reduces overfitting and improves generalization

B Decreases model accuracy but speeds up similarity calculations

C Has no effect on model performance or computational cost

D Improves semantic representation but increases computational cost and risk of overfitting

💡 Hint

Think about trade-offs between detail captured and resource use.

Higher dimension embeddings can capture more detail but require more computation and may overfit if data is limited.

🔧 Debug

expert

Debugging Semantic Search with Embeddings

Given this code snippet for semantic search, what error will it raise when run?

Agentic AI

import numpy as np

embeddings = {'doc1': np.array([0.1, 0.2]), 'doc2': np.array([0.3, 0.4])}
query = np.array([0.1, 0.2, 0.3])

scores = {doc: np.dot(vec, query) for doc, vec in embeddings.items()}
print(scores)

A ValueError due to mismatched vector sizes in np.dot

B KeyError because 'query' is not in embeddings

C TypeError because np.dot expects lists, not arrays

D No error; prints similarity scores

💡 Hint

Check the shapes of vectors used in dot product.

np.dot requires vectors of the same size; here query has 3 elements but embeddings have 2, causing ValueError.

Practice

1. What is the main purpose of embedding models in semantic search?

easy

A. To convert text into numbers that capture meaning

B. To count the number of words in a text

C. To translate text into another language

D. To remove stop words from text

Solution

1. Step 1: Understand embedding models

   Embedding models transform text into numerical vectors that represent the meaning of the text.

2. Step 2: Identify the purpose in semantic search

   These vectors help find texts with similar meanings, even if the exact words differ.

3. Final Answer:

   To convert text into numbers that capture meaning -> Option A

4. Quick Check:

   Embedding models = convert text to meaningful numbers [OK]

Hint: Embedding models turn words into meaningful numbers [OK]

Common Mistakes:

• Thinking embeddings count words
• Confusing embeddings with translation
• Believing embeddings remove words

2. Which of the following is the correct way to get an embedding vector for a text using a model called embed_model in Python?

easy

A. embedding = embed_model.get_embedding('sample text')

B. embedding = embed_model.text_to_vector('sample text')

C. embedding = embed_model.encode('sample text')

D. embedding = embed_model.vectorize('sample text')

Solution

1. Step 1: Recall common embedding method names

   Many embedding libraries use encode to convert text to vectors.

2. Step 2: Check method correctness

   Only embed_model.encode('sample text') is a standard and valid call; others are not typical method names.

3. Final Answer:

   embedding = embed_model.encode('sample text') -> Option C

4. Quick Check:

   Use encode() to get embeddings [OK]

Hint: Use encode() method to get embeddings [OK]

Common Mistakes:

• Using non-existent methods like text_to_vector
• Confusing method names
• Forgetting to call the method with parentheses

3. Given the following Python code using an embedding model, what will be the output type of embedding?

embedding = embed_model.encode('Find similar texts')

medium

A. A list of words

B. A numeric vector (list or array) representing the text

C. A string representing the text

D. A dictionary with word counts

Solution

1. Step 1: Understand what encode() returns

   The encode() method returns a numeric vector that captures the meaning of the input text.

2. Step 2: Identify the output type

   This vector is usually a list or array of numbers, not words, strings, or dictionaries.

3. Final Answer:

   A numeric vector (list or array) representing the text -> Option B

4. Quick Check:

   encode() output = numeric vector [OK]

Hint: Embedding output is always numeric vector [OK]

Common Mistakes:

• Expecting a list of words
• Thinking output is a string
• Confusing embeddings with word counts

4. You wrote this code to get embeddings but get an error:

embedding = embed_model.encode['text to search']

What is the error and how to fix it?

medium

A. Add a return statement before encode

B. Change 'text to search' to a list of words

C. Remove the encode method and use embed_model directly

D. Use parentheses () instead of brackets [] to call encode method

Solution

1. Step 1: Identify the syntax error

   Methods in Python are called with parentheses (), not brackets []. Using brackets causes a TypeError.

2. Step 2: Correct the method call

   Replace encode['text to search'] with encode('text to search') to fix the error.

3. Final Answer:

   Use parentheses () instead of brackets [] to call encode method -> Option D

4. Quick Check:

   Method calls need () not [] [OK]

Hint: Call methods with () not [] [OK]

Common Mistakes:

• Using brackets [] instead of parentheses ()
• Passing wrong argument types
• Trying to call method without parentheses

5. You want to build a semantic search system that finds documents similar in meaning to a query. Which approach best uses embedding models for this task?

hard

A. Convert all documents and the query to embeddings, then find documents with closest vectors

B. Count keyword frequency in documents and query, then match counts

C. Translate documents to another language before searching

D. Sort documents alphabetically and pick the first matches

Solution

1. Step 1: Understand semantic search with embeddings

   Semantic search uses embeddings to represent meaning, so comparing vectors finds similar meaning.

2. Step 2: Identify the correct approach

   Converting documents and query to embeddings and finding closest vectors is the correct method for semantic search.

3. Final Answer:

   Convert all documents and the query to embeddings, then find documents with closest vectors -> Option A

4. Quick Check:

   Semantic search = compare embedding vectors [OK]

Hint: Compare embeddings of query and documents for semantic search [OK]

Common Mistakes:

• Using keyword counts instead of embeddings
• Translating text unnecessarily
• Sorting alphabetically instead of by meaning