pip3
install streamlit
import sys
import hashlib
import pickle
import streamlit as st
from dotenv import load_dotenv
from PyPDF2 import PdfReader  
from streamlit_extras.add_vertical_space import add_vertical_space
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings.openai import OpenAIEmbeddings
from langchain.vectorstores import FAISS
from langchain.llms import OpenAI
from langchain.chains.questions_answering import load_qa_chain
from langchain.callback import get_openai_callback

def compute_hash(file):
    # Create a hash object
    hasher = hashlib.sha256()

    # Read the file in chunks to avoid using too much memory
    chunk_size = 8192
    for chunk in iter(lambda: file.read(chunk_size), b''):
        hasher.update(chunk)

    # Return the hexadecimal digest of the hash
    return hasher.hexdigest()

def main():
    st.header("Smartdoc")
    load_dotenv()

    # Retrieve the API key from environment variable
    api_key = os.getenv('YOUR_ENV_VARIABLE')  # Replace 'YOUR_ENV_VARIABLE' with your actual variable name

    # Upload PDFs
    pdf = st.file_uploader("Upload your PDF", type="pdf")
    st.write(pdf.name)

    if pdf is not None:
        pdf_reader = PdfReader(pdf)
        text = ""
        for page in pdf_reader.pages:
            text += page.extract_text()

        text_splitter = RecursiveCharacterTextSplitter(
            chunk_size=1000,
            chunk_overlap=200,
            length_function=len
        )
        chunks = text_splitter.split_text(text=text)

        # Embeddings
        embeddings = OpenAIEmbeddings(model_name="your_model_name", api_key=api_key)  # Specify the model name here

        # Compute the hash of the PDF content
        pdf_hash = compute_hash(pdf)

        # Use the hash as part of the filename for the embeddings file
        vector_store_path = f"{pdf.name}_{pdf_hash}.pkl"
        if os.path.exists(vector_store_path):
            # If the embeddings file already exists, load it
            with open(vector_store_path, "rb") as f:
                VectorStore = pickle.load(f)
                st.write('Embeddings loaded from the Disk')
        else:
            # If the embeddings file does not exist, calculate the embeddings
            VectorStore = FAISS.from_texts(chunks, embedding=embeddings)
            with open(vector_store_path, "wb") as f:
                pickle.dump(VectorStore, f)
            st.write('Embeddings Computation Completed')

        # Accept user questions/query
        query = st.text_input("Ask questions about your PDF file:")
        st.write(query)
        if query:
            docs = VectorStore.similarity_search(query=query, k=3)  # Provide the correct method name here
            if docs:  # Check if docs is not empty
                llm = OpenAI(model_name="your_model_name", api_key=api_key)  # Specify the model name here
                chain = load_qa_chain(llm=llm, chain_type="stuff")  # Correct function name
                with get_openai_callback() as cb:
                    response = chain.run(input_documents=docs, question=query)
                    print(cb)
                st.write(response if response is not None else "No relevant information found.")
            else:
                st.write("No relevant documents found.")

            st.write(docs)

if __name__ == "__main__":
    main()