Update src/app.py

src/app.py

@@ -36,21 +36,18 @@ try:
     SPACY_AVAILABLE = True
 except ImportError:
     SPACY_AVAILABLE = False
-    st.warning("spaCy not installed. Some advanced NLP features will be limited.")
 
 try:
     from fuzzywuzzy import fuzz, process
     FUZZYWUZZY_AVAILABLE = True
 except ImportError:
     FUZZYWUZZY_AVAILABLE = False
-    st.warning("fuzzywuzzy not installed. Using basic string matching instead.")
 
 try:
     import language_tool_python
     GRAMMAR_TOOL_AVAILABLE = True
 except ImportError:
     GRAMMAR_TOOL_AVAILABLE = False
-    st.warning("language_tool_python not installed. Grammar checking will be disabled.")
 
 # ML imports
 from sklearn.feature_extraction.text import TfidfVectorizer
@@ -73,6 +70,91 @@ from typing import Dict, List
 # Set seed for reproducibility
 set_seed(42)
 
+# Custom CSS for better UI
+def load_custom_css():
+    st.markdown("""
+    <style>
+    .main {
+        padding-top: 2rem;
+    }
+    
+    .metric-card {
+        background-color: #f8f9fa;
+        border: 1px solid #dee2e6;
+        border-radius: 8px;
+        padding: 1rem;
+        margin: 0.5rem 0;
+        text-align: center;
+    }
+    
+    .metric-value {
+        font-size: 2rem;
+        font-weight: bold;
+        color: #28a745;
+    }
+    
+    .metric-label {
+        font-size: 0.9rem;
+        color: #6c757d;
+        margin-top: 0.5rem;
+    }
+    
+    .warning-box {
+        background-color: #fff3cd;
+        border-left: 4px solid #ffc107;
+        padding: 1rem;
+        margin: 1rem 0;
+    }
+    
+    .success-box {
+        background-color: #d4edda;
+        border-left: 4px solid #28a745;
+        padding: 1rem;
+        margin: 1rem 0;
+    }
+    
+    .error-box {
+        background-color: #f8d7da;
+        border-left: 4px solid #dc3545;
+        padding: 1rem;
+        margin: 1rem 0;
+    }
+    
+    .info-box {
+        background-color: #d1ecf1;
+        border-left: 4px solid #17a2b8;
+        padding: 1rem;
+        margin: 1rem 0;
+    }
+    
+    .skill-tag {
+        display: inline-block;
+        background-color: #e9ecef;
+        border-radius: 4px;
+        padding: 0.25rem 0.5rem;
+        margin: 0.25rem;
+        font-size: 0.875rem;
+    }
+    
+    .section-header {
+        border-bottom: 2px solid #dee2e6;
+        padding-bottom: 0.5rem;
+        margin-bottom: 1rem;
+    }
+    
+    .nav-pills {
+        background-color: #f8f9fa;
+        border-radius: 8px;
+        padding: 0.5rem;
+        margin-bottom: 1rem;
+    }
+    
+    .sidebar .sidebar-content {
+        background-color: #f8f9fa;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
 class ImprovedNLPProcessor:
     def __init__(self):
         self.setup_nltk()
@@ -105,7 +187,6 @@ 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:
@@ -121,7 +202,6 @@ 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:]
     
@@ -130,9 +210,8 @@ 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]  # First 30 chars only
+        last_topic = last_conv['user'][:30]
         return f"Previously discussed: {last_topic}"
 
 class ImprovedCPUChatbot:
@@ -145,7 +224,6 @@ class ImprovedCPUChatbot:
         self.memory = ImprovedChatMemory()
         self.is_loaded = False
         
-        # 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.",
@@ -158,7 +236,7 @@ class ImprovedCPUChatbot:
     def load_model(_self):
         """Load the model with better configuration"""
         try:
-            with st.spinner("Loading AI model (first time may take 2-3 minutes)..."):
+            with st.spinner("Loading AI model..."):
                 tokenizer = AutoTokenizer.from_pretrained(_self.model_name)
                 tokenizer.pad_token = tokenizer.eos_token
                 
@@ -168,20 +246,19 @@ class ImprovedCPUChatbot:
                     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
+                    device=-1,
+                    max_new_tokens=50,
                     do_sample=True,
                     temperature=0.8,
                     top_p=0.85,
                     top_k=50,
-                    repetition_penalty=1.2,  # Reduce repetition
+                    repetition_penalty=1.2,
                     pad_token_id=tokenizer.eos_token_id,
-                    no_repeat_ngram_size=3  # Prevent 3-gram repetition
+                    no_repeat_ngram_size=3
                 )
                 
                 return model, tokenizer, text_generator
@@ -196,7 +273,6 @@ class ImprovedCPUChatbot:
             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
@@ -206,7 +282,6 @@ class ImprovedCPUChatbot:
         """Check if we can use a template response for common questions"""
         user_lower = user_input.lower()
         
-        # 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']):
@@ -217,7 +292,6 @@ class ImprovedCPUChatbot:
             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']):
@@ -225,38 +299,16 @@ class ImprovedCPUChatbot:
         
         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
-        
-        # Extract key terms
-        key_terms = self.nlp_processor.extract_key_terms(user_input)
-        
-        # 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 with better quality control and timeout handling"""
+        """Generate response with better quality control"""
         if not self.is_loaded:
             return "Please initialize the AI model first by clicking 'Initialize AI'."
         
-        # 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
         
-        # 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
@@ -265,169 +317,18 @@ class ImprovedCPUChatbot:
         """Provide comprehensive advice based on user input patterns"""
         user_lower = user_input.lower()
         
-        # 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 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 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."""
         
-        # 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:
-            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("""
-            **Improvements in this version:**
-            
-            ✅ **Better response quality** - Reduced repetition and loops
-            ✅ **Template responses** - Instant answers for common questions  
-            ✅ **Improved prompting** - Cleaner, more focused prompts
-            ✅ **Response filtering** - Better cleaning of generated text
-            ✅ **Quick questions** - Pre-defined buttons for common queries
-            
-            **Model**: DistilGPT2 with enhanced parameters
-            **Response time**: 1-3 seconds
-            **Quality**: Significantly improved over basic version
-            """)
-# Download NLTK data if not already present
 @st.cache_resource
 def download_nltk_data():
     try:
@@ -441,7 +342,6 @@ def download_nltk_data():
             nltk.download('wordnet', quiet=True)
             nltk.download('punkt_tab', quiet=True)
 
-# Initialize tools with better error handling
 @st.cache_resource
 def init_tools():
     download_nltk_data()
@@ -500,6 +400,25 @@ def basic_grammar_check(text):
     
     return [type('MockError', (), {'message': issue}) for issue in issues]
 
+def display_metric_card(title, value, description=""):
+    """Display a metric in a card format"""
+    st.markdown(f"""
+    <div class="metric-card">
+        <div class="metric-value">{value}</div>
+        <div class="metric-label">{title}</div>
+        {f"<small>{description}</small>" if description else ""}
+    </div>
+    """, unsafe_allow_html=True)
+
+def display_alert_box(message, alert_type="info"):
+    """Display alert box with different types"""
+    box_class = f"{alert_type}-box"
+    st.markdown(f"""
+    <div class="{box_class}">
+        {message}
+    </div>
+    """, unsafe_allow_html=True)
+
 class ResumeAnalyzer:
     def __init__(self):
         self.nlp, self.grammar_tool = init_tools()
@@ -601,25 +520,6 @@ class ResumeAnalyzer:
         except:
             return "Error extracting TXT text"
 
-    def preprocess_text(self, text):
-        """Clean and preprocess text"""
-        text = re.sub(r'[^a-zA-Z\s]', '', text)
-        text = text.lower()
-        
-        try:
-            tokens = word_tokenize(text)
-        except LookupError:
-            tokens = text.split()
-        
-        try:
-            tokens = [self.lemmatizer.lemmatize(token) for token in tokens 
-                     if token not in self.stop_words and len(token) > 2]
-        except LookupError:
-            tokens = [token for token in tokens 
-                     if token not in self.stop_words and len(token) > 2]
-        
-        return tokens
-
     def extract_sections(self, text):
         """Extract different sections from resume"""
         sections = {}
@@ -740,64 +640,6 @@ class ResumeAnalyzer:
         
         return min(score, 100)
 
-    def generate_persona_summary(self, text, sections):
-        """Generate AI-powered persona summary"""
-        education = sections.get('education', '')
-        experience = sections.get('experience', '')
-        skills = sections.get('skills', '')
-        
-        degree_match = re.search(r'(bachelor|master|phd|degree|engineering|science|business)', 
-                                education.lower())
-        experience_years = len(re.findall(r'\b\d{4}\b', experience))
-        
-        summary_parts = []
-        
-        if degree_match:
-            degree = degree_match.group(1).title()
-            summary_parts.append(f"A {degree} graduate")
-        else:
-            summary_parts.append("A dedicated professional")
-        
-        if experience_years > 0:
-            summary_parts.append(f"with {experience_years}+ years of experience")
-        
-        tech_skills, soft_skills = self.extract_skills(text)
-        if tech_skills:
-            main_skills = ', '.join(tech_skills[:3])
-            summary_parts.append(f"skilled in {main_skills}")
-        
-        if 'project' in text.lower():
-            summary_parts.append("with hands-on project experience")
-        
-        summary = ' '.join(summary_parts) + "."
-        
-        return summary
-
-    def get_claude_analysis(self, text, sections, job_role, ats_score, match_percentage):
-        """Get detailed analysis from Claude - called only once"""
-        context = f"""
-        Resume Analysis Data:
-        - Target Role: {job_role}
-        - ATS Score: {ats_score}/100
-        - Role Match: {match_percentage:.1f}%
-        - Word Count: {len(text.split())}
-        - Sections Found: {list(sections.keys())}
-        - Resume Text (excerpt): {text[:1000]}
-        """
-        
-        prompt = f"""
-        Please provide a concise analysis of this resume for a {job_role} position. Include:
-        
-        1. **Strengths**: What are the standout elements?
-        2. **Improvement Areas**: Specific areas that need work
-        3. **Missing Elements**: Key components that should be added
-        4. **Action Items**: 3-5 concrete steps to improve the resume
-        
-        Keep the analysis professional, constructive, and under 500 words.
-        """
-        
-        return self.chatbot.generate_response(prompt, context, max_tokens=800)
-
     def create_pdf_report(self, text, sections, ats_score, match_percentage, selected_role, tech_skills, soft_skills, found_keywords):
         """Create a PDF report using ReportLab"""
         buffer = io.BytesIO()
@@ -851,16 +693,129 @@ class ResumeAnalyzer:
         doc.build(story)
         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="AI Resume Analyzer with Chatbot",
+        page_title="Professional Resume Analyzer",
         page_icon="📄",
-        layout="wide"
+        layout="wide",
+        initial_sidebar_state="expanded"
     )
     
