Update src/app.py

src/app.py

@@ -187,6 +187,7 @@ class ImprovedNLPProcessor:
                 (token.isalpha() or token in resume_keywords)):
                 filtered_tokens.append(token)
         
+        # Return only the most relevant terms
         return ' '.join(filtered_tokens[:max_terms])
 
 class ImprovedChatMemory:
@@ -202,6 +203,7 @@ class ImprovedChatMemory:
         }
         st.session_state.improved_chat_history.append(conversation)
         
+        # Keep only last 6 conversations
         if len(st.session_state.improved_chat_history) > 6:
             st.session_state.improved_chat_history = st.session_state.improved_chat_history[-6:]
     
@@ -210,131 +212,295 @@ class ImprovedChatMemory:
         if not st.session_state.improved_chat_history:
             return ""
         
+        # Only use the last conversation for context
         last_conv = st.session_state.improved_chat_history[-1]
-        last_topic = last_conv['user'][:30]
+        last_topic = last_conv['user'][:30]  # First 30 chars only
         return f"Previously discussed: {last_topic}"
 
 class ImprovedCPUChatbot:
     def __init__(self):
+        self.model_name = "distilgpt2"
+        self.model = None
+        self.tokenizer = None
+        self.pipeline = None
         self.nlp_processor = ImprovedNLPProcessor()
         self.memory = ImprovedChatMemory()
         self.is_loaded = False
         
-        # Comprehensive template responses for better coverage
+        # Predefined responses for common resume questions
         self.template_responses = {
             'experience': "To improve your experience section: Use bullet points with action verbs, quantify achievements with numbers, focus on results rather than duties, and tailor content to match job requirements.",
             'ats': "Make your resume ATS-friendly by: Using standard section headings, including relevant keywords naturally, avoiding images and complex formatting, using common fonts like Arial, and saving as PDF.",
             'skills': "Enhance your skills section by: Organizing technical and soft skills separately, matching skills to job descriptions, providing proficiency levels, and including both hard and soft skills relevant to your target role.",
             'keywords': "Add relevant keywords by: Studying job descriptions in your field, using industry-specific terms, including both acronyms and full terms, and incorporating them naturally throughout your resume.",
-            'format': "Improve resume formatting with: Clear section headings, consistent bullet points, readable fonts, appropriate white space, and a clean, professional layout that's easy to scan.",
-            'summary': "Write an effective summary by: Starting with your professional title, highlighting 2-3 key achievements, mentioning relevant skills, and keeping it to 3-4 lines maximum.",
-            'education': "Optimize your education section by: Listing degree, institution, and graduation year, including relevant coursework for entry-level positions, mentioning GPA if above 3.5, and adding academic achievements.",
-            'projects': "Showcase projects effectively by: Describing the problem solved, technologies used, your specific role, quantifiable results or impact, and linking to live demos or repositories when possible.",
-            'cover_letter': "Create compelling cover letters by: Addressing specific job requirements, showing knowledge of the company, highlighting relevant achievements, and ending with a strong call to action.",
-            'interview': "Prepare for interviews by: Researching the company and role, practicing STAR method responses, preparing questions to ask, and reviewing your resume thoroughly to discuss any point confidently."
+            'format': "Improve resume formatting with: Clear section headings, consistent bullet points, readable fonts, appropriate white space, and a clean, professional layout that's easy to scan."
         }
     
-    def initialize(self):
-        """Initialize the chatbot - lightweight version without model loading"""
+    @st.cache_resource
+    def load_model(_self):
+        """Load the model with better configuration"""
         try:
