First commit

.gitignore

@@ -0,0 +1,9 @@
+
+.env
+/__pycache__
+/.gradio
+/hr_interviewer
+/knowledge
+/reports
+*.json
+*.json

ai_config.py

@@ -0,0 +1,80 @@
+from io import BytesIO
+
+from langchain_openai import ChatOpenAI
+from openai import OpenAI
+import tiktoken
+import os
+from dotenv import load_dotenv
+import os
+from langchain.text_splitter import MarkdownHeaderTextSplitter
+
+# Load environment variables from .env file
+load_dotenv()
+
+# IBM Connection Parameters (using loaded env variables)
+openai_api_key = os.getenv("OPENAI_API_KEY")
+
+def n_of_questions():
+    n_of_questions = 5
+    return n_of_questions
+
+#openai_api_key = os.environ.get("openai_api_key")
+
+model = "gpt-3.5-turbo-1106"
+
+def load_model(openai_api_key):
+    return ChatOpenAI(
+        model_name=model,
+        openai_api_key=openai_api_key,
+        temperature=0.5
+    )
+
+# Initialize the OpenAI client with the API key
+client = OpenAI(api_key=openai_api_key)
+
+
+def convert_text_to_speech(text, output, voice):
+    try:
+        # Convert the final text to speech
+        response = client.audio.speech.create(model="tts-1-hd", voice=voice, input=text)
+
+        if isinstance(output, BytesIO):
+            # If output is a BytesIO object, write directly to it
+            for chunk in response.iter_bytes():
+                output.write(chunk)
+        else:
+            # If output is a file path, open and write to it
+            with open(output, 'wb') as f:
+                for chunk in response.iter_bytes():
+                    f.write(chunk)
+
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        # Fallback in case of error
+        response = client.audio.speech.create(model="tts-1-hd", voice=voice, input='Here is my Report.')
+
+        if isinstance(output, BytesIO):
+            for chunk in response.iter_bytes():
+                output.write(chunk)
+        else:
+            with open(output, 'wb') as f:
+                for chunk in response.iter_bytes():
+                    f.write(chunk)
+
+
+def transcribe_audio(audio):
+    try:
+        audio_file = open(audio, "rb")
+        transcription = client.audio.transcriptions.create(
+            model="whisper-1",
+            file=audio_file
+        )
+        return transcription.text
+    except Exception as e:
+        return "Audio transcription failed. Please try again."
+    
+    
+def split_text_with_langchain(text, headers_to_split_on):
+    markdown_splitter = MarkdownHeaderTextSplitter(headers_to_split_on=headers_to_split_on)
+    docs = markdown_splitter.create_documents([text])
+    return docs

app-v1.py

@@ -0,0 +1,214 @@
+import grad as gr
+import tempfile
+import os
+import json
+from io import BytesIO
+from gpt import read_questions_from_json, conduct_interview_with_user_input  # Import from gpt.py
+from ai_config import convert_text_to_speech, load_model
+from knowledge_retrieval import setup_knowledge_retrieval, generate_report
+from prompt_instructions import get_interview_initial_message_hr, get_default_hr_questions
+from settings import language
+from utils import save_interview_history
+from questions import generate_and_save_questions_from_pdf
+
+CONFIG_PATH = "config.json"
+QUESTIONS_PATH = "questions.json"
+
+class InterviewState:
+    def __init__(self):
+        self.reset()
+
+    def reset(self, voice="alloy"):
+        self.question_count = 0
+        self.interview_history = []
+        self.selected_interviewer = voice
+        self.interview_finished = False
+        self.audio_enabled = True
+        self.temp_audio_files = []
+        self.admin_authenticated = False
+        self.config = load_config()
+        self.technical_questions = []
+
+def load_config():
+    if os.path.exists(CONFIG_PATH):
+        with open(CONFIG_PATH, "r") as f:
+            return json.load(f)
+    else:
+        return {"n_of_questions": 5, "type_of_interview": "Standard"}
+
+def save_config(config):
+    with open(CONFIG_PATH, "w") as f:
+        json.dump(config, f, indent=4)
+
+def save_questions(questions):
+    with open(QUESTIONS_PATH, "w") as f:
+        json.dump(questions, f, indent=4)
+
+def load_questions():
+    if os.path.exists(QUESTIONS_PATH):
+        with open(QUESTIONS_PATH, "r") as f:
+            return json.load(f)
+    return []
+
+interview_state = InterviewState()
+
+# Load knowledge base and generate technical questions
+def load_knowledge_base(file_input, n_questions_to_generate):
+    if not file_input:
+        return "❌ Error: No document uploaded."
+
+    llm = load_model(os.getenv("OPENAI_API_KEY"))
+    try:
+        _, _, retriever = setup_knowledge_retrieval(llm, language=language, file_path=file_input)
+        technical_questions = generate_and_save_questions_from_pdf(file_input, n_questions_to_generate)
+        save_questions(technical_questions)
+
+        return f"✅ {len(technical_questions)} technical questions generated and saved."
+    except Exception as e:
+        return f"❌ Error: {e}"
+
+def reset_interview_action(voice):
+    interview_state.reset(voice)
+    config = interview_state.config
+    n_of_questions = config.get("n_of_questions", 5)
+    initial_message = {
+        "role": "assistant",
+        "content": get_interview_initial_message_hr(n_of_questions)
+    }
+
+    if config["type_of_interview"] == "Technical":
+        technical_questions = load_questions()
+
+        if not technical_questions:
+            return [{"role": "assistant", "content": "No technical questions available. Please contact the admin."}], None, gr.Textbox(interactive=False)
+
+        # Prepare for displaying questions one at a time
+        interview_state.technical_questions = technical_questions
+        interview_state.question_count = 0
+        return (
+            [initial_message],
+            None,
+            gr.Textbox(interactive=True, placeholder="Technical interview started. Answer the questions below...")
+        )
+    else:
+        initial_audio_buffer = BytesIO()
+        convert_text_to_speech(initial_message["content"], initial_audio_buffer, voice)
+        initial_audio_buffer.seek(0)
+
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+            temp_audio_path = temp_file.name
+            temp_file.write(initial_audio_buffer.getvalue())
+
+        interview_state.temp_audio_files.append(temp_audio_path)
+        return (
+            [initial_message],
+            gr.Audio(value=temp_audio_path, autoplay=True),
+            gr.Textbox(interactive=True, placeholder="Type your answer here...")
+        )
+
+def start_interview():
+    interview_config = load_config()
+    interview_state.config = interview_config
+    return reset_interview_action(interview_state.selected_interviewer)
+
+def update_config(n_of_questions, interview_type):
+    config = {
+        "n_of_questions": int(n_of_questions),
+        "type_of_interview": interview_type
+    }
+    save_config(config)
+    return "✅ Configuration updated successfully."
+
+def update_knowledge_base_and_generate_questions(file_input, n_questions_to_generate):
+    return load_knowledge_base(file_input, n_questions_to_generate)
+
+def bot_response(chatbot, message):
+    config = interview_state.config
+
+    if config["type_of_interview"] == "Standard":
+        response = get_default_hr_questions(interview_state.question_count + 1)
+        chatbot.append({"role": "assistant", "content": response})
+        interview_state.question_count += 1
+    else:
+        if interview_state.question_count < len(interview_state.technical_questions):
+            question = interview_state.technical_questions[interview_state.question_count]
+            chatbot.append({"role": "assistant", "content": f"Q{interview_state.question_count + 1}: {question}"})
+            interview_state.question_count += 1
+            chatbot.append({"role": "user", "content": message})  # Append user response after the question
+        else:
+            chatbot.append({"role": "assistant", "content": "All questions completed."})
+            interview_state.interview_finished = True
+
+    if interview_state.interview_finished:
+        report_content = generate_report(interview_state.report_chain, [msg["content"] for msg in chatbot if msg["role"] == "user"], language)
+        txt_path = save_interview_history([msg["content"] for msg in chatbot], language)
+        return chatbot, gr.File(visible=True, value=txt_path)
+
+    return chatbot, None
+
+def create_app():
+    with gr.Blocks(title="AI HR Interviewer") as demo:
+        gr.Markdown("## 🧑‍💼 HR Interviewer Application")
+
+        with gr.Row():
+            user_role = gr.Dropdown(choices=["Admin", "Candidate"], label="Select User Role", value="Candidate")
+            password_input = gr.Textbox(label="Enter Admin Password", type="password", visible=False)
+            login_button = gr.Button("Login", visible=False)
+            password_status = gr.Markdown("", visible=False)
+
+        admin_tab = gr.Tab("Admin Settings", visible=False)
+        interview_tab = gr.Tab("Interview", visible=True)
+
+        user_role.change(lambda role: (gr.update(visible=role == "Admin"),) * 2, inputs=[user_role], outputs=[password_input, login_button])
+
+        def authenticate_admin(password):
+            if password == "password1":
+                interview_state.admin_authenticated = True
+                return "✅ Password correct", gr.update(visible=False), gr.update(visible=True)
+            else:
+                return "❌ Incorrect password.", gr.update(visible=True), gr.update(visible=False)
+
+        login_button.click(authenticate_admin, inputs=[password_input], outputs=[password_status, password_input, admin_tab])
+
+        with admin_tab:
+            file_input = gr.File(label="Upload Knowledge Base Document", type="filepath")
+            n_questions_input = gr.Number(label="Number of Questions", value=10)
+            update_button = gr.Button("Update Knowledge Base")
+            update_status = gr.Markdown("")
+            update_button.click(update_knowledge_base_and_generate_questions, inputs=[file_input, n_questions_input], outputs=[update_status])
+
+            n_questions_interview_input = gr.Number(label="Number of Questions for Interview", value=5)
+            interview_type_input = gr.Dropdown(choices=["Standard", "Technical"], label="Type of Interview", value="Standard")
+            save_config_button = gr.Button("Save Configuration")
+            config_status = gr.Markdown("")
+            save_config_button.click(update_config, inputs=[n_questions_interview_input, interview_type_input], outputs=[config_status])
+
+        with interview_tab:
+            reset_button = gr.Button("Start Interview")
+            chatbot = gr.Chatbot(label="Chat Session", type="messages")
+            msg_input = gr.Textbox(label="💬 Type your message here...", interactive=True)
+            send_button = gr.Button("Send")
+
+            reset_button.click(start_interview, inputs=[], outputs=[chatbot])
+
+            msg_input.submit(lambda msg, hist: ("", hist + [{"role": "user", "content": msg}]), inputs=[msg_input, chatbot], outputs=[msg_input, chatbot]).then(
+                bot_response, [chatbot, msg_input], [chatbot]
+            )
+
+            send_button.click(lambda msg, hist: ("", hist + [{"role": "user", "content": msg}]), inputs=[msg_input, chatbot], outputs=[msg_input, chatbot]).then(
+                bot_response, [chatbot, msg_input], [chatbot]
+            )
+
+    return demo
+
+def cleanup():
+    for audio_file in interview_state.temp_audio_files:
+        if os.path.exists(audio_file):
+            os.unlink(audio_file)
+
+if __name__ == "__main__":
+    app = create_app()
+    try:
+        app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    finally:
+        cleanup()

app.py

