Update app.py

app.py

@@ -1,6 +1,6 @@
 import gradio as gr
 import torch
-from sentence_transformers import SentenceTransformer
+from transformers import pipeline, AutoTokenizer, AutoModel
 import PyPDF2
 import docx
 import io
@@ -10,6 +10,7 @@ from sklearn.metrics.pairwise import cosine_similarity
 import nltk
 from collections import Counter
 import warnings
+import time
 warnings.filterwarnings("ignore")
 
 # Download required NLTK data
@@ -34,20 +35,72 @@ except LookupError:
 from nltk.corpus import stopwords
 from nltk.tokenize import word_tokenize, sent_tokenize
 
-class ResumeJobMatcher:
+class ATSResumeAnalyzer:
     def __init__(self):
-        # Use a lightweight but effective sentence transformer model
-        # all-MiniLM-L6-v2 is optimized for CPU and works well on limited resources
-        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        # Initialize models for different analysis tasks
+        self.progress_callback = None
+        
+        # For semantic analysis - using a more powerful model
+        self.update_progress("🔄 Loading AI models...", 10)
+        
+        # Use a more sophisticated model for better analysis
+        try:
+            # BAAI/bge-small-en-v1.5 is excellent for semantic similarity and works on CPU
+            from sentence_transformers import SentenceTransformer
+            self.semantic_model = SentenceTransformer('BAAI/bge-small-en-v1.5')
+        except:
+            # Fallback to all-MiniLM if BGE is not available
+            from sentence_transformers import SentenceTransformer
+            self.semantic_model = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        # Initialize text generation pipeline for suggestions (using a small model)
+        try:
+            self.suggestion_generator = pipeline(
+                "text-generation",
+                model="microsoft/DialoGPT-small",
+                tokenizer="microsoft/DialoGPT-small",
+                device=-1  # CPU
+            )
+        except:
+            self.suggestion_generator = None
+        
         self.stop_words = set(stopwords.words('english'))
         
+        # ATS Keywords categories
+        self.ats_categories = {
+            'technical_skills': ['python', 'javascript', 'java', 'sql', 'aws', 'docker', 'kubernetes', 'react', 'angular', 'node.js', 'machine learning', 'data science', 'tensorflow', 'pytorch', 'git', 'linux', 'windows', 'azure', 'gcp', 'html', 'css', 'mongodb', 'postgresql', 'mysql', 'api', 'rest', 'graphql', 'microservices', 'agile', 'scrum', 'devops', 'ci/cd'],
+            'soft_skills': ['leadership', 'communication', 'teamwork', 'problem solving', 'analytical', 'creative', 'adaptable', 'organized', 'detail oriented', 'time management', 'project management', 'collaboration', 'innovation', 'strategic thinking'],
+            'experience_indicators': ['managed', 'led', 'developed', 'implemented', 'designed', 'created', 'improved', 'optimized', 'achieved', 'delivered', 'coordinated', 'executed', 'supervised', 'mentored', 'trained', 'built', 'established', 'streamlined'],
+            'education_keywords': ['degree', 'bachelor', 'master', 'phd', 'certification', 'course', 'training', 'university', 'college', 'institute', 'graduated'],
+            'industry_specific': []  # Will be populated based on job description
+        }
+        
+        self.update_progress("✅ Models loaded successfully!", 20)
+    
+    def set_progress_callback(self, callback):
+        """Set the progress callback function"""
+        self.progress_callback = callback
+    
+    def update_progress(self, message, progress):
+        """Update progress if callback is set"""
+        if self.progress_callback:
+            self.progress_callback(message, progress)
+        time.sleep(0.1)  # Small delay for better UX
+    
     def extract_text_from_pdf(self, pdf_file):
         """Extract text from PDF file"""
         try:
-            pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_file))
-            text = ""
-            for page in pdf_reader.pages:
-                text += page.extract_text() + "\n"
+            if isinstance(pdf_file, str):
+                with open(pdf_file, 'rb') as file:
+                    pdf_reader = PyPDF2.PdfReader(file)
+                    text = ""
+                    for page in pdf_reader.pages:
+                        text += page.extract_text() + "\n"
+            else:
+                pdf_reader = PyPDF2.PdfReader(io.BytesIO(pdf_file))
+                text = ""
+                for page in pdf_reader.pages:
+                    text += page.extract_text() + "\n"
             return text
         except Exception as e:
             return f"Error reading PDF: {str(e)}"
@@ -55,7 +108,10 @@ class ResumeJobMatcher:
     def extract_text_from_docx(self, docx_file):
         """Extract text from DOCX file"""
         try:
-            doc = docx.Document(io.BytesIO(docx_file))
+            if isinstance(docx_file, str):
+                doc = docx.Document(docx_file)
+            else:
+                doc = docx.Document(io.BytesIO(docx_file))
             text = ""
             for paragraph in doc.paragraphs:
                 text += paragraph.text + "\n"
@@ -67,228 +123,311 @@ class ResumeJobMatcher:
         """Clean and preprocess text"""
         # Remove extra whitespace and normalize
         text = re.sub(r'\s+', ' ', text)
-        text = re.sub(r'[^\w\s]', ' ', text)
-        text = text.lower().strip()
+        text = re.sub(r'[^\w\s.,()-]', ' ', text)
+        text = text.strip()
         return text
     
-    def extract_keywords(self, text, top_n=20):
-        """Extract important keywords from text"""
-        words = word_tokenize(text.lower())
-        words = [word for word in words if word.isalpha() and word not in self.stop_words and len(word) > 2]
+    def extract_ats_keywords(self, text, job_text=""):
+        """Extract ATS-relevant keywords with weighting"""
+        text_lower = text.lower()
+        job_lower = job_text.lower() if job_text else ""
         
-        # Get most common words
-        word_freq = Counter(words)
-        keywords = [word for word, freq in word_freq.most_common(top_n)]
-        return keywords
-    
-    def calculate_keyword_match(self, resume_keywords, job_keywords):
-        """Calculate keyword matching score"""
-        resume_set = set(resume_keywords)
-        job_set = set(job_keywords)
+        # Extract keywords by category
+        found_keywords = {}
         
-        if not job_set:
-            return 0
+        for category, keywords in self.ats_categories.items():
+            found = []
+            for keyword in keywords:
+                if keyword in text_lower:
+                    # Give extra weight if keyword is also in job description
+                    weight = 2 if keyword in job_lower else 1
+                    found.append((keyword, weight))
+            found_keywords[category] = found
         
-        intersection = resume_set.intersection(job_set)
-        return len(intersection) / len(job_set) * 100
+        # Extract custom keywords from job description
+        if job_text:
+            job_keywords = self.extract_job_specific_keywords(job_text)
+            found_keywords['job_specific'] = [(kw, 3) for kw in job_keywords if kw in text_lower]
+        
+        return found_keywords
     
-    def get_semantic_similarity(self, resume_text, job_text):
-        """Calculate semantic similarity using sentence transformers"""
-        # Split texts into sentences for better analysis
-        resume_sentences = sent_tokenize(resume_text)
-        job_sentences = sent_tokenize(job_text)
-        
-        # Encode texts
-        resume_embedding = self.model.encode(resume_text)
-        job_embedding = self.model.encode(job_text)
-        
-        # Calculate cosine similarity
-        similarity = cosine_similarity([resume_embedding], [job_embedding])[0][0]
-        return similarity * 100
+    def extract_job_specific_keywords(self, job_text):
+        """Extract important keywords specific to the job posting"""
+        # Remove common job posting fluff
+        job_text = re.sub(r'(we are looking for|ideal candidate|requirements|qualifications|responsibilities)', '', job_text.lower())
+        
+        words = word_tokenize(job_text.lower())
+        words = [word for word in words if word.isalpha() and word not in self.stop_words and len(word) > 3]
+        
+        # Get most frequent words as job-specific keywords
+        word_freq = Counter(words)
+        job_keywords = [word for word, freq in word_freq.most_common(15) if freq >= 2]
+        
+        return job_keywords
     
