Refactored LLM

api/llm.py

@@ -5,13 +5,30 @@ from openai import OpenAI
 from utils.errors import APIError
 
 
+class PromptManager:
+    def __init__(self, prompts):
+        self.prompts = prompts
+        self.limit = os.getenv("DEMO_WORD_LIMIT")
+
+    def add_limit(self, prompt):
+        if self.limit:
+            prompt += f" Keep your responses very short and simple, no more than {self.limit} words."
+        return prompt
+
+    def get_system_prompt(self, key):
+        prompt = self.prompts[key]
+        return self.add_limit(prompt)
+
+    def get_problem_requirements_prompt(self, type, difficulty=None, topic=None, requirements=None):
+        prompt = f"Create a {difficulty} {topic} {type} problem. " f"Additional requirements: {requirements}. "
+        return self.add_limit(prompt)
+
+
 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
-        self.is_demo = os.getenv("IS_DEMO")
-        self.demo_word_limit = os.getenv("DEMO_WORD_LIMIT")
+        self.prompt_manager = PromptManager(prompts)
 
         self.status = self.test_llm()
         if self.status:
@@ -86,46 +103,37 @@ class LLMManager:
         except:
             return False
 
-    def init_bot(self, problem=""):
-        system_prompt = self.prompts["coding_interviewer_prompt"]
-        if self.is_demo:
-            system_prompt += f" Keep your responses very short and simple, no more than {self.demo_word_limit} words."
+    def init_bot(self, problem, interview_type="coding"):
+        system_prompt = self.prompt_manager.get_system_prompt(f"{interview_type}_interviewer_prompt")
 
         return [
             {"role": "system", "content": system_prompt},
             {"role": "system", "content": f"The candidate is solving the following problem: {problem}"},
         ]
 
-    def get_problem_prepare_messages(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."
-        )
-
-        if self.is_demo:
-            full_prompt += f" Keep your response very short and simple, no more than {self.demo_word_limit} words."
+    def get_problem_prepare_messages(self, requirements, difficulty, topic, interview_type):
+        system_prompt = self.prompt_manager.get_system_prompt(f"{interview_type}_problem_generation_prompt")
+        full_prompt = self.prompt_manager.get_problem_requirements_prompt(interview_type, difficulty, topic, requirements)
 
         messages = [
-            {"role": "system", "content": self.prompts["problem_generation_prompt"]},
+            {"role": "system", "content": system_prompt},
             {"role": "user", "content": full_prompt},
         ]
 
         return messages
 
-    def get_problem_full(self, requirements, difficulty, topic):
-        messages = self.get_problem_prepare_messages(requirements, difficulty, topic)
+    def get_problem_full(self, requirements, difficulty, topic, interview_type="coding"):
+        messages = self.get_problem_prepare_messages(requirements, difficulty, topic, interview_type)
         return self.get_text(messages)
 
-    def get_problem_stream(self, requirements, difficulty, topic):
-        messages = self.get_problem_prepare_messages(requirements, difficulty, topic)
+    def get_problem_stream(self, requirements, difficulty, topic, interview_type="coding"):
+        messages = self.get_problem_prepare_messages(requirements, difficulty, topic, interview_type)
         yield from self.get_text_stream(messages)
 
     def update_chat_history(self, code, previous_code, chat_history, chat_display):
         message = chat_display[-1][0]
         if code != previous_code:
-            chat_history.append({"role": "user", "content": f"My latest code:\n{code}"})
+            chat_history.append({"role": "user", "content": f"My latest solution:\n{code}"})
         chat_history.append({"role": "user", "content": message})
 
         return chat_history
@@ -152,12 +160,10 @@ class LLMManager:
 
             yield chat_history, chat_display, code
 
-    def end_interview_prepare_messages(self, problem_description, chat_history):
+    def end_interview_prepare_messages(self, problem_description, chat_history, interview_type):
         transcript = [f"{message['role'].capitalize()}: {message['content']}" for message in chat_history[1:]]
 
