Update app.py

app.py

@@ -1,95 +1,101 @@
-# Import required modules from 'langchain' for document processing, embeddings, Q&A, etc.
-from langchain.document_loaders import PyPDFLoader
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.vectorstores import Chroma
-from langchain.embeddings import OpenAIEmbeddings
-from langchain.chat_models import ChatOpenAI
-from langchain.chains import RetrievalQA
+# Import necessary modules for processing documents, embeddings, Q&A, etc. from 'langchain' library.
+from dotenv import load_dotenv
+load_dotenv()  # Load environment variables from a .env file.
+from langchain.document_loaders import PyPDFLoader  # For loading and reading PDF documents.
+from langchain.text_splitter import RecursiveCharacterTextSplitter  # For splitting large texts into smaller chunks.
+from langchain.vectorstores import Chroma  # Vector storage system for embeddings.
+from langchain.llms import CTransformers  # For loading transformer models.
+from InstructorEmbedding import INSTRUCTOR  # Not clear without context, possibly a custom embedding.
+from langchain.embeddings import HuggingFaceInstructEmbeddings  # Embeddings from HuggingFace models with instructions.
+from langchain.embeddings import HuggingFaceEmbeddings  # General embeddings from HuggingFace models.
+from langchain.embeddings import LlamaCppEmbeddings  # Embeddings using the Llama model.
+from langchain.chains import RetrievalQA  # Q&A retrieval system.
+from langchain.embeddings import OpenAIEmbeddings  # Embeddings from OpenAI models.
+from langchain.vectorstores import FAISS  # Another vector storage system for embeddings.
 
-# Importing Streamlit for creating the web app, and other necessary modules for file handling.
-import streamlit as st
-import tempfile
-import os
+# Import Streamlit for creating a web application and other necessary modules for file handling.
+import streamlit as st  # Main library for creating the web application.
+import tempfile  # For creating temporary directories and files.
+import os  # For handling file and directory paths.
 
 # Import a handler for streaming outputs.
-from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
+from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler  # For live updates in the Streamlit app.
 
 # Set the title of the Streamlit web application.
 st.title("ChatPDF")
-# Create a horizontal line for better visual separation in the app.
+# Create a visual separator in the app.
 st.write("---")
 
-# Provide an input box for users to enter their OpenAI API key.
-openai_key = st.text_input('Enter OPEN_AI_API_KEY', type="password")
-
-# Provide a file upload widget to let users upload their PDF files.
+# Add a file uploader widget for users to upload their PDF files.
 uploaded_file = st.file_uploader("Upload your PDF file!", type=['pdf'])
-# Another visual separation after the file uploader.
+# Another visual separator after the file uploader.
 st.write("---")
 
-# Define a function that converts the uploaded PDF into a document format.
+# Function to convert the uploaded PDF into a readable document format.
 def pdf_to_document(uploaded_file):
-    # Create a temporary directory to store the uploaded PDF file temporarily.
+    # Create a temporary directory for storing the uploaded PDF.
     temp_dir = tempfile.TemporaryDirectory()
-    # Join the directory path with the uploaded file name to get the complete path.
+    # Get the path where the uploaded PDF will be stored temporarily.
     temp_filepath = os.path.join(temp_dir.name, uploaded_file.name)
     
-    # Write the content of the uploaded file into the temporary file path.
+    # Save the uploaded PDF to the temporary path.
     with open(temp_filepath, "wb") as f:
         f.write(uploaded_file.getvalue())
     
-    # Use PyPDFLoader to read and split the PDF into individual pages.
+    # Load the PDF and split it into individual pages.
     loader = PyPDFLoader(temp_filepath)
     pages = loader.load_and_split()
     return pages
 
-# Check if a file has been uploaded by the user.
+# Check if a user has uploaded a file.
 if uploaded_file is not None:
     # Convert the uploaded PDF into a document format.
     pages = pdf_to_document(uploaded_file)
 
-    # Initialize a text splitter to break the document into smaller chunks.
+    # Initialize a tool to split the document into smaller textual chunks.
     text_splitter = RecursiveCharacterTextSplitter(
-        # Define parameters for the splitter: chunk size, overlap, etc.
-        chunk_size = 300,
-        chunk_overlap  = 20,
-        length_function = len
+        chunk_size = 300,  # Define the size of each chunk.
+        chunk_overlap  = 20,  # Define how much chunks can overlap.
+        length_function = len  # Function to determine the length of texts.
     )
-    # Split the document pages into chunks.
+    # Split the document into chunks.
     texts = text_splitter.split_documents(pages)
 
-    # Initialize the OpenAIEmbeddings model for creating embeddings from texts using the provided API key.
-    embeddings_model = OpenAIEmbeddings(openai_api_key=openai_key)
+    ## Below are examples of different embedding techniques, but they are commented out.
+
+    # Load the desired embeddings model.
+    embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2',
+                                       model_kwargs={'device': 'cpu'})
 
-    # Load the textual chunks into Chroma after creating embeddings.
-    db = Chroma.from_documents(texts, embeddings_model)
+    # Load the textual chunks into the Chroma vector store.
+    db = Chroma.from_documents(texts, embeddings)
 
-    # Define a custom handler to stream outputs to the Streamlit app.
+    # Custom handler to stream outputs live to the Streamlit application.
     from langchain.callbacks.base import BaseCallbackHandler
     class StreamHandler(BaseCallbackHandler):
         def __init__(self, container, initial_text=""):
-            self.container = container
+            self.container = container  # Streamlit container to display text.
             self.text=initial_text
         def on_llm_new_token(self, token: str, **kwargs) -> None:
-            self.text+=token
-            self.container.markdown(self.text)
+            self.text+=token  # Add new tokens to the text.
+            self.container.markdown(self.text)  # Display the text.
 
-    # Display a header for the question section of the web app.
+    # Header for the Q&A section of the web app.
     st.header("Ask the PDF a question!")
-    # Provide an input box for users to type in their questions.
+    # Input box for users to type their questions.
     question = st.text_input('Type your question')
 
-    # Check if the user has clicked on the 'Ask' button.
+    # Check if the user has pressed the 'Ask' button.
     if st.button('Ask'):
-        # Show a spinner animation while processing the user's question.
+        # Display a spinner while processing the question.
         with st.spinner('Processing...'):
-            # Create a space to display the answer.
+            # Space to display the answer.
             chat_box = st.empty()
-            # Initialize a handler to stream outputs.
+            # Initialize the handler to stream outputs.
             stream_hander = StreamHandler(chat_box)
-            # Initialize the ChatOpenAI model for Q&A tasks with streaming enabled.
-            llm = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0, openai_api_key=openai_key, streaming=True, callbacks=[stream_hander])
-            # Create a RetrievalQA chain that uses the ChatOpenAI model and Chroma retriever to answer the question.
+
+            # Initialize the Q&A model and chain.
+            llm = CTransformers(model="llama-2-7b-chat.ggmlv3.q2_K.bin", model_type="llama", callbacks=[stream_hander])
             qa_chain = RetrievalQA.from_chain_type(llm, retriever=db.as_retriever())
-            # Fetch the answer to the user's question.
+            # Get the answer to the user's question.
             qa_chain({"query": question})