Abstract

Imagine having a helpful banking expert right in your pocket 📱ready to answer your questions instantly ⏱️, anytime, without the frustration of long waits or confusing paperwork 📄.

This project developed a smart chatbot designed to help bank customers quickly find accurate information by reading real banking documents like guides, FAQs, and policies. Using advanced AI trained specifically for finance, the chatbot understands your questions, corrects spelling mistakes, and focuses only on banking topics to provide clear, helpful responses. Built as an easy-to-use web app, it makes banking support faster, friendlier, and more reliable for everyone. This solution reduces customer wait times and improves satisfaction by delivering trustworthy answers grounded in actual bank content.

Introduction

Ever felt frustrated waiting on hold just to ask your bank a simple question?

You’re not alone. Many customers today expect quick, clear answers without the hassle of navigating long menus or reading through pages of fine print. That’s exactly where this project comes in.

This Bank Customer Service Chatbot is designed to make banking support faster, smarter, and more helpful. It’s not your average chatbot. It uses advanced AI like LangChain, HuggingFace embeddings, and FAISS to understand real questions and find answers directly from financial documents like PDFs, Word files, and text reports.Instead of generic replies, this chatbot searches through actual bank documents and gives relevant, document-based responses. It's trained with finance-specific knowledge, making it much better at understanding terms and topics that matter in the banking world.

Best of all? It runs inside a simple web app built with Streamlit, and it can update its knowledge on the fly meaning you can just drop in new documents and start asking questions right away.

In this report, We’ll walk you through how the system works, the tools behind it, and how it can help banks deliver faster, smarter customer service without the wait.

Methodology

How did we build a chatbot that understands banking questions?

Instead of creating just another chatbot that gives generic answers, our goal was to build something more intelligent something that can search real financial documents and respond in a way that makes sense to customers.

To do this, we followed a process known as Retrieval-Augmented Generation (RAG). In simple terms, this means the chatbot doesn’t just “guess” an answer using a language model it first retrieves relevant information from documents and then generates a response based on that content.

Let’s walk through how we made it happen.

Step 1: Load Bank Documents

We began by collecting real-world banking documents things like account guides, FAQs, loan policies, and service terms. These files were placed in the bank_docs/ folder and could be in PDF, Word (DOCX), or plain text formats.
To process them, we used LangChain’s unstructured document loaders, which convert all those formats into clean, searchable chunks of text.

Step 2: Understand the Content (Embeddings)

Once the text was ready, we needed a way for the chatbot to understand the meaning behind the words. We used a specialized model from HuggingFace:"FinLang/finance-embeddings-investopedia"

def save_vector_db(source_folder, save_path):
    """
    Load documents, generate embeddings using a finance-specific model,
    and save them as a FAISS vector database locally.
    """
    documents = load_documents(source_folder)
    logging.info(f"Loaded {len(documents)} documents from {source_folder}")

    embedder = HuggingFaceEmbeddings(
        model_name="FinLang/finance-embeddings-investopedia"
    )
    logging.info("Using FinLang/finance-embeddings-investopedia for creating embeddings.")

    vectorstore = FAISS.from_documents(documents, embedder)
    logging.info("FAISS vector store created from documents.")

    os.makedirs(save_path, exist_ok=True)
    logging.info(f"Ensured save directory exists: {save_path}")

    vectorstore.save_local(save_path)
    logging.info(f"✅ Vector DB saved to {save_path}")

This model is trained specifically on finance-related content. It turns text into embeddings, which are like numeric fingerprints that represent the meaning of the content. This makes it possible to compare a user’s question with the content of documents using math.

Step 3: Store Smart Data with FAISS

We stored these embeddings in a FAISS vector database. This tool is incredibly fast at finding which document snippets are most relevant to a given question.
So, when someone asks a question like “How do I close my account?”, the chatbot searches the FAISS database to find the most relevant part of any document that answers it.

Step 4: Build the Conversation Engine

Once the most relevant content is found, the chatbot uses LangChain to combine: The user’s question,
The retrieved content from documents.

It then generates a clear, helpful response using a language model by including like, greetings, spell correction, topic filtering and so on.

Here’s a summary of the key logic behind the chatbot, and how it helps ensure a smooth and intelligent user experience:

Step 5: Build an App for Real People

We created a clean and simple web app using Streamlit. Anyone can use it just by running the app no setup required. The app even downloads the vector database automatically from a GitHub release if it’s not already there.

Experiment and Results

To thoroughly evaluate the chatbot’s performance, the following set of questions were posed. These cover all major functionalities, including greetings, banking topics, handling unrelated queries, and robustness. Some responses in the table below are summarized for clarity. For the full, real-time chatbot responses to each question, please refer to the demonstration video included below.

The chatbot successfully handled a diverse set of queries, ranging from basic greetings to domain-specific financial questions. It responded appropriately to invalid inputs, corrected user typos, and gracefully declined unrelated queries demonstrating strong robustness, domain alignment, and user-friendliness.

Limitation and future work

Conclusion

This project introduced a smart banking chatbot designed to provide quick and accurate answers by reading real banking documents. Using advanced AI tools like LangChain, FAISS, and finance-specific embeddings, the chatbot can understand user questions, retrieve relevant information, and generate helpful responses.

The system was tested with a range of queries and performed well in understanding greetings, correcting typos, answering banking-related questions, and handling irrelevant inputs gracefully.

Although the chatbot was built using a limited set of documents from a sample bank (“Global Trust Bank”), it shows strong potential. Current limitations such as document coverage, response speed, and user interface design will be improved in future work.

Overall, the chatbot offers a practical solution for improving customer service in the banking sector — making support faster, more reliable, and easier to access.

Demo Video link: https://www.youtube.com/watch?v=tMqXeoa-HI4