Agent API design patterns in Agentic AI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create an agent that uses a single tool.

Agentic AI

agent = Agent(tools=[[1]])

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

Atools

Btoolset

Ctool_list

Dtool

Attempts:

3 left

💡 Hint

Common Mistakes

Using a variable name that implies multiple tools instead of a single tool.

Passing a string instead of a tool object.

The agent expects a list of tool objects. Using tool as a single tool inside a list is correct.

2fill in blank

medium

Complete the code to initialize an agent with a memory component.

Agentic AI

agent = Agent(memory=[1])

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

Amemory_buffer

BMemoryBuffer()

CMemory

DbufferMemory

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the class name without parentheses.

Passing a variable name that is not an instance.

The agent requires an instance of a memory class. MemoryBuffer() creates a new memory buffer object.

3fill in blank

hard

Fix the error in the agent's run method call to pass the input correctly.

Agentic AI

result = agent.run([1]="What is the weather today?")

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

Ainput

Bquery

Cprompt

Dtext

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'query' or 'prompt' which are not accepted parameter names.

Passing the input as a positional argument instead of keyword.

The run method expects the input text under the keyword input.

4fill in blank

hard

Fill both blanks to create a tool that wraps a function and add it to the agent.

Agentic AI

tool = Tool(name=[1], func=[2])
agent = Agent(tools=[tool])

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

A"calculator"

Bcalculate

Dcalc

Attempts:

3 left

💡 Hint

Common Mistakes

Using the function name as a string.

Not quoting the tool name.

The tool's name should be a string like "calculator", and the function should be the callable calculate.

5fill in blank

hard

Fill all three blanks to define an agent with tools, memory, and a callback manager.

Agentic AI

agent = Agent(
    tools=[[1]],
    memory=[2],
    callback_manager=[3]
)

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

Atool

BMemoryBuffer()

CCallbackManager()

Dtools

Attempts:

3 left

💡 Hint

Common Mistakes

Passing tools without a list.

Passing class names instead of instances for memory and callback manager.

The agent needs a list of tools, so tool is wrapped in a list. Memory and callback manager are instances created by calling their constructors.

Practice

1. What is the main purpose of using Agent API design patterns in AI systems?

easy

A. To organize how AI agents communicate and work together

B. To speed up the training of machine learning models

C. To store large datasets efficiently

D. To improve the hardware performance of AI servers

Solution

1. Step 1: Understand the role of Agent API design patterns

   These patterns help define clear communication and interaction rules between AI agents.

2. Step 2: Compare with other options

   Options A, C, and D relate to training speed, data storage, and hardware, which are not the focus of Agent API design patterns.

3. Final Answer:

   To organize how AI agents communicate and work together -> Option A

4. Quick Check:

   Agent API design patterns = organize communication [OK]

Hint: Agent API patterns focus on agent communication, not hardware or data [OK]

Common Mistakes:

• Confusing design patterns with hardware optimization
• Thinking patterns speed up model training directly
• Mixing data storage with agent communication

2. Which of the following is the correct way to define a simple message passing function in an Agent API?

easy

A. def send_message(agent, message): return message + agent

B. def send_message(agent, message): agent.send(message)

C. def send_message(agent, message): return agent.receive(message)

D. def send_message(agent, message): print(agent + message)

Solution

1. Step 1: Analyze the function purpose

   The function should send a message to an agent and get a response by calling the agent's receive method.

2. Step 2: Check each option

   def send_message(agent, message): return agent.receive(message) correctly calls agent.receive(message). def send_message(agent, message): agent.send(message) calls agent.send which is not standard. Options A and C incorrectly try to add or print agent and message.

3. Final Answer:

   def send_message(agent, message): return agent.receive(message) -> Option C

4. Quick Check:

   Message passing calls agent.receive(message) [OK]

Hint: Message passing calls agent.receive(message) to send data [OK]

Common Mistakes:

• Using agent.send instead of agent.receive
• Trying to concatenate agent object with string
• Printing instead of returning the message

3. Given the code below, what will be the output?

class Agent:
    def receive(self, message):
        return f"Received: {message}"

def send_message(agent, message):
    return agent.receive(message)

agent = Agent()
print(send_message(agent, "Hello"))

medium

A. Error: method not found

B. Hello

C. send_message(agent, Hello)

D. Received: Hello

Solution

1. Step 1: Understand the Agent class and receive method

   The receive method returns the string 'Received: ' plus the message passed.

2. Step 2: Trace the send_message call

   send_message calls agent.receive with "Hello", so it returns 'Received: Hello'.

3. Final Answer:

   Received: Hello -> Option D

4. Quick Check:

   agent.receive("Hello") = "Received: Hello" [OK]

Hint: Agent.receive returns 'Received: ' plus message [OK]

Common Mistakes:

• Expecting just the message without prefix
• Thinking send_message prints instead of returns
• Assuming method does not exist causing error

4. Identify the error in the following Agent API code snippet:

class Agent:
    def receive(self, message):
        print(f"Got message: {message}")

def send_message(agent, message):
    return agent.receive(message)

agent = Agent()
response = send_message(agent, "Hi")
print(response)

medium

A. The receive method should return a value, not just print

B. send_message should not call agent.receive

C. Agent class is missing an __init__ method

D. The print statement in send_message is incorrect

Solution

1. Step 1: Check receive method behavior

   receive only prints the message but does not return anything, so it returns None by default.

2. Step 2: Analyze send_message and print(response)

   send_message returns None, so printing response outputs None, which is likely unintended.

3. Final Answer:

   The receive method should return a value, not just print -> Option A

4. Quick Check:

   receive must return message for send_message to work [OK]

Hint: receive must return, not just print, to pass data back [OK]

Common Mistakes:

• Ignoring that print returns None
• Thinking __init__ is required here
• Confusing print location with syntax error

5. You want to design an Agent API where multiple agents can collaborate by passing messages and roles define their behavior. Which design pattern best supports this?

hard

A. Factory pattern to create agents dynamically

B. Mediator pattern to centralize communication between agents

C. Singleton pattern to ensure one agent instance

D. Observer pattern to notify agents of state changes

Solution

1. Step 1: Understand collaboration and role-based behavior

   Agents need a central way to communicate and coordinate roles effectively.

2. Step 2: Match design patterns to needs

   The Mediator pattern centralizes communication, making it ideal for agent collaboration. Singleton limits to one instance, Factory creates objects, Observer handles notifications but not central communication.

3. Final Answer:

   Mediator pattern to centralize communication between agents -> Option B

4. Quick Check:

   Collaboration with roles = Mediator pattern [OK]

Hint: Mediator centralizes agent communication for collaboration [OK]

Common Mistakes:

• Choosing Singleton which limits to one agent
• Confusing Factory with communication pattern
• Using Observer which is for event notification only