-            # Simulate brief initialization
-            import time
-            time.sleep(0.5)  # Brief delay to show initialization
-            self.is_loaded = True
-            return True
+            with st.spinner("Loading AI model (first time may take 2-3 minutes)..."):
+                tokenizer = AutoTokenizer.from_pretrained(_self.model_name)
+                tokenizer.pad_token = tokenizer.eos_token
+                
+                model = AutoModelForCausalLM.from_pretrained(
+                    _self.model_name,
+                    torch_dtype=torch.float32,
+                    low_cpu_mem_usage=True
+                )
+                
+                # Create pipeline with better parameters
+                text_generator = pipeline(
+                    "text-generation",
+                    model=model,
+                    tokenizer=tokenizer,
+                    device=-1,  # CPU only
+                    max_new_tokens=50,  # Reduced for better quality
+                    do_sample=True,
+                    temperature=0.8,
+                    top_p=0.85,
+                    top_k=50,
+                    repetition_penalty=1.2,  # Reduce repetition
+                    pad_token_id=tokenizer.eos_token_id,
+                    no_repeat_ngram_size=3  # Prevent 3-gram repetition
+                )
+                
+                return model, tokenizer, text_generator
         except Exception as e:
-            st.error(f"Failed to initialize: {str(e)}")
-            return False
+            st.error(f"Failed to load model: {str(e)}")
+            return None, None, None
+    
+    def initialize(self):
+        """Initialize the chatbot"""
+        if not self.is_loaded:
+            result = self.load_model()
+            if result[0] is not None:
+                self.model, self.tokenizer, self.pipeline = result
+                self.is_loaded = True
+                st.success("AI model loaded successfully!")
+                return True
+            else:
+                return False
+        return True
     
     def get_template_response(self, user_input: str) -> str:
-        """Enhanced template response matching"""
+        """Check if we can use a template response for common questions"""
         user_lower = user_input.lower()
         
-        # More comprehensive keyword matching
-        response_mapping = [
-            (['experience', 'work history', 'job history', 'employment', 'career'], 'experience'),
-            (['ats', 'applicant tracking', 'ats-friendly', 'system'], 'ats'),
-            (['skills', 'technical skills', 'abilities', 'competencies'], 'skills'),
-            (['keywords', 'keyword', 'terms', 'buzzwords'], 'keywords'),
-            (['format', 'formatting', 'layout', 'design', 'structure'], 'format'),
-            (['summary', 'objective', 'profile', 'about', 'intro'], 'summary'),
-            (['education', 'degree', 'university', 'college', 'school'], 'education'),
-            (['projects', 'portfolio', 'work samples', 'personal projects'], 'projects'),
-            (['cover letter', 'covering letter', 'application letter'], 'cover_letter'),
-            (['interview', 'interviews', 'interviewing', 'job interview'], 'interview')
-        ]
-        
-        for keywords, response_key in response_mapping:
-            if any(keyword in user_lower for keyword in keywords):
-                return self.template_responses[response_key]
-        
-        # General improvement queries
-        if any(phrase in user_lower for phrase in ['improve my resume', 'better resume', 'hire me', 'get hired', 'land job']):
+        # Check for common patterns
+        if any(word in user_lower for word in ['experience', 'work history', 'job history']):
+            return self.template_responses['experience']
+        elif any(word in user_lower for word in ['ats', 'applicant tracking', 'ats-friendly']):
+            return self.template_responses['ats']
+        elif any(word in user_lower for word in ['skills', 'technical skills', 'abilities']):
+            return self.template_responses['skills']
+        elif any(word in user_lower for word in ['keywords', 'keyword', 'terms']):
+            return self.template_responses['keywords']
+        elif any(word in user_lower for word in ['format', 'formatting', 'layout', 'design']):
+            return self.template_responses['format']
+        # Add general improvement patterns
+        elif any(phrase in user_lower for phrase in ['improve my resume', 'better resume', 'hire me', 'get hired', 'land job']):
             return "To improve your resume for HR success: Use a clear, professional format with standard headings. Tailor your content to match job descriptions. Quantify achievements with numbers. Include relevant keywords naturally. Keep it to 1-2 pages. Use bullet points with action verbs. Proofread carefully for errors."
+        elif any(word in user_lower for word in ['help', 'advice', 'tips', 'suggestions']):
+            return "Key resume tips: Match your resume to each job application. Use metrics to show your impact. Include both technical and soft skills. Write a compelling summary. Use reverse chronological order. Keep formatting clean and simple."
         