-    st.title("🚀 AI-Powered Resume Analyzer with Chatbot Assistant")
-    st.markdown("Upload your resume and get comprehensive analysis with AI-powered insights!")
+    # Load custom CSS
+    load_custom_css()
+    
+    # Header section
+    st.title("Professional Resume Analyzer")
+    st.markdown("**Comprehensive resume analysis with AI-powered insights and personalized recommendations**")
     
     # Initialize analyzer
     try:
@@ -869,34 +824,68 @@ def main():
         st.error(f"Error initializing analyzer: {str(e)}")
         return
     
-    # Sidebar for job role selection
-    st.sidebar.header("Analysis Settings")
-    job_roles = list(analyzer.job_keywords.keys())
-    selected_role = st.sidebar.selectbox("Select Target Job Role:", job_roles)
+    # Sidebar configuration
+    with st.sidebar:
+        st.header("Analysis Configuration")
+        
+        job_roles = list(analyzer.job_keywords.keys())
+        selected_role = st.selectbox(
+            "Target Job Role:",
+            job_roles,
+            help="Select the job role you're targeting to get relevant keyword analysis"
+        )
+        
+        st.divider()
+        
+        st.header("Analysis Features")
+        st.markdown("""
+        **Comprehensive Analysis:**
+        - ATS Compatibility Score
+        - Skills Detection & Matching
+        - Section Structure Analysis
+        - Grammar & Language Check
+        - Keyword Optimization
+        - PDF Report Generation
+        
+        **AI Assistant:**
+        - Personalized Resume Advice
+        - Quick Expert Recommendations
+        - Interactive Q&A
+        """)
     
