🤖 Enterprise Support Chatbot — RAG

An AI-powered Enterprise Support Chatbot that uses Retrieval-Augmented Generation (RAG) to answer questions from uploaded PDF documents.

The application allows users to upload one or multiple PDF documents, processes their content, converts the text into semantic embeddings, retrieves the most relevant sections for a user query, and generates a context-aware response using a locally hosted Llama 3 model through Ollama.

Built with Python, LangChain, FAISS, HuggingFace Embeddings, Ollama, and Streamlit.

✨ Features

📄 Multiple PDF Upload
- Upload one or multiple PDF documents directly through the Streamlit interface.
- PDF content is automatically extracted and processed.
🔍 Semantic Search
- Converts document chunks into vector embeddings.
- Uses FAISS for efficient similarity-based retrieval.
- Retrieves the top 4 most relevant document chunks for each question.
🧠 Retrieval-Augmented Generation
- Retrieved document context is passed to the LLM.
- Llama 3 generates answers based on the retrieved information rather than relying solely on model knowledge.
🔒 Local AI Processing
- Uses Ollama to run Llama 3 locally.
- No external LLM API is required for answer generation.
💬 Interactive Chat Interface
- Built with Streamlit.
- Supports conversational question-and-answer interaction.
📚 Source Visibility
- Displays the source documents associated with retrieved content.
📝 Document Summarization
- Includes a document summarization component using Llama 3.

🏗️ Architecture

                    ┌─────────────────────┐
                    │     PDF Documents   │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │     PDF Loader      │
                    │     PyPDFLoader     │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │   Text Splitter     │
                    │ Chunk: 1000 chars   │
                    │ Overlap: 200 chars  │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │ HuggingFace BGE     │
                    │ Embeddings          │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │    FAISS Vector     │
                    │       Store         │
                    └──────────┬──────────┘
                               │
                         User Question
                               │
                               ▼
                    ┌─────────────────────┐
                    │ Semantic Retrieval  │
                    │      Top 4          │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │      Context        │
                    │   + User Query      │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │      Ollama         │
                    │      Llama 3        │
                    └──────────┬──────────┘
                               │
                               ▼
                    ┌─────────────────────┐
                    │   Grounded Answer   │
                    │    + Sources        │
                    └─────────────────────┘

🔄 RAG Pipeline

The application follows a standard Retrieval-Augmented Generation workflow:

1. Document Upload

Users upload PDF files through the Streamlit sidebar.

PDF 1
PDF 2
PDF 3
   ↓
PDF Loader

The application supports multiple PDFs in a single session.

2. PDF Extraction

PDF documents are loaded using LangChain's PyPDFLoader.

Each PDF is converted into LangChain Document objects containing the extracted text and metadata.

3. Text Chunking

Large documents are divided into smaller chunks using RecursiveCharacterTextSplitter.

Current configuration:

Chunk Size    : 1000 characters
Chunk Overlap : 200 characters

The overlap helps preserve contextual information between adjacent chunks.

4. Embedding Generation

Each document chunk is converted into a numerical vector using:

BAAI/bge-small-en-v1.5

The embedding model runs on CPU and uses normalized embeddings.

Document Chunk
      ↓
BGE-Small
      ↓
Vector Embedding

5. FAISS Vector Store

The generated embeddings are stored in a FAISS vector index.

FAISS enables fast similarity-based retrieval of relevant document chunks.

6. Semantic Retrieval

When a user asks a question, the application performs semantic similarity search against the vector store.

The current retriever returns:

Top K = 4

most relevant document chunks.

For example:

User:
"What is the company's refund policy?"

                ↓

        Semantic Search

                ↓

 ┌─────────────────────────────┐
 │ Chunk 1 — Refund Policy     │
 │ Chunk 2 — Return Conditions │
 │ Chunk 3 — Refund Timeline   │
 │ Chunk 4 — Exceptions        │
 └─────────────────────────────┘

7. LLM Response Generation

The retrieved chunks are combined into a context and passed to Llama 3 through Ollama.

The model receives:

Retrieved Context
        +
User Question
        ↓
      Llama 3
        ↓
Generated Answer

The chatbot uses a temperature of 0 to produce more deterministic responses.

🛠️ Tech Stack

Technology	Purpose
Python	Core application
Streamlit	Web interface
LangChain	RAG pipeline orchestration
PyPDFLoader	PDF document extraction
RecursiveCharacterTextSplitter	Document chunking
HuggingFace	Embedding generation
BAAI/bge-small-en-v1.5	Semantic embeddings
FAISS	Vector similarity search
Ollama	Local LLM inference
Llama 3	Answer generation

📂 Project Structure

support-chatbot-rag/
│
├── data/
│   └── Uploaded PDF documents
│
├── src/
│   ├── __init__.py
│   ├── chatbot.py
│   │   └── Llama 3 RAG response generation
│   │
│   ├── embeddings.py
│   │   └── HuggingFace embedding model
│   │
│   ├── pdf_loader.py
│   │   └── PDF loading and extraction
│   │
│   ├── prompts.py
│   │   └── RAG prompt configuration
│   │
│   ├── retriever.py
│   │   └── Semantic document retrieval
│   │
│   ├── summarizer.py
│   │   └── Document summarization
│   │
│   ├── text_splitter.py
│   │   └── Document chunking
│   │
│   └── vector_store.py
│       └── FAISS vector store management
│
├── utils/
│   └── Utility modules
│
├── app.py
│   └── Streamlit application
│
├── requirements.txt
│   └── Python dependencies
│
└── README.md

