Building a RAG Chatbot Using Langchain and Streamlit:Engage with Your PDFs | by Tarun Singh | Jun, 2024

Interacting with in depth PDFs has by no means been extra fascinating. Think about being able to converse together with your notes, books, and paperwork seamlessly. This complete information will stroll you thru making a Multi-RAG Streamlit-based net software that reads, processes, and engages with PDF information by means of an AI-driven chatbot. Let’s dive into the step-by-step strategy of creating this modern software.

Earlier than we begin constructing, let’s introduce the vital instruments and libraries we are going to use:

• Streamlit: A strong framework that simplifies the method of making and sharing lovely, customized net purposes for machine studying and information science.
• PyPDF2: A complete library designed for studying and manipulating PDF information. It may possibly extract textual content, merge a number of PDFs, and even decrypt secured PDFs.
• Langchain: A flexible suite of instruments aimed toward enhancing pure language processing (NLP) and creating refined conversational AI purposes. Langchain supplies numerous utilities for textual content processing, embedding, and interplay.
• FAISS: A library developed by Fb AI Analysis that’s designed for environment friendly similarity search and clustering of dense vectors. It’s extremely optimized and helps quick indexing and looking out, which is essential for dealing with giant datasets.

Right here’s the preliminary code setup with feedback for higher understanding:

import streamlit as st  # Importing Streamlit for the net interface
from PyPDF2 import PdfReader  # Importing PyPDF2 for studying PDF information
from langchain.text_splitter import RecursiveCharacterTextSplitter  # Importing Langchain's textual content splitter
from langchain_core.prompts import ChatPromptTemplate  # Importing ChatPromptTemplate from Langchain
from langchain_community.embeddings.spacy_embeddings import SpacyEmbeddings  # Importing SpacyEmbeddings
from langchain_community.vectorstores import FAISS  # Importing FAISS for vector retailer
from langchain.instruments.retriever import create_retriever_tool  # Importing retriever instrument from Langchain
from dotenv import load_dotenv  # Importing dotenv to handle setting variables
from langchain_anthropic import ChatAnthropic  # Importing ChatAnthropic from Langchain
from langchain_openai import ChatOpenAI, OpenAIEmbeddings  # Importing ChatOpenAI and OpenAIEmbeddings from Langchain
from langchain.brokers import AgentExecutor, create_tool_calling_agent  # Importing agent-related modules from Langchain
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"  # Setting setting variable to keep away from potential conflicts

The primary main performance of our software includes studying PDF information. That is achieved utilizing a PDF reader which extracts textual content from uploaded PDF information and compiles it right into a single steady string.

When customers add a number of PDFs, the applying processes every doc to extract textual content. This course of includes studying every web page of the PDF and concatenating the textual content to kind a single giant string.

Detailed Clarification:

1. PDF Add: Customers can add a number of PDF information by means of the Streamlit interface.
2. Textual content Extraction: For every uploaded PDF, the applying makes use of PdfReader to iterate by means of each web page and extract the textual content. This textual content is then concatenated right into a single steady string.

def pdf_read(pdf_doc):
textual content = ""
for pdf in pdf_doc:
pdf_reader = PdfReader(pdf)  # Initializing the PDF reader for the given doc
for web page in pdf_reader.pages:  # Iterating by means of every web page within the PDF
textual content += web page.extract_text()  # Extracting and appending the textual content from the present web page
return textual content  # Returning the concatenated textual content from all pages

To effectively analyze and course of the textual content, we break up it into smaller chunks. That is performed utilizing Langchain’s textual content splitter, which helps in managing giant texts by dividing them into smaller, extra manageable segments.

Detailed Clarification:

1. Textual content Chunking: The massive textual content string is split into smaller chunks of 1000 characters every, with an overlap of 200 characters to make sure context is preserved throughout chunks.
2. Effectivity in Processing: Smaller textual content chunks are simpler to course of and analyze, enabling environment friendly retrieval and interplay.

def get_chunks(textual content):
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)  # Initializing the textual content splitter with specified chunk dimension and overlap
chunks = text_splitter.split_text(textual content)  # Splitting the textual content into chunks
return chunks  # Returning the record of textual content chunks

As soon as the textual content is break up into chunks, the following step is to make it searchable by changing these chunks into vector representations. That is the place the FAISS library comes into play.

By changing textual content chunks into vectors, we allow the system to carry out quick and environment friendly searches inside the textual content. The vectors are saved domestically for fast retrieval.