-        if any(phrase in user_lower for phrase in ['hr', 'hiring manager', 'recruiter', 'employer']):
-            return "To appeal to HR professionals: Use standard section headings they recognize. Include relevant keywords for ATS systems. Show clear career progression. Make it scannable with bullet points. Demonstrate measurable value and impact you can bring to their organization."
+        return None
+    
+    def create_simple_prompt(self, user_input: str, resume_context: str = "") -> str:
+        """Create a very simple, clear prompt"""
+        # Try template response first
+        template_response = self.get_template_response(user_input)
+        if template_response:
+            return template_response
         
-        if any(word in user_lower for word in ['help', 'advice', 'tips', 'suggestions']):
-            return "Key resume best practices: Customize for each job application. Use metrics to show impact. Include both technical and soft skills. Write compelling summaries. Use reverse chronological order. Keep formatting clean and professional. Focus on achievements, not just duties."
+        # Extract key terms
+        key_terms = self.nlp_processor.extract_key_terms(user_input)
         
-        return None
+        # Create simple prompt
+        if resume_context:
+            context_snippet = resume_context[:100].replace('\n', ' ')
+            prompt = f"Resume help: {context_snippet}\nQuestion: {user_input}\nAdvice:"
+        else:
+            prompt = f"Resume question: {user_input}\nHelpful advice:"
+        
+        return prompt
     
     def generate_response(self, user_input: str, resume_context: str = "") -> str:
-        """Generate response using templates and contextual advice"""
+        """Generate response with better quality control and timeout handling"""
         if not self.is_loaded:
-            return "Please initialize the AI assistant first by clicking 'Initialize AI'."
+            return "Please initialize the AI model first by clicking 'Initialize AI'."
         
-        # Try template response first
+        # Check for template response first (this should catch most questions)
         template_response = self.get_template_response(user_input)
         if template_response:
             self.memory.add_conversation(user_input, template_response)
             return template_response
         
-        # If no template match, provide contextual advice
-        contextual_response = self.get_contextual_advice(user_input, resume_context)
-        self.memory.add_conversation(user_input, contextual_response)
-        return contextual_response
+        # For non-template questions, provide a general helpful response instead of using the model
+        # This avoids the generation loops and stuck behavior
+        general_response = self.get_comprehensive_advice(user_input)
+        self.memory.add_conversation(user_input, general_response)
+        return general_response
     
-    def get_contextual_advice(self, user_input: str, resume_context: str) -> str:
-        """Provide advice based on resume context and user input"""
+    def get_comprehensive_advice(self, user_input: str) -> str:
+        """Provide comprehensive advice based on user input patterns"""
         user_lower = user_input.lower()
         
-        # Analyze resume context if available
-        if resume_context:
-            word_count = len(resume_context.split())
-            has_contact = '@' in resume_context or any(char.isdigit() for char in resume_context[:200])
-            has_bullets = any(marker in resume_context for marker in ['•', '*', '-', '→'])
-            
-            context_advice = []
-            
-            if word_count < 200:
-                context_advice.append("Your resume appears brief - consider expanding with more detailed achievements and responsibilities.")
-            elif word_count > 800:
-                context_advice.append("Your resume might be too lengthy - focus on the most relevant and impactful information.")
-            
-            if not has_contact:
-                context_advice.append("Ensure your contact information (email and phone) is clearly visible at the top.")
-            
-            if not has_bullets:
-                context_advice.append("Use bullet points to improve readability and make your achievements easier to scan.")
-            
-            if context_advice:
-                return "Based on your resume: " + " ".join(context_advice)
-        
-        # Default comprehensive advice based on query type
+        # Comprehensive resume improvement advice
         if any(phrase in user_lower for phrase in ['improve', 'better', 'enhance', 'optimize']):
