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.