ss

app.py

@@ -15,7 +15,7 @@ from docx import Document
 import csv
 from datasets import load_dataset
 import gc
-from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+from transformers import AutoModelForCausalLM, AutoTokenizer
 import time
 import faiss
 import re
@@ -34,117 +34,107 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# --- Global Device and Model Loading Section ---
-
-# Initialize session state keys for all models, their loading status/errors, and app data
-keys_to_initialize = {
-    'embedding_model': None, 'embedding_model_error': None,
-    'cross_encoder': None, 'cross_encoder_error': None,
-    'qwen3_4b_tokenizer': None, 'qwen3_4b_tokenizer_error': None,
-    'qwen3_4b_model': None, 'qwen3_4b_model_error': None,
-    'results': [], 'resume_texts': [], 'file_names': [], 'current_job_description': ""
-    # Add any other app-specific session state keys here if needed
-}
-for key, default_value in keys_to_initialize.items():
-    if key not in st.session_state:
-        st.session_state[key] = default_value
-
-# Load Embedding Model (BAAI/bge-large-en-v1.5)
-if st.session_state.embedding_model is None and st.session_state.embedding_model_error is None:
-    print("[Global Init] Attempting to load Embedding Model (BAAI/bge-large-en-v1.5) with device_map='auto'...")
-    try:
-        st.session_state.embedding_model = SentenceTransformer(
-            'BAAI/bge-large-en-v1.5', 
-            device_map="auto"
-        )
-        print(f"[Global Init] Embedding Model (BAAI/bge-large-en-v1.5) LOADED with device_map='auto'.")
-    except Exception as e:
-        error_str = str(e) if e else ""
-        if "device_map" in error_str.lower() and "unexpected keyword argument" in error_str.lower():
-            print("⚠️ [Global Init] device_map='auto' not supported for SentenceTransformer. Falling back to default device handling.")
-            try:
-                st.session_state.embedding_model = SentenceTransformer('BAAI/bge-large-en-v1.5')
-                print(f"[Global Init] Embedding Model (BAAI/bge-large-en-v1.5) LOADED (fallback device handling).")
-            except Exception as e_fallback:
-                error_msg = f"Failed to load Embedding Model (fallback): {str(e_fallback) if e_fallback else 'Unknown error'}"
-                print(f"❌ [Global Init] {error_msg}")
-                st.session_state.embedding_model_error = error_msg
-        else:
-            error_msg = f"Failed to load Embedding Model: {error_str}"
-            print(f"❌ [Global Init] {error_msg}")
-            st.session_state.embedding_model_error = error_msg
+# Sidebar configuration
+with st.sidebar:
+    st.title("⚙️ Configuration")
+    
+    # Ranking weights
+    st.subheader("Ranking Weights")
+    semantic_weight = st.slider("Semantic Similarity Weight", 0.0, 1.0, 0.7, 0.1)
+    keyword_weight = 1.0 - semantic_weight
+    st.write(f"Keyword Weight: {keyword_weight:.1f}")
+    
+    # Advanced options
+    st.subheader("Advanced Options")
+    top_k = st.selectbox("Number of results to display", options=[1, 2, 3, 4, 5], index=4)
+    
+    # LLM Settings
+    st.subheader("LLM Settings")
+    use_llm_explanations = st.checkbox("Generate AI Explanations", value=True)
+    if use_llm_explanations:
+        hf_token = st.text_input("Hugging Face Token (optional)", type="password", 
+                                help="Enter your HF token for better rate limits")
+    
+    st.markdown("---")
+    st.markdown("### 🤖 Advanced Pipeline")
+    st.markdown("- **Stage 1**: FAISS Recall (Top 50)")
+    st.markdown("- **Stage 2**: Cross-Encoder Re-ranking (Top 20)")
+    st.markdown("- **Stage 3**: BM25 Keyword Matching")
+    st.markdown("- **Stage 4**: LLM Intent Analysis")
+    st.markdown("- **Final**: Combined Scoring (Top 5)")
+    st.markdown("### 📊 Models Used")
+    st.markdown("- **Embedding**: BAAI/bge-large-en-v1.5")
+    st.markdown("- **Cross-Encoder**: ms-marco-MiniLM-L6-v2")
+    st.markdown("- **LLM Explanations**: Qwen/Qwen3-14B")
+    st.markdown("- **Intent Analysis**: Qwen/Qwen3-1.7B")
+    st.markdown("### 📈 Scoring Formula")
+    st.markdown("**Final Score = Cross-Encoder (0-1) + BM25 (0.1-0.2) + Intent (0-0.3)**")
 
-# Load Cross-Encoder Model (ms-marco-MiniLM-L6-v2)
-if st.session_state.cross_encoder is None and st.session_state.cross_encoder_error is None:
-    print("[Global Init] Attempting to load Cross-Encoder Model (ms-marco-MiniLM-L6-v2) with device_map='auto'...")
-    try:
-        st.session_state.cross_encoder = CrossEncoder(
-            'cross-encoder/ms-marco-MiniLM-L6-v2', 
-            device_map="auto"
-        )
-        print(f"[Global Init] Cross-Encoder Model (ms-marco-MiniLM-L6-v2) LOADED with device_map='auto'.")
-    except Exception as e:
-        error_str = str(e) if e else ""
-        if "device_map" in error_str.lower() and "unexpected keyword argument" in error_str.lower():
-            print("⚠️ [Global Init] device_map='auto' not supported for CrossEncoder. Falling back to default device handling.")
-            try:
-                st.session_state.cross_encoder = CrossEncoder('cross-encoder/ms-marco-MiniLM-L6-v2')
-                print(f"[Global Init] Cross-Encoder Model (ms-marco-MiniLM-L6-v2) LOADED (fallback device handling).")
-            except Exception as e_fallback:
-                error_msg = f"Failed to load Cross-Encoder Model (fallback): {str(e_fallback) if e_fallback else 'Unknown error'}"
-                print(f"❌ [Global Init] {error_msg}")
-                st.session_state.cross_encoder_error = error_msg
-        else:
-            error_msg = f"Failed to load Cross-Encoder Model: {error_str}"
-            print(f"❌ [Global Init] {error_msg}")
-            st.session_state.cross_encoder_error = error_msg
+# Initialize session state
+if 'embedding_model' not in st.session_state:
+    st.session_state.embedding_model = None
+if 'cross_encoder' not in st.session_state:
+    st.session_state.cross_encoder = None
+if 'results' not in st.session_state:
+    st.session_state.results = []
+if 'resume_texts' not in st.session_state:
+    st.session_state.resume_texts = []
+if 'file_names' not in st.session_state:
+    st.session_state.file_names = []
+if 'explanations_generated' not in st.session_state:
+    st.session_state.explanations_generated = False
+if 'current_job_description' not in st.session_state:
+    st.session_state.current_job_description = ""
+if 'qwen3_tokenizer' not in st.session_state:
+    st.session_state.qwen3_tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-14B")
+if 'qwen3_model' not in st.session_state:
+    st.session_state.qwen3_model = AutoModelForCausalLM.from_pretrained(
+        "Qwen/Qwen3-14B",
+        torch_dtype="auto",
+        device_map="auto"
+    )
+# Separate smaller model for intent analysis
+if 'qwen3_intent_tokenizer' not in st.session_state:
+    st.session_state.qwen3_intent_tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-1.7B")
+if 'qwen3_intent_model' not in st.session_state:
+    st.session_state.qwen3_intent_model = AutoModelForCausalLM.from_pretrained(
+        "Qwen/Qwen3-1.7B",
+        torch_dtype="auto",
+        device_map="auto"
+    )
 
