initial commit

app.py

@@ -0,0 +1,49 @@
+import streamlit as st
+from src.graph import build_graph
+
+def main():
+    # Build LangGraph workflow
+    app = build_graph()
+
+    def run_graph(current_state: dict) -> dict:
+        return app.invoke(current_state)
+
+    st.title("🤖 AI-Powered Excel Mock Interviewer (Phi-3-mini, Local LLM)")
+    st.markdown("Welcome! This tool uses a self-hosted open-source model to conduct the interview. Click 'Start New Interview' to begin.")
+
+    # Session State Initialization
+    if "interviewer_state" not in st.session_state:
+        st.session_state.interviewer_state = {
+            "interview_status": 0, "interview_history": [], "questions": [],
+            "question_index": 0, "evaluations": [], "final_feedback": "", "warnings": []
+        }
+
+    # Display chat history
+    for message in st.session_state.interviewer_state.get("interview_history", []):
+        role, text = message
+        with st.chat_message("user" if role == "human" else "assistant"):
+            st.markdown(text)
+
+    # Button handling
+    if st.button("Start New Interview"):
+        st.session_state.interviewer_state = {
+            "interview_status": 0, "interview_history": [], "questions": [],
+            "question_index": 0, "evaluations": [], "final_feedback": "", "warnings": []
+        }
+        new_state = run_graph(st.session_state.interviewer_state)
+        st.session_state.interviewer_state = new_state
+        st.rerun()
+
+    # Input handling
+    if st.session_state.interviewer_state.get("interview_status") == 1:
+        prompt = st.chat_input("Your answer...")
+        if prompt:
+            st.session_state.interviewer_state["interview_history"].append(("human", prompt))
+            new_state = run_graph(st.session_state.interviewer_state)
+            st.session_state.interviewer_state = new_state
+            st.rerun()
+    elif st.session_state.interviewer_state.get("interview_status") == 2:
+        st.success("Interview complete!")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,4 @@
+transformers>=4.41.0
+torch
+streamlit
+langgraph

src/graph.py

@@ -0,0 +1,45 @@
+from langgraph.graph import StateGraph, END
+from . import interview_logic
+
+def build_graph():
+    """
+    Builds the LangGraph for the mock interview process.
+    """
+    workflow = StateGraph(dict)
+
+    # Add nodes (no changes here)
+    workflow.add_node("start_interview", interview_logic.start_interview)
+    workflow.add_node("ask_question", interview_logic.ask_question)
+    workflow.add_node("process_user_response", interview_logic.process_user_response)
+    workflow.add_node("generate_final_report", interview_logic.generate_final_report)
+
+    # Entry point (no changes here)
+    workflow.set_conditional_entry_point(
+        interview_logic.route_start_of_interview,
+    )
+
+    # --- THIS IS THE CRITICAL FIX ---
+
+    # The flow from start to the first question is correct.
+    workflow.add_edge("start_interview", "ask_question")
+    
+    # After asking a question, the graph should STOP for that turn.
+    # This allows the UI to wait for user input.
+    workflow.add_edge("ask_question", END) # <--- THIS IS THE FIX
+
+    # The conditional edge should ONLY come from process_user_response
+    workflow.add_conditional_edges(
+        "process_user_response",
+        interview_logic.route_after_evaluation,
+        {
+            "ask_question": "ask_question",
+            "generate_final_report": "generate_final_report",
+            "terminate": END
+        }
+    )
+    
+    # The final report node still ends the graph normally.
+    workflow.add_edge("generate_final_report", END)
+
+    # Compile the graph
+    return workflow.compile()

src/interview_logic.py