@@ -0,0 +1,551 @@
+import gradio as gr
+import tempfile
+import os
+import json
+from io import BytesIO
+import subprocess
+from collections import deque
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+
+# Imports from other modules
+from generatorgr import (
+    generate_and_save_questions as generate_questions_manager,
+    update_max_questions,
+)
+from generator import (
+    PROFESSIONS_FILE,
+    TYPES_FILE,
+    OUTPUT_FILE,
+    load_json_data,
+    generate_questions,
+)
+from splitgpt import (
+    generate_and_save_questions_from_pdf3
+)
+
+# Placeholder imports for the manager application
+# Ensure these modules and functions are correctly implemented in their respective files
+from ai_config import convert_text_to_speech, load_model  # Placeholder, needs implementation
+from knowledge_retrieval import (
+    setup_knowledge_retrieval,
+    get_next_response,
+    generate_report,
+    get_initial_question,
+)  # Placeholder, needs implementation
+from prompt_instructions import (
+    get_interview_initial_message_hr,
+    get_default_hr_questions,
+)  # Placeholder, needs implementation
+from settings import language  # Placeholder, needs implementation
+from utils import save_interview_history  # Placeholder, needs implementation
+
+
+class InterviewState:
+    def __init__(self):
+        self.reset()
+
+    def reset(self, voice="alloy"):
+        self.question_count = 0
+        self.interview_history = []
+        self.selected_interviewer = voice
+        self.interview_finished = False
+        self.audio_enabled = True
+        self.temp_audio_files = []
+        self.initial_audio_path = None
+        self.admin_authenticated = False
+        self.document_loaded = False
+        self.knowledge_retrieval_setup = False
+        self.interview_chain = None
+        self.report_chain = None
+        self.current_questions = [] # Store the current set of questions
+
+    def get_voice_setting(self):
+        return self.selected_interviewer
+
+
+interview_state = InterviewState()
+
+
+def reset_interview_action(voice):
+    interview_state.reset(voice)
+    n_of_questions = 5  # Default questions
+    print(f"[DEBUG] Interview reset. Voice: {voice}")
+
+    initial_message = {
+        "role": "assistant",
+        "content": get_interview_initial_message_hr(n_of_questions),
+    }
+    print(f"[DEBUG] Interview reset. Voice: {voice}")
+    # Convert the initial message to speech
+    initial_audio_buffer = BytesIO()
+    convert_text_to_speech(initial_message["content"], initial_audio_buffer, voice)
+    initial_audio_buffer.seek(0)
+
+    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+        temp_audio_path = temp_file.name
+        temp_file.write(initial_audio_buffer.getvalue())
+
+    interview_state.temp_audio_files.append(temp_audio_path)
+    print(f"[DEBUG] Audio file saved at {temp_audio_path}")
+
+    return (
+        [initial_message],
+        gr.Audio(value=temp_audio_path, autoplay=True),
+        gr.Textbox(interactive=True),
+    )
+
+
+def start_interview():
+
+    return reset_interview_action(interview_state.selected_interviewer)
+
+
+import os
+from datetime import datetime
+
+def store_interview_report(report_content, folder_path="reports"):
+    """
+    Stores the interview report in a specified reports folder.
+    
+    Args:
+        report_content (str): The content of the report to store.
+        folder_path (str): The directory where the report will be saved.
+    
+    Returns:
+        str: The file path of the saved report.
+    """
+    os.makedirs(folder_path, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    file_path = os.path.join(folder_path, f"interview_report_{timestamp}.txt")
+    
+    try:
+        with open(file_path, "w", encoding="utf-8") as file:
+            file.write(report_content)
+        print(f"[DEBUG] Interview report saved at {file_path}")
+        return file_path
+    except Exception as e:
+        print(f"[ERROR] Failed to save interview report: {e}")
+        return None
+
+
+def bot_response(chatbot, message):
+    n_of_questions = 5  # Default value
+    interview_state.question_count += 1
+    voice = interview_state.get_voice_setting()
+
+    if interview_state.question_count == 1:
+        response = get_initial_question(interview_state.interview_chain)
+    else:
+        response = get_next_response(
+            interview_state.interview_chain,
+            message["content"],
+            [msg["content"] for msg in chatbot if msg.get("role") == "user"],
+            interview_state.question_count,
+        )
+
+    # Generate and save the bot's audio response
+    audio_buffer = BytesIO()
+    convert_text_to_speech(response, audio_buffer, voice)
+    audio_buffer.seek(0)
+    with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+        temp_audio_path = temp_file.name
+        temp_file.write(audio_buffer.getvalue())
+
+    interview_state.temp_audio_files.append(temp_audio_path)
+    chatbot.append({"role": "assistant", "content": response})
+
+    # Check if the interview is finished
+    if interview_state.question_count >= n_of_questions:
+        interview_state.interview_finished = True
+        conclusion_message = (
+            "Thank you for your time. The interview is complete. Please review your report."
+        )
+
+        # Generate conclusion audio message
+        conclusion_audio_buffer = BytesIO()
+        convert_text_to_speech(conclusion_message, conclusion_audio_buffer, voice)
+        conclusion_audio_buffer.seek(0)
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_conclusion_file:
+            temp_conclusion_audio_path = temp_conclusion_file.name
+            temp_conclusion_file.write(conclusion_audio_buffer.getvalue())
+        interview_state.temp_audio_files.append(temp_conclusion_audio_path)
+
+        # Append conclusion message to chatbot history
+        chatbot.append({"role": "system", "content": conclusion_message})
+
+        # Generate the HR report content
+        report_content = generate_report(
+            interview_state.report_chain,
+            [msg["content"] for msg in chatbot],
+            language,
+        )
+
+        # Save the interview history
+        txt_path = save_interview_history(
+            [msg["content"] for msg in chatbot], language
+        )
+        print(f"[DEBUG] Interview history saved at: {txt_path}")
+
+        # Save the report to the reports folder
+        report_file_path = store_interview_report(report_content)
+        print(f"[DEBUG] Interview report saved at: {report_file_path}")
+
+        return chatbot, gr.File(visible=True, value=txt_path), gr.Audio(value=temp_conclusion_audio_path, autoplay=True)
+
+    return chatbot, gr.Audio(value=temp_audio_path, autoplay=True)
+
+
+# --- Candidate Interview Implementation ---
+load_dotenv()
+
+# Function to read questions from JSON
+def read_questions_from_json(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+    with open(file_path, 'r') as f:
+        questions_list = json.load(f)
+
+    if not questions_list:
+        raise ValueError("The JSON file is empty or has invalid content.")
+
+    return questions_list
+
+# Conduct interview and handle user input
+
+import os
+import json
+from io import BytesIO
+import tempfile
+from collections import deque
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+
+# Placeholder imports (ensure these are correctly implemented)
+from ai_config import convert_text_to_speech  # For text-to-speech
+from knowledge_retrieval import generate_report  # For report generation
+from utils import save_interview_history  # For saving interview history
+from settings import language # Placeholder, needs implementation
+
+# Assuming you have interview_state defined elsewhere and accessible here
+# interview_state = InterviewState() # You might need to initialize this or pass it as a parameter
+
+def conduct_interview(questions, language="English", history_limit=5):
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        raise RuntimeError(
+            "OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY."
+        )
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750
+    )
+
+    conversation_history = deque(maxlen=history_limit)
+    system_prompt = (
+        f"You are Sarah, an empathetic HR interviewer conducting a technical interview in {language}. "
+        "Respond to user follow-up questions politely and concisely. If the user is confused, provide clear clarification."
+    )
+
+    interview_data = []
+    current_question_index = [0]
+
+    initial_message = (
+        "👋 Hi there, I'm Sarah, your friendly AI HR assistant! "
+        "I'll guide you through a series of interview questions to learn more about you. "
+        "Take your time and answer each question thoughtfully."
+    )
+
+    def interview_step(user_input, history):
+
+        if user_input.lower() in ["exit", "quit"]:
+            history.append(
+                {
+                    "role": "assistant",
+                    "content": "The interview has ended at your request. Thank you for your time!",
+                }
+            )
+            return history, ""
+
+        question_text = questions[current_question_index[0]]
+        history_content = "\n".join(
+            [
+                f"Q: {entry['question']}\nA: {entry['answer']}"
+                for entry in conversation_history
+            ]
+        )
+        combined_prompt = (
+            f"{system_prompt}\n\nPrevious conversation history:\n{history_content}\n\n"
+            f"Current question: {question_text}\nUser's input: {user_input}\n\n"
+            "Respond in a warm and conversational way, offering natural follow-ups if needed."
+        )
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=combined_prompt),
+        ]
+
+        response = chat.invoke(messages)
+        response_content = response.content.strip()
+
+        # --- Integrated bot_response functionality starts here ---
+
+        interview_state.question_count += 1
+        voice = interview_state.get_voice_setting()  # Get voice setting
+
+        # Generate and save the bot's audio response
+        audio_buffer = BytesIO()
+        convert_text_to_speech(response_content, audio_buffer, voice)
+        audio_buffer.seek(0)
+        with tempfile.NamedTemporaryFile(suffix=".mp3", delete=False) as temp_file:
+            temp_audio_path = temp_file.name
+            temp_file.write(audio_buffer.getvalue())
+
+        interview_state.temp_audio_files.append(temp_audio_path)
+
+        # --- Integrated bot_response functionality ends here ---
+
+        conversation_history.append({"question": question_text, "answer": user_input})
+        interview_data.append({"question": question_text, "answer": user_input})
+        history.append({"role": "user", "content": user_input})
+        history.append({"role": "assistant", "content": response_content, "audio": temp_audio_path}) # Store audio path
+
+        if current_question_index[0] + 1 < len(questions):
+            current_question_index[0] += 1
+            next_question = f"Alright, let's move on. {questions[current_question_index[0]]}"
+            history.append({"role": "assistant", "content": next_question})
+
+        else:
+            conclusion_message = "That wraps up our interview. Thank you so much for your responses—it's been great learning more about you!"
+            history.append(
+                {"role": "assistant", "content": conclusion_message}
+            )
+
+            # --- Generate report and save history (only at the end) ---
+            interview_state.interview_finished = True
+
+            # Generate the HR report content
+            report_content = generate_report(
+                interview_state.report_chain,
+                [msg["content"] for msg in history if msg["role"] != "system"], # Consider only user/assistant messages
+                language,
+            )
+
+            # Save the interview history
+            txt_path = save_interview_history(
+                [msg["content"] for msg in history if msg["role"] != "system"], language # Consider only user/assistant messages
+            )
+            print(f"[DEBUG] Interview history saved at: {txt_path}")
+
+            # Save the report to the reports folder
+            report_file_path = store_interview_report(report_content)
+            print(f"[DEBUG] Interview report saved at: {report_file_path}")
+
+        return history, ""
+
+    return interview_step, initial_message
+
+
+
+def launch_candidate_app():
+    QUESTIONS_FILE_PATH = "questions.json"
+
+    def start_interview_ui():
+        # Reload questions every time the interview starts
+        interview_state.current_questions = read_questions_from_json(QUESTIONS_FILE_PATH)
+        interview_func, initial_message = conduct_interview(interview_state.current_questions)
+        interview_state.interview_func = interview_func
+
+        history = [{"role": "assistant", "content": initial_message}]
+        history.append({"role": "assistant", "content": "Let's begin! Here's your first question: " + interview_state.current_questions[0]})
+        return history, ""
+
+    def clear_interview_ui():
+        # Reset state when clearing the interview
+        interview_state.reset()
+        return [], ""
+
+    def on_enter_submit_ui(history, user_response):
+        if not user_response.strip():
+            return history, ""
+        history, _ = interview_state.interview_func(user_response, history)
+        return history, ""
+
+    with gr.Blocks(title="AI HR Interview Assistant") as candidate_app:
+        gr.Markdown("<h1 style='text-align: center;'>👋 Welcome to Your AI HR Interview Assistant</h1>")
+        start_btn = gr.Button("Start Interview", variant="primary")
+        chatbot = gr.Chatbot(label="Interview Chat", height=650, type="messages")
+        user_input = gr.Textbox(label="Your Response", placeholder="Type your answer here...", lines=1)
+        with gr.Row():
+            submit_btn = gr.Button("Submit")
+            clear_btn = gr.Button("Clear Chat")
+
+        start_btn.click(start_interview_ui, inputs=[], outputs=[chatbot, user_input])
+        submit_btn.click(on_enter_submit_ui, inputs=[chatbot, user_input], outputs=[chatbot, user_input])
+        user_input.submit(on_enter_submit_ui, inputs=[chatbot, user_input], outputs=[chatbot, user_input])
+        clear_btn.click(clear_interview_ui, inputs=[], outputs=[chatbot, user_input])
+
+    return candidate_app
+
+
+def create_manager_app():
+    with gr.Blocks(
+        title="AI HR Interviewer Manager",
+        css="""
+        .tab-button {
+            background-color: #f0f0f0;
+            color: #333;
+            padding: 10px 20px;
+            border: none;
+            cursor: pointer;
+            font-size: 16px;
+            transition: background-color 0.3s ease;
+        }
+        .tab-button:hover {
+            background-color: #d0d0d0;
+        }
+        .tab-button.selected {
+            background-color: #666;
+            color: white;
+        }
+    """,
+    ) as manager_app:
+        gr.HTML(
+            """
+            <div style='text-align: center; margin-bottom: 20px;'>
+                <h1 style='font-size: 36px; color: #333;'>AI HR Interviewer Manager</h1>
+                <p style='font-size: 18px; color: #666;'>Select your role to start the interview process.</p>
+            </div>
+        """
+        )
+
+        with gr.Row():
+            user_role = gr.Dropdown(
+                choices=["Admin", "Candidate"],
+                label="Select User Role",
+                value="Candidate",
+            )
+            proceed_button = gr.Button("👉 Proceed")
+
+        candidate_ui = gr.Column(visible=False)
+        admin_ui = gr.Column(visible=False)
+
+        with candidate_ui:
+            gr.Markdown("## 🚀 Candidate Interview")
+            candidate_app = launch_candidate_app()
+
+        with admin_ui:
+            gr.Markdown("## 🔒 Admin Panel")
+            with gr.Tab("Generate Questions"):
+                try:
+                    professions_data = load_json_data(PROFESSIONS_FILE)
+                    types_data = load_json_data(TYPES_FILE)
+                except (FileNotFoundError, json.JSONDecodeError) as e:
+                    print(f"Error loading data from JSON files: {e}")
+                    professions_data = []
+                    types_data = []
+
+                profession_names = [
+                    item["profession"] for item in professions_data
+                ]
+                interview_types = [item["type"] for item in types_data]
+
+                with gr.Row():
+                    profession_input = gr.Dropdown(
+                        label="Select Profession", choices=profession_names
+                    )
+                    interview_type_input = gr.Dropdown(
+                        label="Select Interview Type", choices=interview_types
+                    )
+
+                num_questions_input = gr.Number(
+                    label="Number of Questions (1-20)",
+                    value=5,
+                    precision=0,
+                    minimum=1,
+                    maximum=20,
+                )
+                overwrite_input = gr.Checkbox(
+                    label="Overwrite all_questions.json?", value=True
+                )
+                # Update num_questions_input when interview_type_input changes
+                interview_type_input.change(
+                    fn=update_max_questions,
+                    inputs=interview_type_input,
+                    outputs=num_questions_input,
+                )
+                generate_button = gr.Button("Generate Questions")
+
+                output_text = gr.Textbox(label="Output")
+                question_output = gr.JSON(label="Generated Questions")
+
+                generate_button.click(
+                    generate_questions_manager,
+                    inputs=[
+                        profession_input,
+                        interview_type_input,
+                        num_questions_input,
+                        overwrite_input,
+                    ],
+                    outputs=[output_text, question_output],
+                )
+
+
+            with gr.Tab("Generate from PDF"):
+                gr.Markdown("### 📄 Upload PDF for Question Generation")
+                pdf_file_input = gr.File(label="Upload PDF File", type="filepath")
+                num_questions_pdf_input = gr.Number(label="Number of Questions", value=5, precision=0)
+                
+                pdf_status_output = gr.Textbox(label="Status", lines=3)
+                pdf_question_output = gr.JSON(label="Generated Questions")
+                
+                generate_pdf_button = gr.Button("Generate Questions from PDF")
+
+                def update_pdf_ui(pdf_path, num_questions):
+                    for status, questions in generate_and_save_questions_from_pdf3(pdf_path, num_questions):
+                        yield gr.update(value=status), gr.update(value=questions)
+
+                generate_pdf_button.click(
+                    update_pdf_ui,
+                    inputs=[pdf_file_input, num_questions_pdf_input],
+                    outputs=[pdf_status_output, pdf_question_output],
+                )
+
+
+
+
+        def show_selected_ui(role):
+            if role == "Candidate":
+                return {candidate_ui: gr.Column(visible=True), admin_ui: gr.Column(visible=False)}
+
+            elif role == "Admin":
+                return {candidate_ui: gr.Column(visible=False), admin_ui: gr.Column(visible=True)}
+            else:
+                return {candidate_ui: gr.Column(visible=False), admin_ui: gr.Column(visible=False)}
+
+
+        proceed_button.click(
+            show_selected_ui,
+            inputs=[user_role],
+            outputs=[candidate_ui, admin_ui],
+        )
+
+    return manager_app
+
+def cleanup():
+    for audio_file in interview_state.temp_audio_files:
+        try:
+            if os.path.exists(audio_file):
+                os.unlink(audio_file)
+        except Exception as e:
+            print(f"Error deleting file {audio_file}: {e}")
+
+
+if __name__ == "__main__":
+    manager_app = create_manager_app()
+    try:
+        manager_app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    finally:
+        cleanup()    

generator.py

