Update app.py

app.py

@@ -1,27 +1,87 @@
 import os
+import io
 import fitz  # PyMuPDF
+import PyPDF2
 from docx import Document
+from dotenv import load_dotenv
+import streamlit as st
 from sentence_transformers import SentenceTransformer
-import faiss
-import numpy as np
-import pickle
-from langchain_community.llms import HuggingFaceEndpoint
+from langchain.prompts import PromptTemplate
+from langchain.chains.question_answering import load_qa_chain
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores.faiss import FAISS
 from langchain_community.embeddings import HuggingFaceEmbeddings
-import gradio as gr
+from langchain_community.llms import HuggingFaceEndpoint
+
+# Load environment variables from .env file
+load_dotenv()
 
 # Initialize the embedding model
 embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
 
 # Initialize the HuggingFace LLM
 llm = HuggingFaceEndpoint(
-    endpoint_url="https://api-inference.huggingface.co/models/gpt-3.5-turbo",  # Use a known model
+    endpoint_url="https://api-inference.huggingface.co/models/gpt-3.5-turbo",
     model_kwargs={"api_key": os.getenv('HUGGINGFACEHUB_API_TOKEN')}
 )
 
 # Initialize the HuggingFace embeddings
 embedding = HuggingFaceEmbeddings()
 