-            return """To improve your resume effectiveness: 1) Tailor content to match specific job descriptions. 2) Use quantifiable achievements with numbers and percentages. 3) Start bullet points with strong action verbs like 'Led', 'Implemented', 'Increased'. 4) Keep it concise but comprehensive (1-2 pages). 5) Use clean, professional formatting with consistent styling. 6) Include both technical and soft skills relevant to your field. 7) Proofread thoroughly for grammar and spelling errors."""
+            return """To improve your resume effectiveness: 1) Tailor it to each job by matching keywords from the job description. 2) Use quantifiable achievements (increased sales by 25%, managed team of 10). 3) Start bullet points with strong action verbs. 4) Keep it concise - ideally 1-2 pages. 5) Use a clean, professional format with consistent styling. 6) Include relevant technical and soft skills. 7) Proofread carefully for any errors."""
         
+        # HR/hiring focused advice  
+        elif any(phrase in user_lower for phrase in ['hr', 'hire', 'hiring', 'recruiter', 'employer']):
+            return """To make your resume appealing to HR and hiring managers: 1) Use standard section headings they expect (Experience, Education, Skills). 2) Include relevant keywords to pass ATS screening. 3) Show clear career progression and achievements. 4) Make it easy to scan with bullet points and white space. 5) Demonstrate value you can bring to their organization. 6) Include measurable results and impacts."""
+        
+        # Job search and career advice
         elif any(phrase in user_lower for phrase in ['job', 'career', 'position', 'role', 'work']):
-            return """For successful job applications: 1) Research each company and role thoroughly. 2) Customize your resume for every application. 3) Highlight experiences most relevant to the specific position. 4) Use industry-specific terminology and keywords. 5) Show clear alignment between your background and their requirements. 6) Demonstrate both technical competencies and interpersonal skills. 7) Follow up professionally after applications."""
+            return """For job search success: 1) Customize your resume for each application. 2) Research the company and role requirements. 3) Highlight relevant experience and skills prominently. 4) Use industry-specific terminology. 5) Show how your background aligns with their needs. 6) Include both technical competencies and soft skills."""
         
-        elif any(word in user_lower for word in ['why', 'what', 'how', 'when', 'where']):
-            return """Resume fundamentals: Focus on achievements over duties, use specific numbers when possible, maintain consistent formatting, tailor content for each application, include relevant keywords naturally, keep information current and accurate, and ensure easy readability with clear section headings."""
+        # General help
+        else:
+            return """Key resume best practices: Use a professional format with clear headings. Lead with your strongest qualifications. Include relevant keywords naturally. Quantify achievements with specific numbers. Keep descriptions concise but impactful. Ensure error-free writing and consistent formatting. Focus on what value you bring to employers."""
+    
+    def get_general_advice(self, user_input: str) -> str:
+        """Fallback advice for when model fails"""
+        user_lower = user_input.lower()
+        if 'experience' in user_lower:
+            return "Focus on achievements with numbers, use action verbs, and show results."
+        elif 'skill' in user_lower:
+            return "List skills that match the job description and organize them by category."
+        elif 'ats' in user_lower:
+            return "Use standard headings, include keywords, and avoid complex formatting."
+        else:
+            return "Make sure your resume is clear, relevant to the job, and easy to read."
+    
+    def clean_response_thoroughly(self, response: str, user_input: str) -> str:
+        """Thoroughly clean the generated response"""
+        if not response or len(response.strip()) < 5:
+            return self.get_general_advice(user_input)
+        
+        # Remove common problematic patterns
+        response = re.sub(r'\|[^|]*\|', '', response)  # Remove pipe-separated content
+        response = re.sub(r'Advice:\s*', '', response)  # Remove "Advice:" repetition
+        response = re.sub(r'\s+', ' ', response)  # Replace multiple spaces
+        response = re.sub(r'[.]{2,}', '.', response)  # Replace multiple periods
+        
+        # Split into sentences and filter
+        sentences = [s.strip() for s in response.split('.') if s.strip()]
+        good_sentences = []
+        
+        seen_content = set()
+        for sentence in sentences[:2]:  # Max 2 sentences
+            if (len(sentence) > 15 and 
+                sentence.lower() not in seen_content and
+                not sentence.lower().startswith(('you are', 'i am', 'as a', 'how do')) and
+                'advice' not in sentence.lower()):
+                
+                good_sentences.append(sentence)
+                seen_content.add(sentence.lower())
         