-    def analyze_sections(self, resume_text, job_text):
-        """Analyze different sections of resume vs job requirements"""
-        # Common resume sections patterns
+    def analyze_resume_structure(self, resume_text):
+        """Analyze resume structure and format (ATS-friendly check)"""
+        structure_score = 100
+        issues = []
+        
+        # Check for common sections
         sections = {
-            'experience': r'(experience|work history|employment|career|professional)',
-            'skills': r'(skills|competencies|technical|technologies|tools)',
-            'education': r'(education|degree|university|college|academic)',
-            'projects': r'(projects|portfolio|achievements|accomplishments)'
+            'contact': r'(email|phone|@|linkedin|github)',
+            'experience': r'(experience|work|employment|career)',
+            'education': r'(education|degree|university|college)',
+            'skills': r'(skills|technical|technologies|competencies)'
         }
         
-        section_scores = {}
+        found_sections = 0
         for section, pattern in sections.items():
-            # Extract relevant text from resume
-            resume_section = self.extract_section_text(resume_text, pattern)
-            if resume_section:
-                score = self.get_semantic_similarity(resume_section, job_text)
-                section_scores[section] = min(score, 100)
+            if re.search(pattern, resume_text, re.IGNORECASE):
+                found_sections += 1
             else:
-                section_scores[section] = 0
+                issues.append(f"Missing {section} section")
         
-        return section_scores
-    
-    def extract_section_text(self, text, pattern):
-        """Extract text from specific sections"""
-        sentences = sent_tokenize(text)
-        relevant_sentences = []
-        
-        for sentence in sentences:
-            if re.search(pattern, sentence, re.IGNORECASE):
-                relevant_sentences.append(sentence)
-        
-        # Also include sentences around matches for context
-        for i, sentence in enumerate(sentences):
-            if re.search(pattern, sentence, re.IGNORECASE):
-                if i > 0:
-                    relevant_sentences.append(sentences[i-1])
-                if i < len(sentences) - 1:
-                    relevant_sentences.append(sentences[i+1])
-        
-        return ' '.join(relevant_sentences)
+        section_score = (found_sections / len(sections)) * 100
+        
+        # Check for formatting issues
+        if len(resume_text.split('\n')) < 10:
+            structure_score -= 20
+            issues.append("Resume appears to lack proper formatting/structure")
+        
+        # Check length
+        word_count = len(resume_text.split())
+        if word_count < 200:
+            structure_score -= 30
+            issues.append("Resume is too short (less than 200 words)")
+        elif word_count > 1000:
+            structure_score -= 10
+            issues.append("Resume might be too long for ATS systems")
+        
+        return max(0, (structure_score + section_score) / 2), issues
     
-    def generate_suggestions(self, resume_text, job_text, overall_score, section_scores, keyword_match_score):
-        """Generate improvement suggestions"""
-        suggestions = []
+    def calculate_ats_score(self, resume_keywords, job_keywords, resume_text, job_text):
+        """Calculate ATS-style matching score"""
+        self.update_progress("🤖 Calculating ATS compatibility...", 60)
         
-        if overall_score < 70:
-            suggestions.append("📈 **Overall Score Enhancement**: Your resume needs significant improvement to match this job. Consider tailoring your resume more specifically to the job requirements.")
+        total_score = 0
+        max_possible_score = 0
+        category_scores = {}
         
-        if keyword_match_score < 40:
-            job_keywords = self.extract_keywords(job_text, 15)
-            resume_keywords = self.extract_keywords(resume_text, 15)
-            missing_keywords = set(job_keywords) - set(resume_keywords)
-            if missing_keywords:
-                suggestions.append(f"🔑 **Missing Keywords**: Consider incorporating these relevant keywords: {', '.join(list(missing_keywords)[:8])}")
+        # Weight different categories
+        category_weights = {
+            'technical_skills': 0.35,
+            'soft_skills': 0.15,
+            'experience_indicators': 0.25,
+            'education_keywords': 0.10,
+            'job_specific': 0.15
+        }
         