-# Load Qwen3-4B Tokenizer and Model with 4-bit quantization (QwQ-32B style)
-if st.session_state.qwen3_4b_tokenizer is None and st.session_state.qwen3_4b_tokenizer_error is None:
-    print("[Global Init] Loading Qwen3-4B Tokenizer...")
+@st.cache_resource
+def load_embedding_model():
+    """Load and cache the BGE embedding model"""
     try:
-        st.session_state.qwen3_4b_tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B")
-        print("[Global Init] Qwen3-4B Tokenizer Loaded.")
+        with st.spinner("🔄 Loading BAAI/bge-large-en-v1.5 model..."):
+            model = SentenceTransformer('BAAI/bge-large-en-v1.5')
+            st.success("✅ Embedding model loaded successfully!")
+            return model
     except Exception as e:
-        error_msg = f"Failed to load Qwen3-4B Tokenizer: {str(e) if e else 'Unknown error'}"
-        print(f"❌ [Global Init] {error_msg}")
-        st.session_state.qwen3_4b_tokenizer_error = error_msg
+        st.error(f"❌ Error loading embedding model: {str(e)}")
+        return None
 
-if st.session_state.qwen3_4b_model is None and st.session_state.qwen3_4b_model_error is None:
-    print("[Global Init] Loading Qwen3-4B Model with 4-bit quantization...")
+@st.cache_resource
+def load_cross_encoder():
+    """Load and cache the Cross-Encoder model"""
     try:
-        quantization_config = BitsAndBytesConfig(
-            load_in_4bit=True,
-            bnb_4bit_quant_type="nf4",
-            bnb_4bit_compute_dtype=torch.float16,
-            bnb_4bit_use_double_quant=True
-        )
-        st.session_state.qwen3_4b_model = AutoModelForCausalLM.from_pretrained(
-            "Qwen/Qwen3-4B",
-            quantization_config=quantization_config,
-            device_map="auto",
-            trust_remote_code=True,
-            torch_dtype=torch.float16,
-            use_cache=True
-        )
-        print("[Global Init] Qwen3-4B Model Loaded with 4-bit quantization.")
+        with st.spinner("🔄 Loading Cross-Encoder ms-marco-MiniLM-L6-v2..."):
+            from sentence_transformers import CrossEncoder
+            model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L6-v2')
+            st.success("✅ Cross-Encoder model loaded successfully!")
+            return model
     except Exception as e:
-        error_msg = f"Failed to load Qwen3-4B Model: {str(e) if e else 'Unknown error'}"
-        print(f"❌ [Global Init] {error_msg}")
-        st.session_state.qwen3_4b_model_error = error_msg
-
-# --- End of Global Model Loading Section ---
-
-# --- Class Definitions and Helper Functions ---
+        st.error(f"❌ Error loading Cross-Encoder model: {str(e)}")
+        return None
 
 def generate_qwen3_response(prompt, tokenizer, model, max_new_tokens=200):