@@ -0,0 +1,84 @@
+# src/interview_logic.py
+
+# No more external LLM libraries needed here!
+from .perplexity_detector import is_ai_generated
+from .local_llm_handler import get_llm_response
+
+EXCEL_QUESTIONS = [
+    "What is the difference between the VLOOKUP and HLOOKUP functions in Excel?",
+    "Explain how to use the INDEX and MATCH functions together, and why you might prefer them over VLOOKUP.",
+    "Describe what a Pivot Table is and give an example of a scenario where it would be useful.",
+    "What is Conditional Formatting in Excel? Can you provide an example?",
+]
+
+def start_interview(state: dict) -> dict:
+    # This function body remains largely the same
+    intro_message = "Welcome to the automated Excel skills assessment..."
+    return {
+        **state, "interview_status": 1, "interview_history": [("ai", intro_message)],
+        "questions": EXCEL_QUESTIONS, "question_index": 0, "evaluations": [], "warnings": [], "final_feedback": "",
+    }
+
+def ask_question(state: dict) -> dict:
+    # This function remains the same
+    question_index = state["question_index"]
+    current_question = state["questions"][question_index]
+    history = state.get("interview_history", [])
+    history.append(("ai", current_question))
+    return { **state, "interview_history": history }
+
+# --- MODIFIED FUNCTION ---
+def process_user_response(state: dict) -> dict:
+    history = state.get("interview_history", [])
+    user_response = history[-1][1]
+
+    if is_ai_generated(user_response, threshold=35.0):
+        termination_message = "This interview will now be terminated..."
+        history.append(("ai", termination_message))
+        return {**state, "interview_history": history, "interview_status": 2}
+    
+    current_question = state["questions"][state["question_index"]]
+
+    # Create the prompt manually for our local LLM
+    evaluation_prompt = (
+        "You are an expert evaluator. Concisely evaluate the following answer to an Excel interview question "
+        "based on its technical accuracy and clarity. Start the evaluation directly without conversational filler.\n\n"
+        f"Question: {current_question}\n"
+        f"Answer: {user_response}"
+    )
+    
+    # Get the evaluation from our new local LLM handler
+    evaluation = get_llm_response(evaluation_prompt)
+    
+    evaluations = state.get("evaluations", [])
+    evaluations.append(evaluation)
+
+    return {**state, "evaluations": evaluations, "question_index": state["question_index"] + 1}
+
+def generate_final_report(state: dict) -> dict:
+    interview_transcript = "\n".join([f"{speaker.capitalize()}: {text}" for speaker, text in state['interview_history']])
+    evaluations_summary = "\n\n".join(f"Evaluation for Q{i+1}:\n{e}" for i, e in enumerate(state['evaluations']))
+
+    # Create the report prompt manually
+    report_prompt = (
+        "You are a career coach. Based on the interview transcript and evaluations below, write a brief, constructive performance summary. "
+        "Use Markdown for a 'Strengths' section and an 'Areas for Improvement' section.\n\n"
+        f"---TRANSCRIPT---\n{interview_transcript}\n\n---EVALUATIONS---\n{evaluations_summary}"
+    )
+    
+    # Get the report from our local LLM handler
+    final_feedback = get_llm_response(report_prompt)
+
+    history = state.get("interview_history", [])
+    history.append(("ai", final_feedback))
+
+    return {**state, "final_feedback": final_feedback, "interview_history": history, "interview_status": 2}
+
+# Routing logic does not need to change
+def route_after_evaluation(state: dict):
+    if state.get("interview_status") == 2: return "terminate"
+    elif state["question_index"] >= len(state["questions"]): return "generate_final_report"
+    else: return "ask_question"
+
+def route_start_of_interview(state: dict):
+    return "start_interview" if state.get("interview_status", 0) == 0 else "process_user_response"

src/local_llm_handler.py

@@ -0,0 +1,55 @@
+# src/local_llm_handler.py
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+import streamlit as st
+
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+@st.cache_resource
+def load_llm_pipeline():
+    """
+    Loads and caches the local LLM pipeline using Phi-3-mini-4k-instruct.
+    Designed for Hugging Face Spaces (with upgraded CPU or T4 GPU).
+    """
+    print("--- Loading main LLM: microsoft/Phi-3-mini-4k-instruct ---")
+    model_name = "microsoft/phi-3-mini-4k-instruct"
+
+    # Load tokenizer and model
+    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        device_map="auto",            # Automatically uses GPU if available
+        torch_dtype=torch.float32,    # Use float16 for memory efficiency
+        trust_remote_code=True
+    )
+
+    # Build text generation pipeline
+    llm_pipeline = pipeline(
+        "text-generation",
+        model=model,
+        tokenizer=tokenizer,
+        max_new_tokens=300,
+        return_full_text=False
+    )
+
+    print("--- Phi-3-mini model loaded successfully ---")
+    return llm_pipeline
+
+
+def get_llm_response(prompt: str) -> str:
+    """
+    Gets a response from the cached Phi-3-mini LLM pipeline.
+    """
+    llm_pipeline = load_llm_pipeline()
+    formatted_prompt = f"<|user|>\n{prompt}\n<|assistant|>"
+
+    print("AI: (Generating response with Phi-3-mini...)")
+    try:
+        outputs = llm_pipeline(formatted_prompt)
+        response = outputs[0]["generated_text"]
+        return response
+    except Exception as e:
+        print(f"Error during Phi-3-mini generation: {e}")
+        return "Sorry, I encountered an error while generating a response."

src/perplexity_detector.py

@@ -0,0 +1,31 @@
+# src/perplexity_detector.py
+
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import streamlit as st
+
+@st.cache_resource
+def load_detector_model():
+    """Loads and caches the gpt-2 model for perplexity calculation."""
+    print("--- Loading detector model (gpt-2) for the first time... ---")
+    model_name = "gpt2"
+    model = AutoModelForCausalLM.from_pretrained(model_name)
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    print("--- Detector model loaded and cached. ---")
+    return model, tokenizer
+
+def calculate_perplexity(text: str) -> float:
+    model, tokenizer = load_detector_model()
+    encodings = tokenizer(text, return_tensors="pt")
+    with torch.no_grad():
+        outputs = model(**encodings, labels=encodings["input_ids"])
+        neg_log_likelihood = outputs.loss
+    ppl = torch.exp(neg_log_likelihood)
+    return ppl.item()
+
+def is_ai_generated(text: str, threshold: float = 45.0) -> bool:
+    if not text or len(text.split()) < 5: return False
+    print("AI: (Calculating perplexity...)")
+    perplexity = calculate_perplexity(text)
+    print(f"AI: (Perplexity score: {perplexity:.2f}, Threshold: {threshold})")
+    return perplexity < threshold