Update app.py

app.py

@@ -1,520 +1,853 @@
-import streamlit as st
-import pandas as pd
-import re
-import json
-import nltk
-from nltk.corpus import stopwords
-from nltk.tokenize import word_tokenize
-import torch
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
-import time
 import os
-import docx2txt
 import io
+import streamlit as st
 import docx
+import docx2txt
+import tempfile
+import time
+import re
+import math
+import concurrent.futures
+import pandas as pd
+from functools import lru_cache
+from transformers import pipeline
 
-# Set page title and configuration
+# Set page title and hide sidebar
 st.set_page_config(
     page_title="Resume-Job Fit Analyzer",
-    page_icon="📊",
-    layout="wide"
+    initial_sidebar_state="collapsed"
 )
 
-# Download NLTK resources if needed
-@st.cache_resource
-def download_nltk_resources():
-    try:
-        nltk.data.find('tokenizers/punkt')
-        nltk.data.find('corpora/stopwords')
-    except LookupError:
-        nltk.download('punkt')
-        nltk.download('stopwords')
-    return stopwords.words('english')
-
-stop_words = download_nltk_resources()
+# Hide sidebar completely with custom CSS
+st.markdown("""
+<style>
+    [data-testid="collapsedControl"] {display: none;}
+    section[data-testid="stSidebar"] {display: none;}
+</style>
+""", unsafe_allow_html=True)
 
-# Load models
-@st.cache_resource
+#####################################
+# Preload Models
+#####################################
+@st.cache_resource(show_spinner=True)
 def load_models():
-    """Load and cache the NLP models"""
-    models = {}
-    
-    # Use BART for resume parsing
-    models['parser'] = pipeline(
-        "text2text-generation",
-        model="facebook/bart-base",  # This would be the fine-tuned model in production
-        device=0 if torch.cuda.is_available() else -1
-    )
-    
-    # Use Qwen for evaluation
-    models['evaluator'] = AutoModelForCausalLM.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
-    models['evaluator_tokenizer'] = AutoTokenizer.from_pretrained("Qwen/Qwen2.5-0.5B-Instruct")
-    
-    return models
+    """Load models at startup"""
+    with st.spinner("Loading AI models... This may take a minute on first run."):
+        models = {}
+        # Use bart-base for summarization
+        models['summarizer'] = pipeline(
+            "summarization", 
+            model="facebook/bart-base", 
+            max_length=100,
+            truncation=True
+        )
+        
+        # Load model for evaluation
+        models['evaluator'] = pipeline(
+            "text2text-generation", 
+            model="Qwen/Qwen2.5-0.5B-Instruct",
+            max_length=300
+        )
+        
+        return models
 
-# Read resume file
-def read_resume_file(uploaded_file):
-    """Extract text from uploaded resume file"""
-    file_extension = os.path.splitext(uploaded_file.name)[1].lower()
-    
-    if file_extension == ".txt":
-        # Text file
-        text = uploaded_file.read().decode('utf-8')
-        return text
-    
-    elif file_extension == ".docx":
-        # Modern Word document
+# Preload models immediately when app starts
+models = load_models()
+
+#####################################
+# Function: Extract Text from File
+#####################################
+@st.cache_data(show_spinner=False)
+def extract_text_from_file(file_obj):
+    """
+    Extract text from .docx and .doc files.
+    Returns the extracted text or an error message if extraction fails.
+    """
+    filename = file_obj.name
+    ext = os.path.splitext(filename)[1].lower()
+    text = ""
+
+    if ext == ".docx":
         try:
-            text = docx2txt.process(uploaded_file)
-            return text
+            document = docx.Document(file_obj)
+            text = "\n".join(para.text for para in document.paragraphs if para.text.strip())
         except Exception as e:
-            st.error(f"Error reading DOCX file: {str(e)}")
-            return None
-    
-    elif file_extension == ".doc":
-        # Legacy Word document - this is more complex
+            text = f"Error processing DOCX file: {e}"
+    elif ext == ".doc":
         try:
-            # For .doc files, we'll return a warning that the conversion might not be perfect
-            st.warning("Note: .doc files might not convert perfectly. For best results, upload .docx or .txt files.")
-            
-            # Save the uploaded file temporarily
-            with open("temp_file.doc", "wb") as f:
-                f.write(uploaded_file.getbuffer())
-            
-            # Use an external converter - this is a placeholder
-            # In a real implementation, you might want to use antiword, textract or similar
-            # Here we'll try using docx2txt as a fallback but it might not work well
+            # For .doc files, we need to save to a temp file
+            with tempfile.NamedTemporaryFile(delete=False, suffix='.doc') as temp_file:
+                temp_file.write(file_obj.getvalue())
+                temp_path = temp_file.name
+        
+            # Use docx2txt which is generally faster
             try:
-                text = docx2txt.process("temp_file.doc")
-            except:
-                # If that fails, try a very basic approach
-                with open("temp_file.doc", "rb") as f:
-                    content = f.read()
-                    text = content.decode('utf-8', errors='ignore')
-                    # Try to extract readable text by removing binary parts
-                    text = re.sub(r'[^\x20-\x7E\n\r\t]', '', text)
-            
-            # Clean up
-            if os.path.exists("temp_file.doc"):
-                os.remove("temp_file.doc")
-            
-            return text
+                text = docx2txt.process(temp_path)
+            except Exception:
+                text = "Could not process .doc file. Please convert to .docx format."
+        
+            # Clean up temp file
+            os.unlink(temp_path)
         except Exception as e:
-            st.error(f"Error reading DOC file: {str(e)}")
-            return None
-    
+            text = f"Error processing DOC file: {e}"
+    elif ext == ".txt":
+        try:
+            text = file_obj.getvalue().decode("utf-8")
+        except Exception as e:
+            text = f"Error processing TXT file: {e}"
     else:
-        st.error(f"Unsupported file format: {file_extension}")
-        return None
+        text = "Unsupported file type. Please upload a .docx, .doc, or .txt file."
+    
+    # Limit text size for faster processing
+    return text[:15000] if text else text
 