-    # ... (implementation of generate_qwen3_response)
     messages = [{"role": "user", "content": prompt}]
     text = tokenizer.apply_chat_template(
         messages,
         tokenize=False,
         add_generation_prompt=True,
-        enable_thinking=True # As per Qwen3-1.7B docs for thinking mode
+        enable_thinking=True
     )
     model_inputs = tokenizer([text], return_tensors="pt").to(model.device)
     generated_ids = model.generate(
@@ -155,32 +145,14 @@ def generate_qwen3_response(prompt, tokenizer, model, max_new_tokens=200):
     response = tokenizer.decode(output_ids, skip_special_tokens=True).strip("\n")
     return response
 
-class ResumeScreener: # Ensure this class definition is BEFORE it's instantiated
+class ResumeScreener:
     def __init__(self):
-        # ... (init logic as before, referencing st.session_state for models)
-        print("[ResumeScreener] Initializing with references to globally loaded models...")
-        self.embedding_model = st.session_state.get('embedding_model')
-        self.cross_encoder = st.session_state.get('cross_encoder')
-
-        if self.embedding_model:
-            print("[ResumeScreener] Embedding model reference set.")
-        else:
-            print("[ResumeScreener] Embedding model not available (check loading errors).")
-
-        if self.cross_encoder:
-            print("[ResumeScreener] Cross-encoder model reference set.")
-        else:
-            print("[ResumeScreener] Cross-encoder model not available (check loading errors).")
-        
-        print("[ResumeScreener] Initialization complete.")
-
-    # ... (all other methods of ResumeScreener: extract_text_from_file, get_embedding, 
-    #      calculate_bm25_scores, advanced_pipeline_ranking, faiss_recall, cross_encoder_rerank, 
-    #      add_bm25_scores, add_intent_scores, analyze_intent, calculate_final_scores, extract_skills)
-    # Make sure all methods are correctly indented within the class
+        # Load models
+        self.embedding_model = load_embedding_model()
+        self.cross_encoder = load_cross_encoder()
     
     def extract_text_from_file(self, file_path, file_type):
-        # ... (implementation)
+        """Extract text from various file types"""
         try:
             if file_type == "pdf":
                 with open(file_path, 'rb') as file:
@@ -188,165 +160,249 @@ class ResumeScreener: # Ensure this class definition is BEFORE it's instantiated
                         text = ""
                         for page in pdf.pages:
                             text += page.extract_text() or ""
+                        
                         if not text.strip():
+                            # Fallback to PyPDF2
                             file.seek(0)
                             reader = PyPDF2.PdfReader(file)
                             text = ""
-                            for page_num in range(len(reader.pages)):
-                                text += reader.pages[page_num].extract_text() or ""
+                            for page in reader.pages:
+                                text += page.extract_text() or ""
                         return text
+                        
             elif file_type == "docx":
                 doc = Document(file_path)
                 return " ".join([paragraph.text for paragraph in doc.paragraphs])
+                
             elif file_type == "txt":
                 with open(file_path, 'r', encoding='utf-8') as file:
                     return file.read()
+                    
             elif file_type == "csv":
                 with open(file_path, 'r', encoding='utf-8') as file:
                     csv_reader = csv.reader(file)
                     return " ".join([" ".join(row) for row in csv_reader])
+                    
         except Exception as e:
             st.error(f"Error extracting text from {file_path}: {str(e)}")
             return ""
     
     def get_embedding(self, text):
+        """Generate embedding for text using BGE model"""
         if self.embedding_model is None:
-            st.error("Embedding model is not available!")
-            return np.zeros(1024)
+            st.error("No embedding model loaded!")
+            return np.zeros(1024)  # BGE-large dimension
+            
         try:
-            if len(text) < 500:
+            # BGE models recommend adding instruction for retrieval
+            # For queries (job description)
+            if len(text) < 500:  # Assuming shorter texts are queries
                 text = "Represent this sentence for searching relevant passages: " + text
+            
+            # Truncate text to avoid memory issues
             text = text[:8192] if text else ""
-            embedding = self.embedding_model.encode(text, convert_to_numpy=True, normalize_embeddings=True)
+            
+            # Generate embedding
+            embedding = self.embedding_model.encode(text, 
+                                                  convert_to_numpy=True,
+                                                  normalize_embeddings=True)
             return embedding
+                    
         except Exception as e:
             st.error(f"Error generating embedding: {str(e)}")
-            return np.zeros(1024)
+            return np.zeros(1024)  # BGE-large dimension
     
     def calculate_bm25_scores(self, resume_texts, job_description):
+        """Calculate BM25 scores for keyword matching"""
         try:
             job_tokens = word_tokenize(job_description.lower())
             corpus = [word_tokenize(text.lower()) for text in resume_texts if text and text.strip()]
+            
             if not corpus:
                 return [0.0] * len(resume_texts)
+                
             bm25 = BM25Okapi(corpus)
             scores = bm25.get_scores(job_tokens)
             return scores.tolist()
+            
         except Exception as e:
             st.error(f"Error calculating BM25 scores: {str(e)}")
             return [0.0] * len(resume_texts)
     
-    def advanced_pipeline_ranking(self, resume_texts, job_description):
-        print("[Pipeline] Advanced Pipeline Ranking started.")
+    def advanced_pipeline_ranking(self, resume_texts, job_description, final_top_k=5):
+        """Advanced pipeline: FAISS recall -> Cross-encoder -> BM25 -> LLM intent -> Final ranking"""
         if not resume_texts:
             return []
-        st.info("🔍 Stage 1: FAISS Recall - Finding top candidates...")
+            
+        # Stage 1: FAISS Recall (Top 50)
+        st.write("🔍 **Stage 1**: FAISS Recall - Finding top 50 candidates...")
         top_50_indices = self.faiss_recall(resume_texts, job_description, top_k=50)
-        st.info("🎯 Stage 2: Cross-Encoder Re-ranking - Selecting top candidates...")
+        
+        # Stage 2: Cross-Encoder Re-ranking (Top 20)
+        st.write("🎯 **Stage 2**: Cross-Encoder Re-ranking - Selecting top 20...")
         top_20_results = self.cross_encoder_rerank(resume_texts, job_description, top_50_indices, top_k=20)
-        st.info("🔤 Stage 3: BM25 Keyword Matching...")
+        
+        # Stage 3: BM25 Keyword Matching
+        st.write("🔤 **Stage 3**: BM25 Keyword Matching...")
         top_20_with_bm25 = self.add_bm25_scores(resume_texts, job_description, top_20_results)
-        st.info("🤖 Stage 4: LLM Intent Analysis (Qwen3-4B)...")
+        
+        # Stage 4: LLM Intent Analysis (using Qwen3-1.7B)
+        st.write("🤖 **Stage 4**: LLM Intent Analysis...")
         top_20_with_intent = self.add_intent_scores(resume_texts, job_description, top_20_with_bm25)
-        st.info("🏆 Stage 5: Final Combined Ranking...")
+        
+        # Stage 5: Final Combined Ranking
+        st.write(f"🏆 **Stage 5**: Final Combined Ranking - Selecting top {final_top_k}...")
         final_results = self.calculate_final_scores(top_20_with_intent)
-        print("[Pipeline] Advanced Pipeline Ranking finished.")
-        return final_results[:st.session_state.get('top_k', 5)]
-
+        
+        return final_results[:final_top_k]  # Return top K as selected by user
+    
     def faiss_recall(self, resume_texts, job_description, top_k=50):
-        print("[faiss_recall] Method started.")
-        st.text("FAISS Recall: Embedding job description...")
-        job_embedding = self.get_embedding(job_description)
-        st.text(f"FAISS Recall: Embedding {len(resume_texts)} resumes...")
-        resume_embeddings = []
-        progress_bar = st.progress(0)
-        for i, text in enumerate(resume_texts):
-            if text:
-                embedding = self.embedding_model.encode(text[:8192], convert_to_numpy=True, normalize_embeddings=True)
-                resume_embeddings.append(embedding)
-            else:
-                resume_embeddings.append(np.zeros(1024))
-            progress_bar.progress((i + 1) / len(resume_texts))
-        progress_bar.empty()
-        resume_embeddings_np = np.array(resume_embeddings).astype('float32') # Renamed variable
-        if resume_embeddings_np.ndim == 1: # Handle case of single resume
-             resume_embeddings_np = resume_embeddings_np.reshape(1, -1)
-        if resume_embeddings_np.size == 0:
-            print("[faiss_recall] No resume embeddings to add to FAISS index.")
-            return [] # Or handle error appropriately
-
-        dimension = resume_embeddings_np.shape[1]
-        index = faiss.IndexFlatIP(dimension)
-        index.add(resume_embeddings_np)
-        job_embedding_np = job_embedding.reshape(1, -1).astype('float32') # Renamed variable
-        scores, indices = index.search(job_embedding_np, min(top_k, len(resume_texts)))
-        return indices[0].tolist()
-
+        """Stage 1: Use FAISS for initial recall to find top 50 resumes"""
+        try:
+            # Get job embedding
+            job_embedding = self.get_embedding(job_description)
+            
+            # Get resume embeddings
+            resume_embeddings = []
+            progress_bar = st.progress(0)
+            
+            for i, text in enumerate(resume_texts):
+                if text:
+                    embedding = self.embedding_model.encode(text[:8192], 
+                                                          convert_to_numpy=True,
+                                                          normalize_embeddings=True)
+                    resume_embeddings.append(embedding)
+                else:
+                    resume_embeddings.append(np.zeros(1024))
+                progress_bar.progress((i + 1) / len(resume_texts))
+            
+            progress_bar.empty()
+            
+            # Create FAISS index
+            resume_embeddings = np.array(resume_embeddings).astype('float32')
+            dimension = resume_embeddings.shape[1]
+            index = faiss.IndexFlatIP(dimension)  # Inner product for cosine similarity
+            index.add(resume_embeddings)
+            
+            # Search for top K
+            job_embedding = job_embedding.reshape(1, -1).astype('float32')
+            scores, indices = index.search(job_embedding, min(top_k, len(resume_texts)))
+            
+            return indices[0].tolist()
+            
+        except Exception as e:
+            st.error(f"Error in FAISS recall: {str(e)}")
+            # Fallback: return all indices
+            return list(range(min(top_k, len(resume_texts))))
+    
     def cross_encoder_rerank(self, resume_texts, job_description, top_50_indices, top_k=20):
-        print("[cross_encoder_rerank] Method started.")
-        if not self.cross_encoder:
-            st.error("Cross-encoder model is not available!")
-            return [(idx, 0.0) for idx in top_50_indices[:top_k]]
-        pairs = []
-        valid_indices = []
-        for idx in top_50_indices:
-            if idx < len(resume_texts) and resume_texts[idx]:
-                job_snippet = job_description[:512]
-                resume_snippet = resume_texts[idx][:512]
-                pairs.append([job_snippet, resume_snippet])
-                valid_indices.append(idx)
-        if not pairs:
+        """Stage 2: Use Cross-Encoder to re-rank top 50 and select top 20"""
+        try:
+            if not self.cross_encoder:
+                st.error("Cross-encoder not loaded!")
+                return [(idx, 0.0) for idx in top_50_indices[:top_k]]
+            
+            # Prepare pairs for cross-encoder
+            pairs = []
+            valid_indices = []
+            
+            for idx in top_50_indices:
+                if idx < len(resume_texts) and resume_texts[idx]:
+                    # Truncate texts for cross-encoder
+                    job_snippet = job_description[:512]
+                    resume_snippet = resume_texts[idx][:512]
+                    pairs.append([job_snippet, resume_snippet])
+                    valid_indices.append(idx)
+            
+            if not pairs:
+                return [(idx, 0.0) for idx in top_50_indices[:top_k]]
+            
+            # Get cross-encoder scores
+            progress_bar = st.progress(0)
+            scores = []
+            
+            # Process in batches to avoid memory issues
+            batch_size = 8
+            for i in range(0, len(pairs), batch_size):
+                batch = pairs[i:i+batch_size]
+                batch_scores = self.cross_encoder.predict(batch)
+                scores.extend(batch_scores)
+                progress_bar.progress(min(1.0, (i + batch_size) / len(pairs)))
+            
+            progress_bar.empty()
+            
+            # Combine indices with scores and sort
+            indexed_scores = list(zip(valid_indices, scores))
+            indexed_scores.sort(key=lambda x: x[1], reverse=True)
+            
+            return indexed_scores[:top_k]
+            
+        except Exception as e:
+            st.error(f"Error in cross-encoder re-ranking: {str(e)}")
             return [(idx, 0.0) for idx in top_50_indices[:top_k]]
-        st.text(f"Cross-Encoder: Preparing {len(pairs)} pairs for re-ranking...")
-        scores = []
-        batch_size = 8
-        progress_bar = st.progress(0)
-        for i in range(0, len(pairs), batch_size):
-            batch = pairs[i:i+batch_size]
-            batch_scores = self.cross_encoder.predict(batch)
-            scores.extend(batch_scores)
-            progress_bar.progress(min(1.0, (i + batch_size) / len(pairs)))
-        progress_bar.empty()
-        indexed_scores = list(zip(valid_indices, scores))
-        indexed_scores.sort(key=lambda x: x[1], reverse=True)
-        return indexed_scores[:top_k]
-
+    
     def add_bm25_scores(self, resume_texts, job_description, top_20_results):
-        st.text("BM25: Calculating keyword scores...")
-        top_20_texts = [resume_texts[idx] for idx, _ in top_20_results]
-        bm25_scores_raw = self.calculate_bm25_scores(top_20_texts, job_description)
-        if bm25_scores_raw and max(bm25_scores_raw) > 0:
-            max_bm25, min_bm25 = max(bm25_scores_raw), min(bm25_scores_raw)
-            if max_bm25 > min_bm25:
-                normalized_bm25 = [0.1 + 0.1 * (s - min_bm25) / (max_bm25 - min_bm25) for s in bm25_scores_raw]
+        """Stage 3: Add BM25 scores to top 20 resumes"""
+        try:
+            # Get texts for top 20
+            top_20_texts = [resume_texts[idx] for idx, _ in top_20_results]
+            
+            # Calculate BM25 scores
+            bm25_scores = self.calculate_bm25_scores(top_20_texts, job_description)
+            
+            # Normalize BM25 scores to 0.1-0.2 range
+            if bm25_scores and max(bm25_scores) > 0:
+                max_bm25 = max(bm25_scores)
+                min_bm25 = min(bm25_scores)
+                if max_bm25 > min_bm25:
+                    normalized_bm25 = [
+                        0.1 + 0.1 * (score - min_bm25) / (max_bm25 - min_bm25) 
+                        for score in bm25_scores
+                    ]
+                else:
+                    normalized_bm25 = [0.15] * len(bm25_scores)
             else:
-                normalized_bm25 = [0.15] * len(bm25_scores_raw)
-        else:
-            normalized_bm25 = [0.15] * len(top_20_results)
-        results_with_bm25 = []
-        for i, (idx, cross_score) in enumerate(top_20_results):
-            results_with_bm25.append((idx, cross_score, normalized_bm25[i] if i < len(normalized_bm25) else 0.15))
-        return results_with_bm25
-
+                normalized_bm25 = [0.15] * len(top_20_results)
+            
+            # Combine with existing results
+            results_with_bm25 = []
+            for i, (idx, cross_score) in enumerate(top_20_results):
+                bm25_score = normalized_bm25[i] if i < len(normalized_bm25) else 0.15
+                results_with_bm25.append((idx, cross_score, bm25_score))
+            
+            return results_with_bm25
+            
+        except Exception as e:
+            st.error(f"Error adding BM25 scores: {str(e)}")
+            return [(idx, cross_score, 0.15) for idx, cross_score in top_20_results]
+    
     def add_intent_scores(self, resume_texts, job_description, top_20_with_bm25):
-        st.text(f"LLM Intent: Analyzing intent for {len(top_20_with_bm25)} candidates (Qwen3-4B)...")
-        results_with_intent = []
-        progress_bar = st.progress(0)
-        for i, (idx, cross_score, bm25_score) in enumerate(top_20_with_bm25):
-            intent_score = self.analyze_intent(resume_texts[idx], job_description)
-            results_with_intent.append((idx, cross_score, bm25_score, intent_score))
-            progress_bar.progress((i + 1) / len(top_20_with_bm25))
-        progress_bar.empty()
-        return results_with_intent
-
+        """Stage 4: Add LLM intent analysis scores"""
+        try:
+            results_with_intent = []
+            progress_bar = st.progress(0)
+            
+            for i, (idx, cross_score, bm25_score) in enumerate(top_20_with_bm25):
+                intent_score = self.analyze_intent(resume_texts[idx], job_description)
+                results_with_intent.append((idx, cross_score, bm25_score, intent_score))
+                progress_bar.progress((i + 1) / len(top_20_with_bm25))
+            
+            progress_bar.empty()
+            return results_with_intent
+            
+        except Exception as e:
+            st.error(f"Error adding intent scores: {str(e)}")
+            return [(idx, cross_score, bm25_score, 0.1) for idx, cross_score, bm25_score in top_20_with_bm25]
+    
     def analyze_intent(self, resume_text, job_description):
-        print(f"[analyze_intent] Analyzing intent for one resume (Qwen3-4B)...")
-        st.text("LLM Intent: Analyzing intent (Qwen3-4B)...")
+        """Analyze candidate's intent using LLM"""
         try:
-            resume_snippet = resume_text[:15000]
-            job_snippet = job_description[:5000]
+            # Truncate texts
+            resume_snippet = resume_text[:1500] if len(resume_text) > 1500 else resume_text
+            job_snippet = job_description[:800] if len(job_description) > 800 else job_description
             
-            prompt = f"""You are given a job description and a candidate's resume. Your task is to analyze whether the candidate is likely seeking this specific type of job.
+            prompt = f"""You are given a job description and a candidate's resume.
+Clearly answer: "Is the candidate likely seeking this job? Respond with 'Yes', 'Maybe', or 'No' and give a brief justification."
 
 Job Description:
 {job_snippet}
@@ -354,145 +410,204 @@ Job Description:
 Candidate Resume:
 {resume_snippet}
 
-Please analyze the candidate's background, skills, experience, and career trajectory to determine if they would be genuinely interested in and likely to apply for this position.
-
-Consider:
-1. Does their experience align with the job requirements?
-2. Is this a logical career progression for them?
-3. Do their skills match what's needed?
-4. Would this role be appealing given their background?
-
-Think through your analysis step by step, then provide your final assessment.
-
-Respond with exactly one of these formats:
-- Intent: Yes (if they would likely seek this job)
-- Intent: Maybe (if it's uncertain or partially aligned)
-- Intent: No (if they would likely not seek this job)"""
-
-            # Check if models are available
-            if not st.session_state.get('qwen3_4b_tokenizer') or not st.session_state.get('qwen3_4b_model'):
-                st.warning("Qwen3-4B model not available, using fallback intent score.")
-                return 0.1
-                
-            response_text = generate_qwen3_response(
+Response format:
+Intent: [Yes/Maybe/No]
+Reason: [Brief justification]"""
+            
+            response = generate_qwen3_response(
                 prompt,
-                st.session_state.qwen3_4b_tokenizer,
-                st.session_state.qwen3_4b_model,
-                max_new_tokens=20000
+                st.session_state.qwen3_intent_tokenizer,
+                st.session_state.qwen3_intent_model,
+                max_new_tokens=100
             )
             
-            # Parse thinking content and intent decision
-            thinking_content = "No detailed thought process extracted."
-            intent_decision_part = response_text
-            think_start_tag = "<think>"
-            think_end_tag = "</think>"
-            start_index = response_text.find(think_start_tag)
-            end_index = response_text.rfind(think_end_tag)
-            if start_index != -1 and end_index != -1 and start_index < end_index:
-                thinking_content = response_text[start_index + len(think_start_tag):end_index].strip()
-                intent_decision_part = response_text[end_index + len(think_end_tag):].strip()
-            
-            response_lower = intent_decision_part.lower()
-            intent_score = 0.1  # Default "Maybe" score
-            
+            # Parse response
+            response_lower = response.lower()
             if 'intent: yes' in response_lower or 'intent:yes' in response_lower:
-                intent_score = 0.3
-            elif 'intent: no' in response_lower or 'intent:no' in response_lower:
-                intent_score = 0.0
+                return 0.3
             elif 'intent: maybe' in response_lower or 'intent:maybe' in response_lower:
-                intent_score = 0.1
-            
-            return intent_score
+                return 0.1
+            else:
+                return 0.0
+                
         except Exception as e:
-            st.warning(f"Error analyzing intent with Qwen3-4B: {str(e)}")
-            return 0.1
-
+            st.warning(f"Error analyzing intent: {str(e)}")
+            return 0.1  # Default to "Maybe"
+    
     def calculate_final_scores(self, results_with_all_scores):
-        final_results = []
-        for idx, cross_score, bm25_score, intent_score in results_with_all_scores:
-            normalized_cross = max(0, min(1, cross_score))
-            final_score = normalized_cross + bm25_score + intent_score
-            final_results.append({
-                'index': idx, 'cross_encoder_score': normalized_cross,
-                'bm25_score': bm25_score, 'intent_score': intent_score,
-                'final_score': final_score
-            })
-        final_results.sort(key=lambda x: x['final_score'], reverse=True)
-        return final_results
-
+        """Stage 5: Calculate final combined scores"""
+        try:
+            final_results = []
+            
+            for idx, cross_score, bm25_score, intent_score in results_with_all_scores:
+                # Normalize cross-encoder score to 0-1 range
+                normalized_cross = max(0, min(1, cross_score))
+                
+                # Final Score = Cross-Encoder (0-1) + BM25 (0.1-0.2) + Intent (0-0.3)
+                final_score = normalized_cross + bm25_score + intent_score
+                
+                final_results.append({
+                    'index': idx,
+                    'cross_encoder_score': normalized_cross,
+                    'bm25_score': bm25_score,
+                    'intent_score': intent_score,
+                    'final_score': final_score
+                })
+            
+            # Sort by final score
+            final_results.sort(key=lambda x: x['final_score'], reverse=True)
+            
+            return final_results
+            
+        except Exception as e:
+            st.error(f"Error calculating final scores: {str(e)}")
+            return []
+    
     def extract_skills(self, text, job_description):
-        # ... (implementation)
-        if not text: return []
-        common_skills = ["python", "java", "javascript", "react", "angular", "vue", "node.js", "express", "django", "flask", "spring", "sql", "nosql", "html", "css", "aws", "azure", "gcp", "docker", "kubernetes", "jenkins", "git", "github", "agile", "scrum", "jira", "ci/cd", "devops", "microservices", "rest", "api", "machine learning", "deep learning", "data science", "artificial intelligence", "tensorflow", "pytorch", "keras", "scikit-learn", "pandas", "numpy", "matplotlib", "seaborn", "jupyter", "r", "sas", "spss", "tableau", "powerbi", "excel", "mysql", "postgresql", "mongodb", "redis", "elasticsearch", "kafka", "rabbitmq", "spark", "hadoop", "hive", "airflow", "linux", "unix"]
+        """Extract skills from resume based on job description"""
+        if not text:
+            return []
+            
+        # Common tech skills
+        common_skills = [
+            "python", "java", "javascript", "react", "angular", "vue", "node.js", 
+            "express", "django", "flask", "spring", "sql", "nosql", "html", "css",
+            "aws", "azure", "gcp", "docker", "kubernetes", "jenkins", "git", "github",
+            "agile", "scrum", "jira", "ci/cd", "devops", "microservices", "rest", "api",
+            "machine learning", "deep learning", "data science", "artificial intelligence", 
+            "tensorflow", "pytorch", "keras", "scikit-learn", "pandas", "numpy", 
+            "matplotlib", "seaborn", "jupyter", "r", "sas", "spss", "tableau", "powerbi",
+            "excel", "mysql", "postgresql", "mongodb", "redis", "elasticsearch", 
+            "kafka", "rabbitmq", "spark", "hadoop", "hive", "airflow", "linux", "unix"
+        ]
+        
+        # Extract potential skills from job description
         job_words = set(word.lower() for word in word_tokenize(job_description) if len(word) > 2)
+        
+        # Find matching skills
         found_skills = []
         text_lower = text.lower()
+        
+        # Check common skills that appear in both resume and job description
         for skill in common_skills:
             if skill in text_lower and any(skill in job_word for job_word in job_words):
                 found_skills.append(skill)
+        
+        # Check for skills mentioned in job description
         for word in job_words:
-            if len(word) > 3 and word in text_lower and word not in found_skills and word not in ['with', 'have', 'that', 'this', 'from', 'what', 'when', 'where']:
-                found_skills.append(word)
-        return list(set(found_skills))[:15]
+            if len(word) > 3 and word in text_lower and word not in found_skills:
+                # Basic filter to avoid common words
+                if word not in ['with', 'have', 'that', 'this', 'from', 'what', 'when', 'where']:
+                    found_skills.append(word)
+        
+        return list(set(found_skills))[:15]  # Return top 15 unique skills
+    
+    def generate_simple_explanation(self, score, semantic_score, bm25_score, skills):
+        """Generate simple explanation for the match (fallback)"""
+        if score > 0.8:
+            quality = "excellent"
+        elif score > 0.6:
+            quality = "strong"
+        elif score > 0.4:
+            quality = "moderate"
+        else:
+            quality = "limited"
+        
+        explanation = f"This candidate shows {quality} alignment with the position (score: {score:.2f}). "
+        
+        if semantic_score > bm25_score:
+            explanation += f"The resume demonstrates strong conceptual relevance ({semantic_score:.2f}) suggesting good experience fit. "
+        else:
+            explanation += f"The resume has high keyword match ({bm25_score:.2f}) indicating direct skill alignment. "
+        
+        if skills:
+            explanation += f"Key matching competencies include: {', '.join(skills[:5])}."
+        
+        return explanation
+    
+    def generate_llm_explanation(self, resume_text, job_description, score, skills, max_retries=3):
+        """Generate detailed explanation using Qwen3-14B"""
+        if not st.session_state.qwen3_model:
+            return self.generate_simple_explanation(score, score, score, skills)
+        
+        # Truncate texts to manage token limits
+        resume_snippet = resume_text[:2000] if len(resume_text) > 2000 else resume_text
+        job_snippet = job_description[:1000] if len(job_description) > 1000 else job_description
+        
+        prompt = f"""You are an expert HR analyst. Analyze this individual candidate's resume against the job requirements and write EXACTLY 150 words explaining why this specific candidate is suitable for the position.
+
+Structure your 150-word analysis as follows:
+1. Experience alignment (40-50 words)
+2. Key strengths and skills match (40-50 words) 
+3. Unique value proposition (40-50 words)
+4. Overall recommendation (10-20 words)
+
+Job Requirements:
+{job_snippet}
+
+Candidate's Resume:
+{resume_snippet}
+
+Identified Matching Skills: {', '.join(skills[:10])}
+Compatibility Score: {score:.1%}
+
+Write a professional, detailed 150-word analysis for THIS INDIVIDUAL CANDIDATE:"""
+        
+        for attempt in range(max_retries):
+            try:
+                response = generate_qwen3_response(
+                    prompt,
+                    st.session_state.qwen3_tokenizer,
+                    st.session_state.qwen3_model,
+                    max_new_tokens=200
+                )
+                
+                # Extract the response and ensure it's about 150 words
+                explanation = response.strip()
+                word_count = len(explanation.split())
+                
+                # If response is close to 150 words (130-170), accept it
+                if 130 <= word_count <= 170:
+                    return explanation
+                
+                # If response is too short or too long, try again with adjusted prompt
+                if word_count < 130:
+                    # Response too short, try again
+                    continue
+                elif word_count > 170:
+                    # Response too long, truncate to approximately 150 words
+                    words = explanation.split()
+                    truncated = ' '.join(words[:150])
+                    # Add proper ending if truncated
+                    if not truncated.endswith('.'):
+                        truncated += '.'
+                    return truncated
+                
+                return explanation
+                
+            except Exception as e:
+                if attempt < max_retries - 1:
+                    time.sleep(2)  # Wait before retry
+                    continue
+                else:
+                    # Fallback to simple explanation
+                    return self.generate_simple_explanation(score, score, score, skills)
+        
+        # If all retries failed, use simple explanation
+        return self.generate_simple_explanation(score, score, score, skills)
 
 def create_download_link(df, filename="resume_screening_results.csv"):
-    # ... (implementation)
+    """Create download link for results"""
     csv = df.to_csv(index=False)
     b64 = base64.b64encode(csv.encode()).decode()
     return f'<a href="data:file/csv;base64,{b64}" download="{filename}" class="download-btn">📥 Download Results CSV</a>'
 
-# --- Sidebar Configuration (Must be after global model loading and class defs if it uses them) ---
-st.markdown("---")
-st.markdown("### 🤖 Advanced Pipeline")
-st.markdown("- **Stage 1**: FAISS Recall (Top 50)")
-st.markdown("- **Stage 2**: Cross-Encoder Re-ranking (Top 20)")
-st.markdown("- **Stage 3**: BM25 Keyword Matching")
-st.markdown("- **Stage 4**: LLM Intent Analysis (Qwen3-4B)")
-st.markdown("- **Final**: Combined Scoring") # Updated this line
-st.markdown("### 📊 Models Used")
-st.markdown("- **Embedding**: BAAI/bge-large-en-v1.5")
-st.markdown("- **Cross-Encoder**: ms-marco-MiniLM-L6-v2")
-st.markdown("- **LLM**: Qwen/Qwen3-4B (4-bit quantized)")
-st.markdown("### 📈 Scoring Formula")
-st.markdown("**Final Score = Cross-Encoder (0-1) + BM25 (0.1-0.2) + Intent (0-0.3)**")
-
-# --- Main App Interface (Must be after global model loading and class defs) ---
+# Main App Interface
 st.title("🎯 AI-Powered Resume Screener")
-# ... (Model Loading Status display as before)
-# ...
-st.markdown("*Find the perfect candidates using BAAI/bge-large-en-v1.5 embeddings and Qwen3-4B for intent analysis*")
-
-st.subheader("🤖 Model Loading Status")
-col1, col2 = st.columns(2)
-with col1:
-    if st.session_state.get('embedding_model_error'):
-        st.error(f"Embedding Model: {st.session_state.embedding_model_error}")
-    elif st.session_state.get('embedding_model'):
-        st.success("✅ Embedding Model (BAAI/bge-large-en-v1.5) loaded.")
-    else:
-        st.warning("⏳ Embedding Model loading or not found (check console).")
-    if st.session_state.get('cross_encoder_error'):
-        st.error(f"Cross-Encoder Model: {st.session_state.cross_encoder_error}")
-    elif st.session_state.get('cross_encoder'):
-        st.success("✅ Cross-Encoder Model (ms-marco-MiniLM-L6-v2) loaded.")
-    else:
-        st.warning("⏳ Cross-Encoder Model loading or not found (check console).")
-with col2:
-    if st.session_state.get('qwen3_4b_tokenizer_error'):
-        st.error(f"Qwen3-4B Tokenizer: {st.session_state.qwen3_4b_tokenizer_error}")
-    elif st.session_state.get('qwen3_4b_tokenizer'):
-        st.success("✅ Qwen3-4B Tokenizer loaded.")
-    else:
-        st.warning("⏳ Qwen3-4B Tokenizer loading or not found (check console).")
-    if st.session_state.get('qwen3_4b_model_error'):
-        st.error(f"Qwen3-4B Model: {st.session_state.qwen3_4b_model_error}")
-    elif st.session_state.get('qwen3_4b_model'):
-        st.success("✅ Qwen3-4B Model loaded (4-bit quantized).")
-    else:
-        st.warning("⏳ Qwen3-4B Model loading or not found (check console).")
+st.markdown("*Find the perfect candidates using BAAI/bge-large-en-v1.5 embeddings and Qwen3-14B explanations*")
 st.markdown("---")
 
-# Initialize screener (This line was causing NameError, ensure class is defined above)
+# Initialize screener
 screener = ResumeScreener()
 
 # Job Description Input
@@ -516,6 +631,7 @@ if st.session_state.resume_texts:
             st.session_state.resume_texts = []
             st.session_state.file_names = []
             st.session_state.results = []
+            st.session_state.explanations_generated = False
             st.session_state.current_job_description = ""
             st.rerun()
 
@@ -683,60 +799,115 @@ col1, col2 = st.columns([1, 1])
 
 with col1:
     if st.button("🚀 Advanced Pipeline Analysis", 
-                 disabled=not (job_description and st.session_state.resume_texts and 
-                              st.session_state.get('embedding_model') and
-                              st.session_state.get('cross_encoder') and
-                              st.session_state.get('qwen3_4b_model') and
-                              st.session_state.get('qwen3_4b_tokenizer')),
+                 disabled=not (job_description and st.session_state.resume_texts),
                  type="primary",
                  help="Run the complete 5-stage advanced pipeline"):
-        print("--- Advanced Pipeline Analysis Button Clicked ---")
-    if len(st.session_state.resume_texts) == 0:
-        st.error("❌ Please upload resumes first!")
-    elif not job_description.strip():
-        st.error("❌ Please enter a job description!")
-    else:
-        print("[UI Button] Pre-checks passed. Starting spinner and pipeline.")
-        with st.spinner("🚀 Running Advanced Pipeline Analysis..."):
-            st.text("Pipeline Initiated: Starting advanced analysis...")
-        try:
-            # Run the advanced pipeline
-            pipeline_results = screener.advanced_pipeline_ranking(
-                st.session_state.resume_texts, job_description
-            )
-            
-            # Prepare results for display
-            results = []
-            
-            for rank, result_data in enumerate(pipeline_results, 1):
-                idx = result_data['index']
-                name = st.session_state.file_names[idx]
-                text = st.session_state.resume_texts[idx]
-                
-                # Extract skills
-                skills = screener.extract_skills(text, job_description)
-                
-                results.append({
-                    'rank': rank,
-                    'name': name,
-                    'final_score': result_data['final_score'],
-                    'cross_encoder_score': result_data['cross_encoder_score'],
-                    'bm25_score': result_data['bm25_score'],
-                    'intent_score': result_data['intent_score'],
-                    'skills': skills,
-                    'text': text,
-                    'text_preview': text[:500] + "..." if len(text) > 500 else text
-                })
-            
-            # Store in session state
-            st.session_state.results = results
-            st.session_state.current_job_description = job_description
-            
-            st.success(f"🚀 Advanced pipeline complete! Found top {len(st.session_state.results)} candidates.")
-            st.text("Displaying Top Candidates...")
-        
-        except Exception as e:
-            st.error(f"❌ Error during analysis: {str(e)}")
+        if len(st.session_state.resume_texts) == 0:
+            st.error("❌ Please upload resumes first!")
+        elif not job_description.strip():
+            st.error("❌ Please enter a job description!")
+        else:
+            with st.spinner("🚀 Running Advanced Pipeline Analysis..."):
+                try:
+                    # Run the advanced pipeline
+                    pipeline_results = screener.advanced_pipeline_ranking(
+                        st.session_state.resume_texts, job_description, final_top_k=top_k
+                    )
+                    
+                    # Prepare results for display
+                    results = []
+                    
+                    for rank, result_data in enumerate(pipeline_results, 1):
+                        idx = result_data['index']
+                        name = st.session_state.file_names[idx]
+                        text = st.session_state.resume_texts[idx]
+                        
+                        # Extract skills
+                        skills = screener.extract_skills(text, job_description)
+                        
+                        results.append({
+                            'rank': rank,
+                            'name': name,
+                            'final_score': result_data['final_score'],
+                            'cross_encoder_score': result_data['cross_encoder_score'],
+                            'bm25_score': result_data['bm25_score'],
+                            'intent_score': result_data['intent_score'],
+                            'skills': skills,
+                            'text': text,
+                            'text_preview': text[:500] + "..." if len(text) > 500 else text,
+                            'explanation': None  # No detailed explanation yet
+                        })
+                    
+                    # Add simple explanations for now
+                    for result in results:
+                        result['explanation'] = screener.generate_simple_explanation(
+                            result['final_score'], 
+                            result['cross_encoder_score'], 
+                            result['bm25_score'], 
+                            result['skills']
+                        )
+                    
+                    # Store in session state
+                    st.session_state.results = results
+                    st.session_state.explanations_generated = False
+                    st.session_state.current_job_description = job_description
+                    
+                    st.success(f"🚀 Advanced pipeline complete! Found top {len(st.session_state.results)} candidates.")
+                    
+                except Exception as e:
+                    st.error(f"❌ Error during analysis: {str(e)}")
+
+# Second button: Generate AI explanations (slower, optional)
+with col2:
+    # Show this button only if we have results and LLM is enabled
+    show_explanation_button = (
+        st.session_state.results and 
+        use_llm_explanations and 
+        st.session_state.qwen3_model and
+        not st.session_state.explanations_generated
+    )
+    
+    if show_explanation_button:
+        if st.button("🤖 Generate AI Explanations", 
+                     type="secondary",
+                     help="Generate detailed 150-word explanations using Qwen3-14B (takes longer)"):
+            with st.spinner("🤖 Generating detailed AI explanations..."):
+                try:
+                    explanation_progress = st.progress(0)
+                    explanation_text = st.empty()
+                    
+                    for i, result in enumerate(st.session_state.results):
+                        explanation_text.text(f"🤖 Generating AI explanation for candidate {i+1}/{len(st.session_state.results)}...")
+                        
+                        llm_explanation = screener.generate_llm_explanation(
+                            result['text'],
+                            st.session_state.current_job_description,
+                            result['final_score'],
+                            result['skills']
+                        )
+                        result['explanation'] = llm_explanation
+                        
+                        explanation_progress.progress((i + 1) / len(st.session_state.results))
+                    
+                    explanation_progress.empty()
+                    explanation_text.empty()
+                    
+                    # Mark explanations as generated
+                    st.session_state.explanations_generated = True
+                    
+                    st.success(f"🤖 AI explanations generated for all {len(st.session_state.results)} candidates!")
+                    
+                except Exception as e:
+                    st.error(f"❌ Error generating explanations: {str(e)}")
+    
+    elif st.session_state.results and st.session_state.explanations_generated:
+        st.info("✅ AI explanations already generated!")
+    
+    elif st.session_state.results and not use_llm_explanations:
+        st.info("💡 Enable 'Generate AI Explanations' in sidebar to use this feature")
+    
+    elif st.session_state.results and not st.session_state.qwen3_model:
+        st.warning("⚠️ LLM model not available. Check your Hugging Face token.")
 
 # Display Results
 if st.session_state.results:
@@ -762,7 +933,7 @@ if st.session_state.results:
                 "Top Skills": ", ".join(result['skills'][:5])
             })
         
