Update app.py

app.py

@@ -1,244 +1,106 @@
 import streamlit as st
-import langchain
+from PyPDF2 import PdfReader
 from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain.embeddings.openai import OpenAIEmbeddings
-from langchain.vectorstores import Chroma
-from langchain import OpenAI, VectorDBQA
-from langchain.chains import RetrievalQAWithSourcesChain
-import PyPDF2
 import os
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+import google.generativeai as genai
+from langchain.vectorstores import FAISS
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.chains.question_answering import load_qa_chain
+from langchain.prompts import PromptTemplate
+from dotenv import load_dotenv
+
+load_dotenv()
+os.getenv("GOOGLE_API_KEY")
+genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
 
-api_key = os.environ["OPENAI_API_KEY"]
-
-#This function will go through pdf and extract and return list of page texts.
-def read_and_textify(files):
-    text_list = []
-    sources_list = []
-    for file in files:
-        pdfReader = PyPDF2.PdfReader(file)
-        #print("Page Number:", len(pdfReader.pages))
-        for i in range(len(pdfReader.pages)):
-          pageObj = pdfReader.pages[i]
-          text = pageObj.extract_text()
-          pageObj.clear()
-          text_list.append(text)
-          sources_list.append(file.name + "_page_"+str(i))
-    return [text_list,sources_list]
-  
-st.set_page_config(layout="centered", page_title="Multidoc_QnA")
-st.header("Multidoc_QnA")
-st.write("---")
-  
-#file uploader
-uploaded_files = st.file_uploader("Upload documents",accept_multiple_files=True, type=["txt","pdf"])
-st.write("---")
-
-if uploaded_files is None:
-  st.info(f"""Upload files to analyse""")
-elif uploaded_files:
-  st.write(str(len(uploaded_files)) + " document(s) loaded..")
-  
-  textify_output = read_and_textify(uploaded_files)
-  
-  documents = textify_output[0]
-  sources = textify_output[1]
-  
-  #extract embeddings
-  embeddings = OpenAIEmbeddings(openai_api_key = api_key)
-  #vstore with metadata. Here we will store page numbers.
-  vStore = Chroma.from_texts(documents, embeddings, metadatas=[{"source": s} for s in sources])
-  #deciding model
-  model_name = "gpt-3.5-turbo"
-  # model_name = "gpt-4"
-
-  retriever = vStore.as_retriever()
-  retriever.search_kwargs = {'k':2}
-
-  #initiate model
-  llm = OpenAI(model_name=model_name, openai_api_key = api_key, streaming=True)
-  model = RetrievalQAWithSourcesChain.from_chain_type(llm=llm, chain_type="stuff", retriever=retriever)
-  
-  st.header("Ask your data")
-  user_q = st.text_area("Enter your questions here")
-  
-  if st.button("Get Response"):
-    try:
-      with st.spinner("Model is working on it..."):
-        result = model({"question":user_q}, return_only_outputs=True)
-        st.subheader('Your response:')
-        st.write(result['answer'])
-        st.subheader('Source pages:')
-        st.write(result['sources'])
-    except Exception as e:
-      st.error(f"An error occurred: {e}")
-      st.error('Oops, the GPT response resulted in an error :( Please try again with a different question.')
-      
-        
-    
-  
-  
-  
-  
-  
-  
-  
-  
-  
 
 
 
 
 
+def 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
 
 
 
+def get_text_chunks(text):
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000, chunk_overlap=1000)
+    chunks = text_splitter.split_text(text)
+    return chunks
 
 
+def get_vector_store(text_chunks):
+    embeddings = GoogleGenerativeAIEmbeddings(model = "models/embedding-001")
+    vector_store = FAISS.from_texts(text_chunks, embedding=embeddings)
+    vector_store.save_local("faiss_index")
 
 
+def get_conversational_chain():
 
+    prompt_template = """
+    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\n\n
+    Context:\n {context}?\n
+    Question: \n{question}\n
 
+    Answer:
+    """
 
+    model = ChatGoogleGenerativeAI(model="gemini-pro",
+                             temperature=0.3)
 
+    prompt = PromptTemplate(template = prompt_template, input_variables = ["context", "question"])
+    chain = load_qa_chain(model, chain_type="stuff", prompt=prompt)
 
+    return chain
 
 
 
+def user_input(user_question):
+    embeddings = GoogleGenerativeAIEmbeddings(model = "models/embedding-001")
+    
+    new_db = FAISS.load_local("faiss_index", embeddings)
+    docs = new_db.similarity_search(user_question)
 
+    chain = get_conversational_chain()
 
+    
+    response = chain(
+        {"input_documents":docs, "question": user_question}
+        , return_only_outputs=True)
 
+    print(response)
+    st.write("Reply: ", response["output_text"])
 