-# Extract skills from text
-def extract_skills(text, skill_keywords):
-    """Extract skills from text based on a predefined list of skills"""
-    found_skills = []
+#####################################
+# Functions for Information Extraction
+#####################################
+
+# Cache the extraction functions to avoid reprocessing
+@lru_cache(maxsize=32)
+def extract_name(text_start):
+    """Extract candidate name from the beginning of resume text"""
+    # Only use the first 500 characters to speed up processing
+    lines = text_start.split('\n')
+    
+    # Check first few non-empty lines for potential names
+    potential_name_lines = [line.strip() for line in lines[:5] if line.strip()]
+    
+    if potential_name_lines:
+        # First line is often the name if it's short and doesn't contain common headers
+        first_line = potential_name_lines[0]
+        if 5 <= len(first_line) <= 40 and not any(x in first_line.lower() for x in ["resume", "cv", "curriculum", "vitae", "profile"]):
+            return first_line
+    
+    # Look for lines that might contain a name
+    for line in potential_name_lines[:3]:
+        if len(line.split()) <= 4 and not any(x in line.lower() for x in ["address", "phone", "email", "resume", "cv"]):
+            return line
+
+    return "Unknown (please extract from resume)"
+
+def extract_age(text):
+    """Extract candidate age from resume text"""
+    # Simplified: just check a few common patterns
+    age_patterns = [
+        r'age:?\s*(\d{1,2})',
+        r'(\d{1,2})\s*years\s*old',
+    ]
+    
     text_lower = text.lower()
+    for pattern in age_patterns:
+        matches = re.search(pattern, text_lower)
+        if matches:
+            return matches.group(1)
+    
+    return "Not specified"
+
+def extract_industry(text, base_summary):
+    """Extract expected job industry from resume"""
+    # Simplified industry keywords focused on the most common ones
+    industry_keywords = {
+        "technology": ["software", "programming", "developer", "IT", "tech", "computer"],
+        "finance": ["banking", "financial", "accounting", "finance", "analyst"],
+        "healthcare": ["medical", "health", "hospital", "clinical", "nurse", "doctor"],
+        "education": ["teaching", "teacher", "professor", "education", "university"],
+        "marketing": ["marketing", "advertising", "digital marketing", "social media"],
+        "engineering": ["engineer", "engineering"],
+        "data science": ["data science", "machine learning", "AI", "analytics"],
+        "information systems": ["information systems", "ERP", "systems management"]
+    }
+    
+    # Count occurrences of industry keywords - using the summary to speed up
+    combined_text = base_summary.lower()
+    
+    counts = {}
+    for industry, keywords in industry_keywords.items():
+        counts[industry] = sum(combined_text.count(keyword.lower()) for keyword in keywords)
+    
+    # Get the industry with the highest count
+    if counts:
+        likely_industry = max(counts.items(), key=lambda x: x[1])
+        if likely_industry[1] > 0:
+            return likely_industry[0].capitalize()
+    
+    # Check for educational background that might indicate industry
+    degrees = ["computer science", "business", "engineering", "medicine", "education", "finance", "marketing"]
     