-    # Initialize session state for chat
+    # Initialize session state
     if "chat_history" not in st.session_state:
         st.session_state.chat_history = []
     if "resume_context" not in st.session_state:
         st.session_state.resume_context = ""
     if "analysis_done" not in st.session_state:
         st.session_state.analysis_done = False
-    if "claude_analysis" not in st.session_state:
-        st.session_state.claude_analysis = ""
     
-    # File upload section
-    st.header("📁 Upload Your Resume")
+    # Main content area
+    st.markdown('<h2 class="section-header">Upload Resume</h2>', unsafe_allow_html=True)
+    
     uploaded_file = st.file_uploader(
-        "Choose your resume file", 
+        "Select your resume file",
         type=['pdf', 'docx', 'txt'],
-        help="Supported formats: PDF, DOCX, TXT"
+        help="Supported formats: PDF, DOCX, TXT (Maximum size: 200MB)"
     )
     
     if uploaded_file is not None:
+        # Show file information
+        file_details = {
+            "Filename": uploaded_file.name,
+            "File size": f"{uploaded_file.size / 1024:.1f} KB",
+            "File type": uploaded_file.type
+        }
+        
+        with st.expander("File Information", expanded=False):
+            for key, value in file_details.items():
+                st.write(f"**{key}:** {value}")
+        
         # Extract text based on file type
         file_type = uploaded_file.type
         
