Update app.py

app.py

@@ -7,14 +7,26 @@ from sklearn.feature_extraction.text import TfidfVectorizer
 from sklearn.metrics.pairwise import cosine_similarity
 from functools import lru_cache
 
+# *** IMPORTANT: YOU MUST REPLACE THIS WITH YOUR ACTUAL LLM CLIENT/API ***
+# For demonstration, we will use a mock function, but in reality, 
+# you'd use a library like 'openai', 'google-genai', or 'llama-cpp-python'.
+
+# MOCK LLM CLIENT (Replace with actual LLM API call)
+def llm_api_call(prompt):
+    """Mocks an LLM API call for demonstration purposes."""
+    if "average salary" in prompt.lower():
+        return "Based on the filtered candidates, the average salary expectation is approximately **$140,000 USD** among the top 5 candidates. Candidate Alice Smith has the highest score."
+    elif "best skills" in prompt.lower():
+        return "The top candidates predominantly possess skills in **Python, PyTorch, TensorFlow, and AWS/Azure**. This aligns well with the roles in the AI category."
+    else:
+        return "I need more context from the question to generate a meaningful analysis. Try asking about salaries, key skills, or location distribution among the top candidates."
+
 # ----------------------------
 # CONFIG
 # ----------------------------
 JSON_FILE = "form-submissions-1.json"
 FILTERED_CSV = "/tmp/filtered_candidates.csv"
 
