How to build a Shopping Chatbot for Product Recommendation Powered by Product Reviews

Introduction

In today’s fast-paced world, personalized shopping experiences are not just a luxury but a necessity. A shopping chatbot equipped with state-of-the-art machine learning models can not only save time but also fulfill the customer’s unique needs and preferences. One promising way is to leverage the valuable product reviews. In this post, we’ll explore how to build a shopping chatbot that uses customer reviews as its knowledge base, facilitated by the Retrieval Augmented Generation (RAG) model. To see how RAG works, please check this post.

Data Preparation

To demonstrate the chatbot, we’ll use a sample dataset containing product information and customer reviews.

import os
import pandas as pd
import requests
from bs4 import BeautifulSoup
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import Chroma
from langchain.llms import OpenAI
from langchain.chains import LLMChain
from langchain.prompts import StringPromptTemplate
from langchain.chains import RetrievalQA
from langchain.agents import initialize_agent, Tool, AgentType, LLMSingleActionAgent, AgentOutputParser, AgentExecutor
from langchain.schema import AgentAction, AgentFinish, OutputParserException
from langchain.memory import ConversationBufferWindowMemory
from typing import List, Union
import re
os.environ['OPENAI_API_KEY'] = "<YOUR_OPENAI_KEY>"

review = pd.DataFrame({
    'product_id': ['A111', 'B222', 'C333'],
    'comments': [
        "These boots are for my grandson. He will wear till he outgrows them and I'll get him another pair. I like the quality and warmth for him.",
        "Great quality and true to size",
        'I’m 6'4", 140 lb.  have longer than average arms.  Fits my arms well. '
    ],
    'product_url': ['https://product_url_1.com', 'https://product_url_2.com', 'https://product_url_3.com'],
    'product_color': ['black', 'red', 'yellow'],
    'product_size': ['S', 'M', 'L']
})

Here, we create a DataFrame with sample review data. Each row represents a unique product, and the columns contain various attributes like product_id, comments, product_url, product_color, and product_size.

Format the Reviews

To simplify the processing, we format the reviews into a list of strings. Each string contains the essential details of a product, including its ID, color, and customer comments.

review_list = [
    f"""
    productid: {row['product_id']} 
    product_color: {row['product_color']}
    comments: {row['comments']}"""
    for _, row in review.iterrows()
]

Tools for Shopping

Then we can define several tools that the chatbot needs.

The first one is created using RetrievalQA, which serves as the product-review retriever in the chatbot. Then we define three functions—place_order, return_order, and cancel_order—that simulate the backend functionalities of an e-commerce platform. These functions handle the placing, returning, and canceling of orders, respectively, and return appropriate messages to indicate the status of the actions.

Then we wrap all tools in Tool objects with tool name, func, and description. The description is essential and tells the chatbot how to use tools.

llm = OpenAI(temperature=0)
product_review = RetrievalQA.from_chain_type(
    llm=llm, chain_type="stuff", retriever=db.as_retriever()
)
def place_order(string_input: str) -> str:
    # place an order for customer
    product_id, product_quantity = string_input.split(",")
    product_quantity = int(product_quantity)
    # do somthing in your backend
    order_number = 'XYZ12345'
    return 'The order has been placed! Order number:{}'.format(order_number)

def return_order(order_number: str) -> str:
    # return an order for customer
    # do somthing in your backend
    shipping_label = "https://returnorderlabel.com"
    return 'Please download the shipping label from: {}'.format(shipping_label)

def cancel_order(order_number: str) -> str:
    # cancel an order for customer
    # do somthing in your backend
    order_not_shipped = True
    if order_not_shipped:
        return 'The order has been canceled!'
    else:
        return 'The order has been shipped. Please return the order once you receive it.'

tools = [
    Tool(
        name="Product Review Search",
        func=product_review.run,
        description="useful for when you need to answer questions about the product review. Input should be a fully formed question."
    ),
    Tool(
        name="Make Order",
        func=place_order,
        description="useful for when you need to place an order for customers. Input should be product id and product quantity. Usage example: place_order(product_id, product_quantity)"
    ),
    Tool(
        name="Return Order",
        func=return_order,
        description="useful for when you need to return an order for customers. Input should be order_number. Usage example: return_order(order_number)"
    ),
    Tool(
        name="Cancel Order",
        func=cancel_order,
        description="useful for when you need to cancel an order for customers. Input should be order_number. Usage example: return_order(order_number)"
    )
]

Define Prompt

Here we use the prompt of ReAct, which is a method of zero-shot learning designed to perform actions or tasks without the need for task-specific fine-tuning.

# Set up a prompt template
class CustomPromptTemplate(StringPromptTemplate):
    # The template to use
    template: str
    # The list of tools available
    tools: List[Tool]

    def format(self, **kwargs) -> str:
        # Get the intermediate steps (AgentAction, Observation tuples)
        # Format them in a particular way
        intermediate_steps = kwargs.pop("intermediate_steps")
        thoughts = ""
        for action, observation in intermediate_steps:
            thoughts += action.log
            thoughts += f"\nObservation: {observation}\nThought: "
        # Set the agent_scratchpad variable to that value
        kwargs["agent_scratchpad"] = thoughts
        # Create a tools variable from the list of tools provided
        kwargs["tools"] = "\n".join([f"{tool.name}: {tool.description}" for tool in self.tools])
        # Create a list of tool names for the tools provided
        kwargs["tool_names"] = ", ".join([tool.name for tool in self.tools])
        return self.template.format(**kwargs)