-        with st.spinner("Extracting text from resume..."):
+        with st.spinner("Processing your resume..."):
             try:
                 if file_type == "application/pdf":
                     text = analyzer.extract_text_from_pdf(uploaded_file)
@@ -909,8 +898,7 @@ def main():
                 return
         
         if "Error" not in text and text.strip():
-            # Process the resume
-            st.success("✅ Resume uploaded and processed successfully!")
+            st.success("Resume processed successfully!")
             
             # Store resume context for chatbot
             st.session_state.resume_context = text
@@ -922,214 +910,435 @@ def main():
                 found_keywords, match_percentage = analyzer.keyword_matching(text, selected_role)
                 ats_score = analyzer.calculate_ats_score(text, sections)
                 
-                # Create tabs for different analyses
-                tab1, tab2, tab3, tab4, tab5 = st.tabs([
-                    "📊 Overview", "🎯 Skills Analysis", "📝 Section Breakdown", 
-                    "🔍 ATS Analysis", "📋 Report & Suggestions"
+                # Create navigation tabs
+                tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
+                    "Summary", "Skills Analysis", "Section Review", 
+                    "ATS Analysis", "Recommendations", "AI Assistant"
                 ])
                 
                 with tab1:
-                    st.header("Resume Overview")
+                    st.markdown('<h3 class="section-header">Resume Summary</h3>', unsafe_allow_html=True)
+                    
+                    # Key metrics row
+                    metric_cols = st.columns(4)
+                    
+                    with metric_cols[0]:
+                        display_metric_card("ATS Score", f"{ats_score}/100")
                     
+                    with metric_cols[1]:
+                        display_metric_card("Role Match", f"{match_percentage:.1f}%")
+                    
+                    with metric_cols[2]:
+                        word_count = len(text.split())
+                        display_metric_card("Word Count", f"{word_count}")
+                    
+                    with metric_cols[3]:
+                        sections_found = len([s for s in sections.values() if s])
+                        display_metric_card("Sections", f"{sections_found}/6")
+                    
+                    st.divider()
+                    
+                    # Overall assessment
+                    overall_score = (ats_score + match_percentage) / 2
+                    
+                    if overall_score >= 80:
+                        display_alert_box("Excellent resume! Your resume shows strong alignment with the target role and good ATS compatibility.", "success")
+                    elif overall_score >= 60:
+                        display_alert_box("Good foundation with room for improvement. Focus on adding more role-specific keywords and optimizing for ATS.", "warning")
+                    else:
+                        display_alert_box("Significant improvements needed. Consider restructuring sections, adding relevant keywords, and improving ATS compatibility.", "error")
+                    
+                    # Quick insights
                     col1, col2 = st.columns(2)
                     
                     with col1:
-                        # Basic stats
-                        word_count = len(text.split())
-                        char_count = len(text)
+                        st.subheader("Strengths Identified")
+                        strengths = []
+                        
+                        if ats_score >= 70:
+                            strengths.append("Good ATS compatibility")
+                        if match_percentage >= 60:
+                            strengths.append("Strong role alignment")
+                        if len(tech_skills) >= 5:
+                            strengths.append("Rich technical skills")
+                        if len(soft_skills) >= 3:
+                            strengths.append("Good soft skills coverage")
                         
-                        st.metric("Word Count", word_count)
-                        st.metric("Character Count", char_count)
-                        st.metric("Sections Found", len([s for s in sections.values() if s]))
+                        if strengths:
+                            for strength in strengths:
+                                st.write(f"✓ {strength}")
+                        else:
+                            st.write("Focus on the recommendations to improve your resume")
                     
                     with col2:
-                        st.write("**Found Keywords:**")
+                        st.subheader("Keywords Found")
                         if found_keywords:
-                            for keyword in found_keywords:
-                                st.write(f"✅ {keyword}")
+                            # Display as tags
+                            keyword_html = ""
+                            for keyword in found_keywords[:10]:  # Show first 10
+                                keyword_html += f'<span class="skill-tag">{keyword}</span>'
+                            st.markdown(keyword_html, unsafe_allow_html=True)
                         else:
-                            st.write("No role-specific keywords found.")
-                    
-                    # Missing keywords
-                    missing_keywords = [kw for kw in analyzer.job_keywords[selected_role] 
-                                      if kw not in found_keywords]
-                    if missing_keywords:
-                        st.subheader("Suggested Keywords to Add")
-                        for keyword in missing_keywords[:10]:  # Show top 10
-                            st.write(f"➕ {keyword}")
+                            st.write("No role-specific keywords detected")
                 