-        # Section-specific suggestions
-        if section_scores.get('skills', 0) < 50:
-            suggestions.append("🛠️ **Skills Section**: Enhance your skills section to better match the job requirements. Include both technical and soft skills mentioned in the job description.")
+        for category, weight in category_weights.items():
+            max_possible_score += weight * 100
+            
+            if category in resume_keywords and category in job_keywords:
+                resume_kw = dict(resume_keywords[category])
+                job_kw = dict(job_keywords[category]) if isinstance(job_keywords[category][0], tuple) else {kw: 1 for kw in job_keywords[category]}
+                
+                if job_kw:  # Only score if there are job keywords in this category
+                    matched_score = 0
+                    for kw, weight_val in resume_kw.items():
+                        if kw in job_kw:
+                            matched_score += weight_val * job_kw[kw]
+                    
+                    category_score = min(100, (matched_score / max(1, sum(job_kw.values()))) * 100)
+                    category_scores[category] = category_score
+                    total_score += weight * category_score
+                else:
+                    category_scores[category] = 0
+            else:
+                category_scores[category] = 0
         
-        if section_scores.get('experience', 0) < 50:
-            suggestions.append("💼 **Experience Section**: Better highlight your relevant work experience. Use action verbs and quantify your achievements where possible.")
+        # Semantic similarity bonus
+        semantic_score = self.get_semantic_similarity(resume_text, job_text)
+        total_score += 0.2 * semantic_score  # 20% weight for semantic similarity
+        max_possible_score += 0.2 * 100
         
-        if section_scores.get('education', 0) < 30 and 'education' in job_text.lower():
-            suggestions.append("🎓 **Education Section**: If you have relevant educational background, make sure it's prominently featured and matches job requirements.")
+        final_score = min(100, (total_score / max_possible_score) * 100)
         
-        if overall_score > 80:
-            suggestions.append("✅ **Great Match**: Your resume shows strong alignment with this job! Consider minor tweaks to optimize further.")
-        elif overall_score > 60:
-            suggestions.append("👍 **Good Foundation**: You have a solid foundation. Focus on highlighting the most relevant experiences and skills.")
+        return final_score, category_scores, semantic_score
+    
+    def get_semantic_similarity(self, resume_text, job_text):
+        """Calculate semantic similarity using transformer model"""
+        try:
+            # Encode texts
+            resume_embedding = self.semantic_model.encode(resume_text)
+            job_embedding = self.semantic_model.encode(job_text)
+            
+            # Calculate cosine similarity
+            similarity = cosine_similarity([resume_embedding], [job_embedding])[0][0]
+            return max(0, similarity * 100)
+        except Exception as e:
+            # Fallback to simple word overlap
+            resume_words = set(resume_text.lower().split())
+            job_words = set(job_text.lower().split())
+            overlap = len(resume_words.intersection(job_words))
+            return min(100, (overlap / len(job_words)) * 100) if job_words else 0
+    
+    def generate_ats_suggestions(self, resume_keywords, job_keywords, category_scores, structure_score, structure_issues):
+        """Generate ATS-specific improvement suggestions"""
+        suggestions = []
+        
+        # Structure suggestions
+        if structure_score < 80:
+            suggestions.append(f"📋 **Resume Structure** (Score: {structure_score:.0f}/100): " + 
+                             f"Improve resume formatting. Issues found: {', '.join(structure_issues)}")
+        
+        # Category-specific suggestions
+        for category, score in category_scores.items():
+            if score < 60:
+                category_name = category.replace('_', ' ').title()
+                if category == 'technical_skills':
+                    suggestions.append(f"💻 **{category_name}** (Score: {score:.0f}/100): Add more relevant technical skills mentioned in the job description. Consider including specific tools, programming languages, or technologies.")
+                elif category == 'experience_indicators':
+                    suggestions.append(f"📈 **{category_name}** (Score: {score:.0f}/100): Use more action verbs like 'managed', 'developed', 'implemented', 'led' to describe your achievements.")
+                elif category == 'job_specific':
+                    suggestions.append(f"🎯 **{category_name}** (Score: {score:.0f}/100): Include more keywords that are specific to this job posting.")
+                else:
+                    suggestions.append(f"🔧 **{category_name}** (Score: {score:.0f}/100): Enhance this section to better match job requirements.")
         