Detailed Clarification:

1. Embedding Era: Every textual content chunk is transformed right into a vector illustration utilizing Spacy embeddings. This numerical illustration is essential for similarity search and retrieval.
2. Vector Storage: The generated vectors are saved utilizing the FAISS library, which facilitates quick indexing and looking out. This makes the textual content database extremely environment friendly and scalable.

embeddings = SpacyEmbeddings(model_name="en_core_web_sm")  # Initializing Spacy embeddings with the desired mannequin
def vector_store(text_chunks):
vector_store = FAISS.from_texts(text_chunks, embedding=embeddings)  # Making a FAISS vector retailer from textual content chunks
vector_store.save_local("faiss_db")  # Saving the vector retailer domestically

The core of this software is the conversational AI, which leverages OpenAI’s highly effective fashions to work together with the processed PDF content material. Right here’s an in depth clarification of how this element is about up:

To allow the chatbot to reply questions based mostly on the PDF content material, we configure it utilizing OpenAI’s GPT mannequin. This setup includes a number of steps:

1. Mannequin Initialization: We initialize the GPT mannequin, specifying the specified mannequin variant (gpt-3.5-turbo) and setting the temperature parameter to regulate the randomness of the responses. A decrease temperature ensures extra deterministic solutions.
2. Immediate Template: A immediate template is used to information the AI in understanding the context and producing acceptable responses. This template contains system directions, placeholders for chat historical past, person enter, and agent scratchpad.
3. Agent Creation: We create an agent utilizing the initialized mannequin and the immediate template. This agent will deal with the dialog, invoking needed instruments to fetch related data from the PDF content material.

The dialog chain is essential for sustaining the context of the dialogue and guaranteeing correct responses. Right here’s a breakdown of the method:

1. Device Integration: We combine instruments that help the AI in retrieving related data from the PDF textual content saved within the vector database.
2. Agent Execution: The agent executes the dialog by invoking the instruments and processing the person’s question. If the reply will not be out there within the offered context, the AI responds with “reply will not be out there within the context,” guaranteeing that customers don’t obtain incorrect data.

Right here’s the detailed code implementation for establishing the conversational AI:

def get_conversational_chain(instruments, ques):
# Initialize the language mannequin with specified parameters
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0, api_key="")
# Outline the immediate template for guiding the AI's responses
immediate = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are a helpful assistant. Answer the question as detailed as possible from the provided context, make sure to provide all the details. If the answer is not in
provided context just say, "answer is not available in the context", don't provide the wrong answer""",
),
("placeholder", "{chat_history}"),
("human", "{input}"),
("placeholder", "{agent_scratchpad}"),
]
)
# Create the instrument record and the agent
instrument = [tools]
agent = create_tool_calling_agent(llm, instrument, immediate)
# Execute the agent to course of the person's question and get a response
agent_executor = AgentExecutor(agent=agent, instruments=instrument, verbose=True)
response = agent_executor.invoke({"enter": ques})
print(response)
st.write("Reply: ", response['output'])

The applying permits customers to enter their questions by means of a easy textual content interface. The person enter is then processed to retrieve related data from the PDF database:

1. Load Vector Database: The vector database containing the textual content chunks is loaded. This database is essential for performing environment friendly searches.
2. Retrieve Info: The retriever instrument is used to fetch the related textual content chunks that may include the reply to the person’s query.
3. Generate Response: The conversational chain is invoked to course of the retrieved data and generate a response.

Right here’s the code for dealing with person enter:

def user_input(user_question):
# Load the vector database
new_db = FAISS.load_local("faiss_db", embeddings, allow_dangerous_deserialization=True)
# Create a retriever from the vector database
retriever = new_db.as_retriever()
retrieval_chain = create_retriever_tool(retriever, "pdf_extractor", "This instrument is to offer solutions to queries from the PDF")
# Get the conversational chain to generate a response
get_conversational_chain(retrieval_chain, user_question)

With the backend prepared, the applying makes use of Streamlit to create a user-friendly interface. This interface facilitates person interactions, together with importing PDFs and querying the chatbot:

Customers work together with the applying by means of a clear and intuitive interface:

• Query Enter: Customers can kind their questions in a textual content enter subject. The AI’s responses are displayed immediately on the internet web page.
• PDF Add and Processing: Customers can add new PDF information, that are processed in real-time to replace the textual content database.

Right here’s the code for the principle software interface:

