Multi-agent graphs in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this multi-agent graph execution?

Consider a Langchain multi-agent graph where Agent A sends a message to Agent B, which then replies back to Agent A with a transformed message. What will Agent A receive after the graph runs?

LangChain

from langchain.agents import Agent

class AgentA(Agent):
    def __init__(self, name):
        super().__init__(name)
    def respond(self, message):
        return f"Received: {message}"

class AgentB(Agent):
    def __init__(self, name):
        super().__init__(name)
    def respond(self, message):
        return message.upper()

# Setup graph
agent_a = AgentA(name="A")
agent_b = AgentB(name="B")

message = "hello"
response_b = agent_b.respond(message)
response_a = agent_a.respond(response_b)

print(response_a)

A "Received: HELLO"

B "hello"

C "HELLO"

D "Received: hello"

💡 Hint

Think about how Agent B transforms the message before Agent A receives it.

Agent B converts the message to uppercase, then Agent A adds 'Received: ' prefix. So the final output is 'Received: HELLO'.

❓ state_output

intermediate

What is the final state of the multi-agent graph after message passing?

In a Langchain multi-agent graph, Agent X stores every message it receives in a list called 'history'. After sending three messages "one", "two", "three" to Agent X, what is the content of Agent X's history?

LangChain

from langchain.agents import Agent

class AgentX(Agent):
    def __init__(self, name):
        super().__init__(name)
        self.history = []
    def respond(self, message):
        self.history.append(message)
        return f"Ack: {message}"

agent_x = AgentX(name="X")
messages = ["one", "two", "three"]
for msg in messages:
    agent_x.respond(msg)

print(agent_x.history)

A ["Ack: one", "Ack: two", "Ack: three"]

B ["one", "two", "three"]

C []

D ["one", "two"]

💡 Hint

Check what is appended to the history list inside respond().

Agent X appends the raw message to history, so after three messages, history contains all three strings.

🔧 Debug

advanced

Why does this multi-agent graph code raise an AttributeError?

This Langchain multi-agent graph code raises an AttributeError when trying to access 'last_message' attribute. Identify the cause.

LangChain

from langchain.agents import Agent

class AgentY(Agent):
    def __init__(self, name):
        super().__init__(name)
    def respond(self, message):
        self.last_message = message
        return f"Got: {message}"

agent_y = AgentY(name="Y")
print(agent_y.last_message)

A The variable 'agent_y' is not instantiated correctly.

B The respond method is missing a return statement.

C The attribute 'last_message' is not set before print is called.

D AgentY class does not inherit from Agent properly.

💡 Hint

When is 'last_message' assigned in the code?

The attribute 'last_message' is assigned only when respond() is called. Since respond() was never called before print, the attribute does not exist yet.

📝 Syntax

advanced

Which option correctly defines a multi-agent graph with cyclic message passing?

You want to create two agents, Agent1 and Agent2, that send messages to each other in a cycle. Which code snippet correctly implements this behavior without syntax errors?

A

class Agent1(Agent):
    def respond(self, message):
        return Agent2().respond(message + " from Agent1")

class Agent2(Agent):
    def respond(self, message):
        return Agent1().respond(message + " from Agent2")

B

class Agent1(Agent):
    def respond(self, message):
        return self.agent2.respond(message + " from Agent1")

class Agent2(Agent):
    def respond(self, message):
        return self.agent1.respond(message + " from Agent2")

agent1 = Agent1()
agent2 = Agent2()
agent1.agent2 = agent2

C

class Agent1(Agent):
    def respond(self, message):
        return self.agent2.respond(message + " from Agent1")

class Agent2(Agent):
    def respond(self, message):
        return self.agent1.respond(message + " from Agent2")

D

class Agent1(Agent):
    def __init__(self):
        super().__init__("Agent1")
        self.agent2 = None
    def respond(self, message):
        return self.agent2.respond(message + " from Agent1")

class Agent2(Agent):
    def __init__(self):
        super().__init__("Agent2")
        self.agent1 = None
    def respond(self, message):
        return self.agent1.respond(message + " from Agent2")

agent1 = Agent1()
agent2 = Agent2()
agent1.agent2 = agent2
agent2.agent1 = agent1

💡 Hint

Check if both agents have references to each other before calling respond.

Option D correctly assigns references to each other after instantiation, allowing cyclic calls without NameError or AttributeError.

🧠 Conceptual

expert

What is the main benefit of using a multi-agent graph in Langchain?

Select the best explanation for why multi-agent graphs are used in Langchain applications.

A They allow multiple agents to collaborate and share information dynamically, enabling complex workflows and decision-making.

B They simplify single-agent tasks by reducing code complexity and removing the need for message passing.

C They replace the need for external APIs by embedding all knowledge inside one agent.

D They guarantee faster execution by running all agents in parallel without any communication overhead.

💡 Hint

Think about how multiple agents working together can improve problem solving.

Multi-agent graphs enable agents to communicate and collaborate, which supports complex workflows and richer decision processes.

Practice