-    for skill in skill_keywords:
-        # Create a regular expression pattern for whole word matching
-        pattern = r'\b' + re.escape(skill.lower()) + r'\b'
-        if re.search(pattern, text_lower):
-            found_skills.append(skill)
-    
-    return list(set(found_skills))
-
-# Parse resume
-def parse_resume(resume_text, models):
-    """Extract structured information from resume text"""
-    # In production, this would use the fine-tuned BART model
-    # For now, we'll implement a simple rule-based parser
-    
-    # Clean the text
-    clean_text = re.sub(r'\s+', ' ', resume_text).strip()
-    
-    # Extract common skill keywords (this would be a more extensive list in production)
-    tech_skills = [
-        "Python", "Java", "C++", "JavaScript", "TypeScript", "Go", "Rust", "SQL", 
-        "React", "Angular", "Vue", "Node.js", "Django", "Flask", "Spring", 
-        "TensorFlow", "PyTorch", "Scikit-learn", "Machine Learning", "Deep Learning", "NLP",
-        "AWS", "Azure", "GCP", "Docker", "Kubernetes", "CI/CD", "Jenkins", "GitHub Actions",
-        "REST API", "GraphQL", "Microservices", "Serverless"
+    for degree in degrees:
+        if degree in combined_text:
+            return f"{degree.capitalize()}-related field"
+    
+    return "Not clearly specified"
+
+def extract_skills_and_work(text):
+    """Extract both skills and work experience at once to save processing time"""
+    # Common skill categories - reduced keyword list for speed
+    skill_categories = {
+        "Programming": ["Python", "Java", "JavaScript", "HTML", "CSS", "SQL", "C++", "C#", "Go"],
+        "Data Science": ["Machine Learning", "Data Analysis", "Statistics", "TensorFlow", "PyTorch", "AI", "Algorithms"],
+        "Database": ["SQL", "MySQL", "MongoDB", "Database", "NoSQL", "PostgreSQL"],
+        "Web Development": ["React", "Angular", "Node.js", "Frontend", "Backend", "Full-Stack"],
+        "Software Development": ["Agile", "Scrum", "Git", "DevOps", "Docker", "System Design"],
+        "Cloud": ["AWS", "Azure", "Google Cloud", "Cloud Computing"],
+        "Security": ["Cybersecurity", "Network Security", "Encryption", "Security"],
+        "Business": ["Project Management", "Business Analysis", "Leadership", "Teamwork"],
+        "Design": ["UX/UI", "User Experience", "Design Thinking", "Adobe"]
+    }
+    
+    # Work experience extraction
+    work_headers = [
+        "work experience", "professional experience", "employment history", 
+        "work history", "experience"
     ]
     
-    soft_skills = [
-        "Leadership", "Communication", "Teamwork", "Problem-solving", "Critical thinking",
-        "Time management", "Adaptability", "Creativity", "Collaboration", "Presentation"
+    next_section_headers = [
+        "education", "skills", "certifications", "projects", "achievements"
     ]
     
-    # Extract skills
-    found_tech_skills = extract_skills(clean_text, tech_skills)
-    found_soft_skills = extract_skills(clean_text, soft_skills)
+    # Process everything at once
+    lines = text.split('\n')
+    text_lower = text.lower()
     
-    # Extract experience using regex patterns (simplified)
-    experience_pattern = r'(?:Experience|EXPERIENCE|Work Experience|WORK EXPERIENCE).*?(?:Education|EDUCATION|Skills|SKILLS|$)'
-    experience_match = re.search(experience_pattern, clean_text, re.DOTALL)
-    experience_text = experience_match.group(0) if experience_match else ""
+    # Skills extraction
+    found_skills = []
+    for category, skills in skill_categories.items():
+        category_skills = []
+        for skill in skills:
+            if skill.lower() in text_lower:
+                category_skills.append(skill)
+        
+        if category_skills:
+            found_skills.append(f"{category}: {', '.join(category_skills)}")
     
-    # Extract education using regex patterns (simplified)
-    education_pattern = r'(?:Education|EDUCATION).*?(?:Skills|SKILLS|Experience|EXPERIENCE|$)'
-    education_match = re.search(education_pattern, clean_text, re.DOTALL)
-    education_text = education_match.group(0) if education_match else ""
+    # Work experience extraction - simplified approach
+    work_section = []
+    in_work_section = False
     
-    # Estimate years of experience (simplified)
-    years_exp = 0
-    year_patterns = [
-        r'(\d{4})\s*-\s*(?:present|current|now|2023|2024|2025)',
-        r'(\d{4})\s*-\s*(\d{4})'
-    ]
+    for idx, line in enumerate(lines):
+        line_lower = line.lower().strip()
+        
+        # Start of work section
+        if not in_work_section:
+            if any(header in line_lower for header in work_headers):
+                in_work_section = True
+                continue
+        # End of work section
+        elif in_work_section:
+            if any(header in line_lower for header in next_section_headers):
+                break
+            
+            if line.strip():
+                work_section.append(line.strip())
     
-    for pattern in year_patterns:
-        matches = re.findall(pattern, clean_text, re.IGNORECASE)
-        for match in matches:
-            if isinstance(match, tuple):
-                start_year = int(match[0])
-                end_year = int(match[1]) if match[1].isdigit() else 2025
-                years_exp += (end_year - start_year)
-            else:
-                start_year = int(match)
-                years_exp += (2025 - start_year)
-    
-    # Cap reasonable years
-    years_exp = min(years_exp, 30)
-    
-    # Create structured data
-    structured_data = {
-        "skills": {
-            "technical": found_tech_skills,
-            "soft": found_soft_skills
-        },
-        "experience": {
-            "years": years_exp,
-            "summary": experience_text[:300] + "..." if len(experience_text) > 300 else experience_text
-        },
-        "education": education_text[:300] + "..." if len(education_text) > 300 else education_text
+    # Simplified work formatting
+    if not work_section:
+        work_experience = "Work experience not clearly identified"
+    else:
+        # Just take the first 5-7 lines of the work section as a summary
+        work_lines = []
+        company_count = 0
+        current_company = ""
+        
+        for line in work_section:
+            # New company entry often has a date
+            if re.search(r'(19|20)\d{2}', line):
+                company_count += 1
+                if company_count <= 3:  # Limit to 3 most recent positions
+                    current_company = line
+                    work_lines.append(f"**{line}**")
+                else:
+                    break
+            elif company_count <= 3 and len(work_lines) < 10:  # Limit total lines
+                work_lines.append(line)
+        
+        work_experience = "\n• " + "\n• ".join(work_lines[:7]) if work_lines else "Work experience not clearly structured"
+    
+    skills_formatted = "\n• " + "\n• ".join(found_skills) if found_skills else "No specific technical skills clearly identified"
+    
+    return skills_formatted, work_experience
+
+#####################################
+# Function: Summarize Resume Text
+#####################################
+def summarize_resume_text(resume_text):
+    """
+    Generates a structured summary of the resume text
+    """
+    start_time = time.time()
+    
+    # First, generate a quick summary using pre-loaded model
+    max_input_length = 1024  # Model limit
+    
+    # Only summarize the first portion of text for speed
+    text_to_summarize = resume_text[:min(len(resume_text), max_input_length)]
+    base_summary = models['summarizer'](text_to_summarize)[0]['summary_text']
+    
+    # Extract information in parallel where possible
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        # These can run in parallel
+        name_future = executor.submit(extract_name, resume_text[:500])  # Only use start of text
+        age_future = executor.submit(extract_age, resume_text)
+        industry_future = executor.submit(extract_industry, resume_text, base_summary)
+        skills_work_future = executor.submit(extract_skills_and_work, resume_text)
+        
+        # Get results
+        name = name_future.result()
+        age = age_future.result()
+        industry = industry_future.result()
+        skills, work_experience = skills_work_future.result()
+    
+    # Format the structured summary
+    formatted_summary = f"Name: {name}\n"
+    formatted_summary += f"Age: {age}\n"
+    formatted_summary += f"Expected Job Industry: {industry}\n\n"
+    formatted_summary += f"Previous Work Experience: {work_experience}\n\n"
+    formatted_summary += f"Skills: {skills}"
+    
+    execution_time = time.time() - start_time
+    
+    return formatted_summary, execution_time
+
+#####################################
+# Function: Extract Job Requirements
+#####################################
+def extract_job_requirements(job_description):
+    """
+    Extract key requirements and skills from a job description
+    """
+    # Common technical skill categories to look for
+    tech_skill_categories = {
+        "programming_languages": ["Python", "Java", "C++", "JavaScript", "TypeScript", "Go", "Rust", "SQL", "Ruby", "PHP", "Swift", "Kotlin"],
+        "web_technologies": ["React", "Angular", "Vue", "Node.js", "HTML", "CSS", "Django", "Flask", "Spring", "REST API", "GraphQL"],
+        "data_tech": ["Machine Learning", "TensorFlow", "PyTorch", "Data Science", "AI", "Big Data", "Deep Learning", "NLP", "Computer Vision"],
+        "cloud_devops": ["AWS", "Azure", "GCP", "Docker", "Kubernetes", "CI/CD", "Jenkins", "GitHub Actions", "Terraform", "Serverless"],
+        "database": ["SQL", "MySQL", "PostgreSQL", "MongoDB", "Redis", "Elasticsearch", "DynamoDB", "Cassandra"],
     }
     
-    return structured_data
-
-# Parse job description
-def parse_job_description(job_text):
-    """Extract key requirements from job description"""
-    # Clean the text
-    clean_text = re.sub(r'\s+', ' ', job_text).strip()
-    
-    # Extract common skill keywords (same as resume parser)
-    tech_skills = [
-        "Python", "Java", "C++", "JavaScript", "TypeScript", "Go", "Rust", "SQL", 
-        "React", "Angular", "Vue", "Node.js", "Django", "Flask", "Spring", 
-        "TensorFlow", "PyTorch", "Scikit-learn", "Machine Learning", "Deep Learning", "NLP",
-        "AWS", "Azure", "GCP", "Docker", "Kubernetes", "CI/CD", "Jenkins", "GitHub Actions",
-        "REST API", "GraphQL", "Microservices", "Serverless"
-    ]
+    # Common soft skills to look for
+    soft_skills = ["Communication", "Leadership", "Teamwork", "Problem-solving", "Critical thinking", "Adaptability", "Creativity", "Time management"]
+    
+    # Clean the text for processing
+    clean_job_text = job_description.lower()
     
-    soft_skills = [
-        "Leadership", "Communication", "Teamwork", "Problem-solving", "Critical thinking",
-        "Time management", "Adaptability", "Creativity", "Collaboration", "Presentation"
+    # Extract job title
+    title_patterns = [
+        r'^([^:.\n]+?)(position|role|job|opening|vacancy)',
+        r'^([^:.\n]+?)\n',
+        r'(hiring|looking for(?: a| an)?|recruiting)(?: a| an)? ([^:.\n]+?)(:-|[.:]|\n|$)'
     ]
     
-    # Extract skills
-    required_tech_skills = extract_skills(clean_text, tech_skills)
-    required_soft_skills = extract_skills(clean_text, soft_skills)
+    job_title = "Not specified"
+    for pattern in title_patterns:
+        title_match = re.search(pattern, clean_job_text, re.IGNORECASE)
+        if title_match:
+            potential_title = title_match.group(1).strip() if len(title_match.groups()) >= 1 else title_match.group(2).strip()
+            if 3 <= len(potential_title) <= 50:  # Reasonable title length
+                job_title = potential_title.capitalize()
+                break
     
-    # Extract years of experience requirement (simplified)
+    # Extract years of experience
     exp_patterns = [
-        r'(\d+)\+?\s*(?:years|yrs|yr)(?:\s*of)?\s*(?:experience|exp)',
-        r'(?:experience|exp)(?:\s*of)?\s*(\d+)\+?\s*(?:years|yrs|yr)'
+        r'(\d+)(?:\+)?\s*(?:years|yrs)(?:\s*of)?\s*(?:experience|exp)',
+        r'experience\s*(?:of)?\s*(\d+)(?:\+)?\s*(?:years|yrs)'
     ]
     
-    required_years = 0
+    years_required = 0
     for pattern in exp_patterns:
-        matches = re.findall(pattern, clean_text, re.IGNORECASE)
-        if matches:
-            # Take the highest mentioned years
-            required_years = max([int(y) for y in matches if y.isdigit()] + [required_years])
+        exp_match = re.search(pattern, clean_job_text, re.IGNORECASE)
+        if exp_match:
+            try:
+                years_required = int(exp_match.group(1))
+                break
+            except:
+                pass
+    
+    # Extract technical skills
+    found_tech_skills = {}
+    all_tech_skills = []
+    
+    for category, skills in tech_skill_categories.items():
+        category_skills = []
+        for skill in skills:
+            if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_job_text):
+                category_skills.append(skill)
+                all_tech_skills.append(skill)
+        
+        if category_skills:
+            found_tech_skills[category] = category_skills
+    
+    # Extract soft skills
+    found_soft_skills = []
+    for skill in soft_skills:
+        if re.search(r'\b' + re.escape(skill.lower()) + r'\b', clean_job_text):
+            found_soft_skills.append(skill)
+    
+    # Extract educational requirements
+    edu_patterns = [
+        r"bachelor'?s degree|bs|b\.s\.",
+        r"master'?s degree|ms|m\.s\.",
+        r"phd|ph\.d\.|doctorate", 
+        r"mba|m\.b\.a\."
+    ]
     
-    # Extract job title
-    title_pattern = r'^(.*?)(?:\n|$)'
-    title_match = re.search(title_pattern, clean_text)
-    job_title = title_match.group(1).strip() if title_match else "Not specified"
+    education_required = []
+    for pattern in edu_patterns:
+        if re.search(pattern, clean_job_text, re.IGNORECASE):
+            edu_match = re.search(pattern, clean_job_text, re.IGNORECASE).group(0)
+            education_required.append(edu_match.capitalize())
     
-    # Create structured data
-    structured_data = {
+    # Format the job requirements
+    job_requirements = {
         "title": job_title,
-        "requirements": {
-            "technical_skills": required_tech_skills,
-            "soft_skills": required_soft_skills,
-            "years_experience": required_years
-        },
-        "full_text": job_text
+        "years_experience": years_required,
+        "technical_skills": all_tech_skills,
+        "soft_skills": found_soft_skills,
+        "education": education_required,
     }
     
-    return structured_data
+    return job_requirements
 
-# Calculate match score
-def calculate_match_score(resume_data, job_data):
-    """Calculate how well the resume matches the job description"""
-    scores = {}
+#####################################
+# Function: Analyze Job Fit
+#####################################
+def analyze_job_fit(resume_summary, job_description):
+    """
+    Analyze how well the candidate fits the job requirements with detailed category breakdowns.
+    """
+    start_time = time.time()
     
-    # Calculate skill match percentage
-    required_tech_skills = set(job_data["requirements"]["technical_skills"])
-    candidate_tech_skills = set(resume_data["skills"]["technical"])
+    # Extract job requirements
+    job_requirements = extract_job_requirements(job_description)
     
-    required_soft_skills = set(job_data["requirements"]["soft_skills"])
-    candidate_soft_skills = set(resume_data["skills"]["soft"])
+    # Define skill categories to evaluate against
+    resume_lower = resume_summary.lower()
+    job_lower = job_description.lower()
     
-    if required_tech_skills:
-        tech_match = len(candidate_tech_skills.intersection(required_tech_skills)) / len(required_tech_skills)
-        scores["technical_skills"] = {
-            "score": int(tech_match * 100),
-            "matched": list(candidate_tech_skills.intersection(required_tech_skills)),
-            "missing": list(required_tech_skills - candidate_tech_skills)
-        }
-    else:
-        scores["technical_skills"] = {"score": 0, "matched": [], "missing": []}
-    
-    if required_soft_skills:
-        soft_match = len(candidate_soft_skills.intersection(required_soft_skills)) / len(required_soft_skills)
-        scores["soft_skills"] = {
-            "score": int(soft_match * 100),
-            "matched": list(candidate_soft_skills.intersection(required_soft_skills)),
-            "missing": list(required_soft_skills - candidate_soft_skills)
-        }
-    else:
-        scores["soft_skills"] = {"score": 0, "matched": [], "missing": []}
+    # Define keyword categories based on the job description
+    # We'll dynamically build these based on the job requirements
+    skill_keywords = {
+        "technical_skills": job_requirements["technical_skills"],
+        "soft_skills": job_requirements["soft_skills"],
+        "education": job_requirements["education"],
+    }
     
-    # Experience match
-    required_years = job_data["requirements"]["years_experience"]
-    candidate_years = resume_data["experience"]["years"]
+    # Add additional keywords from the job description for comprehensive analysis
+    additional_keywords = {
+        "problem_solving": ["problem solving", "analytical", "critical thinking", "troubleshooting", "debugging", 
+                           "optimization", "solution", "resolve", "analyze"],
+        "domain_knowledge": ["industry", "experience", "expertise", "knowledge", "familiar with", "understanding of"],
+        "collaboration": ["team", "collaborate", "cooperation", "cross-functional", "communication", "stakeholder"]
+    }
+    
+    # Merge the keywords
+    skill_keywords.update(additional_keywords)
+    
+    # Category weights with descriptive labels
+    category_weights = {
+        "technical_skills": {"weight": 0.40, "label": "Technical Skills"},
+        "soft_skills": {"weight": 0.15, "label": "Soft Skills"},
+        "education": {"weight": 0.10, "label": "Education"},
+        "problem_solving": {"weight": 0.15, "label": "Problem Solving"},
+        "domain_knowledge": {"weight": 0.10, "label": "Domain Knowledge"},
+        "collaboration": {"weight": 0.10, "label": "Collaboration"}
+    }
     
-    if required_years > 0:
-        if candidate_years >= required_years:
-            exp_score = 100
+    # Calculate category scores and store detailed information
+    category_scores = {}
+    category_details = {}
+    found_skills = {}
+    
+    for category, keywords in skill_keywords.items():
+        if not keywords:  # Skip empty categories
+            category_scores[category] = 0.0
+            category_details[category] = {
+                "raw_percentage": 0,
+                "adjusted_score": 0,
+                "matching_keywords": [],
+                "total_keywords": 0,
+                "matches": 0
+            }
+            found_skills[category] = []
+            continue
+            
+        # Find the specific matching keywords for feedback
+        category_matches = []
+        for keyword in keywords:
+            if keyword.lower() in resume_lower:
+                category_matches.append(keyword)
+        
+        found_skills[category] = category_matches
+        
+        # Count matches but cap at a reasonable level
+        matches = len(category_matches)
+        total_keywords = len(keywords)
+        
+        # Calculate raw percentage for this category
+        raw_percentage = int((matches / max(1, total_keywords)) * 100)
+        
+        # Apply logarithmic scaling for more realistic scores
+        if matches == 0:
+            adjusted_score = 0.0
         else:
-            exp_score = int((candidate_years / required_years) * 100)
+            # Logarithmic scaling to prevent perfect scores
+            adjusted_score = min(0.95, (math.log(matches + 1) / math.log(min(total_keywords, 8) + 1)))
         
-        scores["experience"] = {
-            "score": exp_score,
-            "candidate_years": candidate_years,
-            "required_years": required_years
-        }
-    else:
-        scores["experience"] = {
-            "score": 100 if candidate_years > 0 else 50,
-            "candidate_years": candidate_years,
-            "required_years": "Not specified"
+        # Store both raw and adjusted scores for feedback
+        category_scores[category] = adjusted_score
+        category_details[category] = {
+            "raw_percentage": raw_percentage,
+            "adjusted_score": int(adjusted_score * 100),
+            "matching_keywords": category_matches,
+            "total_keywords": total_keywords,
+            "matches": matches
         }
     
-    # Calculate overall score (weighted)
-    tech_weight = 0.6
-    soft_weight = 0.2
-    exp_weight = 0.2
+    # Check for years of experience match
+    years_required = job_requirements["years_experience"]
     
-    overall_score = (
-        scores["technical_skills"]["score"] * tech_weight +
-        scores["soft_skills"]["score"] * soft_weight +
-        scores["experience"]["score"] * exp_weight
-    )
+    # Extract years of experience from resume
+    experience_years = 0
+    year_patterns = [
+        r'(\d+)\s*(?:\+)?\s*years?\s*(?:of)?\s*experience',
+        r'experience\s*(?:of)?\s*(\d+)\s*(?:\+)?\s*years?'
+    ]
     
-    scores["overall"] = int(overall_score)
+    for pattern in year_patterns:
+        exp_match = re.search(pattern, resume_lower)
+        if exp_match:
+            try:
+                experience_years = int(exp_match.group(1))
+                break
+            except:
+                pass
+    
+    # If we couldn't find explicit years, try to count based on work history
+    if experience_years == 0:
+        # Try to extract from work experience section
+        work_exp_match = re.search(r'work experience:(.*?)(?=\n\n|$)', resume_summary, re.IGNORECASE | re.DOTALL)
+        if work_exp_match:
+            work_text = work_exp_match.group(1).lower()
+            years = re.findall(r'(\d{4})\s*-\s*(\d{4}|present|current)', work_text)
+            
+            total_years = 0
+            for year_range in years:
+                start_year = int(year_range[0])
+                if year_range[1].isdigit():
+                    end_year = int(year_range[1])
+                else:
+                    end_year = 2025  # Assume "present" is current year
+                
+                total_years += (end_year - start_year)
+            
+            experience_years = total_years
     
-    return scores
-
-# Generate expert assessment using Qwen
-def generate_assessment(resume_data, job_data, match_scores, models):
-    """Generate an expert assessment using Qwen model"""
-    # Prepare context
-    job_title = job_data["title"]
-    matched_skills = match_scores["technical_skills"]["matched"]
-    missing_skills = match_scores["technical_skills"]["missing"]
-    experience_match = match_scores["experience"]
-    overall_score = match_scores["overall"]
+    # Calculate experience match score
+    if years_required > 0:
+        if experience_years >= years_required:
+            exp_score = 1.0
+        else:
+            exp_score = experience_years / years_required
+    else:
+        exp_score = 1.0  # If no specific years required, assume full match
+    
+    category_scores["experience"] = exp_score
+    category_details["experience"] = {
+        "raw_percentage": int(exp_score * 100),
+        "adjusted_score": int(exp_score * 100),
+        "candidate_years": experience_years,
+        "required_years": years_required
+    }
     
-    # Determine fit classification
-    fit_status = "FIT" if overall_score >= 70 else "NOT FIT"
+    # Calculate weighted score
+    weighted_score = 0
+    for category, score in category_scores.items():
+        if category in category_weights:
+            weighted_score += score * category_weights[category]["weight"]
     
-    # Create prompt for Qwen
-    prompt = f"""
-    <|im_start|>system
-    You are an expert resume evaluator. Analyze how well a candidate fits a job posting and provide professional feedback.
-    <|im_end|>
+    # Add experience separately (not in the original weights)
+    weighted_score = (weighted_score * 0.8) + (category_scores["experience"] * 0.2)
     
-    <|im_start|>user
-    Evaluate this candidate for a {job_title} position.
+    # Apply final curve to keep scores in a realistic range
+    match_percentage = min(95, max(35, int(weighted_score * 100)))
     
-    Overall match score: {overall_score}%
-    Technical skills match: {match_scores["technical_skills"]["score"]}%
-    Soft skills match: {match_scores["soft_skills"]["score"]}%
-    Experience match: {experience_match["score"]}%
+    # Determine fit/not fit status
+    fit_status = "FIT" if match_percentage >= 70 else "NOT FIT"
     
-    Candidate has: {experience_match["candidate_years"]} years of experience
-    Position requires: {experience_match["required_years"]} years of experience
+    # Get more specific information for a better prompt
+    # Get top skills across all categories (up to 5 total)
+    all_matching_skills = []
+    for category, matches in found_skills.items():
+        if matches:
+            all_matching_skills.extend(matches)
     
-    Matched technical skills: {", ".join(matched_skills) if matched_skills else "None"}
-    Missing technical skills: {", ".join(missing_skills) if missing_skills else "None"}
+    top_skills = list(set(all_matching_skills))[:5]  # Remove duplicates and take top 5
+    skills_text = ", ".join(top_skills) if top_skills else "limited relevant skills"
     
-    Create a professional assessment of this candidate. First state whether they are a FIT or NOT FIT for the position, then explain why with specific strengths and development areas.
-    <|im_end|>
+    # Get strongest and weakest categories for more specific feedback
+    categories_sorted = sorted(
+        [(cat, category_details[cat]["adjusted_score"]) for cat in category_weights.keys() if cat in category_details],
+        key=lambda x: x[1], 
+        reverse=True
+    )
     
-    <|im_start|>assistant
-    """
+    top_category = category_weights[categories_sorted[0][0]]["label"] if categories_sorted else "Technical Skills"
+    weak_category = category_weights[categories_sorted[-1][0]]["label"] if categories_sorted else "Domain Knowledge"
     
+    # Create a prompt for the evaluation model
+    prompt = f"""
+Generate a professional expert assessment for a job candidate applying for the position: {job_requirements['title']}.
+Skills detected in candidate: {skills_text}.
+Strongest area: {top_category} ({categories_sorted[0][1]}%).
+Weakest area: {weak_category} ({categories_sorted[-1][1]}%).
+Overall match: {match_percentage}%.
+Fit status: {fit_status}
+
+Write an evaluative assessment that analyzes the candidate's fit for this position.
+Start with "{fit_status}: This candidate" and provide a professional evaluation of their fit.
+
+{fit_status}: This candidate"""
+
     try:
-        # Generate the assessment using Qwen
-        tokenizer = models['evaluator_tokenizer']
-        qwen_model = models['evaluator']
-        
-        inputs = tokenizer(prompt, return_tensors="pt")
-        outputs = qwen_model.generate(
-            inputs.input_ids,
-            max_new_tokens=512,
+        # Generate the assessment using the evaluation model
+        assessment_results = models['evaluator'](
+            prompt, 
+            max_length=300,
             do_sample=True,
-            temperature=0.7,
-            top_p=0.9
+            temperature=0.75,
+            num_return_sequences=3
         )
+    
+        # Find the best response with thorough cleaning
+        best_assessment = None
+        for result in assessment_results:
+            # Get the raw text
+            raw_text = result['generated_text'].strip()
         
-        assessment = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # Extract the assistant's response
-        if "<|im_start|>assistant" in assessment:
-            assessment = assessment.split("<|im_start|>assistant")[-1]
-        
-        # Clean up any remaining markers
-        assessment = re.sub(r'<\|im_(start|end)\|>', '', assessment)
-        assessment = assessment.strip()
+            # Extract just the part that starts with the fit status
+            if f"{fit_status}: This candidate" in raw_text:
+                # Find the start of the actual assessment
+                start_idx = raw_text.find(f"{fit_status}: This candidate")
+                text = raw_text[start_idx:]
+            
+                # Check if it's actually an assessment (not just instructions)
+                if len(text) > 50 and not any(x in text.lower() for x in [
+                    "actionable advice", 
+                    "include specific", 
+                    "make an assessment", 
+                    "evaluate their", 
+                    "assess their", 
+                    "provide specific areas"
+                ]):
+                    best_assessment = text
+                    break
+    
+        # Use the best response or generate a fallback if none were ideal
+        if best_assessment:
+            assessment = best_assessment
+        else:
+            # Generate a completely manual assessment
+            assessment = generate_fallback_assessment(
+                resume_summary, 
+                job_requirements, 
+                match_percentage,
+                top_skills,
+                top_category,
+                weak_category,
+                fit_status
+            )
         
-        # If no assessment was generated, create a fallback
-        if not assessment or len(assessment) < 50:
-            assessment = generate_fallback_assessment(resume_data, job_data, match_scores, fit_status)
     except Exception as e:
-        st.error(f"Error generating assessment: {str(e)}")
-        assessment = generate_fallback_assessment(resume_data, job_data, match_scores, fit_status)
-        
-    return assessment, fit_status
+        # Fallback to a manual assessment
+        assessment = generate_fallback_assessment(
+            resume_summary, 
+            job_requirements, 
+            match_percentage,
+            top_skills,
+            top_category,
+            weak_category,
+            fit_status
+        )
+
+    # Final cleanup
+    assessment = re.sub(r'include specific actionable advice.*?improvement\.', '', assessment, flags=re.DOTALL|re.IGNORECASE)
+    assessment = re.sub(r'make an assessment.*?resume\.', '', assessment, flags=re.DOTALL|re.IGNORECASE)
+    assessment = re.sub(r'evaluate their technical skills.*?position\.', '', assessment, flags=re.DOTALL|re.IGNORECASE)
+    assessment = re.sub(r'assess their strengths.*?contributions', '', assessment, flags=re.DOTALL|re.IGNORECASE)
+    assessment = re.sub(r'provide specific areas.*?needed', '', assessment, flags=re.DOTALL|re.IGNORECASE)
+    assessment = re.sub(r'give an overall.*?position', '', assessment, flags=re.DOTALL|re.IGNORECASE)
+
+    # Clean up any double spaces, newlines, etc.
+    assessment = re.sub(r'\s+', ' ', assessment)
+    assessment = assessment.strip()
+
+    # If cleaning removed too much text, use the fallback
+    if len(assessment) < 50 or not assessment.startswith(f"{fit_status}: This candidate"):
+        assessment = generate_fallback_assessment(
+            resume_summary, 
+            job_requirements, 
+            match_percentage,
+            top_skills,
+            top_category,
+            weak_category,
+            fit_status
+        )
+    
+    # Make sure percentages are consistent
+    assessment = re.sub(r'\b\d{1,2}%\b', f"{match_percentage}%", assessment)
+    
+    execution_time = time.time() - start_time
+    
+    return assessment, match_percentage, category_details, job_requirements, execution_time
 
 # Generate fallback assessment
-def generate_fallback_assessment(resume_data, job_data, match_scores, fit_status):
+def generate_fallback_assessment(resume_summary, job_requirements, match_percentage, top_skills, top_category, weak_category, fit_status):
     """Generate a fallback assessment if the model fails"""
-    job_title = job_data["title"]
-    matched_skills = match_scores["technical_skills"]["matched"]
-    missing_skills = match_scores["technical_skills"]["missing"]
-    overall_score = match_scores["overall"]
+    job_title = job_requirements["title"]
+    skills_text = ", ".join(top_skills) if top_skills else "relevant skills"
     
     if fit_status == "FIT":
-        assessment = f"""FIT: This candidate demonstrates a strong alignment with the {job_title} position, achieving an overall match score of {overall_score}%. Their proficiency in {', '.join(matched_skills) if matched_skills else 'relevant skills'} positions them well to contribute effectively from the start. The candidate's experience level is suitable for the role's requirements. To maximize their success, they could consider developing expertise in {', '.join(missing_skills) if missing_skills else 'additional specialized areas relevant to this role'}.
+        assessment = f"""{fit_status}: This candidate demonstrates strong alignment with the {job_title} position, achieving an overall match score of {match_percentage}%. Their proficiency in {skills_text} positions them well to contribute effectively, with particular strength in {top_category}. The candidate's experience level is suitable for the role's requirements. To maximize their success, they could consider developing expertise in {weak_category} to round out their skill set for this position.
         """
     else:
-        assessment = f"""NOT FIT: This candidate currently shows limited alignment with the {job_title} position, with an overall match score of {overall_score}%. While they demonstrate some relevant capabilities in {', '.join(matched_skills) if matched_skills else 'a few areas'}, they would need to develop expertise in critical areas such as {', '.join(missing_skills) if missing_skills else 'key technical requirements for this position'}. The candidate may become more competitive for this role by focusing on these skill gaps and gaining more relevant experience.
+        assessment = f"""{fit_status}: This candidate currently shows limited alignment with the {job_title} position, with an overall match score of {match_percentage}%. While they demonstrate some capabilities in {top_category} and have experience with {skills_text}, they would need to develop expertise in {weak_category} to be more competitive for this role. The candidate may become a stronger fit by focusing on these skill gaps and gaining more relevant experience in the key requirements for this position.
         """
     
     return assessment
 
-# Create the main header and interface
+#####################################
+# Main Streamlit Interface
+#####################################
 st.title("Resume-Job Fit Analyzer")
-st.markdown("### Evaluate how well a resume matches a job description")
+st.markdown(
+    """
+Upload your resume file in **.docx**, **.doc**, or **.txt** format and enter a job description to see how well you match with the job requirements. The app performs the following tasks:
+1. Extracts text from your resume.
+2. Uses AI to generate a structured candidate summary.
+3. Analyzes how well your profile fits the specific job requirements.
+"""
+)
 
 # Resume upload
-st.subheader("Resume")
-uploaded_file = st.file_uploader("Upload Resume (.doc, .docx, .txt)", type=["doc", "docx", "txt"])
+uploaded_file = st.file_uploader("Upload your resume (.docx, .doc, or .txt)", type=["docx", "doc", "txt"])
 
 # Job description input
-st.subheader("Job Description")
-job_description = st.text_area("Paste job description here", height=200,
-                    placeholder="Paste the job description here...")
-
-# Display resume text if file is uploaded
-resume_text = None
-if uploaded_file is not None:
-    resume_text = read_resume_file(uploaded_file)
-    if resume_text:
-        with st.expander("View Resume Text"):
-            st.text(resume_text[:1000] + ("..." if len(resume_text) > 1000 else ""))
-
-# Analysis button
-analyze_button = st.button("Analyze Match", type="primary")
-
-# Main analysis logic
-if analyze_button:
-    if not resume_text or not job_description:
-        st.error("Please upload a resume file and provide a job description.")
+job_description = st.text_area("Enter Job Description", height=200, placeholder="Paste the job description here...")
+
+# Process button with optimized flow
+if uploaded_file is not None and job_description and st.button("Analyze Job Fit"):
+    # Create a placeholder for the progress bar
+    progress_bar = st.progress(0)
+    status_text = st.empty()
+    
+    # Step 1: Extract text
+    status_text.text("Step 1/3: Extracting text from resume...")
+    resume_text = extract_text_from_file(uploaded_file)
+    progress_bar.progress(25)
+    
+    if resume_text.startswith("Error") or resume_text == "Unsupported file type. Please upload a .docx, .doc, or .txt file.":
+        st.error(resume_text)
     else:
-        with st.spinner("Analyzing resume and job match..."):
-            # Record start time
-            start_time = time.time()
-            
-            # Load models (uses caching so only loads once)
-            models = load_models()
-            
-            # Parse resume and job description
-            resume_data = parse_resume(resume_text, models)
-            job_data = parse_job_description(job_description)
-            
-            # Calculate match score
-            match_scores = calculate_match_score(resume_data, job_data)
-            
-            # Generate assessment
-            assessment, fit_status = generate_assessment(resume_data, job_data, match_scores, models)
-            
-            # Calculate execution time
-            execution_time = time.time() - start_time
-            
-            # Display results
-            st.success(f"Analysis complete in {execution_time:.2f} seconds")
-            
-            # Display fit status prominently
-            st.markdown(f"## Overall Result: {fit_status}")
-            
-            # Display match score
-            st.subheader("Match Score")
-            score_col1, score_col2, score_col3 = st.columns(3)
-            
-            with score_col1:
-                st.metric("Overall Match", f"{match_scores['overall']}%")
-            
-            with score_col2:
-                st.metric("Technical Skills", f"{match_scores['technical_skills']['score']}%")
-            
-            with score_col3:
-                st.metric("Experience Match", f"{match_scores['experience']['score']}%")
-            
-            # Show skills breakdown
-            st.subheader("Skills Breakdown")
-            skill_col1, skill_col2 = st.columns(2)
-            
-            with skill_col1:
-                st.markdown("##### Matched Skills")
-                if match_scores["technical_skills"]["matched"]:
-                    for skill in match_scores["technical_skills"]["matched"]:
-                        st.markdown(f"✅ {skill}")
-                else:
-                    st.markdown("No matched skills found")
-            
-            with skill_col2:
-                st.markdown("##### Missing Skills")
-                if match_scores["technical_skills"]["missing"]:
-                    for skill in match_scores["technical_skills"]["missing"]:
-                        st.markdown(f"❌ {skill}")
-                else:
-                    st.markdown("No missing skills detected")
-            
-            # Show experience comparison
-            st.subheader("Experience")
-            exp_col1, exp_col2 = st.columns(2)
-            
-            with exp_col1:
-                st.markdown(f"**Required**: {job_data['requirements']['years_experience']} years")
-            
-            with exp_col2:
-                st.markdown(f"**Candidate has**: {resume_data['experience']['years']} years")
-            
-            # Display detailed assessment
-            st.subheader("Expert Assessment")
-            st.markdown(assessment)
-            
-            # Show parsed data (expandable)
-            with st.expander("View Parsed Data"):
-                col1, col2 = st.columns(2)
-                with col1:
-                    st.subheader("Resume Data")
-                    st.json(resume_data)
-                with col2:
-                    st.subheader("Job Requirements")
-                    st.json(job_data)
+        # Step 2: Generate summary
+        status_text.text("Step 2/3: Analyzing resume and generating summary...")
+        summary, summarization_time = summarize_resume_text(resume_text)
+        progress_bar.progress(50)
+        
+        # Display summary
+        st.subheader("Your Resume Summary")
+        st.markdown(summary)
+        st.info(f"Summary generated in {summarization_time:.2f} seconds")
+        
+        # Step 3: Generate job fit assessment
+        status_text.text("Step 3/3: Evaluating job fit...")
+        assessment, match_percentage, category_details, job_requirements, assessment_time = analyze_job_fit(summary, job_description)
+        progress_bar.progress(100)
+
+        # Clear status messages
+        status_text.empty()
+
+        # Display job fit results
+        st.subheader("Job Fit Assessment")
+
+        # Display match percentage with appropriate color and emoji
+        if match_percentage >= 85:
+            st.success(f"**Overall Job Match Score:** {match_percentage}% 🌟")
+        elif match_percentage >= 70:
+            st.success(f"**Overall Job Match Score:** {match_percentage}% ✅")
+        elif match_percentage >= 50:
+            st.warning(f"**Overall Job Match Score:** {match_percentage}% ⚠️")
+        else:
+            st.error(f"**Overall Job Match Score:** {match_percentage}% 🔍")
+
+        # Add detailed score breakdown
+        st.markdown("### Score Breakdown")
+
+        # Create a neat table with category scores
+        breakdown_data = []
+        for category, details in category_details.items():
+            if category == "experience":
+                label = "Experience"
+                matching_info = f"{details['candidate_years']} years (Required: {details['required_years']} years)"
+            else:
+                # Get the nice label for the category
+                label = {"technical_skills": "Technical Skills",
+                        "soft_skills": "Soft Skills",
+                        "education": "Education",
+                        "problem_solving": "Problem Solving",
+                        "domain_knowledge": "Domain Knowledge",
+                        "collaboration": "Collaboration"}[category]
+                
+                matching_info = ", ".join(details["matching_keywords"][:3]) if details.get("matching_keywords") else "None detected"
+    
+            # Add formatted breakdown row
+            breakdown_data.append({
+                "Category": label,
+                "Score": f"{details['adjusted_score']}%",
+                "Matching Items": matching_info
+            })
+
+        # Convert to DataFrame and display
+        breakdown_df = pd.DataFrame(breakdown_data)
+        # Remove the index column entirely
+        st.table(breakdown_df.set_index('Category').reset_index())  # This removes the numerical index
+
+        # Show a note about how scores are calculated
+        with st.expander("How are these scores calculated?"):
+            st.markdown("""
+            - **Technical Skills** (40% of total): Evaluates programming languages, software tools, and technical requirements
+            - **Soft Skills** (15% of total): Assesses communication, teamwork, and interpersonal abilities
+            - **Education** (10% of total): Compares educational requirements with candidate's background
+            - **Problem Solving** (15% of total): Measures analytical thinking and approach to challenges
+            - **Domain Knowledge** (10% of total): Evaluates industry-specific experience and knowledge
+            - **Collaboration** (10% of total): Assesses team skills and cross-functional collaboration
+            - **Experience** (20% overall modifier): Years of relevant experience compared to job requirements
+    
+            Scores are calculated based on keyword matches in your resume, with diminishing returns applied (first few skills matter more than later ones).
+            """)
+
+        # Display assessment
+        st.markdown("### Expert Assessment")
+        st.markdown(assessment)
+
+        st.info(f"Assessment completed in {assessment_time:.2f} seconds")
+        
+        # Add potential next steps based on the match percentage
+        st.subheader("Recommended Next Steps")
+        
+        if match_percentage >= 80:
+            st.markdown("""
+            - Consider applying for this position as you appear to be a strong match
+            - Prepare for technical interviews by focusing on your strongest skills
+            - Review the job description again to prepare for specific interview questions
+            """)
+        elif match_percentage >= 60:
+            st.markdown("""
+            - Focus on strengthening your weaker areas before applying
+            - Highlight your strongest skills and experience in your cover letter
+            - Consider gaining additional experience or certifications in key required areas
+            """)
+        else:
+            st.markdown("""
+            - This position may not be the best fit for your current skills and experience
+            - Consider roles that better align with your strengths
+            - If you're set on this type of position, focus on developing skills in the areas mentioned in the job description
+            """)