Update app.py

app.py

@@ -1,108 +1,166 @@
-# Import necessary modules for processing documents, embeddings, Q&A, etc. from 'langchain' library.
+import streamlit as st
 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 PyPDF2 import PdfReader
+from langchain.text_splitter import CharacterTextSplitter
 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 OpenAIEmbeddings, HuggingFaceInstructEmbeddings
+from langchain.vectorstores import FAISS
 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.
-
-# 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  # For live updates in the Streamlit app.
-
-st.title("ChatPDF")
-
-st.markdown("""
-ChatPDF is a web application that can answer questions based on a PDF document. To use the app, simply upload a PDF file and type your question in the input box. The app will then use a powerful language model to generate an answer to your question.
-""")
-
-# Create a visual separator in the app.
-st.write("---")
-
-# Add a file uploader widget for users to upload their PDF files.
-uploaded_file = st.sidebar.file_uploader("Upload your PDF file!", type=['pdf'])
-# Another visual separator after the file uploader.
-st.write("---")
-
-# Function to convert the uploaded PDF into a readable document format.
-def pdf_to_document(uploaded_file):
-    # Create a temporary directory for storing the uploaded PDF.
-    temp_dir = tempfile.TemporaryDirectory()
-    # Get the path where the uploaded PDF will be stored temporarily.
-    temp_filepath = os.path.join(temp_dir.name, uploaded_file.name)
-    
-    # Save the uploaded PDF to the temporary path.
-    with open(temp_filepath, "wb") as f:
-        f.write(uploaded_file.getvalue())
-    
-    # Load the PDF and split it into individual pages.
-    loader = PyPDFLoader(temp_filepath)
-    pages = loader.load_and_split()
-    return pages
-
-# 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 tool to split the document into smaller textual chunks.
-    text_splitter = RecursiveCharacterTextSplitter(
-        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.
+from langchain.chat_models import ChatOpenAI
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import ConversationalRetrievalChain
+from htmlTemplates import css, bot_template, user_template
+from langchain.llms import HuggingFaceHub
+
+def get_pdf_text(pdf_docs):
+    text = ""
+    pdf_reader = PdfReader(pdf_docs)
+    for page in pdf_reader.pages:
+        text += page.extract_text()
+    return text
+
+
+def get_text_chunks(text):
+    text_splitter = CharacterTextSplitter(
+        separator="\n",
+        chunk_size=1000,
+        chunk_overlap=200,
+        length_function=len
     )
-    # Split the document into chunks.
-    texts = text_splitter.split_documents(pages)
+    chunks = text_splitter.split_text(text)
+    return chunks
 
-    ## Below are examples of different embedding techniques, but they are commented out.
 
+def get_vectorstore(text_chunks):
     # Load the desired embeddings model.
     embeddings = HuggingFaceEmbeddings(model_name='sentence-transformers/all-MiniLM-L6-v2',
                                        model_kwargs={'device': 'cpu'})
-
-    # Load the textual chunks into the Chroma vector store.
-    print('texts = ',texts)
-    print('embeddings = ', embeddings)
-    db = FAISS.from_documents(texts,embeddings)
-    # db = Chroma.from_documents(texts, embeddings)
-
-    # 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  # Streamlit container to display text.
-            self.text=initial_text
-        def on_llm_new_token(self, token: str, **kwargs) -> None:
-            self.text+=token  # Add new tokens to the text.
-            self.container.markdown(self.text)  # Display the text.
-
-    # Header for the Q&A section of the web app.
-    st.header("Ask the PDF a question!")
-    # Input box for users to type their questions.
-    question = st.text_input('Type your question')
-
-    # Check if the user has pressed the 'Ask' button.
-    if st.button('Ask'):
-        # Display a spinner while processing the question.
-        with st.spinner('Processing...'):
-            # Space to display the answer.
-            chat_box = st.empty()
-            # Initialize the handler to stream outputs.
-            stream_hander = StreamHandler(chat_box)
-
-            # 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())
-            # Get the answer to the user's question.
-            qa_chain({"query": question})
+    # embeddings = OpenAIEmbeddings()
+    # embeddings = HuggingFaceInstructEmbeddings(model_name="hkunlp/instructor-xl")
+    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
+    return vectorstore
+
+
+def get_conversation_chain(vectorstore):
+    # llm = ChatOpenAI()
+    # llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature":0.5, "max_length":512})
+    llm = CTransformers(model="llama-2-7b-chat.ggmlv3.q2_K.bin", model_type="llama")
+    memory = ConversationBufferMemory(
+        memory_key='chat_history', return_messages=True)
+    conversation_chain = ConversationalRetrievalChain.from_llm(
+        llm=llm,
+        retriever=vectorstore.as_retriever(),
+        memory=memory
+    )
+    return conversation_chain
+
+
+def handle_userinput(user_question):
+    response = st.session_state.conversation({'query': user_question})
+    st.session_state.chat_history = response['chat_history']
+
+    for i, message in enumerate(st.session_state.chat_history):
+        if i % 2 == 0:
+            st.write(user_template.replace(
+                "{{MSG}}", message.content), unsafe_allow_html=True)
+        else:
+            st.write(bot_template.replace(
+                "{{MSG}}", message.content), unsafe_allow_html=True)
+
+def get_text_file(docs):
+    text = f.read()
+    return text
+
+def get_csv_file(docs):
+    import pandas as pd
+    text = ''
+
+    data = pd.read_csv(docs)
+
+    for index, row in data.iterrows():
+        item_name = row[0]
+        row_text = item_name
+        for col_name in data.columns[1:]:
+            row_text += '{} is {} '.format(col_name, row[col_name])
+        text += row_text + '\n'
+
+    return text
+
+def get_json_file(docs):
+    import json
+    text = ''
+    with open(docs, 'r') as f:
+        json_data = json.load(f)
+
+    for f_key, f_value in json_data.items():
+        for s_value in f_value:
+            text += str(f_key) + str(s_value)
+        text += '\n'
+    #print(text)
+    return text
+
+def get_hwp_file(docs):
+    pass
+
+def get_docs_file(docs):
+    pass
+
+
+def main():
+    load_dotenv()
+    st.set_page_config(page_title="Chat with multiple PDFs",
+                       page_icon=":books:")
+    st.write(css, unsafe_allow_html=True)
+
+    if "conversation" not in st.session_state:
+        st.session_state.conversation = None
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = None
+
+    st.header("Chat with multiple PDFs :books:")
+    user_question = st.text_input("Ask a question about your documents:")
+    if user_question:
+        handle_userinput(user_question)
+
+    with st.sidebar:
+        st.subheader("Your documents")
+        docs = st.file_uploader(
+            "Upload your PDFs here and click on 'Process'", accept_multiple_files=True)
+        if st.button("Process"):
+            with st.spinner("Processing"):
+                # get pdf text
+                raw_text = ""
+                for file in docs:
+                    if file.type == 'text/plain':
+                        #file is .txt
+                        raw_text += get_text_file(file)
+                    elif file.type == 'application/octet-stream':
+                        #file is .pdf
+                        raw_text += get_pdf_text(file)
+                    elif file.type == 'text/csv':
+                        #file is .csv
+                        raw_text += get_csv_file(file)
+                    elif file.type == 'application/json':
+                        # file is .json
+                        raw_text += get_json_file(file)
+                    elif file.type == 'application/x-hwp':
+                        # file is .hwp
+                        raw_text += get_hwp_file(file)
+                    elif file.type == 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+                        # file is .docs
+                        raw_text += get_docs_file(file)
+
+
+                # get the text chunks
+                text_chunks = get_text_chunks(raw_text)
+
+                # create vector store
+                vectorstore = get_vectorstore(text_chunks)
+
+                # create conversation chain
+                st.session_state.conversation = get_conversation_chain(
+                    vectorstore)
+
+
+if __name__ == '__main__':
+    main()