1. What is the main purpose of a multi-agent graph in Langchain?

easy

A. To compile code faster

B. To store large datasets efficiently

C. To create user interfaces for web apps

D. To organize multiple agents and their connections

Solution

1. Step 1: Understand the concept of multi-agent graphs

   Multi-agent graphs are designed to organize agents and show how they connect and communicate.

2. Step 2: Compare options with the concept

   Only To organize multiple agents and their connections correctly describes organizing agents and their connections, which matches the purpose of multi-agent graphs.

3. Final Answer:

   To organize multiple agents and their connections -> Option D

4. Quick Check:

   Multi-agent graph purpose = Organize agents [OK]

Hint: Remember: multi-agent graphs show agents and links [OK]

Common Mistakes:

• Confusing data storage with agent organization
• Thinking it's for UI design
• Assuming it's for code compilation

2. Which of the following is the correct way to add an agent to a multi-agent graph in Langchain?

easy

A. graph.insert_agent('agent_name')

B. graph.create_agent('agent_name')

C. graph.add_agent('agent_name')

D. graph.push_agent('agent_name')

Solution

1. Step 1: Recall the method to add agents in Langchain multi-agent graphs

   The standard method to add an agent is using add_agent.

2. Step 2: Check each option's method name

   Only graph.add_agent('agent_name') uses add_agent, which is the correct syntax. Others are invalid method names.

3. Final Answer:

   graph.add_agent('agent_name') -> Option C

4. Quick Check:

   Adding agent method = add_agent() [OK]

Hint: Look for 'add_agent' method to add agents [OK]

Common Mistakes:

• Using incorrect method names like insert_agent
• Confusing create_agent with add_agent
• Using push_agent which doesn't exist

3. Given the following code snippet, what will be the output when printing the graph's edges?

graph = MultiAgentGraph()
graph.add_agent('AgentA')
graph.add_agent('AgentB')
graph.add_edge('AgentA', 'AgentB')
print(graph.edges)

medium

A. [('AgentA', 'AgentB')]

B. [('AgentB', 'AgentA')]

C. []

D. Error: add_edge method not found

Solution

1. Step 1: Analyze the code adding agents and an edge

   Two agents 'AgentA' and 'AgentB' are added, then an edge from 'AgentA' to 'AgentB' is created.

2. Step 2: Understand the edges property output

   The edges list will contain a tuple representing the connection from 'AgentA' to 'AgentB'.

3. Final Answer:

   [('AgentA', 'AgentB')] -> Option A

4. Quick Check:

   Edges list = [('AgentA', 'AgentB')] [OK]

Hint: Edges show connections as (from, to) tuples [OK]

Common Mistakes:

• Reversing the edge direction
• Expecting empty edges list
• Assuming add_edge method is missing

4. Identify the error in this code snippet for creating a multi-agent graph:

graph = MultiAgentGraph()
graph.add_agent('Agent1')
graph.add_edge('Agent1', 'Agent2')

medium

A. Agent2 was not added before creating an edge

B. add_edge method requires three arguments

C. add_agent method is misspelled

D. MultiAgentGraph cannot add edges

Solution

1. Step 1: Check agent additions before adding edges

   Only 'Agent1' is added; 'Agent2' is missing before adding an edge.

2. Step 2: Understand edge creation requirements

   Edges require both agents to exist; missing 'Agent2' causes an error.

3. Final Answer:

   Agent2 was not added before creating an edge -> Option A

4. Quick Check:

   Both agents must exist before edge [OK]

Hint: Add both agents before connecting them with edges [OK]

Common Mistakes:

• Assuming add_edge needs three arguments
• Thinking add_agent is misspelled
• Believing edges can't be added

5. You want to build a workflow where AgentX sends data to AgentY, and AgentY processes it and sends results to AgentZ. Which multi-agent graph setup correctly represents this flow?

hard

A. Add agents AgentX, AgentY; add edge AgentX->AgentZ only

B. Add agents AgentX, AgentY, AgentZ; add edges AgentX->AgentY and AgentY->AgentZ

C. Add agents AgentX, AgentY, AgentZ; add edges AgentZ->AgentY and AgentY->AgentX

D. Add agents AgentX, AgentY, AgentZ; no edges needed

Solution

1. Step 1: Identify the data flow between agents

   AgentX sends to AgentY, then AgentY sends to AgentZ, so edges must follow this order.

2. Step 2: Match edges to the described flow

   Add agents AgentX, AgentY, AgentZ; add edges AgentX->AgentY and AgentY->AgentZ correctly adds edges from AgentX to AgentY and AgentY to AgentZ, representing the workflow.

3. Final Answer:

   Add agents AgentX, AgentY, AgentZ; add edges AgentX->AgentY and AgentY->AgentZ -> Option B

4. Quick Check:

   Edges follow data flow direction [OK]

Hint: Edges must follow the exact data flow between agents [OK]

Common Mistakes:

• Reversing edge directions
• Omitting necessary agents or edges
• Assuming edges are optional for workflows