Long-term memory with vector stores in Agentic AI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does a vector store help with long-term memory in AI agents?

Imagine you have an AI agent that needs to remember important information from past conversations. How does using a vector store help the agent keep and find this information later?

A It deletes old memories automatically to keep only the newest information.

B It saves all conversations as plain text files for the agent to read later.

C It stores information as numbers in a way that lets the agent quickly find similar past memories based on meaning.

D It compresses the data into a single number to save space but loses details.

💡 Hint

Think about how the agent finds related information, not just storing raw text.

Vector stores convert information into number arrays (vectors) that capture meaning. This allows the agent to search for memories similar in meaning, enabling effective long-term memory retrieval.

❓ Predict Output

intermediate

Output of similarity search in a vector store

Given the following code snippet using a vector store, what will be the output?

Agentic AI

from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

# Stored vectors representing past memories
memory_vectors = np.array([[1, 0], [0, 1], [1, 1]])

# New query vector
query_vector = np.array([[0.9, 0.1]])

# Compute similarity scores
scores = cosine_similarity(query_vector, memory_vectors)

# Find index of most similar memory
most_similar_index = np.argmax(scores)
print(most_similar_index)

A 0

B 1

C 2

D None of the above

💡 Hint

Look at which stored vector is closest to the query vector in direction.

The query vector [0.9, 0.1] is closest to [1, 0] among the stored vectors, so the index 0 is the most similar.

❓ Model Choice

advanced

Choosing the best embedding model for long-term memory

You want to build a long-term memory system for an AI agent that remembers conversations. Which embedding model is best to create vectors that capture semantic meaning for diverse topics?

A A pretrained transformer-based model like BERT that creates context-aware embeddings

B A simple bag-of-words model that counts word frequency

C A one-hot encoding model that marks presence or absence of words

D A random vector generator that assigns random numbers to texts

💡 Hint

Think about which model understands word meaning in context.

Transformer-based models like BERT produce embeddings that capture the meaning of words in context, making them ideal for semantic search in long-term memory.

❓ Hyperparameter

advanced

Effect of vector dimension size on memory performance

When creating vector embeddings for long-term memory, what is the effect of increasing the vector dimension size?

A It always improves memory retrieval speed and accuracy without downsides.

B It causes the vector store to crash due to memory overflow.

C It reduces the quality of embeddings because vectors become too sparse.

D It can improve the detail captured but may slow down search and require more storage.

💡 Hint

Consider trade-offs between detail and resource use.

Larger vector dimensions can capture more information but increase computation and storage needs, potentially slowing down similarity searches.

🔧 Debug

expert

Why does this vector store similarity search return wrong results?

Review the code below. The similarity search returns unexpected results. What is the main issue?

Agentic AI

import numpy as np

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

memory_vectors = np.array([[1, 0], [0, 1], [1, 1]])
query_vector = np.array([0.9, 0.1])

scores = []
for vec in memory_vectors:
    scores.append(cosine_similarity(query_vector, vec))

most_similar_index = np.argmax(scores)
print(most_similar_index)

A The cosine_similarity function does not handle vector inputs correctly and returns a scalar instead of an array.

B The code is correct and will return the expected most similar index.

C The cosine_similarity function is correct, but the memory_vectors array should be normalized first.

D The query_vector should be reshaped to 2D before computing similarity to match memory_vectors shape.

💡 Hint

Check how the cosine similarity is computed for each vector.

The cosine_similarity function computes similarity between two 1D vectors correctly. The loop computes similarity for each stored vector. The code returns the correct most similar index.