Demo Txt and PDF

app.py

@@ -0,0 +1,182 @@
+import streamlit as st
+import os
+# import openai
+from io import StringIO
+from langchain.chat_models import ChatOpenAI
+from langchain import OpenAI, LLMChain, PromptTemplate
+from langchain.memory import ConversationBufferWindowMemory
+
+from langchain.vectorstores import Chroma
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.document_loaders import TextLoader
+from langchain.document_loaders import PyPDFLoader
+# from langchain.chains import ConversationalRetrievalChain
+from langchain.chains.summarize import load_summarize_chain
+import tempfile
+if "file_uploader_key" not in st.session_state:
+    st.session_state["file_uploader_key"] = 0
+
+if "uploaded_files" not in st.session_state:
+    st.session_state["uploaded_files"] = []
+
+# Prompt Template
+template = """You are a chatbot having a conversation with a human.
+
+Given the following extracted parts of a long document and a question, create a final answer.
+
+{context}
+
+{chat_history}
+Human: {human_input}
+Chatbot:"""
+
+# Init Prompt
+prompt = PromptTemplate(
+    input_variables=["chat_history", "human_input", "context"], template=template
+)
+
+a = st.container()
+with a:
+    st.title("CHATBOT")
+    global openai_api_key
+    openai_api_key = st.text_input('OpenAI API Key', type='password')
+if openai_api_key:
+    @st.cache_resource
+    def llm():
+        model = OpenAI(temperature=0.0, openai_api_key=openai_api_key)
+        embedding=OpenAIEmbeddings(openai_api_key=openai_api_key)
+        return model, embedding
+
+    llm,embedding = llm()
+
+    @st.cache_resource
+    def chain():
+        global memory
+        memory = ConversationBufferWindowMemory(memory_key="chat_history", input_key="human_input", return_messages=True, k=3)
+        chain = LLMChain(
+            llm=llm, prompt=prompt, memory=memory
+        )
+        
+        return chain
+
+    global llm_chain
+    llm_chain = chain()
+
+
+    summarize_template = """Write a concise summary of the given documents:
+    {text}"""
+    summarize_PROMPT = PromptTemplate(template=summarize_template, input_variables=["text"])
+    llm_summarize = load_summarize_chain(llm=llm, chain_type="map_reduce",  map_prompt=summarize_PROMPT)
+    # chain({"input_documents": docs}, return_only_outputs=True)
+    # llm_summarize = load_summarize_chain(llm, chain_type="map_reduce")
+
+
+    ########################################
+    ####### CHATBOT interface#############
+    ########################################
+    # Initialize chat history
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    # Display chat messages from history on app rerun
+    with a:
+        for message in st.session_state.messages:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
+
+    global documents
+    documents = []
+
+
+
+    with st.sidebar:
+        uploaded_files = st.file_uploader("Upload file", accept_multiple_files=True, 
+                                        key=st.session_state["file_uploader_key"],
+                                        type=['txt', 'pdf']
+                                        #   on_change = check
+                                        )
+
+    if uploaded_files:
+            # files = set([file.name for file in uploaded_files])
+            st.session_state["uploaded_files"] = uploaded_files
+            text_splitter = RecursiveCharacterTextSplitter(chunk_size=3000 , chunk_overlap=10, separators=[" ", ",", "\n"])
+            for file in uploaded_files:
+                if file.name.endswith(".pdf"):
+                                    # Save the uploaded file to a temporary location
+                    temp_file_path = os.path.join('docs', file.name)
+                    with open(temp_file_path, "wb") as temp_file:
+                        temp_file.write(file.read())
+                    loader = PyPDFLoader(temp_file_path)
+                    # loader = loader.load()
+                elif file.name.endswith('.txt'):
+                    # To read file as bytes:
+                    bytes_data = file.getvalue()
+                    # To convert to a string based IO:
+                    stringio = StringIO(file.getvalue().decode("utf-8"))
+                    # To read file as string:
+                    loader = stringio.read()
+                    filename = os.path.join("docs",'text.txt')
+                    # filename = 'docs/text.txt'
+                    with open(filename,"wb") as f:
+                            f.write(file.getbuffer())
+                    loader = TextLoader(filename, autodetect_encoding=True)
+                loader = loader.load()
+                documents.extend(loader)
+            documents = text_splitter.split_documents(documents)
+
+            # Embedding
+            global docsearch
+            docsearch = Chroma.from_documents(documents,
+                                            embedding=embedding)
+
+    ########################################
+    ########## SIDEBAR ###############
+    ########################################
+
+    # create a function that sets the value in state back to an empty list
+    def clear_msg():
+        st.session_state.messages = []
+        llm_chain = chain()
+        st.session_state["file_uploader_key"] += 1
+        st.experimental_rerun()
+
+    if uploaded_files:
+        if st.sidebar.button('Summarize'):
+            with a:
+                query = 'Summarize uploaded documents'
+                st.chat_message("user").markdown(query)
+                llm_chain.memory.chat_memory.add_user_message(query)
+                # Add user message to chat history
+                st.session_state.messages.append({"role": "user", "content": query})
+                response = llm_summarize.run(documents)
+                # chain({"input_documents": docs}, return_only_outputs=True)
+
+                with st.chat_message("assistant"):
+                    st.markdown(response)
+                llm_chain.memory.chat_memory.add_ai_message(response)
+                # Add assistant response to chat history
+                st.session_state.messages.append({"role": "assistant", "content": response})
+
+
+    st.sidebar.button("Clear", on_click=clear_msg)
+
+    ########################################
+    ####### React to user input#############
+    ########################################
+
+    with a:
+        if query := st.chat_input():
+            # Display user message in chat message container
+            st.chat_message("user").markdown(query)
+            # Add user message to chat history
+            st.session_state.messages.append({"role": "user", "content": query})
+            if documents:
+                docs = docsearch.similarity_search(query)
+            else:
+                docs = 'No Context provide'
+            response = llm_chain.run({"context": docs, "human_input": query})
+            # Display assistant response in chat message container
+            with st.chat_message("assistant"):
+                st.markdown(response)
+            # Add assistant response to chat history
+            st.session_state.messages.append({"role": "assistant", "content": response})

requirements.txt

@@ -0,0 +1,7 @@
+streamlit
+openai
+langchain
+tiktoken
+chromadb
+pypdf
+chardet