Upload 4 files

app.py

@@ -0,0 +1,77 @@
+import streamlit as st
+from llm_functions import load_data, split_text, initialize_llm, generate_questions, create_retrieval_qa_chain
+
+# Initialization of session states
+# Since Streamlit always reruns the script when a widget changes, we need to initialize the session states
+if 'questions' not in st.session_state:
+    st.session_state['questions'] = 'empty'
+    st.session_state['seperated_question_list'] = 'empty'
+    st.session_state['questions_to_answers'] = 'empty'
+    st.session_state['submitted'] = 'empty'
+
+with st.container():
+    st.markdown("""# Smart Study Buddy""")
+
+# Get user's OpenAI API Key
+openai_api_key = st.text_input(label="OpenAI API Key ",  placeholder="Ex: sk-2twmA8tfCb8un4...", key="openai_api_key_input", help="How to get an OpenAI API Key: https://www.howtogeek.com/885918/how-to-get-an-openai-api-key/")
+
+# Container for markdown text
+with st.container():
+    st.markdown("""Make sure you've entered your OpenAI API Key. 
+                Don't have an API key yet? 
+                Read [this](https://medium.com/@joristechtalk/how-to-get-an-openai-api-key-for-chatgpt-fd2cf6a436c5) article on how to get an API key.""")
+    
+# Let user upload a file
+uploaded_file = st.file_uploader("Upload your study material", type=['pdf'])
+
+if uploaded_file is not None:
+    # Check whether user entered an API key
+    if not openai_api_key:
+        st.error("Please enter your OpenAI API Key")
+    else:
+        # Load data from PDF
+        text_from_pdf = load_data(uploaded_file)
+
+        # Split text for question generation
+        documents_for_question_gen = split_text(text_from_pdf, chunk_size=10000, chunk_overlap=200)
+
+        # Split text for question answering
+        documents_for_question_answering = split_text(text_from_pdf, chunk_size=500, chunk_overlap=200)
+
+        # Initialize large language model for question generation
+        llm_question_gen = initialize_llm(openai_api_key=openai_api_key, model="gpt-3.5-turbo-16k", temperature=0.4)
+
+        # Initialize large language model for question answering
+        llm_question_answering = initialize_llm(openai_api_key=openai_api_key, model="gpt-3.5-turbo", temperature=0.1)
+
+        # Create questions if they have not yet been generated
+        if st.session_state['questions'] == 'empty':
+            with st.spinner("Generating questions..."):
+                # Assign the generated questions to the session state. This way, the questions are only generated once.
+                st.session_state['questions'] = generate_questions(llm=llm_question_gen, chain_type="refine", documents=documents_for_question_gen)
+
+        if st.session_state['questions'] != 'empty':
+            # Show questions on screen. You could use st.code for easy copy-pasting.
+            st.info(st.session_state['questions'])
+
+            # Split questions into a list
+            st.session_state['questions_list'] = st.session_state['questions'].split('\n')
+
+            with st.form(key='my_form'):
+                # Create a list of questions that have to be answered
+                st.session_state['questions_to_answers'] = st.multiselect(label="Select questions to answer", options=st.session_state['questions_list'])
+                submitted = st.form_submit_button('Generate answers')
+                if submitted:
+                    st.session_state['submitted'] = True
+
+            if st.session_state['submitted']:
+            # Initialize the Retrieval QA Chain
+                with st.spinner("Generating answers..."):
+                    generate_answer_chain = create_retrieval_qa_chain(openai_api_key=openai_api_key, documents=documents_for_question_answering, llm=llm_question_answering)
+                    # For each question, generate an answer
+                    for question in st.session_state['questions_to_answers']:
+                        # Generate answer
+                        answer = generate_answer_chain.run(question)
+                        # Show answer on screen
+                        st.write(f"Question: {question}")
+                        st.info(f"Answer: {answer}")

llm_functions.py

