Chatbot Creation on Custom Data

Amit Sharma

3 August 2023

In this blog, we will talk about AI Chatbots, we will get their workings, essentials, and the key parts that bring them to life.

Before starting that, we should understand how we can leverage our e-commerce business with Chabtot.

Recently Bagisto has added a new product AI Chatbot. From simple customer service assistants to cutting-edge AI-powered conversational agents, chatbots have become an integral part of our digital landscape, transforming the way we interact with technology and businesses.

Here are a few use cases of how an AI Chatbot can help grow your business and customer satisfaction:

A 24/7 assistant on your e-commerce: AI Chatbot can serve as a 24/7 assistant on your e-commerce platform, it can help users get answers to their queries in a few seconds.
Policies-related Queries: AI Chatbot can answer users’ queries regarding your e-commerce policies like return policy within seconds.
Products-related Queries: Users don’t need to go through hundreds of products, rather AI Chatbot can return the exact products with their URLs.
Discount-related Queries: Users love to know whether discounts are available or not and the chatbot can help them.
Customer engagement: Fast responses from AI Chatbot will grow the user’s engagement on your e-commerce platforms.
Saves customer Time: Faster solutions to their queries and ease in finding the desired products will save a lot of time for users

So let’s start our journey to understand the world of Chatbots:

Let’s start by understanding the Chatbot

An AI chatbot is nothing but a pre-trained Large Language Model that is again trained on custom data to handle user queries.

Understanding Large Language Model

A large language model is a model that can understand human language. It is a Neural Network that is trained on Millions of text documents for hundreds of hours on large number of GPUs.

Why pre-trained large language model?

As we have discussed how an LLM is trained, it is very costly, computationally expensive, and time-consuming, and a highly skilled team of Data Engineers and Data Scientists is required.

And once an LLM is trained it can be reused very easily, so it is highly preferred to use a pre-trained LLM rather than training it again.

To use a pre-trained LLM like OpenAI, we need to provide its OpenAI key. Bagisto has provided the option to enter the API key and use the Chatbot.

Structure of a Chatbot

Custom Knowledge Base

The custom Knowledge base is the text data from which you want the Chatbot to answer the queries. Suppose you want to deploy a chatbot on your e-commerce website, you would be willing to train the chatbot to answer queries of users regarding your return policy or the products/services offered by you.

So in that case, your knowledge base would be the data containing the return policy and list of products/services offered by you.

def load_knowledge_base(file_path):
    loader = TextLoader(file_path)
    documents = loader.load()
    return documents

def load_knowledge_base(file_path):

loader = TextLoader(file_path)

documents = loader.load()

return documents

Training the Chatbot on Custom Data

Now this is the tricky part. The knowledge base can be huge for e.g it can consist of 50000 words, but the pre-trained LLMs like OpenAI have token limits. Token limit is nothing but word limits that an LLM can handle at once.

So, the token limit of the latest OpenAI LLM has a token limit of 16000, so how are we going to train the chatbot to answer queries from data of 50000 words? Here comes the Langchain.

Langchain

LangChain is a framework for developing applications powered by language models. It is written in Python and TypeScript and can be used in a variety of environments, including Node.js, Cloudflare Workers, and the browser.

from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.text_splitter import CharacterTextSplitter
from langchain.vectorstores import Chroma
from langchain.document_loaders import TextLoader

from langchain.docstore.document import Document
from langchain.prompts import PromptTemplate
from langchain.indexes.vectorstore import VectorstoreIndexCreator

from langchain.chains.question_answering import load_qa_chain
from langchain.llms import OpenAI

from langchain.embeddings.openai import OpenAIEmbeddings

from langchain.text_splitter import CharacterTextSplitter

from langchain.vectorstores import Chroma

from langchain.document_loaders import TextLoader

from langchain.docstore.document import Document

from langchain.prompts import PromptTemplate

from langchain.indexes.vectorstore import VectorstoreIndexCreator

from langchain.chains.question_answering import load_qa_chain

from langchain.llms import OpenAI

Solving the issue of the token limit with the help of Langchain

