Upload 10 files

.env

@@ -0,0 +1 @@
+GOOGLE_API_KEY=AIzaSyCA4__JMC_ZIQ9xQegIj5LOMLhSSrn3pMw

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

Homepage.py

@@ -0,0 +1,27 @@
+import streamlit as st
+from streamlit_option_menu import option_menu
+from app_utils import switch_page
+import streamlit as st
+from PIL import Image
+
+im = Image.open("icon.png")
+st.set_page_config(page_title = "AI Interviewer", layout = "centered",page_icon=im)
+
+lan = st.selectbox("#### Language", ["English", "中文"])
+
+if lan == "English":
+    home_title = "AI Interviewer"
+    home_introduction = "Welcome to AI Interviewer, empowering your interview preparation with generative AI."
+    
+    st.markdown(
+        "<style>#MainMenu{visibility:hidden;}</style>",
+        unsafe_allow_html=True
+    )
+    st.image(im, width=100)
+    st.markdown(f"""# {home_title}""",unsafe_allow_html=True)
+    st.markdown("""\n""")
+    #st.markdown("#### Greetings")
+    st.markdown("Welcome to AI Interviewer! 👏 AI Interviewer is your personal interviewer powered by generative AI that conducts mock interviews."
+                "You can upload your resume and enter job descriptions, and AI Interviewer will ask you customized questions. Additionally, you can configure your own Interviewer!")
+    st.markdown("""\n""")
+    

README.md

