Retrieval strategies (similarity, MMR, hybrid) in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Understanding Similarity-Based Retrieval

Which statement best describes how similarity-based retrieval works in information retrieval systems?

A It retrieves documents by measuring how closely their content matches the query using a similarity score.

B It randomly selects documents without considering the query content.

C It ranks documents solely based on their length compared to the query length.

D It retrieves documents based on the time they were added to the database.

💡 Hint

Think about how a search engine finds documents that are most relevant to what you type.

Similarity-based retrieval measures how close the content of documents is to the query, often using scores like cosine similarity, to rank and retrieve the most relevant documents.

❓ Model Choice

intermediate

Choosing a Retrieval Strategy for Diverse Results

You want to retrieve documents that are not only relevant but also diverse to avoid redundancy. Which retrieval strategy should you choose?

A Maximal Marginal Relevance (MMR)

B Retrieval based on document age

C Random sampling of documents

D Pure similarity-based retrieval

💡 Hint

Consider a method that balances relevance and diversity.

MMR balances relevance to the query and diversity among selected documents to reduce redundancy in results.

❓ Predict Output

advanced

Output of MMR Score Calculation

Given the following Python code snippet that calculates MMR scores for candidate documents, what is the output of the print statement?

Agentic AI

query_vec = [1, 0]
candidate_vecs = [[0.9, 0.1], [0.1, 0.9], [0.8, 0.2]]
selected = []

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

lambda_param = 0.5

mmr_scores = []
for i, doc_vec in enumerate(candidate_vecs):
    sim_to_query = cosine_similarity(query_vec, doc_vec)
    sim_to_selected = max([cosine_similarity(doc_vec, candidate_vecs[j]) for j in selected] or [0])
    score = lambda_param * sim_to_query - (1 - lambda_param) * sim_to_selected
    mmr_scores.append(score)

print([round(s, 2) for s in mmr_scores])

A [0.5, 0.5, 0.5]

B [0.95, 0.05, 0.9]

C [0.5, -0.5, 0.5]

D [0.9, -0.05, 0.8]

💡 Hint

Calculate cosine similarity carefully and apply the MMR formula.

The first document has high similarity to the query and no penalty since no documents are selected yet, so score is 0.5*0.9 - 0.5*0 = 0.45 rounded to 0.45 (not 0.9). The others have lower scores due to similarity and penalty terms.

❓ Hyperparameter

advanced

Effect of Lambda in MMR

In Maximal Marginal Relevance (MMR), what happens when the lambda parameter is set close to 1?

A The retrieval balances relevance and diversity equally.

B The retrieval focuses mostly on relevance, ignoring diversity.

C The retrieval randomly selects documents without any scoring.

D The retrieval focuses mostly on document diversity, ignoring relevance.

💡 Hint

Lambda controls the trade-off between relevance and diversity.

Lambda near 1 means the formula weights relevance heavily and diversity very little, so results are mostly relevant but may be redundant.

🔧 Debug

expert

Debugging Hybrid Retrieval Code

Consider this hybrid retrieval code combining similarity and MMR. What error will it raise when run?

Agentic AI

def hybrid_retrieval(query_vec, candidate_vecs, lambda_param=0.7):
    import numpy as np
    def cosine_similarity(a, b):
        return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

    selected = []
    scores = []
    for i, doc_vec in enumerate(candidate_vecs):
        sim_query = cosine_similarity(query_vec, doc_vec)
        sim_selected = max([cosine_similarity(doc_vec, candidate_vecs[j]) for j in selected] or [0])
        score = lambda_param * sim_query - (1 - lambda_param) * sim_selected
        scores.append(score)
    return scores

query = [1, 0]
candidates = [[0.9, 0.1], [0.1, 0.9]]
print(hybrid_retrieval(query, candidates))

A ZeroDivisionError due to zero vector norm

B TypeError due to unsupported operand types

C ValueError because max() arg is an empty sequence

D No error, outputs a list of scores

💡 Hint

Look at the max() function call when selected is empty.

When selected is empty, the list comprehension inside max() is empty, causing max() to raise a ValueError for empty sequence.