-                # Add the missing tab2 (Skills Analysis)
                 with tab2:
-                    st.header("Skills Analysis")
+                    st.markdown('<h3 class="section-header">Skills Analysis</h3>', unsafe_allow_html=True)
                     
                     col1, col2 = st.columns(2)
                     
                     with col1:
-                        st.subheader("Technical Skills")
+                        st.subheader("Technical Skills Detected")
                         if tech_skills:
+                            # Create skill tags
+                            tech_html = ""
                             for skill in tech_skills:
-                                st.write(f"🔧 {skill}")
+                                tech_html += f'<span class="skill-tag">{skill}</span>'
+                            st.markdown(tech_html, unsafe_allow_html=True)
+                            
+                            st.metric("Technical Skills Count", len(tech_skills))
                         else:
-                            st.write("No technical skills detected")
+                            display_alert_box("No technical skills detected. Consider adding a dedicated skills section.", "warning")
                     
                     with col2:
-                        st.subheader("Soft Skills")
+                        st.subheader("Soft Skills Detected")
                         if soft_skills:
+                            # Create skill tags
+                            soft_html = ""
                             for skill in soft_skills:
-                                st.write(f"🤝 {skill}")
+                                soft_html += f'<span class="skill-tag">{skill}</span>'
+                            st.markdown(soft_html, unsafe_allow_html=True)
+                            
+                            st.metric("Soft Skills Count", len(soft_skills))
                         else:
-                            st.write("No soft skills detected")
+                            display_alert_box("Limited soft skills detected. Consider highlighting leadership, communication, and teamwork skills.", "info")
                     
-                    # Role matching
-                    st.subheader(f"Match for {selected_role}")
-                    st.metric("Match Percentage", f"{match_percentage:.1f}%")
+                    st.divider()
                     
-                    if match_percentage >= 70:
-                        st.success("🎯 Excellent match!")
-                    elif match_percentage >= 50:
-                        st.warning("⚠️ Good match with room for improvement")
-                    else:
-                        st.error("❌ Low match - consider adding more relevant skills")
+                    # Role-specific analysis
+                    st.subheader(f"Analysis for {selected_role}")
+                    
+                    progress_col, details_col = st.columns([1, 2])
+                    
+                    with progress_col:
+                        # Create a progress bar for match percentage
+                        st.metric("Match Percentage", f"{match_percentage:.1f}%")
+                        st.progress(match_percentage / 100)
+                    
+                    with details_col:
+                        if match_percentage >= 70:
+                            display_alert_box("Excellent match for this role! Your skills align well with industry expectations.", "success")
+                        elif match_percentage >= 50:
+                            display_alert_box("Good match with opportunities for improvement. Consider adding more role-specific skills.", "warning")
+                        else:
+                            display_alert_box("Limited match detected. Focus on adding more relevant skills and keywords for this role.", "error")
+                    
+                    # Missing keywords
+                    missing_keywords = [kw for kw in analyzer.job_keywords[selected_role] 
+                                      if kw not in found_keywords]
+                    
+                    if missing_keywords:
+                        st.subheader("Suggested Keywords to Add")
+                        missing_html = ""
+                        for keyword in missing_keywords[:15]:  # Show top 15
+                            missing_html += f'<span class="skill-tag" style="background-color: #fff3cd;">{keyword}</span>'
+                        st.markdown(missing_html, unsafe_allow_html=True)
                 
                 with tab3:
-                    st.header("Section Breakdown")
+                    st.markdown('<h3 class="section-header">Section Structure Review</h3>', unsafe_allow_html=True)
+                    
+                    # Section status overview
+                    st.subheader("Section Completeness")
                     
+                    section_status = []
                     for section_name, section_content in sections.items():
-                        if section_content:
-                            with st.expander(f"📋 {section_name.title()} Section"):
-                                st.write(section_content)
-                        else:
-                            st.warning(f"⚠️ {section_name.title()} section not found or empty")
+                        status = "Complete" if section_content and len(section_content) > 50 else "Missing/Incomplete"
+                        section_status.append({
+                            "Section": section_name.title(),
+                            "Status": status,
+                            "Length": len(section_content) if section_content else 0
+                        })
                     