@@ -1,12 +1,79 @@
----
-title: Interview
-emoji: 🌍
-colorFrom: red
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.31.1
-app_file: app.py
-pinned: false
+
+
+# AI Interviewer - Version 0.1.2
+
+Welcome to AI Interviewer! 👏 AI Interviewer is a cutting-edge application powered by generative AI designed to conduct mock interviews. With the ability to analyze your uploaded resume and job descriptions, AI Interviewer generates tailored questions to enhance your interview preparation. You even have the flexibility to customize your own interviewing experience!
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Getting Started](#getting-started)
+- [Features](#features)
+- [Upcoming Updates](#upcoming-updates)
+- [Feedback](#feedback)
+- [Contact](#contact)
+<!-- - [Acknowledgments](#acknowledgments) -->
+
+## Overview
+
+AI Interviewer aims to revolutionize your interview preparation process. Whether you're seeking to improve your technical skills, communication abilities, or adaptability, this application can assist you. Powered by cutting-edge technology from OpenAI, FAISS, and Langchain, AI Interviewer provides a seamless experience that simulates real interview scenarios.
+
+## Getting Started
+
+To begin your AI Interviewer experience, follow these simple steps:
+
+1. **Select Interview Type:** Choose from the following interview screens:
+   - **Homepage:** Overview of AI Interviewer.
+   - **Behavioral Screen:** Assess your behavioral skills.
+   - **Professional Screen:** Evaluate your technical skills.
+   - **Resume Screen:** Review your uploaded resume.
+   
+2. **Customize Your Experience:** Tailor your interview by uploading your resume and providing job descriptions.
+
+3. **Choose Interaction Style:** Opt for your preferred interaction style, whether it's through chat or voice.
+
+4. **Start Interviewing:** Begin the interview by introducing yourself and responding to AI-generated questions.
+
+## Features
+
+- **Personalized Questions:** AI Interviewer generates interview questions customized to your uploaded resume and job descriptions.
+
+- **Multiple Screens:** Access different screens for behavioral, professional, and resume-related interview aspects.
+
+- **Interactive Experience:** Engage in a conversation with the AI interviewer, enhancing the realism of the interview process.
+
+- **Easy Refresh:** Initiate a new interview session simply by refreshing the page.
+
+- **Choice of Interaction:** Select between chat-based or voice-based interaction styles for your interviews.
+
+## Upcoming Updates
+
+We are constantly working to improve AI Interviewer and bring you new features. In the pipeline:
+
+- Enhanced AI capabilities for even more realistic interviews.
+- Expanded question database for a wider range of industries and roles.
+- Improved voice interaction for a seamless experience.
+
+## Feedback
+
+We highly value your feedback! Your insights can help us enhance AI Interviewer. Please take a moment to fill out our [Feedback Form](https://docs.google.com/forms/d/13f4q03bk4lD7sKR7qZ8UM1lQDo6NhRaAKv7uIeXHEaQ/viewform?edit_requested=true).
+
+## Contact
+
+## Contact
+
+- GitHub: [jiatastic](https://github.com/jiatastic)
+
+<!-- ## Acknowledgments
+
+AI Interviewer is powered by a blend of advanced technologies:
+
+- OpenAI: Providing the generative AI capabilities.
+- FAISS: Enhancing search and retrieval capabilities.
+- Langchain: Facilitating natural language interactions.
+
+The application is proudly built with [Streamlit](https://streamlit.io/).
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Remember, AI Interviewer is your partner in preparing for your future interviews. Sharpen your skills, boost your confidence, and seize those career opportunities with confidence! 🚀 -->

initialization.py

@@ -0,0 +1,96 @@
+import streamlit as st
+from langchain.embeddings import OpenAIEmbeddings
+from langchain.vectorstores import FAISS
+from langchain.text_splitter import NLTKTextSplitter
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import RetrievalQA, ConversationChain
+from prompts.prompts import templates
+from langchain.prompts.prompt import PromptTemplate
+from langchain.chat_models import ChatOpenAI
+from PyPDF2 import PdfReader
+from prompts.prompt_selector import prompt_sector
+def embedding(text):
+    """embeddings"""
+    text_splitter = NLTKTextSplitter()
+    texts = text_splitter.split_text(text)
+     # Create emebeddings
+    embeddings = OpenAIEmbeddings()
+    docsearch = FAISS.from_texts(texts, embeddings)
+    return docsearch
+
+def resume_reader(resume):
+    pdf_reader = PdfReader(resume)
+    text = ""
+    for page in pdf_reader.pages:
+        text += page.extract_text()
+    return text
+
+def initialize_session_state(template=None, position=None):
+    """ initialize session states """
+    if 'jd' in st.session_state:
+        st.session_state.docsearch = embedding(st.session_state.jd)
+    else:
+        st.session_state.docsearch = embedding(resume_reader(st.session_state.resume))
+
+    #if 'retriever' not in st.session_state:
+    st.session_state.retriever = st.session_state.docsearch.as_retriever(search_type="similarity")
+    #if 'chain_type_kwargs' not in st.session_state:
+    if 'jd' in st.session_state:
+        Interview_Prompt = PromptTemplate(input_variables=["context", "question"],
+                                              template=template)
+        st.session_state.chain_type_kwargs = {"prompt": Interview_Prompt}
+    else:
+            st.session_state.chain_type_kwargs = prompt_sector(position, templates)
+    #if 'memory' not in st.session_state:
+    st.session_state.memory = ConversationBufferMemory()
+    # interview history
+    #if "history" not in st.session_state:
+    st.session_state.history = []
+    # token count
+    #if "token_count" not in st.session_state:
+    st.session_state.token_count = 0
+    #if "guideline" not in st.session_state:
+    llm = ChatOpenAI(
+            model_name="gpt-3.5-turbo",
+            temperature=0.6, )
+    st.session_state.guideline = RetrievalQA.from_chain_type(
+            llm=llm,
+            chain_type_kwargs=st.session_state.chain_type_kwargs, chain_type='stuff',
+            retriever=st.session_state.retriever, memory=st.session_state.memory).run(
+            "Create an interview guideline and prepare only one questions for each topic. Make sure the questions tests the technical knowledge")
+    # llm chain and memory
+    #if "screen" not in st.session_state:
+    llm = ChatOpenAI(
+            model_name="gpt-3.5-turbo",
+            temperature=0.8, )
+    PROMPT = PromptTemplate(
+            input_variables=["history", "input"],
+            template="""I want you to act as an interviewer strictly following the guideline in the current conversation.
+
+                            Ask me questions and wait for my answers like a real person.
+                            Do not write explanations.
+                            Ask question like a real person, only one question at a time.
+                            Do not ask the same question.
+                            Do not repeat the question.
+                            Do ask follow-up questions if necessary. 
+                            You name is GPTInterviewer.
+                            I want you to only reply as an interviewer.
+                            Do not write all the conversation at once.
+                            If there is an error, point it out.
+
+                            Current Conversation:
+                            {history}
+
+                            Candidate: {input}
+                            AI: """)
+    st.session_state.screen = ConversationChain(prompt=PROMPT, llm=llm,
+                                                    memory=st.session_state.memory)
+    #if "feedback" not in st.session_state:
+    llm = ChatOpenAI(
+        model_name = "gpt-3.5-turbo",
+        temperature = 0.5,)
+    st.session_state.feedback = ConversationChain(
+            prompt=PromptTemplate(input_variables = ["history", "input"], template = templates.feedback_template),
+            llm=llm,
+            memory = st.session_state.memory,
+        )

pages/Behavioral Screen.py

@@ -0,0 +1,205 @@
+import streamlit as st
+from streamlit_lottie import st_lottie
+from typing import Literal
+from dataclasses import dataclass
+import json
+import base64
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import ConversationChain, RetrievalQA
+from langchain.prompts.prompt import PromptTemplate
+from langchain.text_splitter import NLTKTextSplitter
+from langchain.vectorstores import FAISS
+import nltk
+from prompts.prompts import templates
+from langchain_google_genai import ChatGoogleGenerativeAI
+import getpass
+import os
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+
+if "GOOGLE_API_KEY" not in os.environ:
+    os.environ["GOOGLE_API_KEY"] = "AIzaSyCA4__JMC_ZIQ9xQegIj5LOMLhSSrn3pMw"
+
+
+
+def load_lottiefile(filepath: str):
+
+    '''Load lottie animation file'''
+
+    with open(filepath, "r") as f:
+        return json.load(f)
+
+st.title("Behavioral Screen")
+st.markdown("""\n""")
+jd = st.text_area("""Please enter the job description here (If you don't have one, enter keywords, such as "communication" or "teamwork" instead): """)
+
+@dataclass
+class Message:
+    '''dataclass for keeping track of the messages'''
+    origin: Literal["human", "ai"]
+    message: str
+
+def autoplay_audio(file_path: str):
+    '''Play audio automatically'''
+    def update_audio():
+        global global_audio_md
+        with open(file_path, "rb") as f:
+            data = f.read()
+            b64 = base64.b64encode(data).decode()
+            global_audio_md = f"""
+                <audio controls autoplay="true">
+                <source src="data:audio/mp3;base64,{b64}" type="audio/mp3">
+                </audio>
+                """
+    def update_markdown(audio_md):
+        st.markdown(audio_md, unsafe_allow_html=True)
+    update_audio()
+    update_markdown(global_audio_md)
+
+def embeddings(text: str):
+
+    '''Create embeddings for the job description'''
+
+    nltk.download('punkt')
+    text_splitter = NLTKTextSplitter()
+    texts = text_splitter.split_text(text)
+    # Create emebeddings
+    embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+    docsearch = FAISS.from_texts(texts, embeddings)
+    retriever = docsearch.as_retriever(search_tupe='similarity search')
+    return retriever
+
+def initialize_session_state():
+
+    '''Initialize session state variables'''
+
+    if "retriever" not in st.session_state:
+        st.session_state.retriever = embeddings(jd)
+    if "chain_type_kwargs" not in st.session_state:
+        Behavioral_Prompt = PromptTemplate(input_variables=["context", "question"],
+                                          template=templates.behavioral_template)
+        st.session_state.chain_type_kwargs = {"prompt": Behavioral_Prompt}
+    # interview history
+    if "history" not in st.session_state:
+        st.session_state.history = []
+        st.session_state.history.append(Message("ai", "Hello there! I am your interviewer today. I will access your soft skills through a series of questions. Let's get started! Please start by saying hello or introducing yourself. Note: The maximum length of your answer is 4097 tokens!"))
+    # token count
+    if "token_count" not in st.session_state:
+        st.session_state.token_count = 0
+    if "memory" not in st.session_state:
+        st.session_state.memory = ConversationBufferMemory()
+    if "guideline" not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+        st.session_state.guideline = RetrievalQA.from_chain_type(
+            llm=llm,
+            chain_type_kwargs=st.session_state.chain_type_kwargs, chain_type='stuff',
+            retriever=st.session_state.retriever, memory=st.session_state.memory).run(
+            "Create an interview guideline and prepare total of 8 questions. Make sure the questions tests the soft skills")
+    # llm chain and memory
+    if "conversation" not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+        PROMPT = PromptTemplate(
+            input_variables=["history", "input"],
+            template="""I want you to act as an interviewer strictly following the guideline in the current conversation.
+                            Candidate has no idea what the guideline is.
+                            Ask me questions and wait for my answers. Do not write explanations.
+                            Ask question like a real person, only one question at a time.
+                            Do not ask the same question.
+                            Do not repeat the question.
+                            Do ask follow-up questions if necessary. 
+                            You name is GPTInterviewer.
+                            I want you to only reply as an interviewer.
+                            Do not write all the conversation at once.
+                            If there is an error, point it out.
+
+                            Current Conversation:
+                            {history}
+
+                            Candidate: {input}
+                            AI: """)
+        st.session_state.conversation = ConversationChain(prompt=PROMPT, llm=llm,
+                                                       memory=st.session_state.memory)
+    if "feedback" not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+        st.session_state.feedback = ConversationChain(
+            prompt=PromptTemplate(input_variables = ["history", "input"], template = templates.feedback_template),
+            llm=llm,
+            memory = st.session_state.memory,
+        )
+
+def answer_call_back():
+
+    '''callback function for answering user input'''
+
+    # user input
+    human_answer = st.session_state.answer
+    st.session_state.history.append(
+        Message("human", human_answer)
+    )
+    # OpenAI answer and save to history
+    llm_answer = st.session_state.conversation.run(human_answer)
+    st.session_state.history.append(
+        Message("ai", llm_answer)
+    )
+    st.session_state.token_count += len(llm_answer.split())
+    return llm_answer
+
+### ————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————————
+if jd:
+
+    initialize_session_state()
+    credit_card_placeholder = st.empty()
+    col1, col2 = st.columns(2)
+    with col1:
+        feedback = st.button("Get Interview Feedback")
+    with col2:
+        guideline = st.button("Show me interview guideline!")
+    audio = None
+    chat_placeholder = st.container()
+    answer_placeholder = st.container()
+
+    if guideline:
+        st.write(st.session_state.guideline)
+    if feedback:
+        evaluation = st.session_state.feedback.run("please give evalution regarding the interview")
+        st.markdown(evaluation)
+        st.download_button(label="Download Interview Feedback", data=evaluation, file_name="interview_feedback.txt")
+        st.stop()
+    else:
+        with answer_placeholder:
+            voice = 0
+            if voice:
+                print("voice")
+                #st.warning("An UnboundLocalError will occur if the microphone fails to record.")
+            else:
+                answer = st.chat_input("Your answer")
+            if answer:
+                st.session_state['answer'] = answer
+                audio = answer_call_back()
+        with chat_placeholder:
+            for answer in st.session_state.history:
+                if answer.origin == 'ai':
+                    if audio:
+                        with st.chat_message("assistant"):
+                            st.write(answer.message)
+                            st.write(audio)
+                    else:
+                        with st.chat_message("assistant"):
+                            st.write(answer.message)
+                else:
+                    with st.chat_message("user"):
+                        st.write(answer.message)
+
+        credit_card_placeholder.caption(f"""
+                        Progress: {int(len(st.session_state.history) / 30 * 100)}% completed.
+        """)
+
+else:
+    st.info("Please submit job description to start interview.")
+
+
+
+

pages/Professional Screen.py

@@ -0,0 +1,179 @@
+import streamlit as st
+from streamlit_lottie import st_lottie
+from typing import Literal
+from dataclasses import dataclass
+import json
+import base64
+from langchain.memory import ConversationBufferMemory
+
+from langchain.chains import ConversationChain, RetrievalQA
+from langchain.prompts.prompt import PromptTemplate
+from langchain.text_splitter import NLTKTextSplitter
+from langchain.vectorstores import FAISS
+import nltk
+from prompts.prompts import templates
+from langchain_google_genai import ChatGoogleGenerativeAI
+import getpass
+import os
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+
+if "GOOGLE_API_KEY" not in os.environ:
+    os.environ["GOOGLE_API_KEY"] = "AIzaSyCA4__JMC_ZIQ9xQegIj5LOMLhSSrn3pMw"
+
+
+
+st.title("Professional Screen")
+jd = st.text_area("Please enter the job description here (If you don't have one, enter keywords, such as PostgreSQL or Python instead): ")
+
+
+@dataclass
+class Message:
+    """class for keeping track of interview history."""
+    origin: Literal["human", "ai"]
+    message: str
+
+def save_vector(text):
+    """embeddings"""
+
+    nltk.download('punkt')
+    text_splitter = NLTKTextSplitter()
+    texts = text_splitter.split_text(text)
+     # Create emebeddings
+    embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+    docsearch = FAISS.from_texts(texts, embeddings)
+    return docsearch
+
+def initialize_session_state_jd():
+    """ initialize session states """
+    if 'jd_docsearch' not in st.session_state:
+        st.session_state.jd_docserch = save_vector(jd)
+    if 'jd_retriever' not in st.session_state:
+        st.session_state.jd_retriever = st.session_state.jd_docserch.as_retriever(search_type="similarity")
+    if 'jd_chain_type_kwargs' not in st.session_state:
+        Interview_Prompt = PromptTemplate(input_variables=["context", "question"],
+                                          template=templates.jd_template)
+        st.session_state.jd_chain_type_kwargs = {"prompt": Interview_Prompt}
+    if 'jd_memory' not in st.session_state:
+        st.session_state.jd_memory = ConversationBufferMemory()
+    # interview history
+    if "jd_history" not in st.session_state:
+        st.session_state.jd_history = []
+        st.session_state.jd_history.append(Message("ai",
+                                                   "Hello, Welcome to the interview. I am your interviewer today. I will ask you professional questions regarding the job description you submitted."
+                                                   "Please start by introducting a little bit about yourself. Note: The maximum length of your answer is 4097 tokens!"))
+    # token count
+    if "token_count" not in st.session_state:
+        st.session_state.token_count = 0
+    if "jd_guideline" not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+        st.session_state.jd_guideline = RetrievalQA.from_chain_type(
+            llm=llm,
+            chain_type_kwargs=st.session_state.jd_chain_type_kwargs, chain_type='stuff',
+            retriever=st.session_state.jd_retriever, memory = st.session_state.jd_memory).run("Create an interview guideline and prepare only one questions for each topic. Make sure the questions tests the technical knowledge")
+    # llm chain and memory
+    if "jd_screen" not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+        PROMPT = PromptTemplate(
+            input_variables=["history", "input"],
+            template="""I want you to act as an interviewer strictly following the guideline in the current conversation.
+                            Candidate has no idea what the guideline is.
+                            Ask me questions and wait for my answers. Do not write explanations.
+                            Ask question like a real person, only one question at a time.
+                            Do not ask the same question.
+                            Do not repeat the question.
+                            Do ask follow-up questions if necessary. 
+                            You name is GPTInterviewer.
+                            I want you to only reply as an interviewer.
+                            Do not write all the conversation at once.
+                            If there is an error, point it out.
+
+                            Current Conversation:
+                            {history}
+
+                            Candidate: {input}
+                            AI: """)
+
+        st.session_state.jd_screen = ConversationChain(prompt=PROMPT, llm=llm,
+                                                           memory=st.session_state.jd_memory)
+    if 'jd_feedback' not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+        st.session_state.jd_feedback = ConversationChain(
+            prompt=PromptTemplate(input_variables=["history", "input"], template=templates.feedback_template),
+            llm=llm,
+            memory=st.session_state.jd_memory,
+        )
+
+def answer_call_back():
+    formatted_history = []
+    for message in st.session_state.jd_history:
+        if message.origin == "human":
+            formatted_message = {"speaker": "user", "text": message.message}
+        else:
+            formatted_message = {"speaker": "assistant", "text": message.message}
+        formatted_history.append(formatted_message)
+
+    user_answer = st.session_state.get('answer', '')
+
+    answer = st.session_state.jd_screen.run(input=user_answer, history=formatted_history)
+
+    if user_answer:  
+        st.session_state.jd_history.append(Message("human", user_answer))
+    if answer:
+        st.session_state.jd_history.append(Message("ai", answer))
+
+    return answer
+
+
+if jd:
+    # initialize session states
+    initialize_session_state_jd()
+    #st.write(st.session_state.jd_guideline)
+    credit_card_placeholder = st.empty()
+    col1, col2 = st.columns(2)
+    with col1:
+        feedback = st.button("Get Interview Feedback")
+    with col2:
+        guideline = st.button("Show me interview guideline!")
+    chat_placeholder = st.container()
+    answer_placeholder = st.container()
+    audio = None
+    # if submit email adress, get interview feedback imediately
+    if guideline:
+        st.write(st.session_state.jd_guideline)
+    if feedback:
+        evaluation = st.session_state.jd_feedback.run("please give evalution regarding the interview")
+        st.markdown(evaluation)
+        st.download_button(label="Download Interview Feedback", data=evaluation, file_name="interview_feedback.txt")
+        st.stop()
+    else:
+        with answer_placeholder:
+            voice = 0
+            if voice:
+                print(voice)               
+            else:
+                answer = st.chat_input("Your answer")
+            if answer:
+                st.session_state['answer'] = answer
+                audio = answer_call_back()
+        with chat_placeholder:
+            for answer in st.session_state.jd_history:
+                if answer.origin == 'ai':
+                    if audio:
+                        with st.chat_message("assistant"):
+                            st.write(answer.message)
+                            st.write(audio)
+                    else:
+                        with st.chat_message("assistant"):
+                            st.write(answer.message)
+                else:
+                    with st.chat_message("user"):
+                        st.write(answer.message)
+
+        credit_card_placeholder.caption(f"""
+        Progress: {int(len(st.session_state.jd_history) / 30 * 100)}% completed.""")
+else:
+    st.info("Please submit a job description to start the interview.")

pages/Resume Screen.py

@@ -0,0 +1,188 @@
+# langchain: https://python.langchain.com/
+from dataclasses import dataclass
+import streamlit as st
+from langchain.callbacks import get_openai_callback
+from langchain.memory import ConversationBufferMemory
+from langchain.chains import RetrievalQA, ConversationChain
+from langchain.prompts.prompt import PromptTemplate
+from prompts.prompts import templates
+from typing import Literal
+from langchain.vectorstores import FAISS
+from langchain.text_splitter import NLTKTextSplitter
+from PyPDF2 import PdfReader
+from prompts.prompt_selector import prompt_sector
+from streamlit_lottie import st_lottie
+import json
+from IPython.display import Audio
+import nltk
+from langchain_google_genai import ChatGoogleGenerativeAI
+import getpass
+import os
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+
+if "GOOGLE_API_KEY" not in os.environ:
+    os.environ["GOOGLE_API_KEY"] = "AIzaSyCA4__JMC_ZIQ9xQegIj5LOMLhSSrn3pMw"
+
+
+
+st.title("Resume Screen")
+
+st.session_state.history = []
+
+position = st.text_input("Select the position you are applying for :")
+resume = st.file_uploader("Upload your resume", type=["pdf"])
+
+#st.toast("4097 tokens is roughly equivalent to around 800 to 1000 words or 3 minutes of speech. Please keep your answer within this limit.")
+
+@dataclass
+class Message:
+    """Class for keeping track of interview history."""
+    origin: Literal["human", "ai"]
+    message: str
+
+def save_vector(resume):
+    """embeddings"""
+    nltk.download('punkt')
+    pdf_reader = PdfReader(resume)
+    text = ""
+    for page in pdf_reader.pages:
+        text += page.extract_text()
+    # Split the document into chunks
+    text_splitter = NLTKTextSplitter()
+    texts = text_splitter.split_text(text)
+    embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+    docsearch = FAISS.from_texts(texts, embeddings)
+    return docsearch
+
+def initialize_session_state_resume():
+    # convert resume to embeddings
+    if 'docsearch' not in st.session_state:
+        st.session_state.docserch = save_vector(resume)
+    # retriever for resume screen
+    if 'retriever' not in st.session_state:
+        st.session_state.retriever = st.session_state.docserch.as_retriever(search_type="similarity")
+    # prompt for retrieving information
+    if 'chain_type_kwargs' not in st.session_state:
+        st.session_state.chain_type_kwargs = prompt_sector(position, templates)
+    # interview history
+    if "resume_history" not in st.session_state:
+        st.session_state.resume_history = []
+        st.session_state.resume_history.append(Message(origin="ai", message="Hello, I am your interivewer today. I will ask you some questions regarding your resume and your experience. Please start by saying hello or introducing yourself. Note: The maximum length of your answer is 4097 tokens!"))
+    # token count
+    if "token_count" not in st.session_state:
+        st.session_state.token_count = 0
+    # memory buffer for resume screen
+    if "resume_memory" not in st.session_state:
+        st.session_state.resume_memory = ConversationBufferMemory(human_prefix = "Candidate: ", ai_prefix = "Interviewer")
+    # guideline for resume screen
+    if "resume_guideline" not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+
+        st.session_state.resume_guideline = RetrievalQA.from_chain_type(
+            llm=llm,
+            chain_type_kwargs=st.session_state.chain_type_kwargs, chain_type='stuff',
+            retriever=st.session_state.retriever, memory = st.session_state.resume_memory).run("Create an interview guideline and prepare only two questions for each topic. Make sure the questions tests the knowledge")
+    # llm chain for resume screen
+    if "resume_screen" not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+
+        PROMPT = PromptTemplate(
+            input_variables=["history", "input"],
+            template= """I want you to act as an interviewer strictly following the guideline in the current conversation.
+            
+            Ask me questions and wait for my answers like a human. Do not write explanations.
+            Candidate has no assess to the guideline.
+            Only ask one question at a time. 
+            Do ask follow-up questions if you think it's necessary.
+            Do not ask the same question.
+            Do not repeat the question.
+            Candidate has no assess to the guideline.
+            You name is GPTInterviewer.
+            I want you to only reply as an interviewer.
+            Do not write all the conversation at once.
+            Candiate has no assess to the guideline.
+            
+            Current Conversation:
+            {history}
+            
+            Candidate: {input}
+            AI: """)
+        st.session_state.resume_screen =  ConversationChain(prompt=PROMPT, llm = llm, memory = st.session_state.resume_memory)
+    # llm chain for generating feedback
+    if "resume_feedback" not in st.session_state:
+        llm = ChatGoogleGenerativeAI(
+        model="gemini-pro")
+        st.session_state.resume_feedback = ConversationChain(
+            prompt=PromptTemplate(input_variables=["history","input"], template=templates.feedback_template),
+            llm=llm,
+            memory=st.session_state.resume_memory,
+        )
+
+def answer_call_back():
+
+    '''callback function for answering user input'''
+
+    # user input
+    human_answer = st.session_state.answer
+    st.session_state.history.append(
+        Message("human", human_answer)
+    )
+    # OpenAI answer and save to history
+    llm_answer = st.session_state.conversation.run(human_answer)
+    st.session_state.history.append(
+        Message("ai", llm_answer)
+    )
+    st.session_state.token_count += len(llm_answer.split())
+    return llm_answer
+
+if position and resume:
+    # intialize session state
+    initialize_session_state_resume()
+    credit_card_placeholder = st.empty()
+    col1, col2 = st.columns(2)
+    with col1:
+        feedback = st.button("Get Interview Feedback")
+    with col2:
+        guideline = st.button("Show me interview guideline!")
+    chat_placeholder = st.container()
+    answer_placeholder = st.container()
+    audio = None
+    # if submit email adress, get interview feedback imediately
+    if guideline:
+        st.markdown(st.session_state.resume_guideline)
+    if feedback:
+        evaluation = st.session_state.resume_feedback.run("please give evalution regarding the interview")
+        st.markdown(evaluation)
+        st.download_button(label="Download Interview Feedback", data=evaluation, file_name="interview_feedback.txt")
+        st.stop()
+    else:
+        with answer_placeholder:
+            voice: bool = st.checkbox("I would like to speak with AI Interviewer!")
+            if voice:
+                print("voice")                #st.warning("An UnboundLocalError will occur if the microphone fails to record.")
+            else:
+                answer = st.chat_input("Your answer")
+            if answer:
+                st.session_state['answer'] = answer
+                audio = answer_call_back()
+
+        with chat_placeholder:
+            for answer in st.session_state.resume_history:
+                if answer.origin == 'ai':
+                    if audio:
+                        with st.chat_message("assistant"):
+                            st.write(answer.message)
+                            st.write(audio)
+                    else:
+                        with st.chat_message("assistant"):
+                            st.write(answer.message)
+                else:
+                    with st.chat_message("user"):
+                        st.write(answer.message)
+
+        credit_card_placeholder.caption(f"""
+                        Progress: {int(len(st.session_state.resume_history) / 30 * 100)}% completed.""")
+

requirements.txt

@@ -0,0 +1,14 @@
+langchain
+PyPDF2
+openai
+wave
+streamlit==1.25.0
+tiktoken
+nltk
+#azure-cognitiveservices-speech
+audio_recorder_streamlit
+streamlit-option-menu
+streamlit-lottie
+faiss-cpu
+boto3
+Ipython