Structured chat agent in LangChain - Step-by-Step Execution

Concept Flow - Structured chat agent

User Input

↓

Parse Input

↓

Select Tool/Chain

↓

Execute Tool/Chain

↓

Collect Output

↓

Format Response

↓

Return to User

The structured chat agent takes user input, decides which tool or chain to run, executes it, and returns the formatted answer.

Execution Sample

LangChain

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

agent = StructuredChatAgent.from_llm_and_tools(ChatOpenAI(temperature=0), tools)
response = agent.invoke({'input': 'What is the weather today?'})

This code creates a structured chat agent with a chat model and tools, then sends a user question to get a response.

Execution Table

Step	Action	Input/State	Output/State
1	Receive user input	{'input': 'What is the weather today?'}	User query stored
2	Parse input	User query stored	Parsed intent and entities
3	Select tool	Parsed intent and entities	Weather tool selected
4	Execute tool	Weather tool, query	Weather data fetched
5	Format response	Weather data	Formatted answer string
6	Return response	Formatted answer string	Response sent to user

💡 Response returned to user, ending this interaction cycle

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	After Step 5	Final
user_input	None	'What is the weather today?'	'What is the weather today?'	'What is the weather today?'	'What is the weather today?'	'What is the weather today?'
parsed_intent	None	'weather_query'	'weather_query'	'weather_query'	'weather_query'	'weather_query'
selected_tool	None	None	'weather_tool'	'weather_tool'	'weather_tool'	'weather_tool'
tool_output	None	None	None	'Sunny, 25°C'	'Sunny, 25°C'	'Sunny, 25°C'
formatted_response	None	None	None	None	'The weather today is sunny with 25°C.'	'The weather today is sunny with 25°C.'

Key Moments - 2 Insights

How does the agent know which tool to use for the user's question?

The agent parses the input to find the intent and entities (see Step 2 and Step 3 in the execution table), then selects the appropriate tool based on that intent.

What happens if the tool execution fails or returns no data?

The agent would handle this by formatting a fallback response or error message during the formatting step (Step 5), ensuring the user still gets a reply.

Visual Quiz - 3 Questions

Look at the execution table, what is the output after Step 4?

A 'Sunny, 25°C'

B 'weather_tool'

C 'Parsed intent and entities'

D 'Formatted answer string'

💡 Hint

Check the 'Output/State' column for Step 4 in the execution table.

At which step does the agent decide which tool to use?

A Step 5

B Step 2

C Step 3

D Step 6

💡 Hint

Look for the step labeled 'Select tool' in the execution table.

If the user input changes, which variable in the variable tracker changes first?

A parsed_intent

B user_input

C selected_tool

D tool_output

💡 Hint

Check the variable tracker for the variable that stores the raw user question.

Concept Snapshot

Structured chat agent flow:
1. Receive user input
2. Parse input for intent
3. Select appropriate tool
4. Run tool to get data
5. Format response
6. Return answer
Use langchain's StructuredChatAgent with chat models and tools for modular, clear conversations.

Full Transcript

A structured chat agent in langchain works by taking the user's question, understanding what the user wants, choosing the right tool to answer, running that tool, and then giving back a clear answer. The process starts with receiving input, then parsing it to find the intent. Next, the agent picks the tool that fits the intent, runs it to get information, formats the answer nicely, and finally sends it back to the user. Variables like user_input, parsed_intent, selected_tool, tool_output, and formatted_response change step by step as the agent works. This flow helps keep conversations organized and easy to manage.

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