-        # Always add a general suggestion
-        suggestions.append("💡 **Pro Tip**: Customize your resume for each application by emphasizing the most relevant experiences and using similar language to the job description.")
+        # Overall suggestions based on total score
+        overall_score = np.mean(list(category_scores.values()))
+        if overall_score < 40:
+            suggestions.append("🚨 **Critical**: Your resume needs significant optimization for ATS systems. Consider using more keywords from the job description.")
+        elif overall_score < 70:
+            suggestions.append("⚠️ **Moderate**: Your resume has good potential but needs keyword optimization to improve ATS compatibility.")
+        else:
+            suggestions.append("✅ **Good**: Your resume shows strong ATS compatibility. Minor tweaks could make it even better.")
+        
+        # Add specific actionable suggestions
+        suggestions.append("💡 **ATS Tips**: Use standard section headings, include keywords naturally in context, quantify achievements with numbers, and save as PDF to preserve formatting.")
         
         return suggestions
     
-    def process_files(self, resume_file, job_description):
-        """Main processing function"""
+    def process_resume_analysis(self, resume_file, job_description, progress=gr.Progress()):
+        """Main processing function with progress tracking"""
         try:
-            # Extract text from resume file
+            # Set up progress tracking
+            def update_progress_ui(message, prog):
+                progress(prog/100, desc=message)
+            
+            self.set_progress_callback(update_progress_ui)
+            
+            # Validation
             if resume_file is None:
                 return "Please upload a resume file.", "", "", ""
             
             if not job_description.strip():
                 return "Please provide a job description.", "", "", ""
             
-            # Handle different ways Gradio might pass the file
+            self.update_progress("📄 Reading resume file...", 30)
+            
+            # Extract text from resume
             if hasattr(resume_file, 'name'):
                 filename = resume_file.name.lower()
-                # Read the file content
                 with open(resume_file.name, 'rb') as f:
                     file_content = f.read()
             else:
-                # If resume_file is already the file path (string)
                 filename = str(resume_file).lower()
                 with open(resume_file, 'rb') as f:
                     file_content = f.read()
             
-            # Determine file type and extract text
             if filename.endswith('.pdf'):
                 resume_text = self.extract_text_from_pdf(file_content)
             elif filename.endswith('.docx'):
                 resume_text = self.extract_text_from_docx(file_content)
             else:
-                return f"Unsupported file format for file: {filename}. Please upload PDF or DOCX files.", "", "", ""
+                return f"Unsupported file format: {filename}. Please upload PDF or DOCX files.", "", "", ""
             
             if "Error reading" in resume_text:
                 return resume_text, "", "", ""
             
+            self.update_progress("🔍 Analyzing resume structure...", 40)
+            
             # Preprocess texts
             resume_clean = self.preprocess_text(resume_text)
             job_clean = self.preprocess_text(job_description)
             
-            if len(resume_clean) < 50:
-                return "Resume text is too short or couldn't be extracted properly.", "", "", ""
+            if len(resume_clean.split()) < 50:
+                return "Resume text is too short or couldn't be extracted properly. Please ensure your PDF/DOCX contains readable text.", "", "", ""
             
-            # Calculate different scores
-            semantic_score = self.get_semantic_similarity(resume_clean, job_clean)
+            # Structure analysis
+            structure_score, structure_issues = self.analyze_resume_structure(resume_clean)
             
-            # Keyword matching
-            resume_keywords = self.extract_keywords(resume_clean)
-            job_keywords = self.extract_keywords(job_clean)
-            keyword_score = self.calculate_keyword_match(resume_keywords, job_keywords)
+            self.update_progress("🎯 Extracting ATS keywords...", 50)
             
