Refactoring

app.py

@@ -2,43 +2,65 @@ import gradio as gr
 
 from llm import end_interview, get_problem, send_request
 
+languages_list = ["python", "javascript", "html", "css", "typescript", "dockerfile", "shell", "r", "sql"]  # limited by gradio for now
+topics_list = ["Arrays", "Strings", "Linked Lists"]
+models = ["gpt-3.5-turbo"]
+
+
 with gr.Blocks() as demo:
     gr.Markdown("Your coding interview practice AI assistant!")
     with gr.Tab("Coding"):
         chat_history = gr.State([])
         previous_code = gr.State("")
+        client = gr.State(None)
         with gr.Accordion("Settings") as init_acc:
-            requirements = gr.Textbox(
-                label="Requirements",
-                placeholder=(
-                    "Write any requirements here in a plain text: topic, difficulty, complexity, etc. "
-                    "Or keep it blank to just get a random question."
-                ),
-            )
-            # TODO: select language
-            # TODO: select difficulty
-            # TODO: select topic
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("Difficulty")
+                    difficulty_select = gr.Dropdown(
+                        label="Select difficulty", choices=["Easy", "Medium", "Hard"], value="Medium", container=False
+                    )
+
+                    gr.Markdown("Topic")
+                    topic_select = gr.Dropdown(
+                        label="Select topic", choices=topics_list, value="Arrays", container=False, allow_custom_value=True
+                    )
+
+                    gr.Markdown("Select LLM model to use")
+                    model_select = gr.Dropdown(label="Select model", choices=models, value="gpt-3.5-turbo", container=False)
+                with gr.Column():
+                    requirements = gr.Textbox(
+                        label="Requirements", placeholder="Specify requirements: topic, difficulty, language, etc.", lines=5
+                    )
+                    start_btn = gr.Button("Start")
+
             # TODO: select LLM model
-            start_btn = gr.Button("Start")
         with gr.Accordion("Solution", open=True) as solution_acc:
-            # TODO: auto open close
-            with gr.Accordion("Problem description", open=True) as solution_acc:
-                description = gr.Markdown()
+            description = gr.Markdown()
             with gr.Row() as content:
                 with gr.Column(scale=2):
-                    code = gr.Code(label="Solution", language="python", lines=20)
+                    language_select = gr.Dropdown(
+                        label="Select language", choices=languages_list, value="python", container=False, interactive=True
+                    )
+                    code = gr.Code(label="Solution", language=language_select.value, lines=20)
                     message = gr.Textbox(label="Message", lines=1)
-                    answer_btn = gr.Button("Send message")
                 with gr.Column(scale=1):
                     chat = gr.Chatbot(label="Chat history")
                     end_btn = gr.Button("Finish the interview")
         with gr.Accordion("Feedback", open=True) as feedback_acc:
             feedback = gr.Markdown()
 