@@ -0,0 +1,79 @@
+from langchain.text_splitter import TokenTextSplitter
+from langchain.docstore.document import Document
+from langchain_community.chat_models import ChatOpenAI
+from langchain.chains.summarize import load_summarize_chain
+from prompts import PROMPT_QUESTIONS, REFINE_PROMPT_QUESTIONS
+from langchain.chains import RetrievalQA
+from langchain_community.embeddings import OpenAIEmbeddings
+from langchain_community.vectorstores import Chroma
+from PyPDF2 import PdfReader
+
+
+# Function to load data from PDF
+def load_data(uploaded_file):
+    # Load data from PDF
+    pdf_reader = PdfReader(uploaded_file)
+    # Combine text from Document into one string
+    text = ""
+    for page in pdf_reader.pages:
+        text += page.extract_text()
+
+    return text
+
+
+# Function to split text into chunks
+def split_text(text, chunk_size, chunk_overlap):
+    # Initialize text splitter
+    text_splitter = TokenTextSplitter(
+        model_name="gpt-3.5-turbo", chunk_size=chunk_size, chunk_overlap=chunk_overlap
+    )
+
+    # Split text into chunks
+    text_chunks = text_splitter.split_text(text)
+
+    # Convert chunks to documents
+    documents = [Document(page_content=t) for t in text_chunks]
+
+    return documents
+
+
+# Function to initialize large language model
+def initialize_llm(openai_api_key, model, temperature):
+    # Initialize large language model
+    llm = ChatOpenAI(
+        openai_api_key=openai_api_key, model=model, temperature=temperature
+    )
+
+    return llm
+
+
+# Function to generate questions
+def generate_questions(llm, chain_type, documents):
+    # Initialize question chain
+    question_chain = load_summarize_chain(
+        llm=llm,
+        chain_type=chain_type,
+        question_prompt=PROMPT_QUESTIONS,
+        refine_prompt=REFINE_PROMPT_QUESTIONS,
+    )
+
+    # Generate questions
+    questions = question_chain.run(documents)
+
+    return questions
+
+
+# Function to create Retrieval QA Chain
+def create_retrieval_qa_chain(openai_api_key, documents, llm):
+    # Set embeddings
+    embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
+
+    # Create vector database
+    vector_database = Chroma.from_documents(documents=documents, embedding=embeddings)
+
+    # Create Retrieval QA Chain
+    retrieval_qa_chain = RetrievalQA.from_chain_type(
+        llm=llm, chain_type="stuff", retriever=vector_database.as_retriever()
+    )
+
+    return retrieval_qa_chain

prompts.py

@@ -0,0 +1,35 @@
+from langchain.prompts import PromptTemplate
+
+prompt_template_questions = """
+You are an expert in creating practice questions based on study material.
+Your goal is to prepare a student for their an exam. You do this by asking questions about the text below:
+
+------------
+{text}
+------------
+
+Create questions that will prepare the student for their exam. Make sure not to lose any important information.
+
+QUESTIONS:
+"""
+PROMPT_QUESTIONS = PromptTemplate(template=prompt_template_questions, input_variables=["text"])
+
+refine_template_questions = ("""
+You are an expert in creating practice questions based on study material.
+Your goal is to help a student prepare for an exam.
+We have received some practice questions to a certain extent: {existing_answer}.
+We have the option to refine the existing questions or add new ones.
+(only if necessary) with some more context below.
+------------
+{text}
+------------
+
+Given the new context, refine the original questions in English.
+If the context is not helpful, please provide the original questions.
+QUESTIONS:
+"""
+)
+REFINE_PROMPT_QUESTIONS = PromptTemplate(
+    input_variables=["existing_answer", "text"],
+    template=refine_template_questions,
+)

requirements.txt

@@ -0,0 +1,8 @@
+langchain
+streamlit
+openai
+pypdf2
+tiktoken
+chromadb
+langchain_community
+langchain-community