-            # Section analysis
-            section_scores = self.analyze_sections(resume_clean, job_clean)
+            # Extract ATS keywords
+            resume_keywords = self.extract_ats_keywords(resume_clean, job_clean)
+            job_keywords = self.extract_ats_keywords(job_clean)
             
-            # Calculate overall score (weighted average)
-            overall_score = (
-                semantic_score * 0.4 +  # Semantic similarity (40%)
-                keyword_score * 0.3 +   # Keyword matching (30%)
-                np.mean(list(section_scores.values())) * 0.3  # Section scores (30%)
+            # Calculate ATS score
+            ats_score, category_scores, semantic_score = self.calculate_ats_score(
+                resume_keywords, job_keywords, resume_clean, job_clean
             )
             
-            overall_score = min(round(overall_score), 100)  # Cap at 100
+            self.update_progress("💡 Generating improvement suggestions...", 80)
             
             # Generate suggestions
-            suggestions = self.generate_suggestions(
-                resume_clean, job_clean, overall_score, section_scores, keyword_score
+            suggestions = self.generate_ats_suggestions(
+                resume_keywords, job_keywords, category_scores, structure_score, structure_issues
             )
             
+            self.update_progress("✅ Analysis complete!", 100)
+            
             # Format results
-            score_text = f"# 🎯 Resume Match Score: {overall_score}/100\n\n"
+            score_text = f"# 🎯 ATS Compatibility Score: {ats_score:.0f}/100\n\n"
             
-            details = f"""## 📊 Detailed Analysis
+            if ats_score >= 80:
+                score_text += "🟢 **Excellent ATS Compatibility** - Your resume should pass most ATS systems"
+            elif ats_score >= 60:
+                score_text += "🟡 **Good ATS Compatibility** - Some improvements recommended"
+            elif ats_score >= 40:
+                score_text += "🟠 **Moderate ATS Compatibility** - Significant improvements needed"
+            else:
+                score_text += "🔴 **Poor ATS Compatibility** - Major optimization required"
             
-**Semantic Similarity**: {semantic_score:.1f}/100
-**Keyword Match**: {keyword_score:.1f}/100
+            details = f"""## 📊 Detailed ATS Analysis
+
+**Overall Structure Score**: {structure_score:.1f}/100
+**Semantic Match**: {semantic_score:.1f}/100
 
-### Section Scores:
-- **Experience**: {section_scores.get('experience', 0):.1f}/100
-- **Skills**: {section_scores.get('skills', 0):.1f}/100  
-- **Education**: {section_scores.get('education', 0):.1f}/100
-- **Projects**: {section_scores.get('projects', 0):.1f}/100
+### Category Breakdown:
+- **Technical Skills**: {category_scores.get('technical_skills', 0):.1f}/100
+- **Experience Indicators**: {category_scores.get('experience_indicators', 0):.1f}/100  
+- **Job-Specific Keywords**: {category_scores.get('job_specific', 0):.1f}/100
+- **Soft Skills**: {category_scores.get('soft_skills', 0):.1f}/100
+- **Education Keywords**: {category_scores.get('education_keywords', 0):.1f}/100
 """
             
-            suggestions_text = "## 💡 Improvement Suggestions\n\n" + "\n\n".join(suggestions)
+            suggestions_text = "## 💡 ATS Optimization Suggestions\n\n" + "\n\n".join(suggestions)
+            
+            # Keywords analysis
+            resume_tech_kw = [kw for kw, _ in resume_keywords.get('technical_skills', [])]
+            job_specific_kw = [kw for kw, _ in resume_keywords.get('job_specific', [])]
             
-            # Keywords comparison
-            common_keywords = set(resume_keywords[:10]).intersection(set(job_keywords[:10]))
             keywords_text = f"""## 🔍 Keyword Analysis
             
-**Top Resume Keywords**: {', '.join(resume_keywords[:10])}
+**Technical Skills Found**: {', '.join(resume_tech_kw[:10]) if resume_tech_kw else 'None detected'}
 
-**Top Job Keywords**: {', '.join(job_keywords[:10])}
+**Job-Specific Keywords Found**: {', '.join(job_specific_kw[:10]) if job_specific_kw else 'None detected'}
 
-**Matching Keywords**: {', '.join(common_keywords) if common_keywords else 'None found'}
+**ATS Tip**: Ensure keywords appear naturally in context, not just in a skills list.
 """
             
             return score_text, details, suggestions_text, keywords_text
             
         except Exception as e:
-            return f"An error occurred: {str(e)}", "", "", ""
+            return f"An error occurred during analysis: {str(e)}", "", "", ""
 
-# Initialize the matcher
-matcher = ResumeJobMatcher()
+# Initialize the analyzer
+analyzer = ATSResumeAnalyzer()
 
 # Create Gradio interface
 def create_interface():
-    with gr.Blocks(title="Resume Job Matcher", theme=gr.themes.Soft()) as interface:
+    with gr.Blocks(title="ATS Resume Analyzer", theme=gr.themes.Soft()) as interface:
         gr.HTML("""
         <div style='text-align: center; padding: 20px;'>
-            <h1>🎯 AI Resume Job Matcher</h1>
-            <p>Upload your resume and paste the job description to get a compatibility score and improvement suggestions!</p>
+            <h1>🤖 AI-Powered ATS Resume Analyzer</h1>
+            <p>Get your resume analyzed like real ATS systems! Upload your resume and job description to receive detailed compatibility scoring and optimization suggestions.</p>
         </div>
         """)
         
@@ -303,32 +442,32 @@ def create_interface():
                 
                 gr.HTML("<h3>📋 Job Description</h3>")
                 job_description = gr.Textbox(
-                    label="Paste Job Description",
-                    placeholder="Paste the complete job description here...",
-                    lines=10,
-                    max_lines=15
+                    label="Paste Complete Job Description",
+                    placeholder="Paste the full job description including requirements, qualifications, and responsibilities...",
+                    lines=12,
+                    max_lines=20
                 )
                 
-                analyze_btn = gr.Button("🔍 Analyze Match", variant="primary", size="lg")
+                analyze_btn = gr.Button("🚀 Analyze with ATS", variant="primary", size="lg")
             
             with gr.Column(scale=1):
-                score_output = gr.Markdown(label="Match Score")
+                score_output = gr.Markdown(label="ATS Compatibility Score")
                 details_output = gr.Markdown(label="Detailed Analysis")
-                suggestions_output = gr.Markdown(label="Suggestions")
+                suggestions_output = gr.Markdown(label="Optimization Suggestions")
                 keywords_output = gr.Markdown(label="Keywords Analysis")
         
-        # Set up the event handler
+        # Set up the event handler with progress tracking
         analyze_btn.click(
-            fn=matcher.process_files,
+            fn=analyzer.process_resume_analysis,
             inputs=[resume_file, job_description],
             outputs=[score_output, details_output, suggestions_output, keywords_output]
         )
         
         gr.HTML("""
         <div style='text-align: center; padding: 20px; margin-top: 30px; border-top: 1px solid #ddd;'>
-            <p><strong>How it works:</strong> This tool uses advanced AI to analyze semantic similarity between your resume and job description, 
-            performs keyword matching, and provides personalized suggestions for improvement.</p>
-            <p><em>Supported formats: PDF, DOCX</em></p>
+            <p><strong>🎯 ATS-Powered Analysis:</strong> This tool simulates real ATS (Applicant Tracking System) behavior using advanced AI models for keyword extraction, semantic analysis, and resume structure evaluation.</p>
+            <p><strong>📈 What makes this different:</strong> Unlike simple keyword matching, this analyzer considers context, semantic meaning, industry-specific terms, and proper resume structure - just like enterprise ATS systems.</p>
+            <p><em>Supported formats: PDF, DOCX | Optimized for CPU performance</em></p>
         </div>
         """)