-                        summary_df = pd.DataFrame(summary_data)
+        summary_df = pd.DataFrame(summary_data)
         
         # Style the dataframe
         def color_scores(val):
@@ -805,6 +976,7 @@ if st.session_state.results:
                 "Intent_Score": result['intent_score'],
                 "Intent_Analysis": intent_text,
                 "Skills": "; ".join(result['skills']),
+                "AI_Explanation": result['explanation'],
                 "Resume_Preview": result['text_preview']
             })
         
@@ -835,6 +1007,9 @@ if st.session_state.results:
                             st.write(f"• {skill}")
                 
                 with col2:
+                    st.write("**💡 AI-Generated Match Analysis:**")
+                    st.info(result['explanation'])
+                    
                     st.write("**📄 Resume Preview:**")
                     st.text_area("", result['text_preview'], height=200, disabled=True, key=f"preview_{result['rank']}")
     
@@ -894,6 +1069,7 @@ with col1:
         st.session_state.resume_texts = []
         st.session_state.file_names = []
         st.session_state.results = []
+        st.session_state.explanations_generated = False
         st.session_state.current_job_description = ""
         st.success("✅ Resumes cleared!")
         st.rerun()
@@ -903,6 +1079,7 @@ with col2:
         st.session_state.resume_texts = []
         st.session_state.file_names = []
         st.session_state.results = []