@@ -0,0 +1,134 @@
+import os
+import json
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+
+# Load environment variables
+load_dotenv()
+
+# File paths
+PROFESSIONS_FILE = "professions.json"
+TYPES_FILE = "types.json"
+OUTPUT_FILE = "all_questions.json"
+
+def generate_questions(profession, interview_type, description, max_questions):
+    """
+    Generates interview questions using the OpenAI API based on profession, type, and description.
+    """
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+
+    if not openai_api_key:
+        raise RuntimeError(
+            "OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY."
+        )
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750
+    )
+
+    messages = [
+        SystemMessage(
+            content="You are an expert interviewer who generates concise technical interview questions for HR interviews. "
+                    "Answer only with questions. Do not number the questions. Each question should be a separate string. "
+                    "The questions should be appropriate for "
+                    f"the {interview_type} stage of the interview process and relevant to the {profession} profession."
+                    f" Generate no more than {max_questions} questions."
+
+        ),
+        HumanMessage(
+            content=f"Generate interview questions for the role of '{profession}'. "
+                    f"Interview Type: '{interview_type}'. "
+                    f"Description of the role: '{description}'. "
+
+        ),
+    ]
+
+    try:
+        print(f"[DEBUG] Sending request to OpenAI for {profession} - {interview_type}")
+        response = chat.invoke(messages)
+        # Directly split the response into individual questions without numbering
+        questions = [q.strip() for q in response.content.split("\n") if q.strip()]
+
+    except Exception as e:
+        print(f"[ERROR] Failed to generate questions: {e}")
+        questions = ["An error occurred while generating questions."]
+
+    return questions
+
+
+def load_json_data(filepath):
+    """Loads data from a JSON file."""
+    with open(filepath, "r") as f:
+        return json.load(f)
+
+
+def save_questions_to_file(output_file, all_questions, overwrite=True):
+    """
+    Saves the questions to the specified JSON file.
+
+    Args:
+        output_file: The path to the output JSON file.
+        all_questions: The list of question dictionaries to save.
+        overwrite: If True, overwrites the file if it exists. If False, appends to the file.
+    """
+    if overwrite:
+        with open(output_file, "w") as outfile:
+            json.dump(all_questions, outfile, indent=4)
+    else:
+        try:
+            existing_questions = load_json_data(output_file)
+        except (FileNotFoundError, json.JSONDecodeError):
+            existing_questions = []
+
+        existing_questions.extend(all_questions)
+
+        with open(output_file, "w") as outfile:
+            json.dump(existing_questions, outfile, indent=4)
+
+
+def main(overwrite_output=True):
+    """
+    Main function to generate and save interview questions.
+    """
+    try:
+        professions_data = load_json_data(PROFESSIONS_FILE)
+        types_data = load_json_data(TYPES_FILE)
+    except FileNotFoundError as e:
+        print(f"Error: File not found - {e}")
+        return
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON format in file - {e}")
+        return
+
+    all_questions = []
+
+    for profession_info in professions_data:
+        profession = profession_info["profession"]
+        description = profession_info["description"]
+
+        for interview_type_info in types_data:
+            interview_type = interview_type_info["type"]
+            max_questions = interview_type_info.get("max_questions", 5)
+
+            questions = generate_questions(
+                profession, interview_type, description, max_questions
+            )
+
+            all_questions.append(
+                {
+                    "profession": profession,
+                    "interview_type": interview_type,
+                    "description": description,
+                    "max_questions": max_questions,
+                    "questions": questions,
+                }
+            )
+    # Save the questions, either overwriting or appending based on the parameter
+    save_questions_to_file(OUTPUT_FILE, all_questions, overwrite=overwrite_output)
+    print(f"[INFO] Questions saved to {OUTPUT_FILE}")
+
+
+if __name__ == "__main__":
+    # Set overwrite_output to True to overwrite the existing file, False to append
+    main(overwrite_output=True)

generatorgr.py

@@ -0,0 +1,121 @@
+import gradio as gr
+import json
+import time
+import os
+
+from generator import PROFESSIONS_FILE, TYPES_FILE, OUTPUT_FILE
+from generator import generate_questions, load_json_data, save_questions_to_file
+
+# Load professions and interview types from JSON files
+try:
+    professions_data = load_json_data(PROFESSIONS_FILE)
+    types_data = load_json_data(TYPES_FILE)
+except (FileNotFoundError, json.JSONDecodeError) as e:
+    print(f"Error loading data from JSON files: {e}")
+    professions_data = []
+    types_data = []
+
+# Extract profession names and interview types for the dropdown menus
+profession_names = [item["profession"] for item in professions_data]
+interview_types = [item["type"] for item in types_data]
+
+# Define path for the questions.json file
+QUESTIONS_FILE = "questions.json"
+
+
+def generate_and_save_questions(profession, interview_type, num_questions, overwrite=True, progress=gr.Progress()):
+    """
+    Generates questions using the generate_questions function and saves them to JSON files.
+    Provides progress updates.
+    """
+    profession_info = next(
+        (item for item in professions_data if item["profession"] == profession), None
+    )
+    interview_type_info = next(
+        (item for item in types_data if item["type"] == interview_type), None
+    )
+
+    if profession_info is None or interview_type_info is None:
+        return "Error: Invalid profession or interview type selected.", None
+
+    description = profession_info["description"]
+    max_questions = min(int(num_questions), 20)  # Ensure max is 20
+
+    progress(0, desc="Starting question generation...")
+
+    questions = generate_questions(
+        profession, interview_type, description, max_questions
+    )
+
+    progress(0.5, desc=f"Generated {len(questions)} questions. Saving...")
+
+    # Save the generated questions to the all_questions.json file
+    
+    all_questions_entry = {
+            "profession": profession,
+            "interview_type": interview_type,
+            "description": description,
+            "max_questions": max_questions,
+            "questions": questions,
+        }
+    
+    
+    save_questions_to_file(OUTPUT_FILE, [all_questions_entry], overwrite=overwrite)
+
+    # Save the generated questions to the new questions.json file
+    with open(QUESTIONS_FILE, "w") as outfile:
+        json.dump(questions, outfile, indent=4)
+
+    progress(1, desc="Questions saved.")
+
+    return (
+        f"✅ Questions generated and saved for {profession} ({interview_type}). Max questions: {max_questions}",
+        questions,
+    )
+
+
+
+def update_max_questions(interview_type):
+    """
+    Updates the default value of the number input based on the selected interview type.
+    """
+    interview_type_info = next(
+        (item for item in types_data if item["type"] == interview_type), None
+    )
+    if interview_type_info:
+        default_max_questions = interview_type_info.get("max_questions", 5)
+        return gr.update(value=default_max_questions, minimum=1, maximum=20)
+    else:
+        return gr.update(value=5, minimum=1, maximum=20)
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("## 📄 Interview Question Generator for IBM CIC")
+    with gr.Row():
+        profession_input = gr.Dropdown(label="Select Profession", choices=profession_names)
+        interview_type_input = gr.Dropdown(label="Select Interview Type", choices=interview_types)
+
+    num_questions_input = gr.Number(
+        label="Number of Questions (1-20)", value=5, precision=0, minimum=1, maximum=20
+    )
+
+    generate_button = gr.Button("Generate Questions")
+
+    output_text = gr.Textbox(label="Output")
+    question_output = gr.JSON(label="Generated Questions")
+
+    # Update num_questions_input when interview_type_input changes
+    interview_type_input.change(
+        fn=update_max_questions,
+        inputs=interview_type_input,
+        outputs=num_questions_input,
+    )
+
+    generate_button.click(
+        generate_and_save_questions,
+        inputs=[profession_input, interview_type_input, num_questions_input],
+        outputs=[output_text, question_output],
+    )
+
+if __name__ == "__main__":
+    demo.queue().launch()

gpt-general.py

