Structured chat agent in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this LangChain structured chat agent code?

Consider this code snippet using LangChain's StructuredChatAgent. What will be printed when the agent runs?

LangChain

from langchain.schema import SystemMessage, HumanMessage
from langchain.chat_models import ChatOpenAI
from langchain.agents import StructuredChatAgent, AgentExecutor

system_message = SystemMessage(content="You are a helpful assistant.")

chat = ChatOpenAI(temperature=0)

agent = StructuredChatAgent.from_llm_and_tools(
    llm=chat,
    tools=[],
    system_message=system_message
)

executor = AgentExecutor(agent=agent, tools=[])

response = executor.run("Hello, who won the world series in 2020?")
print(response)

A The code raises a RuntimeError due to missing tool implementations.

B The agent returns a direct answer about the 2020 World Series winner.

C The code raises a TypeError because tools list is empty.

D The agent returns an empty string because no tools are provided.

💡 Hint

Think about how StructuredChatAgent uses the LLM and tools. If no tools are needed, it can still answer.

The StructuredChatAgent uses the LLM to generate a response. Even with an empty tools list, it can answer questions that don't require external tools. Hence, it returns the answer about the 2020 World Series winner.

📝 Syntax

intermediate

Which option correctly creates a StructuredChatAgent with tools?

You want to create a StructuredChatAgent with a tool named 'calculator'. Which code snippet is syntactically correct?

LangChain

from langchain.agents import StructuredChatAgent
from langchain.chat_models import ChatOpenAI

calculator_tool = ...  # assume this is a valid tool

# Options below:

A agent = StructuredChatAgent.from_llm_and_tools(llm=ChatOpenAI(), tools=[calculator_tool])

B agent = StructuredChatAgent(llm=ChatOpenAI(), tools=calculator_tool)

C agent = StructuredChatAgent.from_llm_and_tools(llm=ChatOpenAI, tools=[calculator_tool])

D agent = StructuredChatAgent.from_llm_and_tools(llm=ChatOpenAI(), tool=calculator_tool)

💡 Hint

Check the method name and parameter names carefully.

The correct method is from_llm_and_tools, and tools must be a list. llm must be an instance, so ChatOpenAI() is correct. Option A matches all these requirements.

🔧 Debug

advanced

Why does this StructuredChatAgent code raise a ValueError?

This code raises a ValueError: 'tools must be a list of Tool instances'. What is the cause?

LangChain

from langchain.agents import StructuredChatAgent
from langchain.chat_models import ChatOpenAI

calculator_tool = 'calculator'

agent = StructuredChatAgent.from_llm_and_tools(llm=ChatOpenAI(), tools=calculator_tool)

A The tools argument is a string, not a list of Tool objects.

B The llm argument is not instantiated correctly.

C The StructuredChatAgent requires a system_message parameter.

D The calculator_tool variable is not imported from langchain.tools.

💡 Hint

Check the type of the tools argument passed.

The tools argument must be a list of Tool instances. Passing a string causes the ValueError.

❓ state_output

advanced

What is the value of 'agent.tools' after this code runs?

Given the following code, what is the content of the agent's tools attribute?

LangChain

from langchain.agents import StructuredChatAgent
from langchain.chat_models import ChatOpenAI
from langchain.tools import Tool

def dummy_func():
    return "dummy"

dummy_tool = Tool(name="dummy", func=dummy_func, description="A dummy tool")

agent = StructuredChatAgent.from_llm_and_tools(llm=ChatOpenAI(), tools=[dummy_tool])

result = agent.tools

A None

B []

C [Tool(name='dummy', func=<function dummy_func>, description='A dummy tool')]

D ["dummy"]

💡 Hint

The tools list passed to the agent is stored in agent.tools.

The agent stores the list of Tool instances passed during creation in its tools attribute.

🧠 Conceptual

expert

Which statement best describes the role of StructuredChatAgent in LangChain?

Choose the best description of what StructuredChatAgent does in LangChain.

A It is a deprecated class replaced by AgentExecutor in LangChain.

B It is a low-level API for directly calling OpenAI's chat completions without tool integration.

C It only handles static prompts without any dynamic tool usage or user input.

D It manages conversation flow by combining an LLM with external tools using a structured prompt format.

💡 Hint

Think about how StructuredChatAgent connects language models and tools.

StructuredChatAgent is designed to combine an LLM with tools in a structured way to manage chat-based agent workflows.

Practice

1. What is the main purpose of a Structured chat agent in Langchain?

easy

A. To store large datasets efficiently

B. To organize chat conversations step-by-step for clarity

C. To create static web pages

D. To compile code faster

Solution

1. Step 1: Understand the role of structured chat agents

   Structured chat agents help organize chat conversations in a clear, stepwise manner.

2. Step 2: Compare options with this role

   The remaining options describe unrelated tasks like data storage, web pages, or compilation.

3. Final Answer:

   To organize chat conversations step-by-step for clarity -> Option B

4. Quick Check:

   Structured chat agent = step-by-step chat organization [OK]

Hint: Remember: structured means step-by-step chat flow [OK]

Common Mistakes:

• Confusing chat agents with data storage tools
• Thinking structured chat agents create web pages
• Assuming they speed up code compilation

2. Which of the following is the correct way to create a StructuredChatAgent using Langchain's ChatOpenAI model?

easy

A. agent = StructuredChatAgent(llm=ChatOpenAI())

B. agent = StructuredChatAgent(ChatOpenAI)

C. agent = StructuredChatAgent(llm=ChatOpenAI)

D. agent = StructuredChatAgent()

Solution

1. Step 1: Identify correct instantiation syntax

   Langchain expects the model instance passed as a keyword argument, e.g., llm=ChatOpenAI()

2. Step 2: Check each option

   agent = StructuredChatAgent(llm=ChatOpenAI()) correctly creates an instance of ChatOpenAI and passes it as llm. Passing the class instead of an instance or omitting the llm keyword argument or the argument itself will fail.

3. Final Answer:

   agent = StructuredChatAgent(llm=ChatOpenAI()) -> Option A

4. Quick Check:

   Pass model instance with llm=ChatOpenAI() [OK]

Hint: Always instantiate ChatOpenAI() before passing to agent [OK]

Common Mistakes:

• Passing the class ChatOpenAI instead of an instance
• Omitting the llm keyword argument
• Not calling ChatOpenAI() with parentheses

3. Given this code snippet, what will be the output when the agent is run with input 'Hello'?

from langchain.chat_models import ChatOpenAI
from langchain.agents import StructuredChatAgent

llm = ChatOpenAI(temperature=0)
agent = StructuredChatAgent(llm=llm)
response = agent.invoke({'input': 'Hello'})
print(response['output'])

medium

A. KeyError because 'output' key does not exist

B. SyntaxError due to missing import

C. A structured reply generated by the ChatOpenAI model

D. None, because invoke returns nothing

Solution

1. Step 1: Understand the code flow

   The code creates a ChatOpenAI model with zero randomness, wraps it in a StructuredChatAgent, then calls invoke with input 'Hello'.

2. Step 2: Analyze expected output

   StructuredChatAgent's invoke returns a dict with an 'output' key containing the model's reply. No syntax or key errors occur.

3. Final Answer:

   A structured reply generated by the ChatOpenAI model -> Option C

4. Quick Check:

   invoke returns dict with 'output' key [OK]

Hint: invoke returns dict with 'output' key holding reply [OK]

Common Mistakes:

• Expecting invoke to return None
• Assuming 'output' key is missing
• Confusing syntax errors with runtime behavior

4. Identify the error in this code snippet that tries to create a structured chat agent:

from langchain.chat_models import ChatOpenAI
from langchain.agents import StructuredChatAgent

llm = ChatOpenAI(temperature=0.5)
agent = StructuredChatAgent(llm)
response = agent.invoke({'input': 'Hi'})
print(response['output'])

medium

A. print statement syntax error

B. Missing parentheses when creating ChatOpenAI instance

C. invoke method does not accept a dictionary

D. Incorrect argument passing to StructuredChatAgent

Solution

1. Step 1: Check how StructuredChatAgent is instantiated

   The agent expects the language model passed as a keyword argument llm=..., but here llm is passed as a positional argument.

2. Step 2: Verify other parts

   ChatOpenAI is correctly instantiated with parentheses. invoke accepts a dict input. print syntax is correct.

3. Final Answer:

   Incorrect argument passing to StructuredChatAgent -> Option D

4. Quick Check:

   Pass llm=llm, not just llm [OK]

Hint: Pass llm=llm when creating StructuredChatAgent [OK]

Common Mistakes:

• Passing llm as positional instead of keyword argument
• Forgetting parentheses on ChatOpenAI()
• Assuming invoke rejects dict input

5. You want to build a structured chat agent that guides users through a multi-step form. Which approach best uses Langchain's StructuredChatAgent to achieve this?

hard

A. Use a single StructuredChatAgent with a prompt template that includes step instructions

B. Chain multiple StructuredChatAgent instances, each handling one step

C. Create a StructuredChatAgent without a language model and handle steps manually

D. Use StructuredChatAgent only for final summary, not for step guidance

Solution

1. Step 1: Understand structured chat agent capabilities

   StructuredChatAgent can use prompt templates to guide conversations step-by-step within a single agent.

2. Step 2: Evaluate options for multi-step form guidance

   Use a single StructuredChatAgent with a prompt template that includes step instructions uses a single agent with a prompt template including step instructions, which is efficient and clear. Chain multiple StructuredChatAgent instances, each handling one step complicates with multiple agents. Create a StructuredChatAgent without a language model and handle steps manually lacks a language model, so no generation. Use StructuredChatAgent only for final summary, not for step guidance ignores step guidance.

3. Final Answer:

   Use a single StructuredChatAgent with a prompt template that includes step instructions -> Option A

4. Quick Check:

   Single agent + prompt template = guided multi-step chat [OK]

Hint: Use prompt templates inside one agent for step guidance [OK]

Common Mistakes:

• Trying to chain multiple agents unnecessarily
• Omitting the language model in the agent
• Using agent only for summary, missing step control