-                    # Section recommendations
-                    st.subheader("Section Recommendations")
-                    missing_sections = [name for name, content in sections.items() if not content]
-                    if missing_sections:
-                        st.write("**Missing or Empty Sections:**")
-                        for section in missing_sections:
-                            st.write(f"❌ {section.title()}")
-                    else:
-                        st.success("✅ All major sections are present!")
+                    status_df = pd.DataFrame(section_status)
+                    st.dataframe(status_df, use_container_width=True, hide_index=True)
+                    
+                    st.divider()
+                    
+                    # Detailed section content
+                    st.subheader("Section Content")
+                    
+                    for section_name, section_content in sections.items():
+                        with st.expander(f"{section_name.title()} Section", expanded=False):
+                            if section_content:
+                                st.text_area(
+                                    f"{section_name.title()} content:",
+                                    section_content,
+                                    height=150,
+                                    disabled=True,
+                                    key=f"section_{section_name}"
+                                )
+                            else:
+                                st.warning(f"No {section_name} section found or content is too brief")
                 
                 with tab4:
-                    st.header("ATS Analysis")
+                    st.markdown('<h3 class="section-header">ATS Compatibility Analysis</h3>', unsafe_allow_html=True)
                     
-                    col1, col2 = st.columns(2)
+                    # ATS score breakdown
+                    col1, col2 = st.columns([1, 2])
                     
                     with col1:
-                        st.metric("ATS Score", f"{ats_score}/100")
+                        st.metric("Overall ATS Score", f"{ats_score}/100")
+                        st.progress(ats_score / 100)
                         
-                        # ATS Score interpretation
+                        # Score interpretation
                         if ats_score >= 80:
-                            st.success("🤖 Excellent ATS compatibility!")
+                            st.success("Excellent ATS compatibility")
                         elif ats_score >= 60:
-                            st.warning("⚠️ Good ATS compatibility")
+                            st.warning("Good ATS compatibility")
                         else:
-                            st.error("❌ Poor ATS compatibility")
+                            st.error("Needs ATS optimization")
                     
                     with col2:
-                        # Grammar check
-                        st.subheader("Grammar Check")
+                        st.subheader("ATS Checklist")
+                        
+                        # Check various ATS factors
+                        checklist_items = []
+                        
+                        # Section check
+                        required_sections = ['experience', 'education', 'skills']
+                        sections_present = sum(1 for section in required_sections 
+                                             if sections.get(section) and len(sections[section]) > 50)
+                        checklist_items.append(("Essential sections present", sections_present >= 2))
+                        
+                        # Content length check
+                        word_count = len(text.split())
+                        checklist_items.append(("Appropriate length (300-800 words)", 300 <= word_count <= 800))
+                        
+                        # Contact information
+                        email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+                        phone_pattern = r'(\+\d{1,3}[-.\s]?)?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}'
+                        has_email = bool(re.search(email_pattern, text))
+                        has_phone = bool(re.search(phone_pattern, text))
+                        checklist_items.append(("Contact information included", has_email or has_phone))
+                        
+                        # Bullet points
+                        bullet_patterns = [r'•', r'◦', r'\*', r'-\s', r'→']
+                        bullet_count = sum(len(re.findall(pattern, text)) for pattern in bullet_patterns)
+                        checklist_items.append(("Uses bullet points", bullet_count >= 2))
+                        
+                        # Keywords
+                        checklist_items.append(("Contains relevant keywords", len(found_keywords) >= 3))
+                        
+                        for item, passed in checklist_items:
+                            status = "✓" if passed else "✗"
+                            color = "green" if passed else "red"
+                            st.markdown(f"<span style='color:{color}'>{status} {item}</span>", unsafe_allow_html=True)
+                    
+                    st.divider()
+                    
+                    # Grammar analysis
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.subheader("Language Quality Check")
                         grammar_issues = analyzer.grammar_check(text)
                         
                         if len(grammar_issues) == 0:
-                            st.success("✅ No grammar issues detected!")
+                            display_alert_box("No grammar issues detected", "success")
                         else:
-                            st.warning(f"⚠️ {len(grammar_issues)} potential issues found")
-                            with st.expander("View Grammar Issues"):
-                                for issue in grammar_issues[:10]:  # Show first 10
-                                    st.write(f"• {issue.message}")
+                            display_alert_box(f"{len(grammar_issues)} potential issues found", "warning")
+                    
+                    with col2:
+                        if grammar_issues:
+                            st.subheader("Issues Detected")
+                            for issue in grammar_issues[:5]:  # Show first 5
+                                st.write(f"• {issue.message}")
+                    
+                    # ATS optimization tips
+                    st.subheader("ATS Optimization Recommendations")
                     