-    start_btn.click(fn=get_problem, inputs=requirements, outputs=[description, chat_history], scroll_to_output=True)
-    answer_btn.click(
-        fn=send_request, inputs=[code, previous_code, message, chat_history, chat], outputs=[chat_history, chat, message, previous_code]
+    start_btn.click(
+        fn=get_problem,
+        inputs=[requirements, difficulty_select, topic_select, model_select],
+        outputs=[description, chat_history],
+        scroll_to_output=True,
+    )
+    message.submit(
+        fn=send_request,
+        inputs=[code, previous_code, message, chat_history, chat, model_select],
+        outputs=[chat_history, chat, message, previous_code],
     )
-    end_btn.click(fn=end_interview, inputs=chat_history, outputs=feedback)
+    end_btn.click(fn=end_interview, inputs=[chat_history, model_select], outputs=feedback)
 
 demo.launch()

llm.py

@@ -1,74 +1,61 @@
 import json
-import os
 
+from dotenv import load_dotenv
 from openai import OpenAI
 
-try:
-    with open(".env") as file:
-        for line in file:
-            key, value = line.strip().split("=", 1)
-            os.environ[key] = value
-except FileNotFoundError:
-    pass
+from prompts import coding_interviewer_prompt, grading_feedback_prompt
 
+load_dotenv()
 client = OpenAI()
 
 
 def init_bot(problem=""):
-    prompt_system = (
-        "You are ChatGPT acting as a coding round interviewer for a big-tech company. "
-        "You are very strict. You don't give any hints until candidate is stuck or asks for it. "
-        "If a candidate made a mistake let them find and debug it themselves. "
-        "If a solution can be improved let candidate figure it out, you can ask directional questions but delay giving hints. "
-        "For each version of solution ask candidate about time and space complexity. "
-        "Strive to get the most optimal solution possible. "
-        "Always return the answer in json format with 2 fields: reply_to_candidate and hidden_note. "
-        "reply_to_candidate: the answer that will be shown to the candidate. "
-        "hidden_note: the concise hidden note that is not visible to the candidate but will be useful for final grading and feedback, "
-        "it can contain short code snippets, errors found, things to pay attention to. "
-        "'reply_to_candidate' can not be empty, 'hidden_note' can be empty if there is no new important information to note. "
-        "When the interview is finished and you don't have any more questions provide a very detailed feedback. "
-        "Don't wait for the candidate to ask for feedback, provide it as soon as you don't have any more question or if you see that the candidate can't solve the problem at all. "
-        "Provide detailed feedback using all the notes, mentioning not only the final solution but all issues and mistakes made during the interview. "
-    )
-
     chat_history = [
-        {"role": "system", "content": prompt_system},
+        {"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="", client=client):
+def get_problem(requirements, difficulty, topic, model, client=client):
     prompt_system = "You are ChatGPT acting as a coding round interviewer for a big-tech company. "
-    prompt_start = "Generate a coding problem that is expected to be solvable within 30 minutes. " "Follow the additional instructions: "
-    prompt_end = (
-        "Please provide the problem statement, example inputs and outputs, and any special constraints."
-        "Return the results in nicely formatted markdown."
-    )
-    full_prompt = f"{prompt_start} {requirements} {prompt_end}"
-
+    full_prompt = f"Generate a {difficulty} {topic} problem in. Follow additional requirements: {requirements}. The problem should be solvable within 30 minutes."
     response = client.chat.completions.create(
-        model="gpt-3.5-turbo",
+        model=model,
         messages=[
             {"role": "system", "content": prompt_system},
             {"role": "user", "content": full_prompt},
         ],
     )
-
     question = response.choices[0].message.content.strip()
     chat_history = init_bot(question)
-
     return question, chat_history
 
 
-def send_request(code, previous_code, message, chat_history, chat_display, client=client):
+def end_interview(chat_history, model, client=client):
+    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=model,
+        messages=[
+            {"role": "system", "content": grading_feedback_prompt},
+            {"role": "user", "content": "Interview transcript:" + "\n\n".join(transcript)},
+            {"role": "user", "content": "Grade the interview based on the transcript provided and give a feedback."},
+        ],
+    )
+    feedback = response.choices[0].message.content.strip()
+    return feedback
+
+
+def send_request(code, previous_code, message, chat_history, chat_display, model, client=client):
     if code != previous_code:
         chat_history.append({"role": "user", "content": f"My latest code: {code}"})
     chat_history.append({"role": "user", "content": message})
 
-    response = client.chat.completions.create(model="gpt-3.5-turbo", response_format={"type": "json_object"}, messages=chat_history)
+    response = client.chat.completions.create(model=model, response_format={"type": "json_object"}, messages=chat_history)
 
     json_reply = response.choices[0].message.content.strip()
 
@@ -77,46 +64,10 @@ def send_request(code, previous_code, message, chat_history, chat_display, clien
         reply = data["reply_to_candidate"]
     except json.JSONDecodeError as e:
         print("Failed to decode JSON:", str(e))
+        reply = "There was an error processing your request."
 
     chat_history.append({"role": "assistant", "content": json_reply})
 
     chat_display.append([message, str(reply)])
 
     return chat_history, chat_display, "", code
-
-
-def end_interview(chat_history, client=client):
-    prompt_system = (
-        "You are ChatGPT acting as a grader of the coding round interviewer for a big-tech company. "
-        "Below you will see the transcript of interview with and candidate."
-        "Candidate will send you his current code with every message, you can ignore it if it didn't change. "
-        "Provide very detailed feedback using all the notes and full interview transcript. "
-        "Take into account all issues and mistakes made during the interview. "
-        "Provide as many details as possible including: overall feedback, all mistakes, improvement opportunities, "
-        "communication issues, missed edge cases, and any other valuable feedback. "
-        "Use examples and code snippets when necessary. "
-        "If the candidate didn't provide a solution or it was not optimal provide the correct most optimal one. "
-        "Return the results in nicely formatted markdown."
-    )
-
-    transcript = []
-    for message in chat_history[1:]:
-        if message["role"] == "assistant":
-            transcript.append(f"Interviewer: {message['content']}")
-        elif message["role"] == "user":
-            transcript.append(f"Candidate: {message['content']}")
-        else:
-            transcript.append(f"{message['role']}: {message['content']}")
-
-    response = client.chat.completions.create(
-        model="gpt-3.5-turbo",
-        messages=[
-            {"role": "system", "content": prompt_system},
-            {"role": "user", "content": "Interview transcript:" + "\n\n".join(transcript)},
-            {"role": "user", "content": "Grade the interview based on the transcript provided and give a feedback."},
-        ],
-    )
-
-    feedback = response.choices[0].message.content.strip()
-
-    return feedback

prompts.py

@@ -0,0 +1,24 @@
+# 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 strict demeanor. "
+    "Provide hints only when the candidate is noticeably stuck or explicitly requests assistance. "
+    "Allow candidates to identify and resolve errors independently. "
+    "Encourage the candidate to explore improved solutions through probing questions, delaying hints as needed. "
+    "Discuss the time and space complexity after each solution iteration, aiming for optimal outcomes. "
+    "Responses should be in JSON format with two fields: "
+    "1. 'reply_to_candidate': visible feedback to the candidate. "
+    "2. 'hidden_note': internal notes useful for grading, possibly including code snippets, identified errors, and key observations. "
+    "The 'hidden_note' may be omitted if there are no new critical insights. "
+)
+
+# 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. "
+    "Evaluate the transcript. "
+    "Provide comprehensive feedback, incorporating all interview notes. "
+    "Detail 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. "
+    "If the candidate’s solution was suboptimal or absent, suggest a more optimal solution. "
+    "Format all feedback in clear, structured markdown for readability."
+)

requirements.txt

@@ -1,2 +1,3 @@
 gradio==4.26.0
 openai==1.19.0
+python-dotenv==1.0.1