Structured chat agent in LangChain - Mini Project: Build & Apply

Build a Structured Chat Agent with LangChain

📖 Scenario: You want to create a simple chat agent that can answer questions about a specific topic using LangChain. This agent will have a clear structure to handle user input and provide relevant answers.

🎯 Goal: Build a structured chat agent using LangChain that can receive a question and return a relevant answer based on a predefined knowledge base.

📋 What You'll Learn

Create a knowledge base as a dictionary with exact entries

Set up a LangChain prompt template for the chat agent

Implement the core logic to process user input and generate answers

Complete the agent setup to run the chat interaction

💡 Why This Matters

🌍 Real World

Structured chat agents help businesses provide quick, accurate answers to customer questions using predefined knowledge.

💼 Career

Understanding how to build chat agents is useful for roles in AI development, customer support automation, and software engineering.

1

Create the knowledge base dictionary

Create a dictionary called knowledge_base with these exact entries: 'Python': 'A popular programming language.', 'LangChain': 'A framework for building language model applications.', 'Agent': 'An entity that can perform tasks based on input.'

LangChain

# Your code here

Hint

Use a Python dictionary with the exact keys and values given.

2

Set up the prompt template

Create a variable called prompt_template and assign it the string: 'Answer the question based on the knowledge base: {question}'

LangChain

knowledge_base = {
    'Python': 'A popular programming language.',
    'LangChain': 'A framework for building language model applications.',
    'Agent': 'An entity that can perform tasks based on input.'
}

# Your code here

Hint

Assign the exact string to prompt_template.

3

Implement the core logic to answer questions

Define a function called answer_question that takes a parameter question. Inside, use a for loop with variables key and value to iterate over knowledge_base.items(). If key is found in question, return value. If no key matches, return 'Sorry, I do not know the answer.'

LangChain

knowledge_base = {
    'Python': 'A popular programming language.',
    'LangChain': 'A framework for building language model applications.',
    'Agent': 'An entity that can perform tasks based on input.'
}

prompt_template = 'Answer the question based on the knowledge base: {question}'

# Your code here

Hint

Use a function with a for loop to check if any key is in the question string.

4

Complete the chat agent setup

Create a variable called chat_agent and assign it a dictionary with two keys: 'prompt' set to prompt_template and 'answer_function' set to answer_question

LangChain

knowledge_base = {
    'Python': 'A popular programming language.',
    'LangChain': 'A framework for building language model applications.',
    'Agent': 'An entity that can perform tasks based on input.'
}

prompt_template = 'Answer the question based on the knowledge base: {question}'

def answer_question(question):
    for key, value in knowledge_base.items():
        if key in question:
            return value
    return 'Sorry, I do not know the answer.'

# Your code here

Hint

Create a dictionary named chat_agent with the specified keys and values.

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