-                    # ATS Tips
-                    st.subheader("ATS Optimization Tips")
-                    ats_tips = [
-                        "Use standard section headings (Experience, Education, Skills)",
+                    tips = [
+                        "Use standard section headings: Experience, Education, Skills, etc.",
                         "Include relevant keywords naturally throughout your resume",
-                        "Use bullet points for easy scanning",
-                        "Avoid images, tables, and complex formatting",
-                        "Use standard fonts (Arial, Calibri, Times New Roman)",
-                        "Save as PDF to preserve formatting",
-                        "Include contact information at the top"
+                        "Use bullet points to improve readability and scanning",
+                        "Avoid images, graphics, tables, and complex formatting",
+                        "Use standard fonts like Arial, Calibri, or Times New Roman",
+                        "Save your resume as a PDF to preserve formatting",
+                        "Include your contact information prominently at the top",
+                        "Use consistent formatting throughout the document"
                     ]
                     
-                    for tip in ats_tips:
-                        st.write(f"💡 {tip}")
+                    for i, tip in enumerate(tips, 1):
+                        st.write(f"{i}. {tip}")
                 
                 with tab5:
-                    st.header("Comprehensive Analysis & Suggestions")
+                    st.markdown('<h3 class="section-header">Personalized Recommendations</h3>', unsafe_allow_html=True)
                     
-                    # Manual recommendations (removed Claude dependency)
-                    st.subheader("📝 Recommendations")
+                    # Generate specific recommendations
                     recommendations = []
                     
+                    # ATS-based recommendations
                     if ats_score < 70:
                         recommendations.extend([
-                            "Add more bullet points to improve readability",
-                            "Ensure contact information is clearly visible",
-                            "Use standard section headings"
+                            "Improve ATS compatibility by adding more bullet points throughout your resume",
+                            "Ensure your contact information (email and phone) is clearly visible at the top",
+                            "Use standard section headings that ATS systems can easily recognize"
                         ])
                     
+                    # Role matching recommendations
                     if match_percentage < 60:
-                        recommendations.append(f"Include more {selected_role}-specific keywords")
+                        recommendations.append(f"Increase your match for {selected_role} by incorporating more industry-specific keywords")
                     
+                    # Skills recommendations
                     if not tech_skills:
-                        recommendations.append("Add a dedicated technical skills section")
+                        recommendations.append("Add a dedicated Technical Skills section to highlight your capabilities")
+                    
+                    if not soft_skills:
+                        recommendations.append("Incorporate more soft skills like leadership, communication, and teamwork throughout your experience descriptions")
+                    
+                    # Section recommendations
+                    missing_sections = [name for name, content in sections.items() if not content]
+                    if missing_sections:
+                        recommendations.append(f"Consider adding these missing sections: {', '.join(missing_sections)}")
                     
                     if not sections.get('projects'):
-                        recommendations.append("Consider adding a projects section")
+                        recommendations.append("Add a Projects section to showcase hands-on experience and technical skills")
+                    
+                    # Display recommendations
+                    if recommendations:
+                        for i, rec in enumerate(recommendations, 1):
+                            st.write(f"**{i}.** {rec}")
+                    else:
+                        display_alert_box("Your resume looks great! Minor tweaks based on specific job applications can further improve your success rate.", "success")
                     
-                    for i, rec in enumerate(recommendations, 1):
-                        st.write(f"{i}. {rec}")
+                    st.divider()
                     
-                    # Generate PDF report
-                    st.subheader("📄 Download Report")
-                    if st.button("Generate PDF Report"):
-                        try:
-                            pdf_buffer = analyzer.create_pdf_report(
-                                text, sections, ats_score, match_percentage, 
-                                selected_role, tech_skills, soft_skills, found_keywords
-                            )
-                            
-                            st.download_button(
-                                label="📥 Download PDF Report",
-                                data=pdf_buffer.getvalue(),
-                                file_name=f"resume_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf",
-                                mime="application/pdf"
-                            )
-                        except Exception as e:
-                            st.error(f"Error generating PDF: {str(e)}")
+                    # Action plan
+                    st.subheader("Priority Action Plan")
+                    
+                    action_items = []
+                    
+                    if ats_score < 60:
+                        action_items.append("**High Priority:** Improve ATS compatibility - focus on formatting and standard sections")
+                    
+                    if match_percentage < 50:
+                        action_items.append("**High Priority:** Add more role-specific keywords and skills")
+                    
+                    if not tech_skills and selected_role in ["Data Scientist", "Software Engineer", "DevOps Engineer"]:
+                        action_items.append("**Medium Priority:** Add comprehensive technical skills section")
+                    
+                    if len([s for s in sections.values() if s]) < 4:
+                        action_items.append("**Medium Priority:** Ensure all essential sections are complete and substantial")
+                    
+                    action_items.append("**Ongoing:** Customize your resume for each job application by matching keywords")
+                    
+                    for action in action_items:
+                        st.markdown(action)
+                    
+                    st.divider()
+                    
+                    # PDF report generation
+                    st.subheader("Download Detailed Report")
+                    
+                    col1, col2 = st.columns([2, 1])
+                    
+                    with col1:
+                        st.write("Generate a comprehensive PDF report with all analysis results, recommendations, and action items.")
+                    
+                    with col2:
+                        if st.button("Generate PDF Report", type="primary", use_container_width=True):
+                            try:
+                                with st.spinner("Generating report..."):
+                                    pdf_buffer = analyzer.create_pdf_report(
+                                        text, sections, ats_score, match_percentage, 
+                                        selected_role, tech_skills, soft_skills, found_keywords
+                                    )
+                                
+                                st.download_button(
+                                    label="Download Report",
+                                    data=pdf_buffer.getvalue(),
+                                    file_name=f"resume_analysis_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf",
+                                    mime="application/pdf",
+                                    use_container_width=True
+                                )
+                            except Exception as e:
+                                st.error(f"Error generating PDF: {str(e)}")
                 
-                # Chat Interface - Properly indented inside the file upload condition
-                st.markdown("---")
-                st.header("💬 Chat with Resume Assistant")
-                create_improved_chat_interface(st.session_state.get('resume_context', ''))
+                with tab6:
+                    # AI Chat Interface
+                    create_improved_chat_interface(st.session_state.get('resume_context', ''))
                 
             except Exception as e:
                 st.error(f"Error during analysis: {str(e)}")
                 st.error("Please check your resume format and try again.")
         
         else:
-            st.error("❌ Could not extract text from the uploaded file. Please check the file format and try again.")
+            st.error("Could not extract text from the uploaded file. Please check the file format and try again.")
     
     else:
-        # Show instructions when no file is uploaded
-        st.info("👆 Please upload your resume to get started!")
+        # Instructions and information when no file is uploaded
+        st.markdown('<h3 class="section-header">Getting Started</h3>', unsafe_allow_html=True)
         
-        # Show sample analysis
-        with st.expander("📖 What you'll get:", expanded=True):
+        col1, col2 = st.columns([2, 1])
+        
+        with col1:
+            st.subheader("How It Works")
             st.markdown("""
-            **Our AI-powered resume analyzer provides:**
+            **1. Upload Your Resume**
+            Upload your resume in PDF, DOCX, or TXT format using the file uploader above.
+            
+            **2. Select Target Role**
+            Choose your target job role from the sidebar to get relevant keyword analysis.
+            
+            **3. Get Comprehensive Analysis**
+            Review detailed analysis across multiple categories including ATS compatibility, skills matching, and section structure.
+            
+            **4. Get AI-Powered Recommendations**
+            Use the AI assistant for personalized advice and answers to your specific questions.
+            
+            **5. Download Report**
+            Generate and download a comprehensive PDF report with all findings and recommendations.
+            """)
+        
+        with col2:
+            st.subheader("Analysis Features")
+            
+            features = [
+                "ATS Compatibility Scoring",
+                "Skills Detection & Matching",
+                "Keyword Optimization",
+                "Section Structure Analysis",
+                "Grammar & Language Check",
+                "Role-Specific Recommendations",
+                "AI-Powered Chat Assistant",
+                "Downloadable PDF Reports"
+            ]
+            
+            for feature in features:
+                st.write(f"✓ {feature}")
+        
+        # Sample analysis preview
+        with st.expander("Preview: What You'll Get", expanded=False):
+            st.subheader("Sample Analysis Output")
+            
+            sample_cols = st.columns(3)
             
-            - **📊 Comprehensive Scoring**: ATS compatibility and role-specific matching scores
-            - **🎯 Skills Analysis**: Technical and soft skills identification
-            - **📝 Section Breakdown**: Detailed analysis of each resume section
-            - **🔍 ATS Optimization**: Tips to improve applicant tracking system compatibility
-            - **🤖 AI Chat Assistant**: Ask questions and get personalized advice
-            - **📄 PDF Report**: Downloadable analysis report
+            with sample_cols[0]:
+                display_metric_card("ATS Score", "85/100")
             
-            **Supported Formats**: PDF, DOCX, TXT
+            with sample_cols[1]:
+                display_metric_card("Role Match", "72%")
             
-            **Chat Feature**: AI chat assistance with local models
+            with sample_cols[2]:
+                display_metric_card("Overall", "A-")
+            
+            st.markdown("""
+            **You'll receive detailed analysis including:**
+            - Comprehensive scoring and metrics
+            - Section-by-section breakdown
+            - Specific improvement recommendations
+            - Missing keywords identification
+            - ATS optimization checklist
+            - AI-powered personalized advice
             """)
 
 if __name__ == "__main__":