+        if good_sentences:
+            response = '. '.join(good_sentences)
+            if not response.endswith('.'):
+                response += '.'
         else:
-            return """Key resume principles: Use professional formatting with clear headings. Lead with your strongest qualifications. Include relevant keywords naturally throughout. Quantify achievements with specific metrics. Keep descriptions concise but impactful. Ensure error-free writing and consistent style. Focus on the value you can bring to potential employers."""
+            response = self.get_general_advice(user_input)
+        
+        return response.strip()
 
+def create_improved_chat_interface(resume_context: str = ""):
+    """Create improved chat interface"""
+    
+    st.header("AI Resume Assistant")
+    
+    # Initialize chatbot
+    if 'improved_chatbot' not in st.session_state:
+        st.session_state.improved_chatbot = ImprovedCPUChatbot()
+    
+    chatbot = st.session_state.improved_chatbot
+    
+    # Model initialization
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        st.info("Using DistilGPT2 with improved response quality")
+    
+    with col2:
+        if st.button("Initialize AI", type="primary"):
+            chatbot.initialize()
+    
+    # Chat interface
+    if chatbot.is_loaded:
+        st.success("AI Ready")
+        
+        # Quick questions
+        st.subheader("Quick Questions")
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("How to improve experience section?"):
+                st.session_state.quick_question = "What's wrong with my experience section?"
+        
+        with col2:
+            if st.button("Make resume ATS-friendly?"):
+                st.session_state.quick_question = "How do I make it more ATS-friendly?"
+        
+        col3, col4 = st.columns(2)
+        with col3:
+            if st.button("Add better keywords?"):
+                st.session_state.quick_question = "What keywords should I add?"
+        
+        with col4:
+            if st.button("Improve skills section?"):
+                st.session_state.quick_question = "How can I improve my skills section?"
+        
+        # Chat input
+        user_question = st.text_input(
+            "Ask about your resume:",
+            value=st.session_state.get('quick_question', ''),
+            placeholder="How can I improve my resume?",
+            key="improved_chat_input"
+        )
+        
+        # Send button and clear
+        col1, col2 = st.columns([1, 3])
+        with col1:
+            send_clicked = st.button("Send", type="primary")
+        with col2:
+            if st.button("Clear Chat"):
+                st.session_state.improved_chat_history = []
+                if 'quick_question' in st.session_state:
+                    del st.session_state.quick_question
+                st.experimental_rerun()
+        
+        # Generate response
+        if send_clicked and user_question.strip():
+            with st.spinner("Generating advice..."):
+                response = chatbot.generate_response(user_question, resume_context)
+                if 'quick_question' in st.session_state:
+                    del st.session_state.quick_question
+                st.experimental_rerun()
+        
+        # Display chat history
+        if st.session_state.improved_chat_history:
+            st.subheader("💬 Conversation")
+            
+            for conv in reversed(st.session_state.improved_chat_history[-3:]):  # Show last 3
+                st.markdown(f"**You:** {conv['user']}")
+                st.markdown(f"**AI:** {conv['bot']}")
+                st.caption(f"Time: {conv['timestamp']}")
+                st.divider()
+    
+    else:
+        st.warning("Click 'Initialize AI' to start chatting")
+        
+        with st.expander("Improved Features"):
+            st.markdown("""
+            **Model**: DistilGPT2 with enhanced parameters
+            **Response time**: 1-3 seconds
+            **Quality**: Significantly improved over basic version
+            """)
 @st.cache_resource
 def download_nltk_data():
     try:
@@ -700,114 +866,6 @@ class ResumeAnalyzer:
         buffer.seek(0)
         return buffer
 
