Huge refactoring

api/audio.py

@@ -0,0 +1,62 @@
+import io
+import wave
+
+import requests
+
+from openai import OpenAI
+
+
+def numpy_audio_to_bytes(audio_data):
+    sample_rate = 44100
+    num_channels = 1
+    sampwidth = 2
+
+    buffer = io.BytesIO()
+    with wave.open(buffer, "wb") as wf:
+        wf.setnchannels(num_channels)
+        wf.setsampwidth(sampwidth)
+        wf.setframerate(sample_rate)
+        wf.writeframes(audio_data.tobytes())
+    return buffer.getvalue()
+
+
+class STTManager:
+    def __init__(self, config):
+        self.config = config
+
+    def speech_to_text(self, audio, convert_to_bytes=True):
+        if convert_to_bytes:
+            audio = numpy_audio_to_bytes(audio[1])
+
+        if self.config.stt.type == "OPENAI_API":
+            data = ("temp.wav", audio, "audio/wav")
+            client = OpenAI(base_url=self.config.stt.url, api_key=self.config.stt.key)
+            transcription = client.audio.transcriptions.create(model=self.config.stt.name, file=data, response_format="text")
+        elif self.config.stt.type == "HF_API":
+            headers = {"Authorization": "Bearer " + self.config.stt.key}
+            transcription = requests.post(self.config.stt.url, headers=headers, data=audio)
+            transcription = transcription.json()["text"]
+
+        return transcription
+
+
+class TTSManager:
+    def __init__(self, config):
+        self.config = config
+
+    def text_to_speech(self, text):
+        if self.config.tts.type == "OPENAI_API":
+            client = OpenAI(base_url=self.config.tts.url, api_key=self.config.tts.key)
+            response = client.audio.speech.create(model=self.config.tts.name, voice="alloy", response_format="opus", input=text)
+        elif self.config.tts.type == "HF_API":
+            headers = {"Authorization": "Bearer " + self.config.tts.key}
+            response = requests.post(self.config.tts.url, headers=headers)
+
+        return response.content
+
+    def read_last_message(self, chat_display):
+        if chat_display:
+            last_message = chat_display[-1][1]  # Assuming the message is stored at index 1 of the last tuple/list in chat_display
+            if last_message is not None:
+                return self.text_to_speech(last_message)
+        return None

api/llm.py

@@ -0,0 +1,88 @@
+from openai import OpenAI
+
+
+class LLMManager:
+    def __init__(self, config, prompts):
+        self.config = config
+        self.client = OpenAI(base_url=config.llm.url, api_key=config.llm.key)
+        self.prompts = prompts
+
+    def test_connection(self):
+        response = self.client.chat.completions.create(
+            model=self.config.llm.name,
+            messages=[
+                {"role": "system", "content": "You just help me test the connection."},
+                {"role": "user", "content": "Hi!"},
+                {"role": "user", "content": "Ping!"},
+            ],
+        )
+        return response.choices[0].message.content.strip()
+
+    def init_bot(self, problem=""):
+        chat_history = [
+            {"role": "system", "content": self.prompts["coding_interviewer_prompt"]},
+            {"role": "system", "content": f"The candidate is solving the following problem: {problem}"},
+        ]
+        return chat_history
+
+    def get_problem(self, requirements, difficulty, topic):
+        full_prompt = (
+            f"Create a {difficulty} {topic} coding problem. "
+            f"Additional requirements: {requirements}. "
+            "The problem should be clearly stated, well-formatted, and solvable within 30 minutes. "
+            "Ensure the problem varies each time to provide a wide range of challenges."
+        )
+        response = self.client.chat.completions.create(
+            model=self.config.llm.name,
+            messages=[
+                {"role": "system", "content": self.prompts["problem_generation_prompt"]},
+                {"role": "user", "content": full_prompt},
+            ],
+            temperature=1.0,
+        )
+        question = response.choices[0].message.content.strip()
+        chat_history = self.init_bot(question)
+        return question, chat_history
+
+    def send_request(self, code, previous_code, message, chat_history, chat_display):
+        # Update chat history if code has changed
+        if code != previous_code:
+            chat_history.append({"role": "user", "content": f"My latest code:\n{code}"})
+        chat_history.append({"role": "user", "content": message})
+
+        # Process the updated chat history with the language model
+        response = self.client.chat.completions.create(model=self.config.llm.name, messages=chat_history)
+        reply = response.choices[0].message.content.strip()
+        chat_history.append({"role": "assistant", "content": reply})
+
+        # Update chat display with the new reply
+        if chat_display:
+            chat_display[-1][1] = reply
+        else:
+            chat_display.append([message, reply])
+
+        # Return updated chat history, chat display, an empty string placeholder, and the unchanged code
+        return chat_history, chat_display, "", code
+
+    def end_interview(self, problem_description, chat_history):
+        if not chat_history or len(chat_history) <= 2:
+            return "No interview content available to review."
+
+        transcript = []
+        for message in chat_history[1:]:
+            role = message["role"]
+            content = f"{role.capitalize()}: {message['content']}"
+            transcript.append(content)
+
+        response = self.client.chat.completions.create(
+            model=self.config.llm.name,
+            messages=[
+                {"role": "system", "content": self.prompts["grading_feedback_prompt"]},
+                {"role": "user", "content": f"The original problem to solve: {problem_description}"},
+                {"role": "user", "content": "\n\n".join(transcript)},
+                {"role": "user", "content": "Grade the interview based on the transcript provided and give feedback."},
+            ],
+            temperature=0.5,
+        )
+        feedback = response.choices[0].message.content.strip()
+        return feedback