-# The HF_API_TOKEN and LLM-related variables are now completely removed.
-
 CATEGORIES = {
     "AI": [
         "AI/ML Ops Engineer","Senior Machine Learning Engineer","Principal Data Scientist",
@@ -34,40 +46,102 @@ CATEGORIES = {
 # ----------------------------
 @lru_cache(maxsize=1) 
 def calculate_similarity_scores(df_candidates, category_name):
-    """
-    Calculates the cosine similarity between candidate roles and target job titles
-    using TF-IDF for keyword matching based on importance.
-    """
+    # ... (Same function as before: calculates TF-IDF/Cosine Similarity)
     if df_candidates.empty:
         return pd.Series([], dtype='float64')
-
-    # 1. Define the document corpus
-    # Combines all target roles into one reference text
     target_roles = " ".join(CATEGORIES[category_name])
     candidate_roles = df_candidates['Roles'].tolist()
-    
-    # 2. Create the corpus for vectorization
     corpus = [target_roles] + candidate_roles
-    
-    # 3. Vectorize using TF-IDF (converts text to numerical features)
-    # ngrams help match multi-word phrases like 'Data Scientist'
     vectorizer = TfidfVectorizer(ngram_range=(1, 2), stop_words='english')
     tfidf_matrix = vectorizer.fit_transform(corpus)
-    
-    # 4. Extract the vector for the target roles (the first row)
     target_vector = tfidf_matrix[0]
     candidate_vectors = tfidf_matrix[1:]
-    
-    # 5. Calculate Cosine Similarity (score ranges from 0.0 to 1.0)
     similarity_scores = cosine_similarity(target_vector, candidate_vectors).flatten()
-    
-    # Return scores as a Pandas Series aligned with the DataFrame index
     return pd.Series(similarity_scores, index=df_candidates.index)
 
 # ----------------------------
-# Step 1: Filter by roles (Unchanged)
+# Helper: Rank and retrieve Top 5 candidates
+# ----------------------------
+def get_top5_candidates(category_name):
+    if not os.path.exists(FILTERED_CSV):
+        return pd.DataFrame(), "Error: Filtered CSV not found. Run Step 1 and Step 2 first."
+    
+    df_filtered = pd.read_csv(FILTERED_CSV)
+    df_filtered = df_filtered[df_filtered["Category"] == category_name]
+
+    if df_filtered.empty:
+        return pd.DataFrame(), f"No filtered candidates found for category '{category_name}'."
+
+    # Recalculate or retrieve scores (ensures consistency)
+    df_filtered["Similarity_Score"] = calculate_similarity_scores(df_filtered, category_name)
+    df_recommended = df_filtered[df_filtered["Similarity_Score"] > 0.01].copy()
+
+    def parse_salary(s):
+        try:
+            return float(str(s).replace("$","").replace(",","").replace("N/A", str(float('inf'))))
+        except:
+            return float('inf')
+            
+    df_recommended["Salary_sort"] = df_recommended["Salary"].apply(parse_salary)
+
+    df_top5 = df_recommended.sort_values(
+        by=['Similarity_Score', 'Salary_sort'],
+        ascending=[False, True] 
+    ).head(5)
+    
+    # Select only the relevant columns for the LLM context
+    df_top5 = df_top5[['Name', 'Roles', 'Skills', 'Salary', 'Location', 'Similarity_Score']]
+    return df_top5, None
+
+# ----------------------------
+# Step 3: LLM Question Answering (New Feature)
 # ----------------------------
+def ask_llm_about_candidates(question, category_name):
+    """
+    RAG-like function: Loads the top 5 candidates and uses that data
+    as context for the LLM to answer the founder's question.
+    """
+    df_top5, error_msg = get_top5_candidates(category_name)
+    
+    if error_msg:
+        return f"Cannot run Q&A: {error_msg}"
+        
+    if df_top5.empty:
+        return "No top candidates were identified in Step 2 to provide context for this question."
+
+    # 1. Prepare the context for the LLM (serialize the top 5 data)
+    candidate_context = df_top5.to_markdown(index=False)
+    
+    system_prompt = f"""
+    You are an expert Talent Acquisition Analyst. Your task is to analyze the provided table of top-ranked candidates for the '{category_name}' category and answer the founder's question concisely.
+    The candidates were ranked based on the keyword match of their roles to the target category.
+
+    **CONTEXT (Top 5 Candidates):**
+    ---
+    {candidate_context}
+    ---
+    
+    **INSTRUCTIONS:**
+    1. Base your answer ONLY on the provided CONTEXT table. Do not use external knowledge.
+    2. Answer the question in a clear, professional, and business-focused manner.
+    3. If the data is insufficient to answer, state that clearly.
+    """
+    
+    full_prompt = f"{system_prompt}\n\nFOUNDER'S QUESTION: {question}"
+
+    # 2. Call the LLM API (MOCK for this example)
+    try:
+        llm_response = llm_api_call(full_prompt) # <-- Replace with actual API call
+        return llm_response
+    except Exception as e:
+        return f"LLM API Error: Could not connect or receive a response. Check API key and configuration. Error details: {e}"
+
+
+# --- Other Functions (filter_by_roles, similarity_recommendations, show_first_candidates) ---
+# (Keep the rest of the original functions here, unchanged)
+
 def filter_by_roles(category_name):
+    # (The body of the original filter_by_roles function)
     job_titles = CATEGORIES[category_name]
     try:
         with open(JSON_FILE, encoding="utf-8") as f:
@@ -81,7 +155,6 @@ def filter_by_roles(category_name):
         work_exps = person.get("work_experiences", [])
         if not work_exps:
             continue
-        # Filter to get relevant job titles from the work experience
         non_fullstack_roles = [
             exp.get("roleName") for exp in work_exps 
             if exp.get("roleName") and "full stack developer" not in exp.get("roleName").lower()
@@ -89,7 +162,6 @@ def filter_by_roles(category_name):
         if not non_fullstack_roles:
             continue
             
-        # Initial check: filter only candidates who have *at least one* target role
         if any(role in job_titles for role in non_fullstack_roles):
             filtered.append({
                 "Name": person.get("name"),
@@ -109,54 +181,21 @@ def filter_by_roles(category_name):
     df.to_csv(FILTERED_CSV, index=False)
     return df, f"{len(df)} candidates filtered by role for category '{category_name}'. Ready for Similarity Ranking."
 
-
-# ----------------------------
-# Step 2: Recommendations (Using Similarity Matching)
-# ----------------------------
 def similarity_recommendations(category_name):
-    if not os.path.exists(FILTERED_CSV):
-        df_filtered, msg = filter_by_roles(category_name)
-        if df_filtered.empty:
-            return msg
-    else:
-        df_filtered = pd.read_csv(FILTERED_CSV)
-        df_filtered = df_filtered[df_filtered["Category"] == category_name]
-
-    if df_filtered.empty:
-        return f"No filtered candidates found for category '{category_name}'. Run Step 1 first."
-
-    # --- CORE SCORING ---
-    df_filtered["Similarity_Score"] = calculate_similarity_scores(df_filtered, category_name)
+    df_top5, error_msg = get_top5_candidates(category_name)
     
-    # Filter out candidates with near-zero relevance (score < 0.01)
-    df_recommended = df_filtered[df_filtered["Similarity_Score"] > 0.01].copy()
+    if error_msg:
+        return error_msg
 
-    if df_recommended.empty:
+    if df_top5.empty:
         return f"All candidates had insufficient text similarity (less than 1%) to the target roles for '{category_name}'. The roles do not match the target category keywords."
     
-    # Define salary parsing for tie-breaker
-    def parse_salary(s):
-        try:
-            # Replaces '$', ',', and sets 'N/A' to infinity for sorting purposes
-            return float(str(s).replace("$","").replace(",","").replace("N/A", str(float('inf'))))
-        except:
-            return float('inf')
-            
-    df_recommended["Salary_sort"] = df_recommended["Salary"].apply(parse_salary)
-
-    # Sort: 1. Highest Similarity Score (descending), 2. Lowest Salary (ascending)
-    df_top5 = df_recommended.sort_values(
-        by=['Similarity_Score', 'Salary_sort'],
-        ascending=[False, True] 
-    ).head(5)
-
     final_names = df_top5["Name"].tolist()
     
     output_text = f"Top {len(final_names)} Recommended Candidates for the '{category_name}' Category:\n\n"
     
     for i, name in enumerate(final_names):
         score = df_top5.iloc[i]['Similarity_Score']
-        # Display the score as a percentage for readability
         score_percent = f"{score * 100:.2f}%"
         output_text += f"{i+1}. {name} (Role Match: {score_percent})\n"
     
@@ -164,9 +203,6 @@ def similarity_recommendations(category_name):
     
     return output_text
 
-# ----------------------------
-# Show first 5 raw JSON candidates (Unchanged)
-# ----------------------------
 def show_first_candidates():
     try:
         with open(JSON_FILE, encoding="utf-8") as f:
@@ -178,30 +214,58 @@ def show_first_candidates():
         return pd.DataFrame({"Error": [f"Failed to load JSON: {e}"]})
 
 # ----------------------------
-# Gradio interface (Final Version)
+# Gradio interface (Final Version with Q&A)
 # ----------------------------
 with gr.Blocks() as app:
-    gr.Markdown("# 🏆 Candidate Selection (Keyword Similarity Matching)") 
-    gr.Markdown("### **Reliable ranking using objective TF-IDF & Cosine Similarity for keyword overlap.**")
+    gr.Markdown("# 🏆 Candidate Selection & Founder Analysis") 
+    gr.Markdown("### **Reliable ranking using objective TF-IDF & Cosine Similarity, plus an LLM-powered Q&A tool.**")
     
-    gr.Markdown("#### 🔍 Raw JSON Preview: First 5 Candidates")
-    gr.Dataframe(show_first_candidates(), label="First 5 JSON Entries")
+    with gr.Tab("1. Candidate Ranking"):
+        gr.Markdown("#### 🔍 Raw JSON Preview: First 5 Candidates")
+        gr.Dataframe(show_first_candidates(), label="First 5 JSON Entries")
+
+        gr.Markdown("---")
+        category_dropdown = gr.Dropdown(list(CATEGORIES.keys()), label="Select Category", value="AI")
 
-    gr.Markdown("---")
-    category_dropdown = gr.Dropdown(list(CATEGORIES.keys()), label="1. Select Category")
+        # Step 1: Filter by roles
+        filter_button = gr.Button("1. Filter Candidates by Roles (Create CSV)")
+        filtered_df = gr.Dataframe(label="Filtered Candidates (Preview)")
+        filter_status = gr.Textbox(label="Filter Status", placeholder="Click 'Filter Candidates by Roles' to start.")
+        filter_button.click(filter_by_roles, inputs=[category_dropdown], outputs=[filtered_df, filter_status])
 
-    # Step 1: Filter by roles
-    filter_button = gr.Button("2. Filter Candidates by Roles")
-    filtered_df = gr.Dataframe(label="Filtered Candidates (Preview)")
-    filter_status = gr.Textbox(label="Filter Status", placeholder="Click 'Filter Candidates by Roles' to start.")
-    filter_button.click(filter_by_roles, inputs=[category_dropdown], outputs=[filtered_df, filter_status])
+        gr.Markdown("---")
 
-    gr.Markdown("---")
+        # Step 2: Recommendations
+        recommend_button = gr.Button("2. Rank and Find Top 5 Candidates")
+        recommend_output_text = gr.Textbox(label="Top Candidate Recommendations Summary", lines=10, placeholder="Click 'Rank and Find Top 5 Candidates' after Step 1 completes.")
+        recommend_button.click(similarity_recommendations, inputs=[category_dropdown], outputs=[recommend_output_text])
 
-    # Step 2: Recommendations
-    recommend_button = gr.Button("3. Rank Candidates by Role Keyword Match")
-    recommend_output_text = gr.Textbox(label="Top Candidate Recommendations Summary", lines=10, placeholder="Click 'Rank Candidates by Role Keyword Match' after Step 2 completes.")
-    recommend_button.click(similarity_recommendations, inputs=[category_dropdown], outputs=[recommend_output_text])
+    with gr.Tab("2. Founder Q&A"):
+        gr.Markdown("### 🧠 Ask the LLM about the Top Candidates")
+        gr.Markdown("The LLM uses the **Top 5 candidates** identified in the 'Candidate Ranking' tab as its sole source of information.")
+        
+        qa_category_dropdown = gr.Dropdown(list(CATEGORIES.keys()), label="Select Category for Q&A", value="AI")
+        
+        founder_question = gr.Textbox(
+            label="Founder's Question", 
+            lines=2, 
+            placeholder="e.g., What is the average expected salary of the top candidates? Or, What are their most common skills?",
+            value="What is the average expected salary of the top candidates?"
+        )
+        
+        qa_button = gr.Button("3. Get LLM Analysis")
+        
+        llm_response_text = gr.Textbox(
+            label="LLM Response (Context-Based Analysis)", 
+            lines=8, 
+            placeholder="The analysis will appear here after you click the button."
+        )
+        
+        qa_button.click(
+            ask_llm_about_candidates, 
+            inputs=[founder_question, qa_category_dropdown], 
+            outputs=[llm_response_text]
+        )
 
 if __name__ == "__main__":
     app.launch(share=True)