-def create_improved_chat_interface(resume_context: str = ""):
-    """Create improved chat interface with better UI"""
-    
-    st.markdown('<h3 class="section-header">AI Resume Assistant</h3>', unsafe_allow_html=True)
-    
-    # Initialize chatbot
-    if 'improved_chatbot' not in st.session_state:
-        st.session_state.improved_chatbot = ImprovedCPUChatbot()
-    
-    chatbot = st.session_state.improved_chatbot
-    
-    # Model status and initialization
-    col1, col2 = st.columns([3, 1])
-    
-    with col1:
-        if chatbot.is_loaded:
-            display_alert_box("AI Assistant is ready to help with your resume questions", "success")
-        else:
-            display_alert_box("Click 'Initialize AI' to start the assistant", "info")
-    
-    with col2:
-        if st.button("Initialize AI", type="primary", use_container_width=True):
-            with st.spinner("Initializing AI model..."):
-                if chatbot.initialize():
-                    st.success("AI model loaded successfully!")
-                    st.rerun()
-                else:
-                    st.error("Failed to initialize AI model")
-    
-    if chatbot.is_loaded:
-        # Quick questions section
-        st.markdown('<h4 class="section-header">Quick Questions</h4>', unsafe_allow_html=True)
-        
-        quick_questions = [
-            ("Experience Section Help", "How can I improve my experience section?"),
-            ("ATS Optimization", "How do I make my resume ATS-friendly?"),
-            ("Keywords & Skills", "What keywords should I include?"),
-            ("Format & Layout", "How should I format my resume?")
-        ]
-        
-        cols = st.columns(2)
-        for i, (title, question) in enumerate(quick_questions):
-            with cols[i % 2]:
-                if st.button(title, use_container_width=True):
-                    st.session_state.quick_question = question
-        
-        # Chat input section
-        st.markdown('<h4 class="section-header">Ask a Question</h4>', unsafe_allow_html=True)
-        
-        user_question = st.text_input(
-            "Type your resume question here:",
-            value=st.session_state.get('quick_question', ''),
-            placeholder="How can I improve my resume for better results?",
-            key="improved_chat_input"
-        )
-        
-        # Action buttons
-        col1, col2, col3 = st.columns([1, 1, 2])
-        with col1:
-            send_clicked = st.button("Send Question", type="primary", use_container_width=True)
-        with col2:
-            if st.button("Clear Chat", use_container_width=True):
-                st.session_state.improved_chat_history = []
-                if 'quick_question' in st.session_state:
-                    del st.session_state.quick_question
-                st.rerun()
-        
-        # Generate response
-        if send_clicked and user_question.strip():
-            with st.spinner("Generating personalized advice..."):
-                response = chatbot.generate_response(user_question, resume_context)
-                if 'quick_question' in st.session_state:
-                    del st.session_state.quick_question
-                st.rerun()
-        
-        # Display conversation history
-        if st.session_state.improved_chat_history:
-            st.markdown('<h4 class="section-header">Conversation History</h4>', unsafe_allow_html=True)
-            
-            for conv in reversed(st.session_state.improved_chat_history[-3:]):
-                with st.container():
-                    st.markdown(f"**Question:** {conv['user']}")
-                    st.markdown(f"**Answer:** {conv['bot']}")
-                    st.caption(f"Asked at: {conv['timestamp']}")
-                    st.divider()
-    
-    else:
-        # Information about the AI assistant
-        st.markdown('<h4 class="section-header">About the AI Assistant</h4>', unsafe_allow_html=True)
-        
-        with st.expander("Features and Capabilities", expanded=True):
-            st.markdown("""
-            **The AI Resume Assistant provides:**
-            
-            **Instant Expert Advice** - Get immediate answers to common resume questions
-            
-            **Personalized Recommendations** - Tailored advice based on your specific resume content
-            
-            **Quick Response Options** - Pre-built answers for the most frequently asked questions
-            
-            **Conversation Memory** - The assistant remembers your previous questions in the current session
-            
-            **Model Information:**
-            - Uses DistilGPT2 with optimized parameters for resume advice
-            - Runs locally on CPU for privacy and speed
-            - Enhanced with expert knowledge templates for common scenarios
-            """)
-
 def main():
     st.set_page_config(
         page_title="Professional Resume Analyzer",