+        st.session_state.explanations_generated = False
         st.session_state.current_job_description = ""
         
         if torch.cuda.is_available():
@@ -916,7 +1093,7 @@ st.markdown("---")
 st.markdown(
     """
     <div style='text-align: center; color: #666;'>
-        🚀 Powered by BAAI/bge-large-en-v1.5 & Qwen3-4B (4-bit) | Built with Streamlit
+        🚀 Powered by BAAI/bge-large-en-v1.5 & Qwen3-14B | Built with Streamlit
     </div>
     """, 
     unsafe_allow_html=True

requirements.txt

@@ -1,6 +1,6 @@
 streamlit==1.31.0
-transformers>=4.55.0
-torch>=2.3.0
+transformers>=4.51.0
+torch==2.1.2
 pdfplumber==0.10.1
 PyPDF2==3.0.1
 python-docx==1.0.1
@@ -10,9 +10,10 @@ rank-bm25==0.2.2
 pandas==2.1.3
 numpy==1.24.3
 tqdm==4.66.1
-huggingface-hub>=0.27.0
-bitsandbytes>=0.44.1
-accelerate>=0.27.2
+huggingface-hub==0.30.0
+bitsandbytes==0.44.1
+accelerate==0.27.2
 datasets==2.18.0
 sentence-transformers==2.7.0
-einops
+plotly==5.18.0
+einops