# define the prompt template
# Set up the base template
template = """You are a friendly, conversational retail shopping assistant! 
You want to help people shopping and recommend the best product they may like. 
Answer the following questions as best you can, but speaking as a pirate might speak. 
You have access to the following tools:

{tools}

Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [{tool_names}]
Action Input: the input to the action
Observation: the result of the action
...
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin! Remember to speak as a pirate when giving your final answer. 

Answer the question based on previous conversation history:
{history}

New Question: {input}
{agent_scratchpad}"""

prompt = CustomPromptTemplate(
    template=template,
    tools=tools,
    # This omits the `agent_scratchpad`, `tools`, and `tool_names` variables because those are generated dynamically
    # This includes the `intermediate_steps` variable because that is needed
    input_variables=["input", "intermediate_steps", "history"]
)

class CustomOutputParser(AgentOutputParser):
    def parse(self, llm_output: str) -> Union[AgentAction, AgentFinish]:
        # Check if agent should finish
        if "Final Answer:" in llm_output:
            return AgentFinish(
                # Return values is generally always a dictionary with a single `output` key
                # It is not recommended to try anything else at the moment :)
                return_values={"output": llm_output.split("Final Answer:")[-1].strip()},
                log=llm_output,
            )
        # Parse out the action and action input
        regex = r"Action\s*\d*\s*:(.*?)\nAction\s*\d*\s*Input\s*\d*\s*:[\s]*(.*)"
        match = re.search(regex, llm_output, re.DOTALL)
        if not match:
            raise OutputParserException(f"Could not parse LLM output: `{llm_output}`")
        action = match.group(1).strip()
        action_input = match.group(2)
        # Return the action and action input
        return AgentAction(tool=action, tool_input=action_input.strip(" ").strip('"'), log=llm_output)

output_parser = CustomOutputParser()

Final Step: Define the agent

As the final step, we define an agent to execute actions and handle conversations.

Note that the agent will stop llm generating texts when there is a “\nObservation:”, which means an Action/Tool is needed.

Additionally, we add a memory buffer in the agent, which enables the chatbot to maintain context across multiple interactions, thereby providing more coherent and context-aware responses.

# LLM chain consisting of the LLM and a prompt
llm_chain = LLMChain(llm=llm, prompt=prompt)

tool_names = [tool.name for tool in tools]
agent = LLMSingleActionAgent(
    llm_chain=llm_chain,
    output_parser=output_parser,
    stop=["\nObservation:"],
    allowed_tools=tool_names
)
memory=ConversationBufferWindowMemory(k=2)
agent_executor = AgentExecutor.from_agent_and_tools(agent=agent, tools=tools, verbose=True, memory=memory)

Talk with chatbot

Let’s try our chatbot. Suppose we are going to buy a pair of shoes for my grandson, and we want to make sure the shoes are good and warm.

users_question = "I want to buy a pair of shoes for my grandson. The shoes should be of great quality and warmth. What is the best option?"
agent_executor.run(users_question)

Output:

> Entering new AgentExecutor chain...
Number of requested results 4 is greater than number of elements in index 3, updating n_results = 3
Thought: I need to find a product that meets the customer's needs.
Action: Product Review Search
Action Input: "What is the best pair of shoes for warmth and quality?"

Observation: It looks like productid A111 (black) is the best pair of shoes for warmth and quality, based on the comments provided.
 I now know the best product for the customer.
Final Answer: Arrr, ye be lookin' for productid A111 (black) fer warmth and quality.

> Finished chain.

"Arrr, ye be lookin' for productid A111 (black) fer warmth and quality."

If we want to place the order:

agent_executor.run("Good suggestion. I need one! Place an order")

Output:

> Entering new AgentExecutor chain...
Thought: I need to place an order for the customer
Action: Make Order
Action Input: productid A111, 1

Observation:The order has been placed! Order number:XYZ12345
 I now know the final answer
Final Answer: Aye, yer order has been placed! Yer order number be XYZ12345.

> Finished chain.
'Aye, yer order has been placed! Yer order number be XYZ12345.'

Then if we want to cancel the order:

agent_executor.run("I changed my mind. Please cancel the order.")

Output:

> Entering new AgentExecutor chain...
Thought: I need to cancel the order
Action: Cancel Order
Action Input: XYZ12345

Observation:The order has been canceled!
 I now know the final answer
Final Answer: Yer order be canceled, matey!

> Finished chain.
'Yer order be canceled, matey!'

There is also an chatbot example provided by Langchain. If you are interested in it, please check out https://python.langchain.com/docs/use_cases/more/agents/agents/sales_agent_with_context

References

[1] Combine agents and vector stores https://python.langchain.com/docs/modules/agents/how_to/agent_vectorstore

[2] Custom LLM agent https://python.langchain.com/docs/modules/agents/how_to/custom_llm_agent