-# import gradio as gr
-# import streamlit as st
-# from langchain.embeddings.openai import OpenAIEmbeddings
-# from langchain.text_splitter import CharacterTextSplitter
-# from langchain.vectorstores import Chroma
-# from langchain.chains import ConversationalRetrievalChain
-# from langchain.chat_models import ChatOpenAI
-# from langchain.document_loaders import PyPDFLoader
-# import os
-# import fitz
-# from PIL import Image
 
 
-# # Global variables
-# COUNT, N = 0, 0
-# chat_history = []
-# chain = None  # Initialize chain as None
 
-# # Function to set the OpenAI API key
+def main():
+    st.set_page_config("Chat PDF")
+    st.header("Chat with PDF using Gemini💁")
 
-# api_key = os.environ['OPENAI_API_KEY']
+    user_question = st.text_input("Ask a Question from the PDF Files")
 
-# st.write(api_key)
+    if user_question:
+        user_input(user_question)
 
-    
-# # Function to enable the API key input box
-# def enable_api_box():
-#     return enable_box
-
-# # Function to add text to the chat history
-# def add_text(history, text):
-#     if not text:
-#         raise gr.Error('Enter text')
-#     history = history + [(text, '')]
-#     return history
-
-# # Function to process the PDF file and create a conversation chain
-# def process_file(file):
-#     global chain
-#     if 'OPENAI_API_KEY' not in os.environ:
-#         raise gr.Error('Upload your OpenAI API key')
-
-#     # Replace with your actual PDF processing logic
-#     loader = PyPDFLoader(file.name)
-#     documents = loader.load()
-#     embeddings = OpenAIEmbeddings()
-#     pdfsearch = Chroma.from_documents(documents, embeddings)
-
-#     chain = ConversationalRetrievalChain.from_llm(ChatOpenAI(temperature=0.3),
-#                                     retriever=pdfsearch.as_retriever(search_kwargs={"k": 1}),
-#                                     return_source_documents=True)
-#     return chain
-
-# # Function to generate a response based on the chat history and query
-# def generate_response(history, query, pdf_upload):
-#     global COUNT, N, chat_history, chain
-#     if not pdf_upload:
-#         raise gr.Error(message='Upload a PDF')
-
-#     if COUNT == 0:
-#         chain = process_file(pdf_upload)
-#         COUNT += 1
-
-#     # Replace with your LangChain logic to generate a response 
-#     result = chain({"question": query, 'chat_history': chat_history}, return_only_outputs=True)  
-#     chat_history += [(query, result["answer"])]
-#     N = list(result['source_documents'][0])[1][1]['page']  # Adjust as needed
-
-#     for char in result['answer']:
-#         history[-1][-1] += char  
-#     return history, ''  
-
-# # Function to render a specific page of a PDF file as an image
-# def render_file(file):
-#     global N
-#     doc = fitz.open(file.name)
-#     page = doc[N]
-#     pix = page.get_pixmap(matrix=fitz.Matrix(300/72, 300/72)) 
-#     image = Image.frombytes('RGB', [pix.width, pix.height], pix.samples)
-#     return image
-
-# # Function to render initial content from the PDF
-# def render_first(pdf_file): 
-#     # Replace with logic to process the PDF and generate an initial image
-#     image = Image.new('RGB', (600, 400), color = 'white') # Placeholder
-#     return image
-
-# # Streamlit & Gradio Interface
-
-# st.title("PDF-Powered Chatbot") 
-
-# with st.container():      
-#   gr.Markdown("""     
-#   <style>       
-#   .image-container { height: 680px; }     
-#   </style>     
-#   """)    
-
-# with gr.Blocks() as demo:
-#     pdf_upload1 = gr.UploadButton("📁 Upload PDF 1", file_types=[".pdf"])  # Define pdf_upload1
-
-#     # ... (rest of your interface creation)
-
-#     txt = gr.Textbox(label="Enter your query", placeholder="Ask a question...")     
-#     submit_btn = gr.Button('Submit')
-
-#     @submit_btn.click()
-#     def on_submit():
-#       add_text(chatbot, txt)
-#       generate_response(chatbot, txt, pdf_upload1)  # Use pdf_upload1 here
-#       render_file(pdf_upload1)  # Use pdf_upload1 here
-
-# if __name__ == "__main__":
-#     gr.Interface(         
-#         fn=generate_response,
-#         inputs=[
-#             "file",  # Define pdf_upload1
-#             "text",  # Define chatbot output
-#             "text"   # Define txt
-#         ],
-#         outputs=[
-#             "image",  # Define show_img
-#             "text",   # Define chatbot output
-#             "text"    # Define txt
-#         ],   
-#         title="PDF-Powered Chatbot"     
-#     ).launch()
-
-
- 
+    with st.sidebar:
+        st.title("Menu:")
+        pdf_docs = st.file_uploader("Upload your PDF Files and Click on the Submit & Process Button", accept_multiple_files=True)
+        if st.button("Submit & Process"):
+            with st.spinner("Processing..."):
+                raw_text = get_pdf_text(pdf_docs)
+                text_chunks = get_text_chunks(raw_text)
+                get_vector_store(text_chunks)
+                st.success("Done")
 
 
 
-    
+if __name__ == "__main__":
+    main()