Langchain trains the data into smaller chunks using CharacterTextSplitter and stores all the chunks in the form of embeddings(Vectors). Now whenever a query is asked by the user it first checks which chunk of text is most related to the user’s query, after that, it sends that chunk along with the query to the LLM to generate the answer.

def split_data_to_chunks(documents):
    if os.path.exists("chunks.pkl"):
        with open("chunks.pkl", "rb") as file:
            docs=pickle.load(file)
    else:
        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
        docs = text_splitter.split_documents(documents)
        with open("chunks.pkl", "wb") as file:
            pickle.dump(docs, file)
    return docs

def split_data_to_chunks(documents):

if os.path.exists("chunks.pkl"):

with open("chunks.pkl", "rb") as file:

docs=pickle.load(file)

else:

text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)

docs = text_splitter.split_documents(documents)

with open("chunks.pkl", "wb") as file:

pickle.dump(docs, file)

return docs

def compute_embeddings(docs):
    embeddings = OpenAIEmbeddings(openai_api_key= openai_api_key)
    return embeddings

def compute_embeddings(docs):

embeddings = OpenAIEmbeddings(openai_api_key= openai_api_key)

return embeddings

How does Langchain find the most related text chunk to the user’s queries?

Actually, computers only understand numbers, so each word is stored in the form of long vectors, which are also called embeddings. So to find the most related chunk of text, it uses an algorithm, which is nothing but a mathematical equation that finds similarity between two vectors. This algorithm is called Cosine Similarity.

So, it converts all the text chunks into vectors and stores them in the form of a vector database. When a query is asked, it converts the query into a vector. After that, Vector Store applies the cosine similarity between the query vector and each text chunk vector and returns the most similar text chunk.

def make_vector_database(docs, embeddings):
    db = Chroma.from_documents(docs, embeddings)
    return db

def make_vector_database(docs, embeddings):

db = Chroma.from_documents(docs, embeddings)

return db

Understanding Vector Store

Vectorstores retrieve the most similar text from the vector database. All the vector Database end functions are performed by vector stores. Langchain provides a variety of Vector Stores.

def store_and_retrieve_embeddings(docs,db, embeddings):
    persist_directory = 'db'


    vectordb = Chroma.from_documents(documents=docs, embedding=embeddings, persist_directory=persist_directory)

    vectordb.persist()
    vectordb = None

    vectordb = Chroma(persist_directory=persist_directory, embedding_function=embeddings)

    retriever = db.as_retriever(search_type="mmr")

def store_and_retrieve_embeddings(docs,db, embeddings):

persist_directory = 'db'

vectordb = Chroma.from_documents(documents=docs, embedding=embeddings, persist_directory=persist_directory)

vectordb.persist()

vectordb = None

vectordb = Chroma(persist_directory=persist_directory, embedding_function=embeddings)

retriever = db.as_retriever(search_type="mmr")

Now, finally run the Chatbot

def chatbot(query,retriever):
    docs=retriever.get_relevant_documents(query)[0]
#input_documents = [doc for doc in docs]
    chain = load_qa_chain(OpenAI(openai_api_key=str(openai_api_key),temperature=0), chain_type="stuff")
    response = chain.run(input_documents=[docs], question=query)
    print("AI Agent:- ",response)

def chatbot(query,retriever):

docs=retriever.get_relevant_documents(query)[0]

#input_documents = [doc for doc in docs]

chain = load_qa_chain(OpenAI(openai_api_key=str(openai_api_key),temperature=0), chain_type="stuff")

response = chain.run(input_documents=[docs], question=query)

print("AI Agent:- ",response)

Here are a few key points for using Bagisto’s AI Chatbot

In Bagisto’s AI Chatbot, we have provided the option to choose between the most efficient Vector Store. There is an option to select between Chroma and Pinecone Vector Store.

After choosing the Vector Store, you have to provide the Vector Store API Key to use that Vector Store.

With these simple steps, harness the power of AI effortlessly and unlock a seamless conversational experience with Bagisto’s AI Chatbot. Leave the technical intricacies to us; now you can focus on engaging your customers and enhancing your online store like never before!