-# Function to extract text from a Word document
+# Streamlit setup
+st.set_page_config(layout="centered")
+st.markdown("<h1 style='font-size:24px;'>PDF and DOCX ChatBot</h1>", unsafe_allow_html=True)
+
+# Retrieve API key from environment variable
+google_api_key = os.getenv("GOOGLE_API_KEY")
+
+# Check if the API key is available
+if google_api_key is None:
+    st.warning("API key not found. Please set the google_api_key environment variable.")
+    st.stop()
+
+# File Upload
+uploaded_file = st.file_uploader("Upload your PDF or DOCX file", type=["pdf", "docx"])
+
+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:
+"""
+
+prompt_template += """
+--------------------------------------------------
+Prompt Suggestions:
+1. Summarize the primary theme of the context.
+2. Elaborate on the crucial concepts highlighted in the context.
+3. Pinpoint any supporting details or examples pertinent to the question.
+4. Examine any recurring themes or patterns relevant to the question within the context.
+5. Contrast differing viewpoints or elements mentioned in the context.
+6. Explore the potential implications or outcomes of the information provided.
+7. Assess the trustworthiness and validity of the information given.
+8. Propose recommendations or advice based on the presented information.
+9. Forecast likely future events or results stemming from the context.
+10. Expand on the context or background information pertinent to the question.
+11. Define any specialized terms or technical language used within the context.
+12. Analyze any visual representations like charts or graphs in the context.
+13. Highlight any restrictions or important considerations when responding to the question.
+14. Examine any presuppositions or biases evident within the context.
+15. Present alternate interpretations or viewpoints regarding the information provided.
+16. Reflect on any moral or ethical issues raised by the context.
+17. Investigate any cause-and-effect relationships identified in the context.
+18. Uncover any questions or areas requiring further exploration.
+19. Resolve any vague or conflicting information in the context.
+20. Cite case studies or examples that demonstrate the concepts discussed in the context.
+--------------------------------------------------
+Context:\n{context}\n
+Question:\n{question}\n
+Answer:
+"""
+
 def extract_text_from_docx(docx_path):
     text = ""
     try:
@@ -31,7 +91,6 @@ def extract_text_from_docx(docx_path):
         print(f"Error extracting text from DOCX: {e}")
     return text
 
-# Function to extract text from a PDF document
 def extract_text_from_pdf(pdf_path):
     text = ""
     try:
@@ -43,113 +102,38 @@ def extract_text_from_pdf(pdf_path):
         print(f"Error extracting text from PDF: {e}")
     return text
 
-# Load or create FAISS index
-index_path = "faiss_index.pkl"
-document_texts_path = "document_texts.pkl"
-
-document_texts = []
-
-if os.path.exists(index_path) and os.path.exists(document_texts_path):
-    try:
-        with open(index_path, "rb") as f:
-            index = pickle.load(f)
-            print("Loaded FAISS index from faiss_index.pkl")
-        with open(document_texts_path, "rb") as f:
-            document_texts = pickle.load(f)
-            print("Loaded document texts from document_texts.pkl")
-    except Exception as e:
-        print(f"Error loading FAISS index or document texts: {e}")
-else:
-    # Create a new FAISS index if it doesn't exist
-    index = faiss.IndexFlatL2(embedding_model.get_sentence_embedding_dimension())
-    with open(index_path, "wb") as f:
-        pickle.dump(index, f)
-        print("Created new FAISS index and saved to faiss_index.pkl")
-
-def preprocess_text(text):
-    # Add more preprocessing steps if necessary
-    return text.strip()
-
-def upload_files(files):
-    global index, document_texts
-    try:
-        for file in files:
-            file_path = file.name  # Get the file path from the NamedString object
-            if file_path.endswith('.docx'):
-                text = extract_text_from_docx(file_path)
-            elif file_path.endswith('.pdf'):
-                text = extract_text_from_pdf(file_path)
-            else:
-                continue
-
-            # Process the text and update FAISS index
-            sentences = text.split("\n")
-            sentences = [preprocess_text(sentence) for sentence in sentences if sentence.strip()]
-            embeddings = embedding_model.encode(sentences)
-            index.add(np.array(embeddings))
-            document_texts.extend(sentences)  # Store sentences for retrieval
-
-        # Save the updated index and documents
-        with open(index_path, "wb") as f:
-            pickle.dump(index, f)
-            print("Saved updated FAISS index to faiss_index.pkl")
-        with open(document_texts_path, "wb") as f:
-            pickle.dump(document_texts, f)
-            print("Saved updated document texts to document_texts.pkl")
-        
-        return "Files processed successfully"
-    except Exception as e:
-        print(f"Error processing files: {e}")
-        return f"Error processing files: {e}"
-
-def query_text(text):
-    try:
-        # Encode the query text
-        query_embedding = embedding_model.encode([text])
-        
-        # Search the FAISS index
-        D, I = index.search(np.array(query_embedding), k=5)
-        
-        top_documents = []
-        for idx in I[0]:
-            if idx != -1 and idx < len(document_texts):  # Ensure that a valid index is found
-                top_documents.append(document_texts[idx])  # Append the actual sentences for the response
-        
-        # Prepare the prompt
-        context = "\n".join(top_documents)
-        prompt = f"Context:\n{context}\n\nQuestion:\n{text}\n\nAnswer:\n"
-
-        # Query the LLM
-        response = llm(prompt)
-        print(f"Prompt: {prompt}")
-        print(f"Response: {response}")
-        return response
-    except Exception as e:
-        print(f"Error querying text: {e}")
-        return f"Error querying text: {e}"
-
-def main():
-    # Gradio interface for uploading files
-    file_upload_interface = gr.Interface(
-        fn=upload_files,
-        inputs=gr.File(file_count="multiple", label="Upload DOCX or PDF files"),
-        outputs="text",
-        title="Upload Files",
-        description="Upload DOCX or PDF files to process and add to the FAISS index."
-    )
-
-    # Gradio interface for querying text
-    query_interface = gr.Interface(
-        fn=query_text,
-        inputs="text",
-        outputs="text",
-        title="Query Text",
-        description="Query the indexed text and get answers from the language model."
-    )
-
-    # Create a tabbed interface
-    demo = gr.TabbedInterface([file_upload_interface, query_interface], ["Upload Files", "Query Text"])
-    demo.launch()
-
-if __name__ == "__main__":
-    main()
+if uploaded_file is not None:
+    st.text("File Uploaded Successfully!")
+    
+    context = ""
+    
+    # Process the uploaded file
+    if uploaded_file.name.endswith('.pdf'):
+        pdf_data = uploaded_file.read()
+        pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_data))
+        pdf_pages = pdf_reader.pages
+        context = "\n\n".join(page.extract_text() for page in pdf_pages)
+    elif uploaded_file.name.endswith('.docx'):
+        docx_data = uploaded_file.read()
+        context = extract_text_from_docx(io.BytesIO(docx_data))
+
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=10000, chunk_overlap=200)
+    texts = text_splitter.split_text(context)
+    embeddings = HuggingFaceEmbeddings()
+    vector_index = FAISS.from_texts(texts, embeddings).as_retriever()
+
+    user_question = st.text_input("Ask Anything from the Document:", "")
+
+    if st.button("Get Answer"):
+        if user_question:
+            with st.spinner("Processing..."):
+                docs = vector_index.get_relevant_documents(user_question)
+                prompt = PromptTemplate(template=prompt_template, input_variables=['context', 'question'])
+                chain = load_qa_chain(llm, chain_type="stuff", prompt=prompt)
+                response = chain({"input_documents": docs, "question": user_question}, return_only_outputs=True)
+                st.subheader("Answer:")
+                st.write(response['output_text'])
+        else:
+            st.warning("Please enter a question.")
+
+