Why memory makes agents useful in Agentic AI - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an agent that remembers past inputs.

Agentic AI

class Agent:
    def __init__(self):
        self.memory = [1]

agent = Agent()

Drag options to blanks, or click blank then click option'

A[]

B{}

CNone

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using None or 0 which cannot store multiple past inputs.

Using a dictionary which is unordered for this simple memory.

The agent's memory should be a list to store past inputs in order.

2fill in blank

medium

Complete the code to add a new input to the agent's memory.

Agentic AI

class Agent:
    def __init__(self):
        self.memory = []
    def remember(self, input):
        self.memory.[1](input)

agent = Agent()
agent.remember('hello')

Drag options to blanks, or click blank then click option'

Aextend

Bappend

Cinsert

Dadd

Attempts:

3 left

💡 Hint

Common Mistakes

Using add() which is for sets, not lists.

Using extend() which expects an iterable, not a single item.

The append() method adds a single item to the end of a list, perfect for memory.

3fill in blank

hard

Fix the error in the code that retrieves the last remembered input.

Agentic AI

class Agent:
    def __init__(self):
        self.memory = []
    def remember(self, input):
        self.memory.append(input)
    def recall(self):
        return self.memory[1]

agent = Agent()
agent.remember('data')
last = agent.recall()

Drag options to blanks, or click blank then click option'

A[-2]

B[0]

C[-1]

D[1]

Attempts:

3 left

💡 Hint

Common Mistakes

Using [0] which returns the first item, not the last.

Using [1] which may cause errors if list has only one item.

Using [-1] gets the last item added to the list, which is the most recent memory.

4fill in blank

hard

Fill both blanks to create a method that clears the agent's memory and checks if memory is empty.

Agentic AI

class Agent:
    def __init__(self):
        self.memory = []
    def clear_memory(self):
        self.memory.[1]()
    def is_memory_empty(self):
        return len(self.memory) [2] 0

Drag options to blanks, or click blank then click option'

Aclear

Bappend

C==

D!=

Attempts:

3 left

💡 Hint

Common Mistakes

Using append() instead of clear() to empty the list.

Using != instead of == to check if memory is empty.

clear() empties the list; len(self.memory) == 0 checks if memory is empty.

5fill in blank

hard

Fill all three blanks to create a method that returns a dictionary of memory items with their lengths, filtering only those longer than 3 characters.

Agentic AI

class Agent:
    def __init__(self):
        self.memory = []
    def memory_summary(self):
        return { [1]: [2] for item in self.memory if len(item) [3] 3 }

Drag options to blanks, or click blank then click option'

Aitem

C>

Dlen(item)

Attempts:

3 left

💡 Hint

Common Mistakes

Using list comprehension instead of dictionary comprehension.

Using < instead of > for filtering longer items.

The dictionary comprehension uses {item: len(item)} and filters items with length > 3.

Practice

1. Why is memory important for an AI agent?

easy

A. It makes the agent run faster on a computer.

B. It helps the agent remember past information to make better decisions.

C. It allows the agent to use more colors in its interface.

D. It reduces the size of the agent's code.

Solution

1. Step 1: Understand the role of memory in agents

   Memory stores past information that the agent can use later.

2. Step 2: Connect memory to decision-making

   Remembering past events helps the agent make smarter choices.

3. Final Answer:

   It helps the agent remember past information to make better decisions. -> Option B

4. Quick Check:

   Memory improves decisions = A [OK]

Hint: Memory means remembering past info for better choices [OK]

Common Mistakes:

• Thinking memory speeds up code execution
• Confusing memory with interface design
• Assuming memory reduces code size

2. Which of the following is the correct way to describe an agent's memory?

easy

A. A place where the agent stores past experiences.

B. A function that deletes all data after each step.

C. A tool that makes the agent forget previous tasks instantly.

D. A feature that only stores the agent's name.

Solution

1. Step 1: Define agent memory

   Memory is where the agent keeps past experiences or information.

2. Step 2: Eliminate incorrect options

   Deleting data or forgetting instantly is opposite of memory's purpose.

3. Final Answer:

   A place where the agent stores past experiences. -> Option A

4. Quick Check:

   Memory stores past info = C [OK]

Hint: Memory means storing past experiences, not deleting them [OK]

Common Mistakes:

• Confusing memory with forgetting
• Thinking memory only stores names
• Believing memory deletes data after each step

3. Consider this simple agent code snippet using memory:

memory = []
for event in ['rain', 'sun', 'rain']:
    memory.append(event)
print(memory.count('rain'))

What will be the output?

medium

A. 0

B. 1

C. 3

D. 2

Solution

1. Step 1: Understand the loop and memory updates

   The loop adds 'rain', 'sun', and 'rain' to the memory list.

2. Step 2: Count how many times 'rain' appears

   'rain' appears twice in the list, so memory.count('rain') returns 2.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Count of 'rain' = 2 [OK]

Hint: Count how many times 'rain' is added to memory [OK]

Common Mistakes:

• Counting only once instead of twice
• Confusing list length with count
• Assuming count returns total list size

4. This agent code is supposed to remember unique events only:

memory = []
events = ['rain', 'sun', 'rain']
for event in events:
    if event not in memory:
        memory.append(event)
print(memory)

What is the output?

medium

A. ['rain', 'sun']

B. ['sun']

C. ['sun', 'rain']

D. ['rain', 'sun', 'rain']

Solution

1. Step 1: Check how memory stores unique events

   The code adds 'rain' first, then 'sun', and skips the second 'rain' because it's already in memory.

2. Step 2: Review the final memory list

   Memory contains ['rain', 'sun'] after the loop finishes.

3. Final Answer:

   ['rain', 'sun'] -> Option A

4. Quick Check:

   Memory stores unique events = D [OK]

Hint: Memory only adds event if not already present [OK]

Common Mistakes:

• Assuming all events are added including duplicates
• Mixing order of events in memory
• Forgetting the 'if' condition effect

5. An agent uses memory to personalize responses. It stores user preferences as a dictionary:

memory = {}
inputs = [('color', 'blue'), ('food', 'pizza'), ('color', 'green')]
for key, value in inputs:
    memory[key] = value
print(memory)

What is the final content of memory and why does this show memory's usefulness?

hard

A. {'color': 'blue', 'food': 'pizza', 'color': 'green'} because memory stores all entries separately.

B. {} because memory is cleared after each input.

C. {'color': 'green', 'food': 'pizza'} because memory updates preferences, enabling personalization.

D. {'food': 'pizza'} because 'color' keys are ignored.

Solution

1. Step 1: Analyze how dictionary memory updates

   Each key in the dictionary is updated with the latest value; 'color' changes from 'blue' to 'green'.

2. Step 2: Understand why this helps personalization

   Memory keeps the latest user preferences, so the agent can respond based on current info.

3. Final Answer:

   {'color': 'green', 'food': 'pizza'} because memory updates preferences, enabling personalization. -> Option C

4. Quick Check:

   Memory updates preferences = B [OK]

Hint: Latest key value overwrites old, aiding personalization [OK]

Common Mistakes:

• Thinking dictionary stores duplicate keys
• Assuming memory clears after each input
• Ignoring key update behavior in dictionaries