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.

Practice

1. What is the main purpose of using a vector store in long-term memory for AI agents?

easy

A. To replace all databases with text files

B. To store images and videos directly

C. To slow down data retrieval for security

D. To save information as lists of numbers for quick searching

Solution

1. Step 1: Understand vector store role

   Vector stores save data as number lists (vectors) to represent information compactly.

2. Step 2: Identify purpose in AI memory

   This allows fast searching by comparing vector similarity, making recall efficient.

3. Final Answer:

   To save information as lists of numbers for quick searching -> Option D

4. Quick Check:

   Vector store = number lists for fast recall [OK]

Hint: Vector stores = numbers for fast search [OK]

Common Mistakes:

• Thinking vector stores save raw images or videos
• Confusing vector stores with simple text files
• Assuming vector stores slow down retrieval

2. Which of the following is the correct way to add a vector to a vector store in Python-like pseudocode?

easy

A. vector_store.insert('doc1', [0.1, 0.2, 0.3])

B. vector_store.push_vector([0.1, 0.2, 0.3], 'doc1')

C. vector_store.add_vector(id='doc1', vector=[0.1, 0.2, 0.3])

D. vector_store.append_vector('doc1', vector=[0.1, 0.2, 0.3])

Solution

1. Step 1: Identify typical vector store method

   Common vector stores use an add_vector method with id and vector parameters.

2. Step 2: Match correct syntax

   vector_store.add_vector(id='doc1', vector=[0.1, 0.2, 0.3]) matches this pattern: add_vector(id='doc1', vector=[0.1, 0.2, 0.3]). Others use incorrect method names or argument order.

3. Final Answer:

   vector_store.add_vector(id='doc1', vector=[0.1, 0.2, 0.3]) -> Option C

4. Quick Check:

   Correct method and argument names = vector_store.add_vector(id='doc1', vector=[0.1, 0.2, 0.3]) [OK]

Hint: Look for method named add_vector with id and vector [OK]

Common Mistakes:

• Using wrong method names like insert or push_vector
• Swapping argument order
• Missing parameter names

3. Given this code snippet, what will be the output?

query_vector = [0.5, 0.5]
results = vector_store.search(query_vector, top_k=2)
print(results)

Assuming the vector store contains vectors close to [0.5, 0.5] for ids 'docA' and 'docB'.

medium

A. [('docA', 0.98), ('docB', 0.95)]

B. [('docC', 0.50), ('docD', 0.45)]

C. []

D. Error: search method not found

Solution

1. Step 1: Understand search behavior

   The search method returns the top_k closest vectors by similarity score.

2. Step 2: Match expected results

   Since 'docA' and 'docB' are closest to [0.5, 0.5], they appear with high similarity scores like 0.98 and 0.95.

3. Final Answer:

   [('docA', 0.98), ('docB', 0.95)] -> Option A

4. Quick Check:

   Top matches with high similarity = [('docA', 0.98), ('docB', 0.95)] [OK]

Hint: Search returns closest vectors with highest similarity scores [OK]

Common Mistakes:

• Expecting unrelated documents in results
• Assuming empty list if vectors exist
• Thinking search method causes error

4. You run this code but get an error:

vector_store.add_vector([0.1, 0.2, 0.3], id='doc1')

What is the likely cause of the error?

medium

A. The add_vector method requires id first, then vector as keyword arguments

B. The vector argument should be named before id

C. Vectors cannot be lists, must be strings

D. The method add_vector does not exist

Solution

1. Step 1: Check method signature

   add_vector usually expects id first, then vector as keyword arguments.

2. Step 2: Identify argument order error

   Passing vector first without naming causes error; correct call is add_vector(id='doc1', vector=[0.1, 0.2, 0.3]).

3. Final Answer:

   The add_vector method requires id first, then vector as keyword arguments -> Option A

4. Quick Check:

   Correct argument order = The add_vector method requires id first, then vector as keyword arguments [OK]

Hint: Check argument order and names for add_vector [OK]

Common Mistakes:

• Passing vector before id without naming
• Thinking vectors must be strings
• Assuming method does not exist

5. You want your AI agent to remember past conversations using a vector store. Which approach best ensures it retrieves relevant past info quickly and accurately?

hard

A. Store conversation texts as raw strings and search by keyword matching

B. Convert conversation texts into vectors and search by similarity in the vector store

C. Save conversations in a plain text file and read line by line

D. Use a random vector for each conversation and pick one randomly

Solution

1. Step 1: Understand vector store advantage

   Vector stores allow searching by similarity, capturing meaning beyond exact words.

2. Step 2: Compare options for retrieval quality

   Convert conversation texts into vectors and search by similarity in the vector store converts texts to vectors and searches by similarity, enabling fast and accurate recall of related past conversations.

3. Final Answer:

   Convert conversation texts into vectors and search by similarity in the vector store -> Option B

4. Quick Check:

   Similarity search in vector store = best for relevant recall [OK]

Hint: Use vector similarity, not keyword or random picks [OK]

Common Mistakes:

• Relying on keyword matching only
• Using random vectors losing relevance
• Reading plain text files linearly