app.py

@@ -2,9 +2,17 @@ import os
 
 import gradio as gr
 
-from config import LLM_NAME, STT_NAME, TTS_NAME
-from llm import end_interview, get_problem, read_last_message, send_request, speech_to_text, test_connection, text_to_speech
-from options import fixed_messages, topics_list
+from api.audio import STTManager, TTSManager
+from api.llm import LLMManager
+from config import config
+from docs.instruction import instruction
+from resources.data import fixed_messages, topics_list
+from resources.prompts import prompts
+from utils.ui import add_candidate_message, add_interviewer_message
+
+llm = LLMManager(config, prompts)
+tts = TTSManager(config)
+stt = STTManager(config)
 
 default_audio_params = {
     "label": "Record answer",
@@ -26,19 +34,6 @@ def hide_settings():
     return init_acc, start_btn, solution_acc, end_btn, audio_input
 
 
-def add_interviewer_message(message):
-    def f(chat):
-        chat.append((None, message))
-        return chat
-
-    return f
-
-
-def add_candidate_message(message, chat):
-    chat.append((message, None))
-    return chat
-
-
 def hide_solution():
     solution_acc = gr.Accordion("Solution", open=False)
     end_btn = gr.Button("Finish the interview", interactive=False)
@@ -52,51 +47,36 @@ with gr.Blocks() as demo:
         with gr.Row():
             with gr.Column(scale=10):
                 gr.Markdown("# Welcome to the AI Tech Interviewer Training!")
-                gr.Markdown(
-                    """
-                This project leverages the latest AI models to simulate a realistic tech interview experience, 
-                allowing you to practice your coding interview skills in an environment that closely mimics the real thing. 
-                While it's not designed to replace a human interviewer or the essential steps of interview preparation, such as studying algorithms and practicing coding, 
-                it serves as a valuable addition to your preparation arsenal.
-                """
-                )
+                gr.Markdown(instruction["intro"])
 
                 if os.getenv("IS_DEMO"):
-                    gr.Markdown(
-                        """
-                    ### Demo Version Notice
-                    **This is a demo version running on limited resources, which may respond slower than usual.**
-                    It's primarily for demonstration purposes. 
-                    For optimal performance, we recommend running this application on your local machine using your own OpenAI API_KEY or local models. 
-                    See the instructions below on how to set up and run this application locally for the best experience.
-                    I also recommend to read this introduction page first.
-                    If you proceed to the interview interface right now, just click on the 'Coding' tab.
-                    """
-                    )
+                    gr.Markdown(instruction["demo"])
 
                 gr.Markdown("### Introduction")
                 gr.Markdown("### Setting Up Locally")
                 gr.Markdown("### Interview Interface Overview")
                 gr.Markdown("### Models Configuration")
+                gr.Markdown("### Acknowledgement")
+                gr.Markdown(instruction["acknowledgements"])
 
             with gr.Column(scale=1):
                 try:
-                    audio_test = text_to_speech("Handshake")
-                    gr.Markdown(f"TTS status: 🟢.   Model: {TTS_NAME}")
+                    audio_test = tts.text_to_speech("Handshake")
+                    gr.Markdown(f"TTS status: 🟢.   Model: {config.tts.name}")
                 except:
-                    gr.Markdown(f"TTS status: 🔴.   Model: {TTS_NAME}")
+                    gr.Markdown(f"TTS status: 🔴.   Model: {config.tts.name}")
 
                 try:
-                    text_test = speech_to_text(audio_test, False)
-                    gr.Markdown(f"STT status: 🟢.   Model: {STT_NAME}")
+                    text_test = stt.speech_to_text(audio_test, False)
+                    gr.Markdown(f"STT status: 🟢.   Model: {config.stt.name}")
                 except:
-                    gr.Markdown(f"STT status: 🔴.   Model: {STT_NAME}")
+                    gr.Markdown(f"STT status: 🔴.   Model: {config.stt.name}")
 
                 try:
-                    test_connection()
-                    gr.Markdown(f"LLM status: 🟢.   Model: {LLM_NAME}")
+                    llm.test_connection()
+                    gr.Markdown(f"LLM status: 🟢.   Model: {config.llm.name}")
                 except:
-                    gr.Markdown(f"LLM status: 🔴.   Model: {LLM_NAME}")
+                    gr.Markdown(f"LLM status: 🔴.   Model: {config.llm.name}")
 
     with gr.Tab("Coding") as coding_tab:
         chat_history = gr.State([])
@@ -148,14 +128,14 @@ with gr.Blocks() as demo:
     coding_tab.select(fn=add_interviewer_message(fixed_messages["intro"]), inputs=[chat], outputs=[chat])
 
     start_btn.click(fn=add_interviewer_message(fixed_messages["start"]), inputs=[chat], outputs=[chat]).then(
-        fn=get_problem,
+        fn=llm.get_problem,
         inputs=[requirements, difficulty_select, topic_select],
         outputs=[description, chat_history],
         scroll_to_output=True,
     ).then(fn=hide_settings, inputs=None, outputs=[init_acc, start_btn, solution_acc, end_btn, audio_input])
 
     message.submit(
-        fn=send_request,
+        fn=llm.send_request,
         inputs=[code, previous_code, message, chat_history, chat],
         outputs=[chat_history, chat, message, previous_code],
     )
@@ -165,18 +145,18 @@ with gr.Blocks() as demo:
         inputs=[chat],
         outputs=[chat],
     ).then(
-        fn=end_interview, inputs=[description, chat_history], outputs=feedback
+        fn=llm.end_interview, inputs=[description, chat_history], outputs=feedback
     ).then(fn=hide_solution, inputs=None, outputs=[solution_acc, end_btn, problem_acc, audio_input])
 
