Update app.py

app.py

@@ -1,102 +1,152 @@
 import streamlit as st
-from dotenv import load_dotenv
-from PyPDF2 import PdfReader
+from langchain_community.document_loaders import WebBaseLoader
 from langchain.text_splitter import CharacterTextSplitter
-from langchain.embeddings import OpenAIEmbeddings, HuggingFaceInstructEmbeddings
-from langchain.vectorstores import FAISS
-from langchain.chat_models import ChatOpenAI
-from langchain.memory import ConversationBufferMemory
-from langchain.chains import ConversationalRetrievalChain
-from css_template import css, bot_template, user_template
-from langchain.llms import HuggingFaceHub
-import os
-# os.environ['FAISS_NO_AVX2'] = '1'
-
-def method_get_pdf_text(pdf_docs):
-    text = ""
-    for pdf in pdf_docs:
-        pdf_reader = PdfReader(pdf)
-        for page in pdf_reader.pages:
-            text += page.extract_text()
-    return text
+from langchain_community.vectorstores import Chroma
+from langchain_nomic.embeddings import NomicEmbeddings
 
+from langchain_community.llms import HuggingFaceHub
 
-def method_get_text_chunks(text):
-    text_splitter = CharacterTextSplitter(
-        separator="\n\n",
-        chunk_size=1000,
-        chunk_overlap=200,
-        length_function=len,
-        is_separator_regex=False,
-    )
-    chunks = text_splitter.split_text(text)
-    return chunks
-
-
-def method_get_vectorstore(text_chunks):
-    # embeddings = OpenAIEmbeddings()
-    embeddings = HuggingFaceInstructEmbeddings(model_name="hkunlp/instructor-xl")
-    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embeddings)
-    return vectorstore
+# from langchain_core.runnables import RunnablePassthrough
+# from langchain_core.output_parsers import StrOutputParser
+# from langchain_core.prompts import ChatPromptTemplate
 
 
-def method_get_conversation_chain(vectorstore):
-    #llm = ChatOpenAI()
-    llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature":0.5, "max_length":512})
+def method_get_website_text(url):
+    # Convert string of URLs to list
+    urls_list = urls.split("\n")
+    docs = [WebBaseLoader(url).load() for url in urls_list]
+    docs_list = [item for sublist in docs for item in sublist]
+    return docs_list
 
-    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 method_get_text_chunks(text):
+    #split the text into chunks
+    text_splitter = CharacterTextSplitter.from_tiktoken_encoder(chunk_size=7500, chunk_overlap=100)
+    doc_splits = text_splitter.split_documents(docs_list)
+    return doc_splits
 