@@ -0,0 +1,96 @@
+import os
+import json
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI  # Correct import from langchain-openai
+from langchain.schema import HumanMessage, SystemMessage  # For creating structured chat messages
+
+# Load environment variables
+load_dotenv()
+
+# Function to read questions from JSON
+# The JSON is expected to contain a list of dictionaries or strings.
+def read_questions_from_json(file_path):
+    """
+    Reads questions from a JSON file.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+    with open(file_path, 'r') as f:
+        questions_list = json.load(f)
+
+    if not questions_list:
+        raise ValueError("The JSON file is empty or has invalid content.")
+
+    return questions_list
+
+# Function to generate interview questions using LLM and collect user answers
+def conduct_interview_with_llm(questions, language="English"):
+    """
+    Generates interview questions using the LLM and collects user responses.
+    """
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        raise RuntimeError("OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY.")
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750
+    )
+
+    interview_data = []
+    print("\n--- Technical Interview Started ---\n")
+
+    for index, question_text in enumerate(questions):
+        # Create the system and user prompts
+        system_prompt = f"You are Sarah, a compassionate and empathetic HR professional conducting a technical interview in {language}."  
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=f"Generate the next interview question based on the context and previous history. Current question number: {index + 1}/{len(questions)}.")
+        ]
+
+        try:
+            # Generate a question from the LLM
+            print(f"Generating question {index + 1}...")
+            response = chat.invoke(messages)
+            llm_generated_question = response.content.strip()
+            print(f"Q{index + 1}: {llm_generated_question}")
+
+            # Collect the user’s answer
+            user_answer = input("Your answer: ").strip()
+            interview_data.append({"question": llm_generated_question, "answer": user_answer})
+
+        except Exception as e:
+            print(f"Error with OpenAI API: {e}")
+            interview_data.append({"question": "An error occurred while generating the question.", "answer": "No answer recorded."})
+
+    print("\n--- Technical Interview Completed ---\n")
+    return interview_data
+
+# Function to save interview to a text file
+def save_interview_to_file(interview_data, file_path):
+    """
+    Saves the questions and answers to a text file.
+    """
+    with open(file_path, 'w') as f:
+        for entry in interview_data:
+            f.write(f"Q: {entry['question']}\n")
+            f.write(f"A: {entry['answer']}\n\n")
+
+    print(f"Interview saved to {file_path}")
+
+if __name__ == "__main__":
+    QUESTIONS_FILE_PATH = "questions.json"
+    INTERVIEW_FILE_PATH = "interview.txt"
+
+    try:
+        # Read questions from JSON file
+        questions = read_questions_from_json(QUESTIONS_FILE_PATH)
+
+        # Conduct the interview
+        interview_results = conduct_interview_with_llm(questions, language="English")
+
+        # Save the interview to a text file
+        save_interview_to_file(interview_results, INTERVIEW_FILE_PATH)
+
+    except Exception as e:
+        print(f"Error: {e}")

gpt.py

@@ -0,0 +1,109 @@
+import os
+import json
+from collections import deque
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+
+# Load environment variables
+load_dotenv()
+
+# Function to read questions from JSON
+def read_questions_from_json(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+    with open(file_path, 'r') as f:
+        questions_list = json.load(f)
+
+    if not questions_list:
+        raise ValueError("The JSON file is empty or has invalid content.")
+
+    return questions_list
+
+# Function to handle user input and responses from the LLM
+def handle_user_input(chat, system_prompt, conversation_history, question_text):
+    while True:
+        user_input = input(f"Your response: ").strip()
+        if user_input.lower() in ["exit", "quit"]:
+            print("Interview terminated as requested.")
+            return "[Interview Terminated by User]", True
+
+        history_content = "\n".join([f"Q: {entry['question']}\nA: {entry['answer']}" for entry in conversation_history])
+        combined_prompt = (f"{system_prompt}\n\nPrevious conversation history:\n{history_content}\n\n"
+                           f"Current question: {question_text}\nUser's input: {user_input}\n\n"
+                           "Respond naturally to any follow-up questions or requests for clarification, and let the user know when you're ready to proceed.")
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=combined_prompt)
+        ]
+
+        response = chat.invoke(messages)
+        response_content = response.content.strip()
+
+        if "proceed" in response_content.lower() or "continue" in response_content.lower():
+            print("Understood. Let’s continue to the next question.")
+            return user_input, False
+        else:
+            print(f"LLM's Response: {response_content}")
+            #print("Whenever you're ready, just let me know if you want to move forward or discuss further.")
+            print("Whenever you're ready, just let me know, if you want to move to the next question tell me proceed, or provide further clarifications.")
+
+# Function to conduct the interview
+def conduct_interview_with_user_input(questions, language="English", history_limit=5):
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        raise RuntimeError("OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY.")
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750
+    )
+
+    interview_data = []
+    conversation_history = deque(maxlen=history_limit)
+    system_prompt = (f"You are Sarah, an empathetic HR interviewer conducting a technical interview in {language}. "
+                     "Respond to user follow-up questions politely and concisely. If the user is confused, provide clear clarification.")
+
+    print("\n--- Technical Interview Started ---\n")
+
+    for index, question_text in enumerate(questions):
+        print(f"{index + 1}/{len(questions)}: {question_text}")
+        try:
+            user_answer, terminate = handle_user_input(chat, system_prompt, conversation_history, question_text)
+            if terminate:
+                break
+
+            conversation_history.append({"question": question_text, "answer": user_answer})
+            interview_data.append({"question": question_text, "answer": user_answer})
+
+            if index + 1 == len(questions):
+                print("Thank you for your time. This concludes the interview. We will prepare a report based on the gathered information.")
+
+        except Exception as e:
+            print(f"Error during the interview process: {e}")
+            interview_data.append({"question": question_text, "answer": "No answer recorded due to an error."})
+
+    print("\n--- Technical Interview Completed ---\n")
+    return interview_data
+
+# Function to save interview to a text file
+def save_interview_to_file(interview_data, file_path):
+    with open(file_path, 'w') as f:
+        for entry in interview_data:
+            f.write(f"Q: {entry['question']}\n")
+            f.write(f"A: {entry['answer']}\n\n")
+
+    print(f"Interview saved to {file_path}")
+
+if __name__ == "__main__":
+    QUESTIONS_FILE_PATH = "questions.json"
+    INTERVIEW_FILE_PATH = "interview.txt"
+
+    try:
+        questions = read_questions_from_json(QUESTIONS_FILE_PATH)
+        interview_results = conduct_interview_with_user_input(questions, language="English")
+        save_interview_to_file(interview_results, INTERVIEW_FILE_PATH)
+
+    except Exception as e:
+        print(f"Error: {e}")

gptgr-manager.py

@@ -0,0 +1,185 @@
+import gradio as gr
+import tempfile
+import os
+import json
+from io import BytesIO
+from collections import deque
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+
+# Load environment variables
+load_dotenv()
+
+class InterviewState:
+    def __init__(self):
+        self.reset()
+
+    def reset(self, voice="alloy"):
+        self.question_count = 0
+        self.interview_history = []
+        self.selected_interviewer = voice
+        self.interview_finished = False
+        self.audio_enabled = True
+        self.temp_audio_files = []
+        self.initial_audio_path = None
+        self.admin_authenticated = False
+        self.document_loaded = False
+        self.knowledge_retrieval_setup = False
+        self.interview_chain = None
+        self.report_chain = None
+
+    def get_voice_setting(self):
+        return self.selected_interviewer
+
+interview_state = InterviewState()
+
+# Function to read questions from JSON
+def read_questions_from_json(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+    with open(file_path, 'r') as f:
+        questions_list = json.load(f)
+
+    if not questions_list:
+        raise ValueError("The JSON file is empty or has invalid content.")
+
+    return questions_list
+
+# Conduct interview and handle user input
+def conduct_interview(questions, language="English", history_limit=5):
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        raise RuntimeError("OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY.")
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750
+    )
+
+    conversation_history = deque(maxlen=history_limit)
+    system_prompt = (f"You are Sarah, an empathetic HR interviewer conducting a technical interview in {language}. "
+                     "Respond to user follow-up questions politely and concisely. If the user is confused, provide clear clarification.")
+
+    interview_data = []
+    current_question_index = [0]
+
+    initial_message = ("👋 Hi there, I'm Sarah, your friendly AI HR assistant! "
+                       "I'll guide you through a series of interview questions to learn more about you. "
+                       "Take your time and answer each question thoughtfully.")
+
+    def interview_step(user_input, history):
+        if user_input.lower() in ["exit", "quit"]:
+            history.append({"role": "assistant", "content": "The interview has ended at your request. Thank you for your time!"})
+            return history, ""
+
+        question_text = questions[current_question_index[0]]
+        history_content = "\n".join([f"Q: {entry['question']}\nA: {entry['answer']}" for entry in conversation_history])
+        combined_prompt = (f"{system_prompt}\n\nPrevious conversation history:\n{history_content}\n\n"
+                           f"Current question: {question_text}\nUser's input: {user_input}\n\n"
+                           "Respond in a warm and conversational way, offering natural follow-ups if needed.")
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=combined_prompt)
+        ]
+
+        response = chat.invoke(messages)
+        response_content = response.content.strip()
+
+        conversation_history.append({"question": question_text, "answer": user_input})
+        interview_data.append({"question": question_text, "answer": user_input})
+        history.append({"role": "user", "content": user_input})
+        history.append({"role": "assistant", "content": response_content})
+
+        if current_question_index[0] + 1 < len(questions):
+            current_question_index[0] += 1
+            next_question = f"Alright, let's move on. {questions[current_question_index[0]]}"
+            history.append({"role": "assistant", "content": next_question})
+            return history, ""
+        else:
+            history.append({"role": "assistant", "content": "That wraps up our interview. Thank you so much for your responses—it's been great learning more about you!"})
+            return history, ""
+
+    return interview_step, initial_message
+
+def launch_candidate_app():
+    QUESTIONS_FILE_PATH = "questions.json"
+    try:
+        questions = read_questions_from_json(QUESTIONS_FILE_PATH)
+        interview_func, initial_message = conduct_interview(questions)
+
+        def start_interview_ui():
+            history = [{"role": "assistant", "content": initial_message}]
+            history.append({"role": "assistant", "content": "Let's begin! Here's your first question: " + questions[0]})
+            return history, ""
+
+        def clear_interview_ui():
+            return [], ""
+
+        def on_enter_submit_ui(history, user_response):
+            if not user_response.strip():
+                return history, ""
+            history, _ = interview_func(user_response, history)
+            return history, ""
+
+        with gr.Blocks(title="AI HR Interview Assistant") as candidate_app:
+            gr.Markdown("<h1 style='text-align: center;'>👋 Welcome to Your AI HR Interview Assistant</h1>")
+            start_btn = gr.Button("Start Interview", variant="primary")
+            chatbot = gr.Chatbot(label="Interview Chat", height=650, type="messages")
+            user_input = gr.Textbox(label="Your Response", placeholder="Type your answer here...", lines=1)
+            with gr.Row():
+                submit_btn = gr.Button("Submit")
+                clear_btn = gr.Button("Clear Chat")
+
+            start_btn.click(start_interview_ui, inputs=[], outputs=[chatbot, user_input])
+            submit_btn.click(on_enter_submit_ui, inputs=[chatbot, user_input], outputs=[chatbot, user_input])
+            user_input.submit(on_enter_submit_ui, inputs=[chatbot, user_input], outputs=[chatbot, user_input])
+            clear_btn.click(clear_interview_ui, inputs=[], outputs=[chatbot, user_input])
+
+        return candidate_app
+
+    except Exception as e:
+        print(f"Error: {e}")
+        return None
+
+def create_manager_app():
+    with gr.Blocks(title="AI HR Interviewer Manager") as manager_app:
+        gr.HTML("<h1 style='text-align: center;'>AI HR Interviewer Manager</h1>")
+        user_role = gr.Dropdown(choices=["Admin", "Candidate"], label="Select User Role", value="Candidate")
+        proceed_button = gr.Button("👉 Proceed")
+
+        candidate_ui = gr.Column(visible=False)
+        admin_ui = gr.Column(visible=False)
+
+        with candidate_ui:
+            gr.Markdown("## 🚀 Candidate Interview")
+            candidate_app = launch_candidate_app()
+
+        with admin_ui:
+            gr.Markdown("## 🔒 Admin Panel")
+            gr.Markdown("Admin operations and question generation will go here.")
+
+        def show_selected_ui(role):
+            if role == "Candidate":
+                return gr.update(visible=True), gr.update(visible=False)
+            elif role == "Admin":
+                return gr.update(visible=False), gr.update(visible=True)
+            else:
+                return gr.update(visible=False), gr.update(visible=False)
+
+        proceed_button.click(show_selected_ui, inputs=[user_role], outputs=[candidate_ui, admin_ui])
+
+    return manager_app
+
+def cleanup():
+    for audio_file in interview_state.temp_audio_files:
+        if os.path.exists(audio_file):
+            os.unlink(audio_file)
+
+if __name__ == "__main__":
+    manager_app = create_manager_app()
+    try:
+        manager_app.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+    finally:
+        cleanup()

gptgr.py

@@ -0,0 +1,145 @@
+import os
+import json
+from collections import deque
+from dotenv import load_dotenv
+import gradio as gr
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+
+# Load environment variables
+load_dotenv()
+
+# Function to read questions from JSON
+def read_questions_from_json(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+    with open(file_path, 'r') as f:
+        questions_list = json.load(f)
+
+    if not questions_list:
+        raise ValueError("The JSON file is empty or has invalid content.")
+
+    return questions_list
+
+# Conduct interview and handle user input
+def conduct_interview(questions, language="English", history_limit=5):
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        raise RuntimeError("OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY.")
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750
+    )
+
+    conversation_history = deque(maxlen=history_limit)
+    system_prompt = (f"You are Sarah, an empathetic HR interviewer conducting a technical interview in {language}. "
+                     "Respond to user follow-up questions politely and concisely. If the user is confused, provide clear clarification.")
+
+    interview_data = []
+    current_question_index = [0]  # Use a list to hold the index
+
+    initial_message = ("👋 Hi there, I'm Sarah, your friendly AI HR assistant! "
+                       "I'll guide you through a series of interview questions to learn more about you. "
+                       "Take your time and answer each question thoughtfully.")
+
+    def interview_step(user_input, history):
+        if user_input.lower() in ["exit", "quit"]:
+            history.append((None, "The interview has ended at your request. Thank you for your time!"))
+            return history, ""
+
+        question_text = questions[current_question_index[0]]
+        history_content = "\n".join([f"Q: {entry['question']}\nA: {entry['answer']}" for entry in conversation_history])
+        combined_prompt = (f"{system_prompt}\n\nPrevious conversation history:\n{history_content}\n\n"
+                           f"Current question: {question_text}\nUser's input: {user_input}\n\n"
+                           "Respond in a warm and conversational way, offering natural follow-ups if needed.")
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=combined_prompt)
+        ]
+
+        response = chat.invoke(messages)
+        response_content = response.content.strip()
+
+        conversation_history.append({"question": question_text, "answer": user_input})
+        interview_data.append({"question": question_text, "answer": user_input})
+        history.append((user_input, None))
+        history.append((None, response_content))
+
+        if current_question_index[0] + 1 < len(questions):
+            current_question_index[0] += 1
+            next_question = f"Alright, let's move on. {questions[current_question_index[0]]}"
+            history.append((None, next_question))
+            return history, ""
+        else:
+            history.append((None, "That wraps up our interview. Thank you so much for your responses—it's been great learning more about you!"))
+            return history, ""
+
+    return interview_step, initial_message
+
+# Gradio interface
+def main():
+    QUESTIONS_FILE_PATH = "questions.json"  # Ensure you have a questions.json file with your interview questions
+
+    try:
+        questions = read_questions_from_json(QUESTIONS_FILE_PATH)
+        interview_func, initial_message = conduct_interview(questions)
+
+        css = """
+        .contain { display: flex; flex-direction: column; }
+        .gradio-container { height: 100vh !important; }
+        #component-0 { height: 100%; }
+        .chatbot { flex-grow: 1; overflow: auto; height: 100px; }
+        .chatbot .wrap.svelte-1275q59.wrap.svelte-1275q59 {flex-wrap : nowrap !important}
+        .user > div > .message {background-color : #dcf8c6 !important}
+        .bot > div > .message {background-color : #f7f7f8 !important}
+        """
+
+        with gr.Blocks(css=css) as demo:
+            gr.Markdown("""
+            <h1 style='text-align: center; margin-bottom: 1rem'>👋 Welcome to Your AI HR Interview Assistant</h1>
+            """)
+
+            start_btn = gr.Button("Start Interview", variant="primary")
+
+            gr.Markdown("""
+            <p style='text-align: center; margin-bottom: 1rem'>I will ask you a series of questions. Please answer honestly and thoughtfully. When you are ready, click "Start Interview" to begin.</p>
+            """)
+
+            chatbot = gr.Chatbot(label="Interview Chat", elem_id="chatbot", height=650)
+            user_input = gr.Textbox(label="Your Response", placeholder="Type your answer here...", lines=1)
+
+            with gr.Row():
+                submit_btn = gr.Button("Submit", variant="primary")
+                clear_btn = gr.Button("Clear Chat")
+
+            def start_interview():
+                history = []
+                history.append((None, initial_message))
+                history.append((None, "Let's begin! Here's your first question: " + questions[0]))
+                return history, ""
+
+            def clear_interview():
+                return [], ""
+
+            def interview_step(user_response, history):
+                return interview_func(user_response, history)
+
+            def on_enter_submit(history, user_response):
+                if not user_response.strip():
+                    return history, ""
+                return interview_step(user_response, history)
+
+            start_btn.click(start_interview, inputs=[], outputs=[chatbot, user_input])
+            submit_btn.click(interview_step, inputs=[user_input, chatbot], outputs=[chatbot, user_input])
+            user_input.submit(on_enter_submit, inputs=[chatbot, user_input], outputs=[chatbot, user_input])
+            clear_btn.click(clear_interview, inputs=[], outputs=[chatbot, user_input])
+
+        demo.launch()
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    main()

grad.py

@@ -0,0 +1,104 @@
+import os
+import json
+import gradio as gr
+from collections import deque
+from dotenv import load_dotenv
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+
+# Load environment variables
+load_dotenv()
+
+# Function to read questions from JSON
+def read_questions_from_json(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+    with open(file_path, 'r') as f:
+        questions_list = json.load(f)
+    if not questions_list:
+        raise ValueError("The JSON file is empty or has invalid content.")
+    return questions_list
+
+# Function to handle user input and LLM's response
+def handle_user_input(chat, system_prompt, conversation_history, question_text, user_input):
+    history_content = "\n".join([f"Q: {entry['question']}\nA: {entry['answer']}" for entry in conversation_history])
+    combined_prompt = (f"{system_prompt}\n\nPrevious conversation history:\n{history_content}\n\n"
+                       f"Current question: {question_text}\nUser's input: {user_input}\n\n"
+                       "Respond naturally to any follow-up questions or requests for clarification."
+                       " Provide the next question or end the interview when appropriate.")
+
+    messages = [SystemMessage(content=system_prompt), HumanMessage(content=combined_prompt)]
+    response = chat.invoke(messages)
+    return response.content.strip()
+
+# Function to conduct the interview dynamically
+def conduct_interview(questions, language="English", history_limit=5):
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        raise RuntimeError("OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY.")
+
+    chat = ChatOpenAI(openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750)
+    conversation_history = deque(maxlen=history_limit)
+    system_prompt = f"You are Sarah, an empathetic HR interviewer conducting an interview in {language}."
+
+    def gradio_interview(user_input, history):
+        if not history:
+            # Initial greeting and first question
+            initial_message = (f"👋 Hello, I'm your AI HR assistant!\n"
+                               f"I will ask you {len(questions)} questions.\n"
+                               "Please answer honestly and to the best of your ability.")
+            history = [{"role": "assistant", "content": initial_message}]
+            current_question = questions[0]
+            history.append({"role": "assistant", "content": f"First question: {current_question}"})
+            return history, ""
+
+        current_question_index = (len(history) - 2) // 2  # Adjust for assistant's intro
+        if current_question_index < len(questions):
+            current_question = questions[current_question_index]
+            response = handle_user_input(chat, system_prompt, conversation_history, current_question, user_input)
+            conversation_history.append({"question": current_question, "answer": user_input})
+            history.append({"role": "user", "content": user_input})
+            history.append({"role": "assistant", "content": response})
+
+            if current_question_index + 1 < len(questions):
+                next_question = questions[current_question_index + 1]
+                history.append({"role": "assistant", "content": f"Next question: {next_question}"})
+            else:
+                history.append({"role": "assistant", "content": "Thank you for your time. This concludes the interview."})
+
+        return history, ""
+
+    return gradio_interview
+
+# Load questions and start Gradio app
+def start_hr_chatbot():
+    QUESTIONS_FILE_PATH = "questions.json"
+    try:
+        questions = read_questions_from_json(QUESTIONS_FILE_PATH)
+    except Exception as e:
+        print(f"Error: {e}")
+        return
+
+    interview_fn = conduct_interview(questions)
+
+    with gr.Blocks(css=".gradio-container { font-family: Arial, sans-serif; max-width: 700px; margin: auto; }") as demo:
+        gr.Markdown("## 🤖 HR Interview Chatbot")
+        chatbot = gr.Chatbot(label="HR Chatbot", type="messages")
+        user_input = gr.Textbox(label="💬 Your answer:", placeholder="Type your answer here and press Enter...", interactive=True)
+        start_button = gr.Button("Start Interview")
+        state = gr.State([])
+
+        def on_start(history):
+            return interview_fn("", history)
+
+        def on_submit(user_input, history):
+            history, new_input = interview_fn(user_input, history)
+            return history, ""
+
+        start_button.click(fn=on_start, inputs=[state], outputs=[chatbot, state])
+        user_input.submit(fn=on_submit, inputs=[user_input, state], outputs=[chatbot, state])
+
+        demo.launch(server_name="0.0.0.0", server_port=7860, debug=True)
+
+if __name__ == "__main__":
+    start_hr_chatbot()

interview.py

@@ -0,0 +1,61 @@
+import json
+import os
+
+def read_questions_from_json(file_path):
+    """
+    Reads questions from a JSON file.
+    """
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+    with open(file_path, 'r') as f:
+        questions = json.load(f)
+
+    if not questions:
+        raise ValueError("The JSON file is empty or has invalid content.")
+
+    return questions
+
+def conduct_interview(questions):
+    """
+    Conducts an interview by printing each question, taking input for the answer,
+    and storing the questions and answers in a list.
+    """
+    interview_data = []
+    print("\n--- Interview Started ---\n")
+
+    for question in questions:
+        print(f"{question}")
+        answer = input("Your answer: ").strip()
+        interview_data.append({"question": question, "answer": answer})
+
+    print("\n--- Interview Completed ---\n")
+    return interview_data
+
+def save_interview_to_file(interview_data, file_path):
+    """
+    Saves the questions and answers to a text file.
+    """
+    with open(file_path, 'w') as f:
+        for entry in interview_data:
+            f.write(f"Q: {entry['question']}\n")
+            f.write(f"A: {entry['answer']}\n\n")
+
+    print(f"Interview saved to {file_path}")
+
+if __name__ == "__main__":
+    QUESTIONS_FILE_PATH = "questions.json"
+    INTERVIEW_FILE_PATH = "interview.txt"
+
+    try:
+        # Read questions from JSON file
+        questions = read_questions_from_json(QUESTIONS_FILE_PATH)
+
+        # Conduct the interview
+        interview_data = conduct_interview(questions)
+
+        # Save the interview to a text file
+        save_interview_to_file(interview_data, INTERVIEW_FILE_PATH)
+
+    except Exception as e:
+        print(f"Error: {e}")

knowledge_retrieval.py

@@ -0,0 +1,135 @@
+import os
+import fitz  # PyMuPDF for PDF handling
+from langchain_community.vectorstores import FAISS
+from langchain_openai import OpenAIEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.prompts import ChatPromptTemplate, PromptTemplate
+from langchain.schema import Document, StrOutputParser
+from langchain.chains.combine_documents.stuff import StuffDocumentsChain
+from langchain.chains import RetrievalQA
+from langchain.chains.llm import LLMChain
+from langchain_core.runnables import RunnablePassthrough
+from prompt_instructions import get_interview_prompt_hr, get_report_prompt_hr
+
+# Function to load documents based on file type
+def load_document(file_path):
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext == ".txt":
+        with open(file_path, "r", encoding="utf-8") as f:
+            text = f.read()
+        return [Document(page_content=text, metadata={"source": file_path})]
+    elif ext == ".pdf":
+        try:
+            with fitz.open(file_path) as pdf:
+                text = ""
+                for page in pdf:
+                    text += page.get_text()
+            return [Document(page_content=text, metadata={"source": file_path})]
+        except Exception as e:
+            raise RuntimeError(f"Error loading PDF file: {e}")
+    else:
+        raise RuntimeError(f"Unsupported file format: {ext}")
+
+# Function to set up knowledge retrieval
+def setup_knowledge_retrieval(llm, language='english', file_path=None):
+    embedding_model = OpenAIEmbeddings()
+
+    if file_path:
+        # Load and split the document
+        documents = load_document(file_path)
+        text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=100)
+        texts = text_splitter.split_documents(documents)
+
+        # Create a new FAISS index from the document
+        faiss_index_path = "knowledge/faiss_index_hr_documents"
+        try:
+            documents_faiss_index = FAISS.from_documents(texts, embedding_model)
+            documents_faiss_index.save_local(faiss_index_path)
+            print(f"New FAISS vector store created and saved at {faiss_index_path}")
+        except Exception as e:
+            raise RuntimeError(f"Error during FAISS index creation: {e}")
+    else:
+        raise RuntimeError("No document provided for knowledge retrieval setup.")
+
+    documents_retriever = documents_faiss_index.as_retriever()
+
+    # Prompt template for the interview
+    interview_prompt_template = """
+    Use the following pieces of context to answer the question at the end. 
+    If you don't know the answer, just say that you don't know, don't try to make up an answer. 
+    Keep the answer as concise as possible.
+    {context}
+    Question: {question}
+    Helpful Answer:"""
+    interview_prompt = PromptTemplate.from_template(interview_prompt_template)
+
+    # Prompt template for the report
+    report_prompt_template = """
+    Use the following pieces of context to generate a report at the end. 
+    If you don't know the answer, just say that you don't know, don't try to make up an answer. 
+    Keep the answer as concise as possible.
+    {context}
+    Question: {question}
+    Helpful Answer:"""
+    report_prompt = PromptTemplate.from_template(report_prompt_template)
+
+    # Create RetrievalQA chains
+    interview_chain = RetrievalQA.from_chain_type(
+        llm=llm,
+        chain_type="stuff",
+        retriever=documents_retriever,
+        chain_type_kwargs={"prompt": interview_prompt}
+    )
+
+    report_chain = RetrievalQA.from_chain_type(
+        llm=llm,
+        chain_type="stuff",
+        retriever=documents_retriever,
+        chain_type_kwargs={"prompt": report_prompt}
+    )
+
+    return interview_chain, report_chain, documents_retriever
+
+def get_next_response(interview_chain, message, history, question_count):
+    if question_count >= 5:
+        return "Thank you for your responses. I will now prepare a report."
+
+    if not interview_chain:
+        return "Error: Knowledge base not loaded. Please contact an admin."
+
+    # Generate the next question using RetrievalQA
+    response = interview_chain.invoke({"query": message})
+    next_question = response.get("result", "Could you provide more details on that?")
+
+    return next_question
+
+def generate_report(report_chain, history, language):
+    combined_history = "\n".join(history)
+
+    # If report_chain is not available, return a fallback report
+    if not report_chain:
+        print("[DEBUG] Report chain not available. Generating a fallback HR report.")
+        fallback_report = f"""
+        HR Report in {language}:
+        Interview Summary:
+        {combined_history}
+
+        Assessment:
+        Based on the responses, the candidate's strengths, areas for improvement, and overall fit for the role have been noted. No additional knowledge-based insights due to missing vector database.
+        """
+        return fallback_report
+
+    # Generate report using the retrieval chain
+    result = report_chain.invoke({"query": f"Please provide an HR report based on the interview in {language}. Interview history: {combined_history}"})
+
+    return result.get("result", "Unable to generate report due to insufficient information.")
+
+def get_initial_question(interview_chain):
+    if not interview_chain:
+        return "Please introduce yourself and tell me a little bit about your professional background."
+
+    result = interview_chain.invoke({"query": "What should be the first question in an HR interview?"})
+    return result.get("result", "Could you tell me a little bit about yourself and your professional background?")
+
+
+

m6.py

@@ -0,0 +1,245 @@
+import os
+import json
+from collections import deque
+from dotenv import load_dotenv
+import gradio as gr
+from langchain_openai import ChatOpenAI
+from langchain.schema import HumanMessage, SystemMessage
+from openai import OpenAI
+import tempfile
+import time
+
+# Load environment variables
+load_dotenv()
+
+# Function to read questions from JSON
+def read_questions_from_json(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+    with open(file_path, 'r') as f:
+        questions_list = json.load(f)
+
+    if not questions_list:
+        raise ValueError("The JSON file is empty or has invalid content.")
+
+    return questions_list
+
+# Function to convert text to speech
+def convert_text_to_speech(text):
+    start_time = time.time()
+    try:
+        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        response = client.audio.speech.create(model="tts-1", voice="alloy", input=text)
+
+        # Save the audio stream to a temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+            for chunk in response.iter_bytes():
+                tmp_file.write(chunk)
+            temp_audio_path = tmp_file.name
+
+        print(f"DEBUG - Text-to-speech conversion time: {time.time() - start_time:.2f} seconds")
+        return temp_audio_path
+
+    except Exception as e:
+        print(f"Error during text-to-speech conversion: {e}")
+        return None
+
+# Function to transcribe audio
+def transcribe_audio(audio_file_path):
+    start_time = time.time()
+    try:
+        client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
+        with open(audio_file_path, "rb") as audio_file:
+            transcription = client.audio.transcriptions.create(
+                model="whisper-1",
+                file=audio_file
+            )
+        print(f"DEBUG - Audio transcription time: {time.time() - start_time:.2f} seconds")
+        return transcription.text
+    except Exception as e:
+        print(f"Error during audio transcription: {e}")
+        return None
+
+# Conduct interview and handle user input
+def conduct_interview(questions, language="English", history_limit=5):
+    start_time = time.time()
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+    if not openai_api_key:
+        raise RuntimeError("OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY.")
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4o", temperature=0.7, max_tokens=750
+    )
+
+    conversation_history = deque(maxlen=history_limit)
+    system_prompt = (f"You are Sarah, an empathetic HR interviewer conducting a technical interview in {language}. "
+                     "Respond to user follow-up questions politely and concisely. If the user is confused, provide clear clarification.")
+
+    interview_data = []
+    current_question_index = [0]  # Use a list to hold the index
+    is_interview_finished = False
+
+    initial_message = ("👋 Hi there, I'm Sarah, your friendly AI HR assistant! "
+                       "I'll guide you through a series of interview questions to learn more about you. "
+                       "Take your time and answer each question thoughtfully.")
+    final_message = "That wraps up our interview. Thank you so much for your responses—it's been great learning more about you!"
+    print(f"DEBUG - conduct_interview setup time: {time.time() - start_time:.2f} seconds")
+
+    def interview_step(user_input, audio_input, history):
+        nonlocal current_question_index
+        nonlocal is_interview_finished
+        
+        step_start_time = time.time()
+
+        # Transcribe audio input if provided
+        if audio_input:
+            user_input = transcribe_audio(audio_input)
+            print("Transcription:", user_input)
+
+        if user_input.lower() in ["exit", "quit"]:
+            history.append({"role": "assistant", "content": "The interview has ended at your request. Thank you for your time!"})
+            is_interview_finished = True
+            return history, "", None
+
+        # If interview is finished, do nothing
+        if is_interview_finished:
+            return history, "", None
+        
+        question_text = questions[current_question_index[0]]
+        history_content = "\n".join([f"Q: {entry['question']}\nA: {entry['answer']}" for entry in conversation_history])
+        combined_prompt = (f"{system_prompt}\n\nPrevious conversation history:\n{history_content}\n\n"
+                           f"Current question: {question_text}\nUser's input: {user_input}\n\n"
+                           "Respond in a warm and conversational way, offering natural follow-ups if needed.")
+
+        messages = [
+            SystemMessage(content=system_prompt),
+            HumanMessage(content=combined_prompt)
+        ]
+
+        chat_start_time = time.time()
+        response = chat.invoke(messages)
+        print(f"DEBUG - Chat response time: {time.time() - chat_start_time:.2f} seconds")
+        response_content = response.content.strip()
+
+        # Convert response to speech
+        audio_file_path = convert_text_to_speech(response_content)
+
+        conversation_history.append({"question": question_text, "answer": user_input})
+        interview_data.append({"question": question_text, "answer": user_input})
+
+        # Use the correct format for messages
+        history.append({"role": "user", "content": user_input})
+        history.append({"role": "assistant", "content": response_content})
+
+        if current_question_index[0] + 1 < len(questions):
+            current_question_index[0] += 1
+            next_question = f"Alright, let's move on. {questions[current_question_index[0]]}"
+            next_question_audio_path = convert_text_to_speech(next_question)
+            history.append({"role": "assistant", "content": next_question})
+            print(f"DEBUG - Interview step time: {time.time() - step_start_time:.2f} seconds")
+            return history, "", next_question_audio_path
+        
+        else:
+            # Convert final message to speech and play it
+            final_message_audio_path = convert_text_to_speech(final_message)
+            history.append({"role": "assistant", "content": final_message})
+
+            # Convert the last question to speech
+            last_question_audio_path = convert_text_to_speech(questions[current_question_index[0]])
+            is_interview_finished = True
+            print(f"DEBUG - Interview step time: {time.time() - step_start_time:.2f} seconds")
+            return history, "", last_question_audio_path
+
+    return interview_step, initial_message, final_message
+
+# Gradio interface
+def main():
+    QUESTIONS_FILE_PATH = "questions.json"  # Ensure you have a questions.json file with your interview questions
+
+    try:
+        questions = read_questions_from_json(QUESTIONS_FILE_PATH)
+        interview_func, initial_message, final_message = conduct_interview(questions)
+
+        css = """
+        .contain { display: flex; flex-direction: column; }
+        .gradio-container { height: 100vh !important; }
+        #component-0 { height: 100%; }
+        .chatbot { flex-grow: 1; overflow: auto; height: 100px; }
+        .chatbot .wrap.svelte-1275q59.wrap.svelte-1275q59 {flex-wrap : nowrap !important}
+        .user > div > .message {background-color : #dcf8c6 !important}
+        .bot > div > .message {background-color : #f7f7f8 !important}
+        """
+
+        with gr.Blocks(css=css) as demo:
+            gr.Markdown("""
+            <h1 style='text-align: center; margin-bottom: 1rem'>👋 Welcome to Your AI HR Interview Assistant</h1>
+            """)
+
+            start_btn = gr.Button("Start Interview", variant="primary")
+
+            gr.Markdown("""
+            <p style='text-align: center; margin-bottom: 1rem'>I will ask you a series of questions. Please answer honestly and thoughtfully. When you are ready, click "Start Interview" to begin.</p>
+            """)
+
+            chatbot = gr.Chatbot(label="Interview Chat", elem_id="chatbot", height=650, type='messages')
+            audio_input = gr.Audio(sources=["microphone"], type="filepath", label="Record Your Answer")
+            user_input = gr.Textbox(label="Your Response", placeholder="Type your answer here or use the microphone...", lines=1)
+
+            audio_output = gr.Audio(label="Response Audio", autoplay=True)
+
+            with gr.Row():
+                submit_btn = gr.Button("Submit", variant="primary")
+                clear_btn = gr.Button("Clear Chat")
+
+            def start_interview():
+                history = []
+
+                # Convert and play initial message
+                start_time = time.time()
+                initial_audio_path = convert_text_to_speech(initial_message)
+
+                # Combine initial message and first question
+                first_question = "Let's begin! Here's your first question: " + questions[0]
+                combined_message = initial_message + " " + first_question
+
+                # Convert combined message to speech
+                combined_audio_path = convert_text_to_speech(combined_message)
+
+                history.append({"role": "assistant", "content": combined_message})
+
+                print(f"DEBUG - Initial message audio time: {time.time() - start_time:.2f} seconds")
+
+                return history, "", combined_audio_path
+
+            def clear_interview():
+                # Reset the interview state
+                interview_func, initial_message, final_message = conduct_interview(questions)
+                
+                return [], "", None
+
+            def interview_step_wrapper(user_response, audio_response, history):
+                history, _, audio_path = interview_func(user_response, audio_response, history)
+                time.sleep(0.1)  # Reduced delay
+                return history, "", audio_path
+
+            def on_enter_submit(history, user_response):
+                if not user_response.strip():
+                    return history, "", None
+                history, _, audio_path = interview_step_wrapper(user_response, None, history)
+                time.sleep(0.1)  # Reduced delay
+                return history, "", audio_path
+
+            audio_input.stop_recording(interview_step_wrapper, inputs=[user_input, audio_input, chatbot], outputs=[chatbot, user_input, audio_output])
+            start_btn.click(start_interview, inputs=[], outputs=[chatbot, user_input, audio_output])
+            submit_btn.click(interview_step_wrapper, inputs=[user_input, audio_input, chatbot], outputs=[chatbot, user_input, audio_output])
+            user_input.submit(on_enter_submit, inputs=[chatbot, user_input], outputs=[chatbot, user_input, audio_output])
+            clear_btn.click(clear_interview, inputs=[], outputs=[chatbot, user_input, audio_output])
+
+        demo.launch()
+
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    main()

prompt_instructions.py

@@ -0,0 +1,181 @@
+from datetime import datetime
+
+current_datetime = datetime.now()
+current_date = current_datetime.strftime("%Y-%m-%d")
+
+# Initial Interview Messages
+def get_interview_initial_message_hr(n_of_questions):
+    return f"""Hello, I'm an AI HR assistant. I'll be conducting this interview.
+    I will ask you about {n_of_questions} questions.
+    Please answer truthfully and to the best of your ability.
+    Could you please tell me which language you prefer to use for this interview?"""
+
+def get_interview_initial_message_sarah(n_of_questions):
+    return f"""Hello, I'm Sarah, an AI assistant for technical interviews.
+    I will guide you through the process and ask you around {n_of_questions} questions.
+    Please feel free to share as much or as little as you're comfortable with."""
+
+def get_interview_initial_message_aaron(n_of_questions):
+    return f"""Hello, I'm Aaron, an AI interviewer for behavioral and leadership assessments.
+    I will be asking you approximately {n_of_questions} questions. Be concise and direct in your responses.
+    Let's begin!"""
+
+# HR Interview Prompts
+def get_interview_prompt_hr(language, n_of_questions):
+    return f"""You are an AI HR interviewer, conducting an interview in {language}.
+    Use the following context and interview history to guide your response:
+
+    Context from knowledge base: {{context}}
+
+    Previous interview history:
+    {{history}}
+
+    Current question number: {{question_number}}/{n_of_questions}
+
+    Respond to the candidate's input briefly and directly in {language}.
+    Ask specific, detailed questions relevant to the job and the candidate's experience.
+    Remember all the previous answers given by the candidate.
+    If the candidate asks about a previous question, answer like an HR professional and then continue with the next question.
+    Keep in mind that you have a total of {n_of_questions} questions.
+    After {n_of_questions} interactions, indicate that you will prepare a report based on the gathered information and the provided document.
+    """
+
+def get_interview_prompt_sarah_v3(language, index, n_of_questions):
+    return f"""You are Sarah, an empathic and compassionate HR interviewer conducting an interview in {language}.
+Use the following context and interview history to guide your response:
+
+Previous interview history:
+{{history}}
+
+Current question number: {index + 1}/{n_of_questions}
+
+Respond directly in {language}. Ask a specific, professional HR-related question.
+You must remember all the previous answers given by the candidate, and use this information if necessary.
+Keep the tone professional but approachable.
+Here's your question: {{question}}
+"""
+
+def get_interview_prompt_aaron(language, n_of_questions):
+    return f"""You are Aaron, a direct, results-oriented interviewer conducting a professional interview in {language}.
+Use the following context and interview history to guide your response:
+
+Previous interview history:
+{{history}}
+
+Current question number: {{question_number}}/{n_of_questions}
+
+Respond directly in {language}. Ask a precise, results-focused question that helps evaluate the candidate's suitability for the role.
+Remember all the previous answers given by the candidate.
+Keep the tone professional and efficient.
+"""
+
+# Default HR Questions for Non-Technical Interviews
+def get_default_hr_questions(index):
+    default_questions = [
+        "Can you please introduce yourself and share a bit about your professional background?",
+        "What are your career goals for the next few years?",
+        "Why did you apply for this position, and what excites you about this role?",
+        "Can you describe a challenging situation you’ve faced at work and how you handled it?",
+        "How do you prioritize tasks when you have multiple deadlines to meet?",
+        "Can you provide an example of a time when you worked in a team to achieve a common goal?",
+        "What is your preferred style of communication when working with your team or manager?",
+        "How do you handle constructive feedback and what’s a time you’ve grown from it?",
+        "What do you consider your greatest strengths and areas for improvement?",
+        "Is there anything you'd like to ask us or share that wasn’t covered in the interview?"
+    ]
+    if 0 <= index - 1 < len(default_questions):
+        return default_questions[index - 1]
+    return "That's all for now. Thank you for your time!"
+
+# Report Prompts
+def get_report_prompt_hr(language):
+    return f"""You are an HR professional preparing a report in {language}.
+    Use the following context and interview history to create your report:
+
+    Context from knowledge base: {{context}}
+
+    Complete interview history:
+    {{history}}
+
+    Prepare a brief report in {language} based strictly on the information gathered during the interview and the provided document.
+    Date: {current_date}
+
+    Report Structure:
+
+    Candidate Overview:
+    - Name (if provided)
+    - Position applied for (if discernible from context)
+
+    Assessment Summary:
+    - Key strengths based on the interview
+    - Areas of concern or further development
+    - Overall suitability for the role based on responses and provided document
+
+    Candidate's Experience and Skills:
+    - Relevant experience highlighted by the candidate
+    - Skills demonstrated during the interview
+    - Alignment with job requirements (based on the provided document)
+
+    Candidate's Responses:
+    - Communication skills
+    - Problem-solving abilities
+    - Behavioral traits observed
+
+    Recommendations:
+    - Next steps in the hiring process (e.g., further interviews, assessments)
+    - Any specific training or development if the candidate were to be hired
+
+    Concluding Remarks:
+    - Overall impression of the candidate
+    - Potential fit within the company culture
+
+    Ensure all sections are concise, focused, and evidence-based.
+    Avoid making assumptions and base any conclusions on the facts derived from the candidate's interview and the provided document.
+    """
+
+def get_report_prompt(language):
+    return f"""You are a technical interviewer preparing a report in {language}.
+Use the following context and interview history to create your report:
+
+Complete interview history:
+{{history}}
+
+Prepare a concise technical report based on the gathered information, including:
+- Summary of the candidate’s technical knowledge
+- Strengths and areas of improvement
+- Recommendations for next steps in the hiring process
+Date: {current_date}
+
+Keep the report objective, fact-based, and focused on technical evaluation.
+"""
+
+
+# prompt_instructions.py
+
+# HR Interview Prompts
+def get_interview_prompt_technical(language, n_of_questions, question):
+    return f"""You are an AI Technical Interviewer conducting an interview in {language}.
+Please follow these guidelines:
+
+Current question number: {{question_number}}/{n_of_questions}
+
+Respond to the candidate's input briefly and directly in {language}.
+Pose the following technical question to the candidate:
+{question}
+"""
+
+
+def get_interview_initial_message_hr(n_of_questions):
+    return f"""Hello, I'm your AI assistant. I'll be conducting this interview.
+I will ask you {n_of_questions} questions to learn more about you. 
+Take your time and answer each question thoughtfully."""
+
+
+# Example usage for testing:
+if __name__ == "__main__":
+    print(get_interview_initial_message_hr(5))
+    print(get_default_hr_questions(1))
+
+
+
+

questions.py

@@ -0,0 +1,147 @@
+import os
+import json
+from dotenv import load_dotenv
+import fitz  # PyMuPDF
+from langchain_openai import ChatOpenAI  # Correct import from langchain-openai
+from langchain.schema import HumanMessage, SystemMessage  # For creating structured chat messages
+
+QUESTIONS_PATH = "questions.json"
+
+# Load environment variables
+load_dotenv()
+
+def split_text_into_chunks(text: str, chunk_size: int) -> list:
+    """
+    Splits the text into chunks of a specified maximum size.
+    """
+    # Trim the text to remove leading/trailing whitespace and reduce multiple spaces to a single space
+    cleaned_text = " ".join(text.split())
+    words = cleaned_text.split(" ")
+
+    chunks = []
+    current_chunk = []
+    current_length = 0
+
+    for word in words:
+        if current_length + len(word) + 1 > chunk_size:
+            chunks.append(" ".join(current_chunk))
+            current_chunk = [word]
+            current_length = len(word)
+        else:
+            current_chunk.append(word)
+            current_length += len(word) + 1
+
+    if current_chunk:
+        chunks.append(" ".join(current_chunk))
+
+    return chunks
+
+
+def distribute_questions_across_chunks(n_chunks: int, n_questions: int) -> list:
+    """
+    Distributes a specified number of questions across a specified number of chunks.
+    """
+    questions_per_chunk = [1] * min(n_chunks, n_questions)
+    remaining_questions = n_questions - len(questions_per_chunk)
+
+    if remaining_questions > 0:
+        for i in range(len(questions_per_chunk)):
+            if remaining_questions == 0:
+                break
+            questions_per_chunk[i] += 1
+            remaining_questions -= 1
+
+    while len(questions_per_chunk) < n_chunks:
+        questions_per_chunk.append(0)
+
+    return questions_per_chunk
+
+
+def extract_text_from_pdf(pdf_path):
+    text = ""
+    try:
+        print(f"[DEBUG] Opening PDF: {pdf_path}")
+        with fitz.open(pdf_path) as pdf:
+            print(f"[DEBUG] Extracting text from PDF: {pdf_path}")
+            for page in pdf:
+                text += page.get_text()
+    except Exception as e:
+        print(f"Error reading PDF: {e}")
+        raise RuntimeError("Unable to extract text from PDF.")
+    return text
+
+
+def generate_questions_from_text(text, n_questions=5):
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+
+    if not openai_api_key:
+        raise RuntimeError(
+            "OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY."
+        )
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750
+    )
+
+    messages = [
+        SystemMessage(
+            content="You are an expert interviewer who generates concise technical interview questions. Do not enumerate the questions. Answer only with questions."
+        ),
+        HumanMessage(
+            content=f"Based on the following content, generate {n_questions} technical interview questions:\n{text}"
+        ),
+    ]
+
+    try:
+        print(f"[DEBUG] Sending request to OpenAI with {n_questions} questions.")
+        response = chat.invoke(messages)
+        questions = response.content.strip().split("\n\n")
+        questions = [q.strip() for q in questions if q.strip()]
+    except Exception as e:
+        print(f"[ERROR] Failed to generate questions: {e}")
+        questions = ["An error occurred while generating questions."]
+
+    return questions
+
+
+def save_questions(questions):
+    with open(QUESTIONS_PATH, "w") as f:
+        json.dump(questions, f, indent=4)
+
+
+def generate_and_save_questions_from_pdf(pdf_path, total_questions=5):
+    print(f"[INFO] Generating questions from PDF: {pdf_path}")
+    pdf_text = extract_text_from_pdf(pdf_path)
+
+    if not pdf_text.strip():
+        raise RuntimeError("The PDF content is empty or could not be read.")
+
+    chunk_size = 2000
+    chunks = split_text_into_chunks(pdf_text, chunk_size)
+    n_chunks = len(chunks)
+
+    questions_distribution = distribute_questions_across_chunks(n_chunks, total_questions)
+    combined_questions = []
+
+    for i, (chunk, n_questions) in enumerate(zip(chunks, questions_distribution)):
+        print(f"[DEBUG] Processing chunk {i + 1} of {n_chunks}")
+        if n_questions > 0:
+            questions = generate_questions_from_text(chunk, n_questions=n_questions)
+            combined_questions.extend(questions)
+
+    print(f"[INFO] Total questions generated: {len(combined_questions)}")
+    save_questions(combined_questions)
+    print(f"[INFO] Questions saved to {QUESTIONS_PATH}")
+    return combined_questions
+
+
+if __name__ == "__main__":
+    pdf_path = "professional_machine_learning_engineer_exam_guide_english.pdf"
+
+    try:
+        generated_questions = generate_and_save_questions_from_pdf(
+            pdf_path, total_questions=5
+        )
+        print(f"Generated Questions:\n{json.dumps(generated_questions, indent=2)}")
+    except Exception as e:
+        print(f"Failed to generate questions: {e}")

questionsgr.py

@@ -0,0 +1,38 @@
+import gradio as gr
+from questions import generate_and_save_questions_from_pdf
+
+def generate_questions(pdf_file, num_questions):
+  """
+  Generates questions from a PDF file using the questions.py script.
+
+  Args:
+    pdf_file: The PDF file to generate questions from.
+    num_questions: The number of questions to generate.
+
+  Returns:
+    A string indicating success or failure, and a list of generated questions.
+  """
+  try:
+    questions = generate_and_save_questions_from_pdf(pdf_file.name, total_questions=int(num_questions))
+    return f"✅ {len(questions)} questions generated and saved.", questions
+  except Exception as e:
+    return f"❌ Error: {e}", None
+
+
+with gr.Blocks() as demo:
+  gr.Markdown("## 📄 PDF Question Generator")
+  with gr.Row():
+    pdf_input = gr.File(label="Upload PDF File", type="filepath")  # Changed type to "filepath"
+    num_questions_input = gr.Number(label="Number of Questions", value=5)
+  generate_button = gr.Button("Generate Questions")
+  output_text = gr.Textbox(label="Output")
+  question_output = gr.JSON(label="Generated Questions")
+
+  generate_button.click(
+      generate_questions,
+      inputs=[pdf_input, num_questions_input],
+      outputs=[output_text, question_output]
+  )
+
+if __name__ == "__main__":
+  demo.launch()

requirements.txt

@@ -0,0 +1,23 @@
+python-dotenv==1.0.1
+pandas==2.1.4
+langchain==0.2.6
+langchain-openai==0.1.14
+langchain-core==0.2.11
+langchain-ibm==0.1.8
+langchain-community==0.2.6
+ibm-watson-machine-learning==1.0.359
+ipykernel
+notebook
+urllib3 
+requests==2.32.0
+gradio
+PyPDF2
+python-docx
+reportlab
+openai
+faiss-cpu
+cryptography
+pymysql
+scikit-learn
+pymupdf
+

requirements_dev.txt

@@ -0,0 +1,178 @@
+aiofiles==23.2.1
+aiohappyeyeballs==2.4.4
+aiohttp==3.11.11
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.7.0
+argon2-cffi==23.1.0
+argon2-cffi-bindings==21.2.0
+arrow==1.3.0
+asttokens==2.4.1
+async-lru==2.0.4
+attrs==24.3.0
+babel==2.16.0
+beautifulsoup4==4.12.3
+bleach==6.2.0
+certifi==2024.12.14
+cffi==1.17.1
+chardet==5.2.0
+charset-normalizer==3.4.1
+click==8.1.8
+colorama==0.4.6
+comm==0.2.2
+cryptography==44.0.0
+dataclasses-json==0.6.7
+debugpy==1.8.1
+decorator==5.1.1
+defusedxml==0.7.1
+distro==1.9.0
+executing==2.0.1
+faiss-cpu==1.9.0.post1
+fastapi==0.115.6
+fastjsonschema==2.21.1
+ffmpy==0.5.0
+filelock==3.16.1
+fqdn==1.5.1
+frozenlist==1.5.0
+fsspec==2024.12.0
+gradio==5.9.1
+gradio_client==1.5.2
+greenlet==3.1.1
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.28.1
+huggingface-hub==0.27.0
+ibm-cos-sdk==2.13.6
+ibm-cos-sdk-core==2.13.6
+ibm-cos-sdk-s3transfer==2.13.6
+ibm_watson_machine_learning==1.0.359
+ibm_watsonx_ai==1.1.26
+idna==3.10
+importlib_metadata==8.5.0
+ipykernel==6.29.4
+ipython==8.25.0
+isoduration==20.11.0
+jedi==0.19.1
+Jinja2==3.1.5
+jiter==0.8.2
+jmespath==1.0.1
+joblib==1.4.2
+json5==0.10.0
+jsonpatch==1.33
+jsonpointer==3.0.0
+jsonschema==4.23.0
+jsonschema-specifications==2024.10.1
+jupyter-events==0.11.0
+jupyter-lsp==2.2.5
+jupyter_client==8.6.2
+jupyter_core==5.7.2
+jupyter_server==2.15.0
+jupyter_server_terminals==0.5.3
+jupyterlab==4.3.4
+jupyterlab_pygments==0.3.0
+jupyterlab_server==2.27.3
+langchain==0.2.6
+langchain-community==0.2.6
+langchain-core==0.2.11
+langchain-ibm==0.1.8
+langchain-openai==0.1.14
+langchain-text-splitters==0.2.2
+langsmith==0.1.147
+lomond==0.3.3
+lxml==5.3.0
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.23.3
+matplotlib-inline==0.1.7
+mdurl==0.1.2
+mistune==3.1.0
+multidict==6.1.0
+mypy-extensions==1.0.0
+nbclient==0.10.2
+nbconvert==7.16.5
+nbformat==5.10.4
+nest-asyncio==1.6.0
+notebook==7.3.2
+notebook_shim==0.2.4
+numpy==1.26.4
+openai==1.59.2
+orjson==3.10.13
+overrides==7.7.0
+packaging==24.1
+pandas==2.1.4
+pandocfilters==1.5.1
+parso==0.8.4
+pillow==11.1.0
+platformdirs==4.2.2
+prometheus_client==0.21.1
+prompt_toolkit==3.0.47
+propcache==0.2.1
+psutil==6.0.0
+pure-eval==0.2.2
+pycparser==2.22
+pydantic==2.10.4
+pydantic_core==2.27.2
+pydub==0.25.1
+Pygments==2.18.0
+PyMuPDF==1.25.1
+PyMySQL==1.1.1
+PyPDF2==3.0.1
+python-dateutil==2.9.0.post0
+python-docx==1.1.2
+python-dotenv==1.0.1
+python-json-logger==3.2.1
+python-multipart==0.0.20
+pytz==2024.2
+pywin32==306
+pywinpty==2.0.14
+PyYAML==6.0.2
+pyzmq==26.0.3
+referencing==0.35.1
+regex==2024.11.6
+reportlab==4.2.5
+requests==2.32.0
+requests-toolbelt==1.0.0
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rich==13.9.4
+rpds-py==0.22.3
+ruff==0.8.5
+safehttpx==0.1.6
+scikit-learn==1.6.0
+scipy==1.15.0
+semantic-version==2.10.0
+Send2Trash==1.8.3
+setuptools==75.1.0
+shellingham==1.5.4
+six==1.16.0
+sniffio==1.3.1
+soupsieve==2.6
+SQLAlchemy==2.0.36
+stack-data==0.6.3
+starlette==0.41.3
+tabulate==0.9.0
+tenacity==8.5.0
+terminado==0.18.1
+threadpoolctl==3.5.0
+tiktoken==0.8.0
+tinycss2==1.4.0
+tomlkit==0.13.2
+tornado==6.4.1
+tqdm==4.67.1
+traitlets==5.14.3
+typer==0.15.1
+types-python-dateutil==2.9.0.20241206
+typing-inspect==0.9.0
+typing_extensions==4.12.2
+tzdata==2024.2
+uri-template==1.3.0
+urllib3==2.3.0
+uvicorn==0.34.0
+wcwidth==0.2.13
+webcolors==24.11.1
+webencodings==0.5.1
+websocket-client==1.8.0
+websockets==14.1
+wheel==0.44.0
+yarl==1.18.3
+zipp==3.21.0

response.py

@@ -0,0 +1,120 @@
+def bot_response(history):
+    if not interview_state.interview_history:
+        
+        reset_interview_action(interview_state.selected_interviewer)
+
+    if interview_state.interview_history[-1]["role"] == "user":
+        interview_state.question_count += 1
+
+    
+    voice = interview_state.get_voice_setting()
+    
+    if interview_state.question_count > interview_state.n_of_questions:
+        response = "That's all for now. Thank you for your time!"
+        interview_state.interview_finished = True
+
+    else:
+        # Select prompts based on interview type
+        if interview_state.interview_type == "hr":
+            if not interview_state.knowledge_retrieval_setup:
+                response = get_default_hr_questions(
+                    interview_state.question_count
+                )
+            else:
+                if interview_state.question_count == 1:
+                    response = get_initial_question(
+                        interview_state.interview_chain
+                    )
+                else:
+                    response = get_next_response(
+                        interview_state.interview_chain,
+                        interview_state.interview_history[-1]["content"] if interview_state.interview_history[-1]["role"] == "user" else "",
+                        [
+                            msg["content"]
+                            for msg in interview_state.interview_history
+                            if msg.get("role") == "user"
+                        ],
+                        interview_state.question_count,
+                    )
+        elif interview_state.interview_type == "sarah":
+            response = get_next_response(
+                interview_state.interview_chain,
+                interview_state.interview_history[-1]["content"] if interview_state.interview_history[-1]["role"] == "user" else "",
+                [
+                    msg["content"]
+                    for msg in interview_state.interview_history
+                    if msg.get("role") == "user"
+                            ],
+                            interview_state.question_count,
+                        )
+                    elif interview_state.interview_type == "aaron":
+                        response = get_next_response(
+                            interview_state.interview_chain,
+                            interview_state.interview_history[-1]["content"] if interview_state.interview_history[-1]["role"] == "user" else "",
+                            [
+                                msg["content"]
+                                for msg in interview_state.interview_history
+                                if msg.get("role") == "user"
+                            ],
+                            interview_state.question_count,
+                        )
+
+                    else:
+                        response = "Invalid interview type."
+
+                audio_buffer = BytesIO()
+                convert_text_to_speech(response, audio_buffer, voice)
+                audio_buffer.seek(0)
+                with tempfile.NamedTemporaryFile(
+                    suffix=".mp3", delete=False
+                ) as temp_file:
+                    temp_audio_path = temp_file.name
+                    temp_file.write(audio_buffer.getvalue())
+                interview_state.temp_audio_files.append(temp_audio_path)
+
+                
+                history.append({"role": "assistant", "content": response})
+                interview_state.interview_history.append({"role": "assistant", "content": response})
+
+                if interview_state.interview_finished:
+                    
+                    conclusion_message = "Thank you for being here. We will review your responses and provide feedback soon."
+                    history.append(
+                        {"role": "system", "content": conclusion_message}
+                    )
+                    interview_state.interview_history.append({"role": "system", "content": conclusion_message})
+
+                    txt_path = save_interview_history(
+                        [msg["content"] for msg in history if msg["role"] != "system"], interview_state.language
+                    )
+                    if txt_path:
+                        return (
+                            history,
+                            gr.Audio(
+                                value=temp_audio_path,
+                                autoplay=True,
+                                visible=True,
+                            ),
+                            gr.File(visible=True, value=txt_path),
+                            gr.Textbox(interactive=False)
+                        )
+                    else:
+                        return (
+                            history,
+                            gr.Audio(
+                                value=temp_audio_path,
+                                autoplay=True,
+                                visible=True,
+                            ),
+                            None,
+                            gr.Textbox(interactive=False)
+                        )
+
+                return (
+                    history,
+                    gr.Audio(
+                        value=temp_audio_path, autoplay=True, visible=True
+                    ),
+                    None,
+                    gr.Textbox(interactive=True)
+                )

settings.py

@@ -0,0 +1,3 @@
+# Interview settings
+language = "english"  # Default language
+n_of_questions = 5  # Default number of questions

split.py

@@ -0,0 +1,88 @@
+from typing import List, Tuple
+import math
+
+def split_text_into_chunks(text: str, chunk_size: int) -> List[str]:
+    """
+    Splits the text into chunks of a specified maximum size.
+    """
+    # Trim the text to remove leading/trailing whitespace and reduce multiple spaces to a single space
+    cleaned_text = " ".join(text.split())
+    words = cleaned_text.split(" ")
+
+    chunks = []
+    current_chunk = []
+    current_length = 0
+
+    for word in words:
+        if current_length + len(word) + 1 > chunk_size:
+            chunks.append(" ".join(current_chunk))
+            current_chunk = [word]
+            current_length = len(word)
+        else:
+            current_chunk.append(word)
+            current_length += len(word) + 1
+
+    if current_chunk:
+        chunks.append(" ".join(current_chunk))
+
+    return chunks
+
+
+def distribute_questions_across_chunks(n_chunks: int, n_questions: int) -> List[int]:
+    """
+    Distributes a specified number of questions across a specified number of chunks.
+    """
+    # Initial allocation of at least one question to early chunks if possible
+    questions_per_chunk = [1] * min(n_chunks, n_questions)
+
+    remaining_questions = n_questions - len(questions_per_chunk)
+
+    # Distribute remaining questions evenly across chunks
+    if remaining_questions > 0:
+        for i in range(len(questions_per_chunk)):
+            if remaining_questions == 0:
+                break
+            questions_per_chunk[i] += 1
+            remaining_questions -= 1
+
+    # If chunks remain, add zeros to match the total chunks.
+    while len(questions_per_chunk) < n_chunks:
+        questions_per_chunk.append(0)
+
+    return questions_per_chunk
+
+
+def generate_questions_for_text(text: str, chunk_size: int, n_questions: int) -> List[Tuple[str, int]]:
+    """
+    Splits the text into chunks, distributes questions across them, and returns a list of
+    (chunk, number of questions).
+    """
+    chunks = split_text_into_chunks(text, chunk_size)
+    n_chunks = len(chunks)
+
+    questions_distribution = distribute_questions_across_chunks(n_chunks, n_questions)
+
+    return list(zip(chunks, questions_distribution))
+
+
+# Example usage
+text = (
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Proin hendrerit urna "
+    "vel erat bibendum, eget condimentum ipsum interdum. Nulla facilisi. Quisque dictum "
+    "eros eu velit varius, eget faucibus mauris euismod. Etiam placerat nisi at urna maximus "
+    "viverra. Integer ut odio nec justo volutpat varius ut quis quam. Suspendisse potenti. "
+    "Donec vulputate quam quis metus sagittis, sed commodo justo ultricies. Nam ut velit "
+    "finibus, venenatis eros vel, consectetur arcu. Praesent vulputate at ligula non elementum. "
+    "Nulla varius condimentum justo, non placerat nisl ullamcorper eu."
+)
+
+chunk_size = 100  # Max length of each chunk in characters
+n_questions = 5   # Total number of questions to be asked
+
+result = generate_questions_for_text(text, chunk_size, n_questions)
+
+for i, (chunk, num_questions) in enumerate(result):
+    print(f"Chunk {i + 1} ({len(chunk.split())} words):")
+    print(f"Questions: {num_questions}")
+    print(chunk)
+    print("-" * 40)

splitgpt.py

@@ -0,0 +1,331 @@
+import os
+import json
+from dotenv import load_dotenv
+import fitz  # PyMuPDF
+from langchain_openai import ChatOpenAI  # Correct import from langchain-openai
+from langchain.schema import HumanMessage, SystemMessage  # For creating structured chat messages
+
+QUESTIONS_PATH = "questions.json"
+
+# Load environment variables
+load_dotenv()
+
+def split_text_into_chunks(text: str, chunk_size: int) -> list:
+    """
+    Splits the text into chunks of a specified maximum size.
+    """
+    # Trim the text to remove leading/trailing whitespace and reduce multiple spaces to a single space
+    cleaned_text = " ".join(text.split())
+    words = cleaned_text.split(" ")
+
+    chunks = []
+    current_chunk = []
+    current_length = 0
+
+    for word in words:
+        if current_length + len(word) + 1 > chunk_size:
+            chunks.append(" ".join(current_chunk))
+            current_chunk = [word]
+            current_length = len(word)
+        else:
+            current_chunk.append(word)
+            current_length += len(word) + 1
+
+    if current_chunk:
+        chunks.append(" ".join(current_chunk))
+
+    return chunks
+
+
+def distribute_questions_across_chunks(n_chunks: int, n_questions: int) -> list:
+    """
+    Distributes a specified number of questions across a specified number of chunks.
+    """
+    questions_per_chunk = [1] * min(n_chunks, n_questions)
+    remaining_questions = n_questions - len(questions_per_chunk)
+
+    if remaining_questions > 0:
+        for i in range(len(questions_per_chunk)):
+            if remaining_questions == 0:
+                break
+            questions_per_chunk[i] += 1
+            remaining_questions -= 1
+
+    while len(questions_per_chunk) < n_chunks:
+        questions_per_chunk.append(0)
+
+    return questions_per_chunk
+
+
+def extract_text_from_pdf(pdf_path):
+    text = ""
+    try:
+        print(f"[DEBUG] Opening PDF: {pdf_path}")
+        with fitz.open(pdf_path) as pdf:
+            print(f"[DEBUG] Extracting text from PDF: {pdf_path}")
+            for page in pdf:
+                text += page.get_text()
+    except Exception as e:
+        print(f"Error reading PDF: {e}")
+        raise RuntimeError("Unable to extract text from PDF.")
+    return text
+
+
+def generate_questions_from_text(text, n_questions=5):
+    openai_api_key = os.getenv("OPENAI_API_KEY")
+
+    if not openai_api_key:
+        raise RuntimeError(
+            "OpenAI API key not found. Please add it to your .env file as OPENAI_API_KEY."
+        )
+
+    chat = ChatOpenAI(
+        openai_api_key=openai_api_key, model="gpt-4", temperature=0.7, max_tokens=750
+    )
+
+    messages = [
+        SystemMessage(
+            content="You are an expert interviewer who generates concise technical interview questions. Do not enumerate the questions. Answer only with questions."
+        ),
+        HumanMessage(
+            content=f"Based on the following content, generate {n_questions} technical interview questions:\n{text}"
+        ),
+    ]
+
+    try:
+        print(f"[DEBUG] Sending request to OpenAI with {n_questions} questions.")
+        response = chat.invoke(messages)
+        questions = response.content.strip().split("\n\n")
+        questions = [q.strip() for q in questions if q.strip()]
+    except Exception as e:
+        print(f"[ERROR] Failed to generate questions: {e}")
+        questions = ["An error occurred while generating questions."]
+
+    return questions
+
+
+def save_questions(questions):
+    with open(QUESTIONS_PATH, "w") as f:
+        json.dump(questions, f, indent=4)
+
+
+def generate_and_save_questions_from_pdf(pdf_path, total_questions=5):
+    print(f"[INFO] Generating questions from PDF: {pdf_path}")
+    
+    try:
+        pdf_text = extract_text_from_pdf(pdf_path)
+
+        if not pdf_text.strip():
+            raise RuntimeError("The PDF content is empty or could not be read.")
+
+        chunk_size = 2000
+        chunks = split_text_into_chunks(pdf_text, chunk_size)
+        n_chunks = len(chunks)
+
+        questions_distribution = distribute_questions_across_chunks(n_chunks, total_questions)
+        combined_questions = []
+
+        for i, (chunk, n_questions) in enumerate(zip(chunks, questions_distribution)):
+            print(f"[DEBUG] Processing chunk {i + 1} of {n_chunks}")
+            if n_questions > 0:
+                questions = generate_questions_from_text(chunk, n_questions=n_questions)
+                combined_questions.extend(questions)
+
+        if not combined_questions:
+            raise RuntimeError("No questions generated from the PDF content.")
+
+        print(f"[INFO] Total questions generated: {len(combined_questions)}")
+        save_questions(combined_questions)
+        print(f"[INFO] Questions saved to {QUESTIONS_PATH}")
+
+        # Return a status message and the JSON object
+        return "Questions generated successfully.", {"questions": combined_questions}
+    
+    except Exception as e:
+        # Handle exceptions and return meaningful error messages
+        error_message = f"Error during question generation: {str(e)}"
+        print(f"[ERROR] {error_message}")
+        return error_message, {"questions": []}
+
+
+
+
+
+
+import gradio as gr
+import json
+import os
+import time
+
+def generate_and_save_questions_from_pdf3_mock(pdf_path, total_questions=5):
+    print(f"[INFO] Generating questions from PDF: {pdf_path}")
+
+    if not os.path.exists(pdf_path):
+        yield "❌ Error: PDF file not found.", {}
+        return
+
+    yield "📄 PDF uploaded successfully. Processing started...", {}
+
+    try:
+        # Simulate PDF text extraction and processing
+        time.sleep(1)
+        pdf_text = "This is some mock PDF text for testing purposes."
+
+        if not pdf_text.strip():
+            yield "❌ Error: The PDF content is empty or could not be read.", {}
+            return
+
+        chunk_size = 2000
+        chunks = [pdf_text[i:i + chunk_size] for i in range(0, len(pdf_text), chunk_size)]
+        n_chunks = len(chunks)
+
+        yield f"🔄 Splitting text into {n_chunks} chunks...", {}
+
+        questions_distribution = [total_questions // n_chunks] * n_chunks
+        combined_questions = []
+
+        for i, (chunk, n_questions) in enumerate(zip(chunks, questions_distribution)):
+            yield f"🔄 Processing chunk {i + 1} of {n_chunks}...", {}
+            time.sleep(1)  # Simulating processing time
+            combined_questions.append(f"Sample Question from Chunk {i + 1}")
+
+        if not combined_questions:
+            yield "❌ Error: No questions generated from the PDF content.", {}
+            return
+
+        yield f"✅ Total {len(combined_questions)} questions generated. Saving questions...", {}
+        save_path = "generated_questions_from_pdf.json"
+        with open(save_path, "w") as f:
+            json.dump({"questions": combined_questions}, f)
+
+        yield "✅ PDF processing complete. Questions saved successfully!", {"questions": combined_questions}
+
+    except Exception as e:
+        yield f"❌ Error during question generation: {str(e)}", {}
+
+def generate_and_save_questions_from_pdf3_v1(pdf_path, total_questions=5):
+    print(f"[INFO] Generating questions from PDF: {pdf_path}")
+
+    if not os.path.exists(pdf_path):
+        yield "❌ Error: PDF file not found.", {}
+        return
+
+    yield "📄 PDF uploaded successfully. Processing started...", {}
+
+    try:
+        # Extract text from the PDF file
+        pdf_text = extract_text_from_pdf(pdf_path)
+
+        if not pdf_text.strip():
+            yield "❌ Error: The PDF content is empty or could not be read.", {}
+            return
+
+        # Split the PDF content into chunks
+        chunk_size = 2000  # Adjust this as necessary
+        chunks = split_text_into_chunks(pdf_text, chunk_size)
+        n_chunks = len(chunks)
+
+        yield f"🔄 Splitting text into {n_chunks} chunks...", {}
+
+        # Distribute the total number of questions across chunks
+        questions_distribution = distribute_questions_across_chunks(n_chunks, total_questions)
+        combined_questions = []
+
+        # Process each chunk and generate questions
+        for i, (chunk, n_questions) in enumerate(zip(chunks, questions_distribution)):
+            yield f"🔄 Processing chunk {i + 1} of {n_chunks}...", {}
+            if n_questions > 0:
+                questions = generate_questions_from_text(chunk, n_questions=n_questions)
+                combined_questions.extend(questions)
+
+        if not combined_questions:
+            yield "❌ Error: No questions generated from the PDF content.", {}
+            return
+
+        yield f"✅ Total {len(combined_questions)} questions generated. Saving questions...", {}
+
+        # Save generated questions to a file
+        save_path = "generated_questions_from_pdf.json"
+        with open(save_path, "w") as f:
+            json.dump({"questions": combined_questions}, f)
+
+        yield "✅ PDF processing complete. Questions saved successfully!", {"questions": combined_questions}
+
+    except Exception as e:
+        error_message = f"❌ Error during question generation: {str(e)}"
+        print(f"[ERROR] {error_message}")
+        yield error_message, {}
+
+import json
+import os
+
+def generate_and_save_questions_from_pdf3(pdf_path, total_questions=5):
+    print(f"[INFO] Generating questions from PDF: {pdf_path}")
+
+    if not os.path.exists(pdf_path):
+        yield "❌ Error: PDF file not found.", {}
+        return
+
+    yield "📄 PDF uploaded successfully. Processing started...", {}
+
+    try:
+        # Extract text from the PDF file
+        pdf_text = extract_text_from_pdf(pdf_path)
+
+        if not pdf_text.strip():
+            yield "❌ Error: The PDF content is empty or could not be read.", {}
+            return
+
+        # Split the PDF content into chunks
+        chunk_size = 2000  # Adjust this as necessary
+        chunks = split_text_into_chunks(pdf_text, chunk_size)
+        n_chunks = len(chunks)
+
+        yield f"🔄 Splitting text into {n_chunks} chunks...", {}
+
+        # Distribute the total number of questions across chunks
+        questions_distribution = distribute_questions_across_chunks(n_chunks, total_questions)
+        combined_questions = []
+
+        # Process each chunk and generate questions
+        for i, (chunk, n_questions) in enumerate(zip(chunks, questions_distribution)):
+            yield f"🔄 Processing chunk {i + 1} of {n_chunks}...", {}
+            if n_questions > 0:
+                questions = generate_questions_from_text(chunk, n_questions=n_questions)
+                combined_questions.extend(questions)
+
+        if not combined_questions:
+            yield "❌ Error: No questions generated from the PDF content.", {}
+            return
+
+        yield f"✅ Total {len(combined_questions)} questions generated. Saving questions...", {}
+
+        # Save the combined questions in `generated_questions_from_pdf.json` (detailed version)
+        detailed_save_path = "generated_questions_from_pdf.json"
+        with open(detailed_save_path, "w") as f:
+            json.dump({"questions": combined_questions}, f)
+
+        # Save only the questions (overwrite `questions.json` if it already exists)
+        simple_save_path = "questions.json"
+        with open(simple_save_path, "w") as f:
+            json.dump(combined_questions, f)
+
+        yield "✅ PDF processing complete. Questions saved successfully!", {"questions": combined_questions}
+
+    except Exception as e:
+        error_message = f"❌ Error during question generation: {str(e)}"
+        print(f"[ERROR] {error_message}")
+        yield error_message, {}
+
+
+
+if __name__ == "__main__":
+    pdf_path = "professional_machine_learning_engineer_exam_guide_english.pdf"
+
+    try:
+        generated_questions = generate_and_save_questions_from_pdf(
+            pdf_path, total_questions=5
+        )
+        print(f"Generated Questions:\n{json.dumps(generated_questions, indent=2)}")
+    except Exception as e:
+        print(f"Failed to generate questions: {e}")

utils.py

@@ -0,0 +1,147 @@
+from datetime import datetime
+from docx import Document
+from docx.shared import Pt
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+from pathlib import Path
+
+def save_interview_history_old(history, language):
+    """Saves the interview history to a TXT file."""
+    file_name = f"interview_history_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt"
+    file_path = Path("hr_interviewer") / file_name
+
+    with open(file_path, "w", encoding="utf-8") as file:
+        for item in history:
+            file.write(f"{item}\n")
+
+    return file_path
+
+
+import os
+from datetime import datetime
+
+def save_interview_history_fix(interview_history, language, folder_path="hr_interviewer"):
+    """
+    Saves the interview history to a file in the specified folder.
+
+    Args:
+        interview_history: The content of the interview history as a string.
+        language: Language of the report.
+        folder_path: Folder path where the history file will be saved.
+
+    Returns:
+        The file path of the saved interview history.
+    """
+    # Ensure the directory exists
+    os.makedirs(folder_path, exist_ok=True)
+
+    # Generate the filename with the current date and time
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    file_path = os.path.join(folder_path, f"interview_history_{timestamp}.txt")
+
+    try:
+        with open(file_path, "w", encoding="utf-8") as file:
+            file.write("\n".join(interview_history))
+        print(f"[DEBUG] Interview history saved at {file_path}")
+        return file_path
+    except Exception as e:
+        print(f"[ERROR] Failed to save interview history: {e}")
+        return None
+
+import os
+from datetime import datetime
+
+def save_interview_history(interview_history, language, folder_path="hr_interviewer"):
+    os.makedirs(folder_path, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    file_path = os.path.join(folder_path, f"interview_history_{timestamp}.txt")
+
+    try:
+        with open(file_path, "w", encoding="utf-8") as file:
+            file.write("\n".join(interview_history))
+        print(f"[DEBUG] Interview history saved at {file_path}")
+        return file_path
+    except Exception as e:
+        print(f"[ERROR] Failed to save interview history: {e}")
+        return None
+
+
+
+def generate_interview_report(interview_history, language):
+    """
+    Generates a report in DOCX format based on the interview history.
+    Args:
+        interview_history: A list of strings representing the interview history.
+        language: The language of the report.
+    Returns:
+        A tuple containing the report content as a string and the path to the generated DOCX file.
+    """
+    doc = Document()
+
+    # Add title
+    title = doc.add_heading('Interview Report', level=1)
+    title.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+    title_run = title.runs[0]
+    title_run.font.name = 'Arial'
+    title_run.font.size = Pt(16)
+    title_run.bold = True
+
+    # Add date
+    date_para = doc.add_paragraph(f"Date: {datetime.now().strftime('%Y-%m-%d')}")
+    date_para.alignment = WD_PARAGRAPH_ALIGNMENT.RIGHT
+    date_run = date_para.runs[0]
+    date_run.font.name = 'Arial'
+    date_run.font.size = Pt(11)
+
+    # Add interview history
+    doc.add_heading('Interview History', level=2)
+    for item in interview_history:
+        para = doc.add_paragraph(item)
+        para_run = para.runs[0]
+        para_run.font.name = 'Arial'
+        para_run.font.size = Pt(12)
+
+    # Save the document
+    file_name = f"interview_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
+    file_path = Path("hr_interviewer") / file_name
+    doc.save(file_path)
+
+    # Convert DOCX to string (for display in Gradio, etc.)
+    report_content = ""
+    for para in doc.paragraphs:
+        report_content += para.text + "\n"
+
+    return report_content, file_path
+
+
+import json
+from datetime import datetime
+from docx import Document
+from docx.shared import Pt
+from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
+from pathlib import Path
+
+# ... (other functions remain the same)
+
+def load_config(config_path="hr_interviewer/config.json"):
+    """Loads the configuration from a JSON file."""
+    try:
+        with open(config_path, "r") as f:
+            config = json.load(f)
+    except FileNotFoundError:
+        print(f"[WARNING] Config file not found at {config_path}. Using default settings.")
+        config = {}  # Return empty dict to use defaults
+    except json.JSONDecodeError:
+        print(f"[ERROR] Error decoding JSON in {config_path}. Using default settings.")
+        config = {}
+    return config
+
+def save_config(config, config_path="hr_interviewer/config.json"):
+    """Saves the configuration to a JSON file."""
+    try:
+        with open(config_path, "w") as f:
+            json.dump(config, f, indent=4)
+        print(f"[INFO] Configuration saved to {config_path}")
+        return True
+    except Exception as e:
+        print(f"[ERROR] Failed to save configuration: {e}")
+        return False