-    audio_input.stop_recording(fn=speech_to_text, inputs=[audio_input], outputs=[message]).then(
+    audio_input.stop_recording(fn=stt.speech_to_text, inputs=[audio_input], outputs=[message]).then(
         fn=lambda: None, inputs=None, outputs=[audio_input]
     ).then(fn=add_candidate_message, inputs=[message, chat], outputs=[chat]).then(
-        fn=send_request,
+        fn=llm.send_request,
         inputs=[code, previous_code, message, chat_history, chat],
         outputs=[chat_history, chat, message, previous_code],
     )
 
-    chat.change(fn=read_last_message, inputs=[chat], outputs=[audio_output])
+    chat.change(fn=tts.read_last_message, inputs=[chat], outputs=[audio_output])
 
     audio_output.stop(fn=lambda: None, inputs=None, outputs=[audio_output])
 

audio.py

@@ -1,17 +0,0 @@
-import io
-import wave
-
-
-def numpy_audio_to_bytes(audio_data):
-    sample_rate = 44100
-    num_channels = 1
-    sampwidth = 2
-
-    buffer = io.BytesIO()
-    with wave.open(buffer, "wb") as wf:
-        wf.setnchannels(num_channels)
-        wf.setsampwidth(sampwidth)
-        wf.setframerate(sample_rate)
-        wf.writeframes(audio_data.tobytes())
-
-    return buffer.getvalue()

config.py

@@ -1,28 +1,22 @@
-# X_URL - the URL for the model endpoint, can be None if using OpenAI API
-# X_TYPE - the type of the model, can be "OPENAI_API" or "HF_API"
-# there should be an environment variable with the f"{}_KEY" name and the key as the value to authenticate the API
-# X_NAME - the name of the model, used only for OpenAI API
+import os
 
-LLM_URL = None
-LLM_TYPE = "OPENAI_API"
-LLM_NAME = "gpt-3.5-turbo"
-# "gpt-3.5-turbo" - ~3 seconds delay with decent quality
-# "gpt-4-turbo","gpt-4", etc. 10+ seconds delay but higher quality
-# For HuggingFace models, the Messages API is used, it if compatible with Open AI API
-# Don't forget to add "/v1" to the end of the URL for HuggingFace LLM models
-# https://huggingface.co/docs/text-generation-inference/en/messages_api
+from dotenv import load_dotenv
 
-STT_URL = "https://api-inference.huggingface.co/models/openai/whisper-tiny.en"
-STT_TYPE = "HF_API"
-STT_NAME = "whisper-1"
-# "whisper-1" is the only OpenAI STT model available for OpenAI API
-# The whisper family with more models is available on HuggingFace:
-# https://huggingface.co/collections/openai/whisper-release-6501bba2cf999715fd953013
-# you can also use any other compatible model from HuggingFace
 
-TTS_URL = None
-TTS_TYPE = "OPENAI_API"
-TTS_NAME = "tts-1"
-# OpenAI "tts-1" - very good quality and close to real-time response
-# OpenAI "tts-1-hd" - slightly better quality with slightly longer response time (no obvious benefits in this case)
-# I think OS models on HuggingFace have much more artificial voices, but you can try them out
+class ServiceConfig:
+    def __init__(self, url_var, type_var, name_var):
+        self.url = os.getenv(url_var)
+        self.type = os.getenv(type_var)
+        self.name = os.getenv(name_var)
+        self.key = os.getenv(f"{self.type}_KEY")
+
+
+class Config:
+    def __init__(self):
+        load_dotenv()
+        self.llm = ServiceConfig("LLM_URL", "LLM_TYPE", "LLM_NAME")
+        self.stt = ServiceConfig("STT_URL", "STT_TYPE", "STT_NAME")
+        self.tts = ServiceConfig("TTS_URL", "TTS_TYPE", "TTS_NAME")
+
+
+config = Config()

docs/instruction.py

@@ -0,0 +1,29 @@
+# I will change it into proper format later
+
+instruction = {
+    "intro": """
+                This project leverages the latest AI models to simulate a realistic tech interview experience, 
+                allowing you to practice your coding interview skills in an environment that closely mimics the real thing. 
+                While it's not designed to replace a human interviewer or the essential steps of interview preparation, such as studying algorithms and practicing coding, 
+                it serves as a valuable addition to your preparation arsenal.
+                """,
+    "demo": """
+                    ### Demo Version Notice
+                    **This is a demo version running on limited resources, which may respond slower than usual.**
+                    It's primarily for demonstration purposes. 
+                    For optimal performance, we recommend running this application on your local machine using your own OpenAI API_KEY or local models. 
+                    See the instructions below on how to set up and run this application locally for the best experience.
+                    I also recommend to read this introduction page first.
+                    If you proceed to the interview interface right now, just click on the 'Coding' tab.
+                    """,
+    "acknowledgements": """
+                    The library can be used with a wide variety of models and APIs depending on configuration.
+                    But I would like to acknowledge the following models in particular:
+                    * OpenAI: GPT-3.5, GPT-4, Whisper, TTS-1, etc.
+                    * Meta: Llama family, especially Meta-Llama-3-70B-Instruct and Meta-Llama-3-8B-Instruct.
+                    * HuggingFace: for providing a wide range of models and APIs that can be used with this library.
+
+                    Please, make sure to check the documentation of the models and APIs you are using to understand their capabilities and limitations.
+                    Also, make sure to comply with the terms of service and acceptable use policies of the models and APIs you are using.
+    """,
+}

llm.py

@@ -1,135 +0,0 @@
-import json
-import os
-
-import requests
-
-from dotenv import load_dotenv
-from openai import OpenAI
-
-from audio import numpy_audio_to_bytes
-from config import LLM_NAME, LLM_TYPE, LLM_URL, STT_NAME, STT_TYPE, STT_URL, TTS_NAME, TTS_TYPE, TTS_URL
-from prompts import coding_interviewer_prompt, grading_feedback_prompt, problem_generation_prompt
-
-load_dotenv()
-
-client_LLM = OpenAI(base_url=LLM_URL, api_key=os.getenv(f"{LLM_TYPE}_KEY"))
-
-
-def test_connection():
-    response = client_LLM.chat.completions.create(
-        model=LLM_NAME,
-        messages=[
-            {"role": "system", "content": "You just help me test the connection."},
-            {"role": "user", "content": "Hi!"},
-            {"role": "user", "content": "Ping!"},
-        ],
-    )
-    return response.choices[0].message.content.strip()
-
-
-def init_bot(problem=""):
-    chat_history = [
-        {"role": "system", "content": coding_interviewer_prompt},
-        {"role": "system", "content": f"The candidate is solving the following problem: {problem}"},
-    ]
-    return chat_history
-
-
-def get_problem(requirements, difficulty, topic, client=client_LLM):
-    full_prompt = (
-        f"Create a {difficulty} {topic} coding problem. "
-        f"Additional requirements: {requirements}. "
-        "The problem should be clearly stated, well-formatted, and solvable within 30 minutes. "
-        "Ensure the problem varies each time to provide a wide range of challenges."
-    )
-    response = client.chat.completions.create(
-        model=LLM_NAME,
-        messages=[
-            {"role": "system", "content": problem_generation_prompt},
-            {"role": "user", "content": full_prompt},
-        ],
-        temperature=1.0,
-    )
-    question = response.choices[0].message.content.strip()
-    chat_history = init_bot(question)
-    return question, chat_history
-
-
-def end_interview(problem_description, chat_history, client=client_LLM):
-    if not chat_history or len(chat_history) <= 2:
-        return "No interview content available to review."
-
-    transcript = []
-    for message in chat_history[1:]:
-        role = message["role"]
-        content = f"{role.capitalize()}: {message['content']}"
-        transcript.append(content)
-
-    response = client.chat.completions.create(
-        model=LLM_NAME,
-        messages=[
-            {"role": "system", "content": grading_feedback_prompt},
-            {"role": "user", "content": f"The original problem to solve: {problem_description}"},
-            {"role": "user", "content": "\n\n".join(transcript)},
-            {"role": "user", "content": "Grade the interview based on the transcript provided and give feedback."},
-        ],
-        temperature=0.5,
-    )
-    feedback = response.choices[0].message.content.strip()
-    return feedback
-
-
-def send_request(code, previous_code, message, chat_history, chat_display, client=client_LLM):
-    if code != previous_code:
-        chat_history.append({"role": "user", "content": f"My latest code:\n{code}"})
-    chat_history.append({"role": "user", "content": message})
-
-    response = client.chat.completions.create(model=LLM_NAME, messages=chat_history)
-
-    reply = response.choices[0].message.content.strip()
-
-    chat_history.append({"role": "assistant", "content": reply})
-    chat_display[-1][1] = reply
-
-    return chat_history, chat_display, "", code
-
-
-def speech_to_text(audio, convert_to_bytes=True):
-    assert STT_TYPE in ["OPENAI_API", "HF_API"]
-
-    if convert_to_bytes:
-        audio = numpy_audio_to_bytes(audio[1])
-
-    if STT_TYPE == "OPENAI_API":
-        data = ("temp.wav", audio, "audio/wav")
-        client = OpenAI(base_url=STT_URL, api_key=os.getenv(f"{STT_TYPE}_KEY"))
-        transcription = client.audio.transcriptions.create(model=STT_NAME, file=data, response_format="text")
-    elif STT_TYPE == "HF_API":
-        headers = {"Authorization": "Bearer " + os.getenv(f"{STT_TYPE}_KEY")}
-        transcription = requests.post(STT_URL, headers=headers, data=audio)
-        transcription = transcription.json()["text"]
-
-    return transcription
-
-
-def text_to_speech(text):
-    assert TTS_TYPE in ["OPENAI_API", "HF_API"]
-
-    if TTS_TYPE == "OPENAI_API":
-        client = OpenAI(base_url=TTS_URL, api_key=os.getenv(f"{TTS_TYPE}_KEY"))
-        response = client.audio.speech.create(model=TTS_NAME, voice="alloy", response_format="opus", input=text)
-    elif TTS_TYPE == "HF_API":
-        headers = {"Authorization": "Bearer " + os.getenv(f"{STT_TYPE}_KEY")}
-        response = requests.post(TTS_URL, headers=headers)
-
-    audio = response.content
-    return audio
-
-
-def read_last_message(chat_display):
-    if len(chat_display) > 0:
-        last_message = chat_display[-1][1]
-        if last_message is not None:
-            audio = text_to_speech(last_message)
-            return audio
-    return None

prompts.py

@@ -1,37 +0,0 @@
-problem_generation_prompt = (
-    "You are AI acting as a coding round interviewer for a big-tech company. "
-    "Generate a problem that tests the candidate's ability to solve real-world coding challenges efficiently. "
-    "Ensure the problem tests for problem-solving skills, technical proficiency, code quality, and handling of edge cases. "
-)
-
-# Coding round interviewer instructions
-coding_interviewer_prompt = (
-    "As an AI acting as a coding interviewer for a major tech company, you are to maintain a professional and analytical demeanor. "
-    "You must consistently ask about the time and space complexity of the candidate's solutions after each significant problem-solving step. "
-    "Prompt the candidate to explain how they compute these complexities, and guide them through the process if necessary, without providing the answers directly. "
-    "Encourage thorough exploration of solutions without revealing answers directly. Provide hints subtly only after observing the candidate struggle significantly or upon explicit request. "
-    "Probe the candidate with questions related to problem-solving approaches, algorithm choices, handling of edge cases, and error identification to assess technical proficiency comprehensively. "
-    "If the candidate deviates from the problem, gently guide them back to focus on the task at hand. "
-    "After multiple unsuccessful attempts by the candidate to identify or fix an error, provide more direct hints or rephrase the problem slightly to aid understanding. "
-    "Encourage the candidate to think about real-world applications and scalability of their solutions, asking how changes to the problem parameters might affect their approach. "
-)
-
-
-# Prompt for grading feedback
-grading_feedback_prompt = (
-    "You are the AI grader for a coding interview at a major tech firm. "
-    "The following is the interview transcript with the candidate's responses. "
-    "Ignore minor transcription errors unless they impact comprehension. "
-    "If there are no real solution provide just say it. "
-    "Evaluate the candidate’s performance based on the following criteria: "
-    "\n- **Problem-Solving Skills**: Approach to solving problems, creativity, and handling of complex issues."
-    "\n- **Technical Proficiency**: Accuracy of the solution, usage of appropriate algorithms and data structures, consideration of edge cases, and error handling."
-    "\n- **Code Quality**: Readability, maintainability, scalability, and overall organization."
-    "\n- **Communication Skills**: Ability to explain their thought process clearly, interaction during the interview, and responsiveness to feedback."
-    "\n- **Debugging Skills**: Efficiency in identifying and resolving errors."
-    "\n- **Adaptability**: Ability to incorporate feedback and adjust solutions as needed."
-    "\n- **Handling Ambiguity**: Approach to dealing with uncertain or incomplete requirements."
-    "\nProvide comprehensive feedback, detailing overall performance, specific errors, areas for improvement, communication lapses, overlooked edge cases, and any other relevant observations. "
-    "Use code examples to illustrate points where necessary. Your feedback should be critical, aiming to fail candidates who do not meet high standards while providing detailed improvement areas. "
-    "Format all feedback in clear, structured markdown for readability."
-)

resources/prompts.py

@@ -0,0 +1,34 @@
+prompts = {
+    "problem_generation_prompt": (
+        "You are AI acting as a coding round interviewer for a big-tech company. "
+        "Generate a problem that tests the candidate's ability to solve real-world coding challenges efficiently. "
+        "Ensure the problem tests for problem-solving skills, technical proficiency, code quality, and handling of edge cases. "
+    ),
+    "coding_interviewer_prompt": (
+        "As an AI acting as a coding interviewer for a major tech company, you are to maintain a professional and analytical demeanor. "
+        "You must consistently ask about the time and space complexity of the candidate's solutions after each significant problem-solving step. "
+        "Prompt the candidate to explain how they compute these complexities, and guide them through the process if necessary, without providing the answers directly. "
+        "Encourage thorough exploration of solutions without revealing answers directly. Provide hints subtly only after observing the candidate struggle significantly or upon explicit request. "
+        "Probe the candidate with questions related to problem-solving approaches, algorithm choices, handling of edge cases, and error identification to assess technical proficiency comprehensively. "
+        "If the candidate deviates from the problem, gently guide them back to focus on the task at hand. "
+        "After multiple unsuccessful attempts by the candidate to identify or fix an error, provide more direct hints or rephrase the problem slightly to aid understanding. "
+        "Encourage the candidate to think about real-world applications and scalability of their solutions, asking how changes to the problem parameters might affect their approach. "
+    ),
+    "grading_feedback_prompt": (
+        "You are the AI grader for a coding interview at a major tech firm. "
+        "The following is the interview transcript with the candidate's responses. "
+        "Ignore minor transcription errors unless they impact comprehension. "
+        "If there are no real solution provide just say it. "
+        "Evaluate the candidate’s performance based on the following criteria: "
+        "\n- **Problem-Solving Skills**: Approach to solving problems, creativity, and handling of complex issues."
+        "\n- **Technical Proficiency**: Accuracy of the solution, usage of appropriate algorithms and data structures, consideration of edge cases, and error handling."
+        "\n- **Code Quality**: Readability, maintainability, scalability, and overall organization."
+        "\n- **Communication Skills**: Ability to explain their thought process clearly, interaction during the interview, and responsiveness to feedback."
+        "\n- **Debugging Skills**: Efficiency in identifying and resolving errors."
+        "\n- **Adaptability**: Ability to incorporate feedback and adjust solutions as needed."
+        "\n- **Handling Ambiguity**: Approach to dealing with uncertain or incomplete requirements."
+        "\nProvide comprehensive feedback, detailing overall performance, specific errors, areas for improvement, communication lapses, overlooked edge cases, and any other relevant observations. "
+        "Use code examples to illustrate points where necessary. Your feedback should be critical, aiming to fail candidates who do not meet high standards while providing detailed improvement areas. "
+        "Format all feedback in clear, structured markdown for readability."
+    ),
+}

utils/ui.py

@@ -0,0 +1,11 @@
+def add_interviewer_message(message):
+    def f(chat):
+        chat.append((None, message))
+        return chat
+
+    return f
+
+
+def add_candidate_message(message, chat):
+    chat.append((message, None))
+    return chat