def primary():
st.set_page_config("Chat PDF")
st.header("RAG based mostly Chat with PDF")
user_question = st.text_input("Ask a Query from the PDF Information")
if user_question:
user_input(user_question)
with st.sidebar:
st.title("Menu:")
pdf_doc = st.file_uploader("Add your PDF Information and Click on on the Submit & Course of Button", accept_multiple_files=True)
if st.button("Submit & Course of"):
with st.spinner("Processing..."):
raw_text = pdf_read(pdf_doc)
text_chunks = get_chunks(raw_text)
vector_store(text_chunks)
st.success("Executed")
if __name__ == "__main__":
primary()

This tutorial demonstrates construct a classy Multi-PDF RAG chatbot utilizing Langchain, Streamlit, and different highly effective libraries. By following these steps, you may create an software that not solely processes and understands giant PDF paperwork but additionally interacts with customers in a significant method.

The potential purposes of this know-how are huge:

• Training: College students can use this chatbot to shortly discover solutions of their textbooks and notes.
• Analysis: Researchers can work together with giant volumes of analysis papers, extracting related data effectively.
• Enterprise: Companies can automate the extraction of key data from in depth reviews and paperwork, saving time and growing productiveness.

By persevering with to boost the capabilities of this chatbot, integrating extra superior NLP strategies, and optimizing the person interface, we will create much more highly effective instruments that bridge the hole between people and the huge quantities of digital data out there right this moment.

On your comfort, right here’s the whole code for the applying:

import streamlit as st
from PyPDF2 import PdfReader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate
from langchain_community.embeddings.spacy_embeddings import SpacyEmbeddings
from langchain_community.vectorstores import FAISS
from langchain.instruments.retriever import create_retriever_tool
from dotenv import load_dotenv
from langchain_anthropic import ChatAnthropic
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.brokers import AgentExecutor, create_tool_calling_agent
import os
os.environ["KMP_DUPLICATE_LIB_OK"] = "TRUE"
embeddings = SpacyEmbeddings(model_name="en_core_web_sm")
def pdf_read(pdf_doc):
textual content = ""
for pdf in pdf_doc:
pdf_reader = PdfReader(pdf)
for web page in pdf_reader.pages:
textual content += web page.extract_text()
return textual content
def get_chunks(textual content):
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = text_splitter.split_text(textual content)
return chunks
def vector_store(text_chunks):
vector_store = FAISS.from_texts(text_chunks, embedding=embeddings)
vector_store.save_local("faiss_db")
def get_conversational_chain(instruments, ques):
llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0, api_key="")
immediate = ChatPromptTemplate.from_messages(
[
(
"system",
"""You are a helpful assistant. Answer the question as detailed as possible from the provided context, make sure to provide all the details. If the answer is not in
provided context just say, "answer is not available in the context", don't provide the wrong answer""",
),
("placeholder", "{chat_history}"),
("human", "{input}"),
("placeholder", "{agent_scratchpad}"),
]
)
instrument = [tools]
agent = create_tool_calling_agent(llm, instrument, immediate)
agent_executor = AgentExecutor(agent=agent, instruments=instrument, verbose=True)
response = agent_executor.invoke({"enter": ques})
print(response)
st.write("Reply: ", response['output'])
def user_input(user_question):
new_db = FAISS.load_local("faiss_db", embeddings, allow_dangerous_deserialization=True)
retriever = new_db.as_retriever()
retrieval_chain = create_retriever_tool(retriever, "pdf_extractor", "This instrument is to offer solutions to queries from the PDF")
get_conversational_chain(retrieval_chain, user_question)
def primary():
st.set_page_config("Chat PDF")
st.header("RAG based mostly Chat with PDF")
user_question = st.text_input("Ask a Query from the PDF Information")
if user_question:
user_input(user_question)
with st.sidebar:
st.title("Menu:")
pdf_doc = st.file_uploader("Add your PDF Information and Click on on the Submit & Course of Button", accept_multiple_files=True)
if st.button("Submit & Course of"):
with st.spinner("Processing..."):
raw_text = pdf_read(pdf_doc)
text_chunks = get_chunks(raw_text)
vector_store(text_chunks)
st.success("Executed")
if __name__ == "__main__":
primary()

Run the applying by saving it as app.py after which utilizing the command:

streamlit run app.py

This software serves as a basis for constructing extra complicated and succesful conversational brokers, opening the door to quite a few potentialities in doc administration and knowledge retrieval.