The repository currently follows this high-level structure with data, src, utils, app.py, and requirements.txt.

⚙️ Installation

1. Clone the Repository

git clone https://github.com/prathamesh1079/support-chatbot-rag.git

cd support-chatbot-rag

2. Create a Virtual Environment

Windows

python -m venv venv

venv\Scripts\activate

macOS / Linux

python3 -m venv venv

source venv/bin/activate

3. Install Dependencies

pip install -r requirements.txt

🧠 Install Ollama

This project uses Ollama to run Llama 3 locally.

Install Ollama and then download the required model:

ollama pull llama3

Verify that the model is available:

ollama list

The application is configured to use:

Model: llama3
Temperature: 0

▶️ Run the Application

Start the Streamlit application:

streamlit run app.py

The application will open in your browser.

Typically:

http://localhost:8501

💬 How to Use

Step 1 — Upload Documents

Use the sidebar to upload one or multiple PDF files.

Upload PDFs
   ├── company_policy.pdf
   ├── employee_handbook.pdf
   └── support_documentation.pdf

Step 2 — Ask a Question

Enter a question in the chat box.

Example:

What is the refund policy?

Step 3 — Retrieval

The system searches the FAISS vector store and retrieves the four most relevant chunks.

Step 4 — Generate Answer

The retrieved context is passed to Llama 3.

The chatbot generates an answer based on the retrieved document content.

Step 5 — View Sources

The application provides a Sources section showing the source metadata associated with retrieved documents.

📊 Example

Uploaded Document

Company_Policies.pdf

User Query

How many days do I have to request a refund?

RAG Pipeline

Question
   ↓
Query Embedding
   ↓
FAISS Similarity Search
   ↓
Top 4 Relevant Chunks
   ↓
Context Construction
   ↓
Llama 3
   ↓
Answer

Example Response

According to the company policy, customers can request
a refund within the specified refund period mentioned
in the policy document.

The answer is generated using the retrieved document context rather than directly querying an external knowledge source.

🧩 Core Components

PDF Loader

Responsible for loading and parsing one or multiple PDF files.

PDFLoader()

It uses LangChain's PyPDFLoader internally.

Document Splitter

Breaks documents into manageable chunks.

DocumentSplitter(
    chunk_size=1000,
    chunk_overlap=200
)

This improves retrieval by allowing the vector store to search smaller sections of the documents.

Embedding Model

The project uses:

BAAI/bge-small-en-v1.5

for semantic representation of document chunks.

Vector Store

FAISS manages the document embeddings and performs similarity search.

FAISS.from_documents(
    documents,
    embeddings
)

The project also includes functionality to save and load the FAISS index locally.

Retriever

The retriever performs semantic search and returns the top four relevant documents.

similarity_search(
    query,
    k=4
)

LLM

The chatbot uses Ollama with Llama 3:

ChatOllama(
    model="llama3",
    temperature=0
)

The retrieved documents are supplied as context to the model before generating the final response.

🔐 Why RAG?

Traditional LLM applications can generate answers based on their pretrained knowledge, which may not contain an organization's latest internal information.

RAG addresses this by introducing a retrieval step:

       User Question
             │
             ▼
      Retrieve Relevant
        Documents
             │
             ▼
       Provide Context
             │
             ▼
          LLM
             │
             ▼
      Grounded Answer

This makes the chatbot particularly useful for:

Enterprise documentation
Internal policies
Product documentation
Employee handbooks
Technical manuals
Customer support knowledge bases

🎯 Key Learning Outcomes

This project demonstrates practical implementation of:

Retrieval-Augmented Generation
Semantic search
Vector databases
Document ingestion
PDF processing
Text chunking
HuggingFace embeddings
FAISS similarity search
LangChain pipelines
Local LLM inference
Prompt engineering
Streamlit application development
Source-aware question answering

🚀 Future Improvements

Potential improvements include:

📌 Limitations

The current implementation focuses on PDF documents.
Llama 3 must be available through a local Ollama installation.
Embeddings currently run on CPU.
The vector store is created from the uploaded documents during application processing.
Retrieval currently returns a fixed top-4 set of documents.
Answer quality depends on the quality of the uploaded documents and retrieved context.

👨‍💻 Author

Prathamesh Tekale

Computer Science Engineering Student & Software Developer

GitHub: @prathamesh1079

⭐ Project Highlights

📄 Multi-PDF Document Processing
        ↓
✂️ Intelligent Text Chunking
        ↓
🧠 BGE Semantic Embeddings
        ↓
🔎 FAISS Vector Search
        ↓
📚 Top-4 Context Retrieval
        ↓
🤖 Llama 3 via Ollama
        ↓
💬 Grounded Support Response

📄 License

This project is intended for educational and demonstration purposes.

Name		Name	Last commit message	Last commit date
data		data
src		src
utils		utils
README.md		README.md
app.py		app.py
requirements.txt		requirements.txt

Latest commit

History

Folders and files

Repository files navigation