Structured chat agent in LangChain - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the StructuredChatAgent class from langchain.agents.

LangChain

from langchain.agents import [1]

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

AConversationAgent

BChatAgent

CAgentExecutor

DStructuredChatAgent

Attempts:

3 left

💡 Hint

Common Mistakes

Importing a wrong class name like ChatAgent or AgentExecutor.

Forgetting to import from langchain.agents.

The StructuredChatAgent class is imported from langchain.agents to create structured chat agents.

2fill in blank

medium

Complete the code to create a StructuredChatAgent instance using an llm and a prompt.

LangChain

agent = StructuredChatAgent.from_llm([1], prompt=prompt)

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

Amodel

Bllm

Cclient

Dchatbot

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a variable named 'model' or 'client' which may not exist.

Passing the prompt instead of the llm.

The from_llm method requires the language model instance, commonly named llm.

3fill in blank

hard

Fix the error in the code to run the agent with input 'Hello'.

LangChain

response = agent.run([1])

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

A'Hello'

BHello

Cagent_input

Dinput

Attempts:

3 left

💡 Hint

Common Mistakes

Passing Hello without quotes causes a NameError.

Passing variables that are undefined.

The input to agent.run() must be a string, so it needs quotes.

4fill in blank

hard

Fill both blanks to create a prompt template and initialize the agent with it.

LangChain

from langchain.prompts import [1]
prompt = [2].from_template(template=template_str)

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

AChatPromptTemplate

BPromptTemplate

CStructuredPromptTemplate

DAgentPromptTemplate

Attempts:

3 left

💡 Hint

Common Mistakes

Using PromptTemplate instead of ChatPromptTemplate causes incompatibility.

Importing one class but instantiating another.

The ChatPromptTemplate class is used to create chat prompts for the StructuredChatAgent.

5fill in blank

hard

Fill all three blanks to create a StructuredChatAgent, wrap it in an AgentExecutor, and run it with input 'Hi'.

LangChain

agent = StructuredChatAgent.from_llm([1], prompt=prompt)
executor = AgentExecutor.from_agent_and_tools(agent, [2])
result = executor.run([3])

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

Allm

Btools

C'Hi'

Dprompt

Attempts:

3 left

💡 Hint

Common Mistakes

Passing the prompt instead of llm in the first blank.

Passing prompt instead of tools in the second blank.

Passing input without quotes in the third blank.

We pass the language model llm to create the agent, the list of tools to the executor, and the input string 'Hi' to run.

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