-        system_prompt = self.prompts["grading_feedback_prompt"]
-        if self.is_demo:
-            system_prompt += f" Keep your response very short and simple, no more than {self.demo_word_limit} words."
+        system_prompt = self.prompt_manager.get_system_prompt(f"{interview_type}_grading_feedback_prompt")
 
         messages = [
             {"role": "system", "content": system_prompt},
@@ -168,16 +174,16 @@ class LLMManager:
 
         return messages
 
-    def end_interview_full(self, problem_description, chat_history):
+    def end_interview_full(self, problem_description, chat_history, interview_type="coding"):
         if len(chat_history) <= 2:
             return "No interview history available"
         else:
-            messages = self.end_interview_prepare_messages(problem_description, chat_history)
+            messages = self.end_interview_prepare_messages(problem_description, chat_history, interview_type)
             return self.get_text_stream(messages)
 
-    def end_interview_stream(self, problem_description, chat_history):
+    def end_interview_stream(self, problem_description, chat_history, interview_type="coding"):
         if len(chat_history) <= 2:
             yield "No interview history available"
         else:
-            messages = self.end_interview_prepare_messages(problem_description, chat_history)
+            messages = self.end_interview_prepare_messages(problem_description, chat_history, interview_type)
             yield from self.get_text_stream(messages)

resources/data.py

@@ -1,4 +1,4 @@
-topics_list = [
+coding_topics_list = [
     "Arrays",
     "Strings",
     "Linked Lists",

resources/prompts.py

@@ -1,8 +1,10 @@
 prompts = {
-    "problem_generation_prompt": (
+    "coding_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. "
+        "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."
     ),
     "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. "
@@ -13,8 +15,9 @@ prompts = {
         "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. "
         "Ask the candidate 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. "
+        "Keep your answers concise and clear, avoiding jargon or overly complex explanations. "
     ),
-    "grading_feedback_prompt": (
+    "coding_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. "

ui/coding.py

@@ -1,7 +1,7 @@
 import gradio as gr
 import numpy as np
 
-from resources.data import fixed_messages, topics_list
+from resources.data import coding_topics_list, fixed_messages
 from utils.ui import add_candidate_message, add_interviewer_message
 
 
@@ -10,6 +10,7 @@ def get_codding_ui(llm, tts, stt, default_audio_params, audio_output):
         chat_history = gr.State([])
         previous_code = gr.State("")
         started_coding = gr.State(False)
+        interview_type = gr.State("coding")
         with gr.Accordion("Settings") as init_acc:
             with gr.Row():
                 with gr.Column():
@@ -26,7 +27,7 @@ def get_codding_ui(llm, tts, stt, default_audio_params, audio_output):
                     with gr.Row():
                         gr.Markdown("Topic (can type custom value)")
                         topic_select = gr.Dropdown(
-                            label="Select topic", choices=topics_list, value="Arrays", container=False, allow_custom_value=True
+                            label="Select topic", choices=coding_topics_list, value="Arrays", container=False, allow_custom_value=True
                         )
                 with gr.Column(scale=2):
                     requirements = gr.Textbox(label="Requirements", placeholder="Specify additional requirements", lines=5)
@@ -68,11 +69,11 @@ def get_codding_ui(llm, tts, stt, default_audio_params, audio_output):
             fn=lambda: (gr.update(open=False), gr.update(interactive=False)), outputs=[init_acc, start_btn]
         ).success(
             fn=llm.get_problem,
-            inputs=[requirements, difficulty_select, topic_select],
+            inputs=[requirements, difficulty_select, topic_select, interview_type],
             outputs=[description],
             scroll_to_output=True,
         ).success(
-            fn=llm.init_bot, inputs=[description], outputs=[chat_history]
+            fn=llm.init_bot, inputs=[description, interview_type], outputs=[chat_history]
         ).success(
             fn=lambda: (gr.update(open=True), gr.update(interactive=True), gr.update(interactive=True)),
             outputs=[solution_acc, end_btn, audio_input],
@@ -86,7 +87,7 @@ def get_codding_ui(llm, tts, stt, default_audio_params, audio_output):
             fn=lambda: (gr.update(open=False), gr.update(interactive=False), gr.update(open=False), gr.update(interactive=False)),
             outputs=[solution_acc, end_btn, problem_acc, audio_input],
         ).success(
-            fn=llm.end_interview, inputs=[description, chat_history], outputs=[feedback]
+            fn=llm.end_interview, inputs=[description, chat_history, interview_type], outputs=[feedback]
         )
 
         send_btn.click(fn=add_candidate_message, inputs=[message, chat], outputs=[chat]).success(