-def method_handle_userinput(user_question):
-    response = st.session_state.conversation({'question': 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 method_get_vectorstore(doc_splits):
+    #convert text chunks into embeddings and store in vector database
 
+    # create the open-source embedding function
+    embeddings = NomicEmbeddings(model="nomic-embed-text-v1.5")
 
-def main():
-    load_dotenv()
-    st.set_page_config(page_title="Converse with multiple PDFs",page_icon=":books:")
-    st.write(css, unsafe_allow_html=True)
+    # create a vectorstore from the chunks
+    vector_store = Chroma.from_documents(document_chunks, embeddings)
+    return vectorstore
 
-    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
+def get_context_retriever_chain(vector_store):
+    # Initialize the retriever
+    retriever = vector_store.as_retriever()
+    
+    # Initialize the language model
+    llm = HuggingFaceHub(repo_id="mistralai/Mistral-7B-v0.1", model_kwargs={"temperature": 0.6, "max_length": 512})
+    
+    # Define the response template
+    response_template = """Answer the question based only on the following context:
+    {context}
+    Question: {question}
+    """
+    
+    return retriever, llm, response_template
+
+
+# def get_context_retriever_chain(vector_store):
+#     #llm = ChatOpenAI()
+#     llm = HuggingFaceHub(repo_id="mistralai/Mistral-7B-v0.1", model_kwargs={"temperature":0.6, "max_length":512})
+
+#     retriever = vector_store.as_retriever()
+    
+#     prompt = ChatPromptTemplate.from_messages([
+#       MessagesPlaceholder(variable_name="chat_history"),
+#       ("user", "{input}"),
+#       ("user", "Given the above conversation, generate a search query to look up in order to get information relevant to the conversation")
+#     ])
+    
+#     retriever_chain = create_history_aware_retriever(llm, retriever, prompt)
+    
+#     return retriever_chain, llm
+
+# def method_get_conversation_chain(retriever_chain, question):
+#     # Use the retriever chain to generate a response to the user query
+#     response = retriever_chain(question)
+#     return response
+    
+# def method_get_conversation_chain(retriever_chain,llm,question):
+#     retriever = vectorstore.as_retriever()
+
+#     #perform the RAG 
+    
+#     after_rag_template = """Answer the question based only on the following context:
+#     {context}
+#     Question: {question}
+#     """
+#     after_rag_prompt = ChatPromptTemplate.from_template(after_rag_template)
+#     after_rag_chain = (
+#         {"context": retriever, "question": RunnablePassthrough()}
+#         | after_rag_prompt
+#         | model_local
+#         | StrOutputParser()
+#     )
+#     return after_rag_chain.invoke(question) 
+
+    
+#     #llm = ChatOpenAI()
+#     llm = HuggingFaceHub(repo_id="google/flan-t5-xxl", model_kwargs={"temperature":0.5, "max_length":512})
+
+#     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
 
-    st.header("Converse with multiple PDFs :books:")
-    user_question = st.text_input("Ask a question about your documents:")
-    if user_question:
-        method_handle_userinput(user_question)
 
+def main():
+    load_dotenv()
+    st.set_page_config(page_title="Chat with websites", page_icon="🤖")
+    st.title("Chat with websites")
+    
+    # sidebar
     with st.sidebar:
-        st.subheader("Documents Upload")
-        pdf_docs = st.file_uploader("Upload your PDFs here and click on 'Submit'", accept_multiple_files=True)
-        if st.button("Submit"):
-            with st.spinner("Processing"):
+        st.header("Settings")
+        website_url = st.text_input("Website URL")
+    
+    if website_url is None or website_url == "":
+        st.info("Please enter a website URL")
+    
+    else:
+        # Input fields
+        question = st.text_input("Question")
+        
+        # Button to process input
+        if st.button('Query Documents'):
+            with st.spinner('Processing...'):
                 # get pdf text
-                raw_text = method_get_pdf_text(pdf_docs)
+                raw_text = method_get_website_text(website_url)
                 # get the text chunks
-                text_chunks = method_get_text_chunks(raw_text)
+                doc_splits = method_get_text_chunks(raw_text)
                 # create vector store
-                vectorstore = method_get_vectorstore(text_chunks)
-                st.write(text_chunks)
-                # create conversation chain
-                st.session_state.conversation = method_get_conversation_chain(vectorstore)
-                
+                vectorstore = method_get_vectorstore(doc_splits)
+                st.write(doc_splits)
+                # retriever_chain = get_context_retriever_chain(vector_store)
+                # # create conversation chain
+                # answer = method_get_conversation_chain(retriever_chain,question)
+                # st.text_area("Answer", value=answer, height=300, disabled=True)
 
+                
+                # Get the retriever, LLM, and response template
+                retriever, llm, response_template = get_context_retriever_chain(vectorstore)
+                # Retrieve relevant context using the retriever
+                context = retriever(question)
+                # Generate response using the LLM
+                llm_response = llm(question)
+                # Apply the response template to format the final answer
+                answer = response_template.format(context=context, question=question) + llm_response
+                # Display the generated answer
+                st.text_area("Answer", value=answer, height=300, disabled=True)
 
 if __name__ == '__main__':
     main()