def calculate_job_profile_skill_priority_score(user_skills, job_profile_skills, course_skills): """ Calculate priority score based on job profile skills alignment. Higher scores for courses that align with job profile requirements. Skills required for the target role that the user lacks are given the highest priority. """ if not course_skills: return 0 # Create skill maps for efficient lookup user_skill_map = { skill.get('skill_id'): { 'name': skill.get('skill_name'), 'current_level': int(skill.get('skill_type', 1)) } for skill in (user_skills or []) if skill.get('skill_id') } course_skill_map = { skill.get('skill_id'): { 'name': skill.get('skill_name'), 'course_level': int(skill.get('skill_type', 1)) } for skill in course_skills if skill.get('skill_id') } # Also map by skill name for better matching user_skill_name_map = { skill.get('skill_name', '').lower(): { 'current_level': int(skill.get('skill_type', 1)) } for skill in (user_skills or []) if skill.get('skill_name') } course_skill_name_map = { skill.get('skill_name', '').lower(): { 'course_level': int(skill.get('skill_type', 1)) } for skill in course_skills if skill.get('skill_name') } priority_score = 0 # Prioritize job profile skills for target_skill in job_profile_skills: skill_id = target_skill.get('skill_id') skill_name = target_skill.get('skill_name', '').lower() required_level = int(target_skill.get('skill_type', 1)) # Check if course covers this skill (by ID or name) course_covers_skill = False course_level = 0 if skill_id and skill_id in course_skill_map: course_covers_skill = True course_level = course_skill_map[skill_id]['course_level'] elif skill_name in course_skill_name_map: course_covers_skill = True course_level = course_skill_name_map[skill_name]['course_level'] if course_covers_skill: # Get user's current level for this skill user_current_level = 0 if skill_id and skill_id in user_skill_map: user_current_level = user_skill_map[skill_id]['current_level'] elif skill_name in user_skill_name_map: user_current_level = user_skill_name_map[skill_name]['current_level'] # CRITICAL: User doesn't have the required skill at all if user_current_level == 0: priority_score += 35 # Maximum critical priority # HIGH: User has the skill but significantly below the required level elif user_current_level < required_level: gap = required_level - user_current_level priority_score += 25 + (gap * 4) # Scale based on gap size # MEDIUM: Course can advance the skill beyond the required level elif course_level > user_current_level: priority_score += 15 # LOW: Skill maintenance or reinforcement else: priority_score += 5 # Additional scoring for courses that teach new skills (not in target skills) for course_skill in course_skills: skill_id = course_skill.get('skill_id') skill_name = course_skill.get('skill_name', '').lower() # Check if this is a new skill not in target skills is_target_skill = any( (skill_id and target_skill.get('skill_id') == skill_id) or (skill_name and target_skill.get('skill_name', '').lower() == skill_name) for target_skill in job_profile_skills ) if not is_target_skill: # Check if user has this skill user_current_level = 0 if skill_id and skill_id in user_skill_map: user_current_level = user_skill_map[skill_id]['current_level'] elif skill_name in user_skill_name_map: user_current_level = user_skill_name_map[skill_name]['current_level'] # Bonus for teaching new skills if user_current_level == 0: priority_score += 10 # Medium priority for new skills elif int(course_skill.get('skill_type', 1)) > user_current_level: priority_score += 8 # Low priority for skill advancement return min(priority_score, 100) # Cap at 100 def calculate_skill_gap_bonus(user_skills, course_skills): """Calculate bonus for courses that fill skill gaps""" if not course_skills: return 0 user_skill_ids = {skill.get('skill_id') for skill in user_skills if skill.get('skill_id')} course_skill_ids = {skill.get('skill_id') for skill in course_skills if skill.get('skill_id')} # Bonus for teaching new skills new_skills = course_skill_ids - user_skill_ids new_skill_bonus = len(new_skills) * 5 # Bonus for advancing existing skills advancement_bonus = 0 user_skill_levels = { skill.get('skill_id'): int(skill.get('skill_type', 1)) for skill in user_skills if skill.get('skill_id') } for course_skill in course_skills: skill_id = course_skill.get('skill_id') course_level = int(course_skill.get('skill_type', 1)) user_level = user_skill_levels.get(skill_id, 0) if user_level > 0 and course_level > user_level: advancement_bonus += (course_level - user_level) * 3 return min(new_skill_bonus + advancement_bonus, 25) def calculate_designation_progression_bonus(designation, course_skills, user_skills): """Calculate bonus based on career progression relevance for designation""" if not designation or not course_skills: return 0 designation_lower = designation.lower() progression_bonus = 0 # Enhanced career progression mapping progression_skills_map = { 'intern': { 'next_level': ['junior', 'associate'], 'skills': ['communication', 'time management', 'learning', 'basic technical'], 'bonus': 8 }, 'junior': { 'next_level': ['engineer', 'developer', 'analyst'], 'skills': ['programming', 'problem solving', 'teamwork', 'project work'], 'bonus': 10 }, 'engineer': { 'next_level': ['senior engineer', 'lead engineer', 'specialist'], 'skills': ['leadership', 'architecture', 'mentoring', 'advanced technical'], 'bonus': 12 }, 'senior': { 'next_level': ['lead', 'principal', 'manager'], 'skills': ['leadership', 'strategy', 'system design', 'team management'], 'bonus': 15 }, 'lead': { 'next_level': ['manager', 'director', 'principal'], 'skills': ['team leadership', 'project management', 'strategic planning', 'decision making'], 'bonus': 18 }, 'manager': { 'next_level': ['senior manager', 'director'], 'skills': ['people management', 'budgeting', 'strategic thinking', 'stakeholder management'], 'bonus': 20 }, 'analyst': { 'next_level': ['senior analyst', 'data scientist', 'consultant'], 'skills': ['data analysis', 'visualization', 'reporting', 'statistical analysis'], 'bonus': 12 }, 'developer': { 'next_level': ['senior developer', 'tech lead', 'architect'], 'skills': ['advanced programming', 'code review', 'technical leadership', 'system design'], 'bonus': 12 } } # Find matching progression path progression_info = None for role_key, info in progression_skills_map.items(): if role_key in designation_lower: progression_info = info break if not progression_info: return 5 # Default small bonus # Check if course covers progression-relevant skills course_skill_names = [skill.get('skill_name', '').lower() for skill in course_skills] relevant_skills = progression_info['skills'] base_bonus = progression_info['bonus'] skill_matches = 0 for relevant_skill in relevant_skills: for course_skill_name in course_skill_names: if any(keyword in course_skill_name for keyword in relevant_skill.split()): skill_matches += 1 break if skill_matches > 0: progression_bonus = base_bonus + (skill_matches * 3) return min(progression_bonus, 35) def match_skills(user_skills, course_skills): """Original skill matching function (preserved for compatibility)""" if not course_skills or not user_skills: return 0 user_skill_levels = { skill.get('skill_id'): int(skill.get('skill_type', 1)) for skill in user_skills if skill.get('skill_id') } course_skill_levels = { skill.get('skill_id'): int(skill.get('skill_type', 1)) for skill in course_skills if skill.get('skill_id') } if not user_skill_levels or not course_skill_levels: return 0 match_score = 0 total_possible_matches = 0 for skill_id, course_level in course_skill_levels.items(): total_possible_matches += 1 if skill_id in user_skill_levels: user_level = user_skill_levels[skill_id] # Perfect match if course_level == user_level: match_score += 3 # Course is one level higher (good for progression) elif course_level == user_level + 1: match_score += 2 # Course is higher level (challenging but beneficial) elif course_level > user_level: match_score += 1 else: # New skill - moderate value match_score += 1 if total_possible_matches > 0: return min((match_score / (total_possible_matches * 3)) * 100, 100) return 0 def analyze_job_profile_alignment(user_skills, job_profile_skills, job_profile_name): """Analyze how well user's current skills align with job profile requirements""" if not job_profile_skills: return { "alignment_percentage": 0.0, "missing_skills": [], "skill_gaps": [], "strengths": [], "job_profile_name": job_profile_name or "Not specified" } user_skill_map = { skill.get('skill_id'): { 'name': skill.get('skill_name'), 'level': int(skill.get('skill_type', 1)) } for skill in user_skills if skill.get('skill_id') } missing_skills = [] skill_gaps = [] strengths = [] total_required_skills = len(job_profile_skills) aligned_skills = 0 for required_skill in job_profile_skills: skill_id = required_skill.get('skill_id') skill_name = required_skill.get('skill_name') required_level = int(required_skill.get('skill_type', 1)) if skill_id in user_skill_map: user_level = user_skill_map[skill_id]['level'] if user_level >= required_level: strengths.append({ 'skill_name': skill_name, 'user_level': user_level, 'required_level': required_level }) aligned_skills += 1 else: skill_gaps.append({ 'skill_name': skill_name, 'user_level': user_level, 'required_level': required_level, 'gap': required_level - user_level }) else: missing_skills.append({ 'skill_name': skill_name, 'required_level': required_level }) alignment_percentage = (aligned_skills / total_required_skills) * 100 if total_required_skills > 0 else 0.0 return { "alignment_percentage": round(alignment_percentage, 1), "missing_skills": missing_skills, "skill_gaps": skill_gaps, "strengths": strengths, "job_profile_name": job_profile_name or "Not specified" } def build_enhanced_prompt_section(job_profile_analysis): """Build the job profile analysis section for the prompt with proper formatting""" alignment_pct = job_profile_analysis['alignment_percentage'] # Ensure the percentage is properly formatted as a string alignment_text = f"{alignment_pct:.1f}%" if alignment_pct > 0 else "0.0%" return f""" PROFESSIONAL ANALYSIS CONTEXT: Current Job Profile Alignment: {alignment_text} Missing Critical Skills: {len(job_profile_analysis['missing_skills'])} skills Skill Gaps to Address: {len(job_profile_analysis['skill_gaps'])} skills Current Strengths: {len(job_profile_analysis['strengths'])} skills at required level """ def analyze_skill_gaps(user_skills, job_profile_skills=None, job_profile_name=None): """Enhanced skill gap analysis with job profile consideration""" if not user_skills and not job_profile_skills: return { "chart_data": { "radar": { "labels": ["No Skills Data Available"], "datasets": [ { "label": "Current Skills", "data": [0], "backgroundColor": "rgba(54, 162, 235, 0.2)", "borderColor": "rgba(54, 162, 235, 1)", "pointBackgroundColor": "rgba(54, 162, 235, 1)" }, { "label": "Target Skills", "data": [3], "backgroundColor": "rgba(255, 99, 132, 0.2)", "borderColor": "rgba(255, 99, 132, 1)", "pointBackgroundColor": "rgba(255, 99, 132, 1)" } ] }, "bar": { "labels": ["No Skills Data Available"], "datasets": [ { "label": "Skill Gap", "data": [3], "backgroundColor": "rgba(255, 159, 64, 0.7)" } ] } }, "summary": "No skill data available. Complete a skills assessment for personalized recommendations.", "job_profile_gaps": [], "other_gaps": [], "strengths": [], "total_skills_analyzed": 0 } # Comprehensive skill analysis all_skills = {} # Process user skills for skill in user_skills or []: skill_id = skill.get('skill_id') if skill_id: all_skills[skill_id] = { 'name': skill.get('skill_name', 'Unknown Skill'), 'current_level': int(skill.get('skill_type', 1)), 'target_level': 3, # Default advanced target 'is_user_skill': True, 'is_job_profile_skill': False } # Process job profile skills for skill in job_profile_skills or []: skill_id = skill.get('skill_id') if skill_id: required_level = int(skill.get('skill_type', 1)) if skill_id in all_skills: all_skills[skill_id]['target_level'] = max(required_level, all_skills[skill_id]['target_level']) all_skills[skill_id]['is_job_profile_skill'] = True else: all_skills[skill_id] = { 'name': skill.get('skill_name', 'Unknown Skill'), 'current_level': 0, # Set to 0 if the user does not have the skill 'target_level': required_level, 'is_user_skill': False, 'is_job_profile_skill': True } # Calculate gaps and prepare analysis skills_analysis = [] for skill_id, skill_data in all_skills.items(): gap = skill_data['target_level'] - skill_data['current_level'] skill_data['gap'] = max(gap, 0) # Ensure non-negative gaps skills_analysis.append(skill_data) # Prioritize: job profile skills first, then by gap size skills_analysis.sort(key=lambda x: (not x['is_job_profile_skill'], -x['gap'], x['name'])) # Select top skills for visualization top_skills = skills_analysis[:12] # Show more skills in analysis # Prepare chart data skill_names = [skill["name"] for skill in top_skills] current_levels = [skill["current_level"] for skill in top_skills] target_levels = [skill["target_level"] for skill in top_skills] gap_values = [skill["gap"] for skill in top_skills] chart_data = { "radar": { "labels": skill_names, "datasets": [ { "label": "Current Skills", "data": current_levels, "backgroundColor": "rgba(54, 162, 235, 0.2)", "borderColor": "rgba(54, 162, 235, 1)", "pointBackgroundColor": "rgba(54, 162, 235, 1)" }, { "label": f"Target Skills{' (' + job_profile_name + ')' if job_profile_name else ''}", "data": target_levels, "backgroundColor": "rgba(255, 99, 132, 0.2)", "borderColor": "rgba(255, 99, 132, 1)", "pointBackgroundColor": "rgba(255, 99, 132, 1)" } ] }, "bar": { "labels": skill_names, "datasets": [ { "label": "Skill Gap", "data": gap_values, "backgroundColor": [ "rgba(255, 99, 132, 0.7)" if skill['is_job_profile_skill'] else "rgba(255, 159, 64, 0.7)" for skill in top_skills ] } ] } } # Generate comprehensive summary job_profile_gaps = [skill for skill in top_skills if skill['is_job_profile_skill'] and skill['gap'] > 0] other_gaps = [skill for skill in top_skills if not skill['is_job_profile_skill'] and skill['gap'] > 0] strengths = [skill for skill in top_skills if skill['gap'] == 0 and skill['current_level'] >= 2] summary_parts = [] if job_profile_name: if job_profile_gaps: critical_gaps = [skill for skill in job_profile_gaps if skill['gap'] >= 2] if critical_gaps: summary_parts.append(f"CRITICAL: {len(critical_gaps)} essential {job_profile_name} skills need development") else: summary_parts.append(f"Minor gaps in {len(job_profile_gaps)} {job_profile_name} skills") else: summary_parts.append(f"✓ All {job_profile_name} skill requirements met") if other_gaps: summary_parts.append(f"{len(other_gaps)} additional skills for career advancement") if strengths: summary_parts.append(f"Strong in {len(strengths)} key areas") # Generate the summary with the desired text for skill levels if job_profile_gaps: priority_skills = [f"{skill['name']} ({get_skill_level_name(skill['current_level'])})" for skill in job_profile_gaps] summary_parts.append(f"For your {job_profile_name} role, priority skill gaps: {', '.join(priority_skills)}") if other_gaps: growth_opportunities = [f"{skill['name']} ({get_skill_level_name(skill['current_level'])})" for skill in other_gaps] summary_parts.append(f"Additional growth opportunities: {', '.join(growth_opportunities)}") summary = ". ".join(summary_parts) if summary_parts else "Complete skills assessment for detailed analysis." return { "chart_data": chart_data, "summary": summary, "job_profile_gaps": job_profile_gaps, "other_gaps": other_gaps, "strengths": strengths, "total_skills_analyzed": len(skills_analysis) } def analyze_skill_gaps_with_target_role(user_skills, job_profile_skills=None, job_profile_name=None, user_query=""): """Enhanced skill gap analysis that prioritizes target role from query""" # Extract target role from query target_role = extract_target_role_from_query(user_query) target_role_skills = get_target_role_required_skills(target_role) if target_role else [] # Create comprehensive skill analysis all_skills = {} # Process existing user skills for skill in user_skills or []: skill_id = skill.get('skill_id') skill_name = skill.get('skill_name') if skill_id and skill_name: all_skills[skill_name.lower()] = { 'name': skill_name, 'current_level': int(skill.get('skill_type', 1)), 'target_level': int(skill.get('skill_type', 1)), 'is_user_skill': True, 'is_job_profile_skill': False, 'is_target_role_skill': False, 'priority': 'existing' } # Process target role skills (HIGHEST PRIORITY) for skill_info in target_role_skills: skill_name = skill_info['skill_name'] skill_key = skill_name.lower() required_level = skill_info['skill_type'] priority = skill_info['priority'] if skill_key in all_skills: # Update existing skill with target role requirements all_skills[skill_key]['target_level'] = required_level all_skills[skill_key]['is_target_role_skill'] = True all_skills[skill_key]['priority'] = priority else: # NEW SKILL required for target role - CRITICAL PRIORITY all_skills[skill_key] = { 'name': skill_name, 'current_level': 0, 'target_level': required_level, 'is_user_skill': False, 'is_job_profile_skill': False, 'is_target_role_skill': True, 'priority': 'critical' # Force critical for new target role skills } # Process current job profile skills for skill in job_profile_skills or []: skill_name = skill.get('skill_name') if skill_name: skill_key = skill_name.lower() required_level = int(skill.get('skill_type', 1)) if skill_key in all_skills: # Only update if not already a target role skill if not all_skills[skill_key]['is_target_role_skill']: all_skills[skill_key]['target_level'] = max(required_level, all_skills[skill_key]['target_level']) all_skills[skill_key]['is_job_profile_skill'] = True all_skills[skill_key]['priority'] = 'current_role' else: # NEW SKILL from job profile - HIGH PRIORITY all_skills[skill_key] = { 'name': skill_name, 'current_level': 0, 'target_level': required_level, 'is_user_skill': False, 'is_job_profile_skill': True, 'is_target_role_skill': False, 'priority': 'high' # High priority for new job profile skills } # Calculate gaps and apply FIXED priority logic skills_analysis = [] for skill_data in all_skills.values(): gap = skill_data['target_level'] - skill_data['current_level'] skill_data['gap'] = max(gap, 0) # FIXED PRIORITY LOGIC: New skills (current_level = 0) get highest priority if skill_data['current_level'] == 0 and skill_data['gap'] > 0: if skill_data['is_target_role_skill']: skill_data['priority'] = 'critical' # New target role skills = CRITICAL skill_data['priority_score'] = 1 # Highest priority score elif skill_data['is_job_profile_skill']: skill_data['priority'] = 'high' # New job profile skills = HIGH skill_data['priority_score'] = 2 else: skill_data['priority'] = 'high' # Other new skills = HIGH skill_data['priority_score'] = 2 else: # Existing skills with gaps if skill_data['is_target_role_skill']: if skill_data.get('priority') == 'critical': skill_data['priority_score'] = 3 else: skill_data['priority_score'] = 4 elif skill_data['is_job_profile_skill']: skill_data['priority_score'] = 5 else: skill_data['priority_score'] = 6 skills_analysis.append(skill_data) # Sort by priority: NEW SKILLS with lowest priority_score come first skills_analysis.sort(key=lambda x: ( x.get('priority_score', 10), # Primary sort by priority score -x['gap'], # Secondary sort by gap size (descending) x['name'] # Tertiary sort by name for consistency )) # Get top skills top_skills = skills_analysis[:12] # Prepare chart data skill_names = [skill["name"] for skill in top_skills] current_levels = [skill["current_level"] for skill in top_skills] target_levels = [skill["target_level"] for skill in top_skills] gap_values = [skill["gap"] for skill in top_skills] # Create color coding based on priority - FIXED FOR NEW SKILLS bar_colors = [] for skill in top_skills: if skill['current_level'] == 0: # New skills get red coloring if skill['is_target_role_skill']: bar_colors.append("rgba(220, 53, 69, 0.9)") # Bright red for new target role skills else: bar_colors.append("rgba(255, 107, 107, 0.8)") # Lighter red for new job skills elif skill['priority'] == 'critical': bar_colors.append("rgba(220, 53, 69, 0.7)") # Red for critical existing skills elif skill['is_target_role_skill']: bar_colors.append("rgba(255, 193, 7, 0.8)") # Yellow for target role skills elif skill['is_job_profile_skill']: bar_colors.append("rgba(13, 202, 240, 0.7)") # Blue for current role skills else: bar_colors.append("rgba(108, 117, 125, 0.6)") # Gray for existing skills chart_data = { "radar": { "labels": skill_names, "datasets": [ { "label": "Current Skills", "data": current_levels, "backgroundColor": "rgba(54, 162, 235, 0.2)", "borderColor": "rgba(54, 162, 235, 1)", "pointBackgroundColor": "rgba(54, 162, 235, 1)" }, { "label": f"Target Skills{' (' + target_role + ')' if target_role else (' (' + job_profile_name + ')' if job_profile_name else '')}", "data": target_levels, "backgroundColor": "rgba(255, 99, 132, 0.2)", "borderColor": "rgba(255, 99, 132, 1)", "pointBackgroundColor": "rgba(255, 99, 132, 1)" } ] }, "bar": { "labels": skill_names, "datasets": [ { "label": "Skill Gap", "data": gap_values, "backgroundColor": bar_colors } ] } } # Generate categorized skill lists - FIXED CATEGORIZATION # Separate new skills from existing skills with gaps new_skills_needed = [skill for skill in top_skills if skill['current_level'] == 0 and skill['gap'] > 0] critical_new_skills = [skill for skill in new_skills_needed if skill['is_target_role_skill']] high_priority_new_skills = [skill for skill in new_skills_needed if not skill['is_target_role_skill']] # Existing skills that need improvement target_role_gaps = [skill for skill in top_skills if skill['is_target_role_skill'] and skill['gap'] > 0 and skill['current_level'] > 0] current_role_gaps = [skill for skill in top_skills if skill['is_job_profile_skill'] and skill['gap'] > 0 and not skill['is_target_role_skill']] strengths = [skill for skill in top_skills if skill['current_level'] >= skill['target_level'] and skill['current_level'] >= 2] # CORRECTED: other_gaps should prioritize NEW SKILLS first other_gaps = critical_new_skills + high_priority_new_skills + target_role_gaps if not other_gaps: # Fallback if no target role skills other_gaps = [skill for skill in top_skills if not skill['is_job_profile_skill'] and skill['gap'] > 0] job_profile_gaps = current_role_gaps # Generate summary with correct priority emphasis summary_parts = [] # PRIORITY 1: New critical skills for target role if critical_new_skills: critical_skill_names = [skill['name'] for skill in critical_new_skills[:3]] summary_parts.append(f"CRITICAL NEW SKILLS NEEDED: {', '.join(critical_skill_names)}") # PRIORITY 2: New high priority skills if high_priority_new_skills: high_skill_names = [skill['name'] for skill in high_priority_new_skills[:3]] summary_parts.append(f"HIGH PRIORITY NEW SKILLS: {', '.join(high_skill_names)}") # PRIORITY 3: Target role existing skill improvements if target_role and target_role_gaps: existing_improvements = [f"{skill['name']} ({get_skill_level_name(skill['current_level'])} → {get_skill_level_name(skill['target_level'])})" for skill in target_role_gaps[:3]] summary_parts.append(f"Enhance for {target_role}: {', '.join(existing_improvements)}") if current_role_gaps and not target_role: new_current_skills = [skill for skill in current_role_gaps if skill['current_level'] == 0] if new_current_skills: summary_parts.append(f"New skills for current role: {len(new_current_skills)} skills to acquire") else: summary_parts.append(f"Current role development: {len(current_role_gaps)} skills to enhance") if strengths: summary_parts.append(f"Strong foundation: {len(strengths)} advanced skills") summary = ". ".join(summary_parts) if summary_parts else "Complete skills assessment for detailed analysis." return { "chart_data": chart_data, "summary": summary, "job_profile_gaps": job_profile_gaps, "other_gaps": other_gaps, # Now correctly prioritizes new skills first "strengths": strengths, "total_skills_analyzed": len(skills_analysis) } def get_target_role_required_skills(target_role): """Get required skills for target role from query analysis - UPDATED""" if not target_role: return [] target_role_lower = target_role.lower() # Enhanced skill mapping with more comprehensive roles role_skill_mapping = { 'sales manager': [ {'skill_name': 'Sales Strategy', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Team Leadership', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Customer Relationship Management', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Negotiation', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Business Development', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Sales Forecasting', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Market Analysis', 'skill_type': 2, 'priority': 'medium'}, {'skill_name': 'Presentation Skills', 'skill_type': 2, 'priority': 'medium'}, ], 'product manager': [ {'skill_name': 'Product Strategy', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Market Research', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'User Experience Design', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Data Analysis', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Agile Methodology', 'skill_type': 2, 'priority': 'medium'}, {'skill_name': 'Stakeholder Management', 'skill_type': 2, 'priority': 'medium'}, ], 'marketing manager': [ {'skill_name': 'Digital Marketing', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Brand Management', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Content Strategy', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Social Media Marketing', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Marketing Analytics', 'skill_type': 2, 'priority': 'medium'}, {'skill_name': 'Campaign Management', 'skill_type': 2, 'priority': 'medium'}, ], 'project manager': [ {'skill_name': 'Project Planning', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Risk Management', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Stakeholder Management', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Budget Management', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Quality Assurance', 'skill_type': 2, 'priority': 'medium'}, {'skill_name': 'Agile Methodology', 'skill_type': 2, 'priority': 'medium'}, ], 'business analyst': [ {'skill_name': 'Business Process Analysis', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Requirements Gathering', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Data Modeling', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'SQL', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Process Improvement', 'skill_type': 2, 'priority': 'medium'}, {'skill_name': 'Stakeholder Management', 'skill_type': 2, 'priority': 'medium'}, ], 'software development engineer': [ {'skill_name': 'Programming', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Software Development', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Algorithms', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Data Structures', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'System Design', 'skill_type': 2, 'priority': 'medium'}, {'skill_name': 'Debugging', 'skill_type': 2, 'priority': 'medium'}, ] } # Find exact or partial matches for role_key, skills in role_skill_mapping.items(): if role_key in target_role_lower or target_role_lower in role_key: return skills # Check for partial matches (e.g., "sales" in "sales manager") role_words = role_key.split() target_words = target_role_lower.split() if any(word in target_words for word in role_words): return skills # Generic management skills if no specific role found but contains management keywords if any(keyword in target_role_lower for keyword in ['manager', 'lead', 'director', 'head', 'supervisor']): return [ {'skill_name': 'Team Leadership', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'Strategic Planning', 'skill_type': 3, 'priority': 'critical'}, {'skill_name': 'People Management', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Decision Making', 'skill_type': 2, 'priority': 'high'}, {'skill_name': 'Budget Management', 'skill_type': 2, 'priority': 'medium'}, {'skill_name': 'Performance Management', 'skill_type': 2, 'priority': 'medium'}, ] return [] def build_llm_skill_analysis_prompt(user_query, user_skills=None, job_profile_skills=None, job_profile_name=None, designation=None): """Build advanced LLM prompt for intelligent skill analysis based on user query""" # User skills context user_skills_text = "" if user_skills: user_skills_list = [] for skill in user_skills: skill_name = skill.get('skill_name', 'Unknown') skill_level = get_skill_level_name(int(skill.get('skill_type', 1))) user_skills_list.append(f"{skill_name} ({skill_level})") user_skills_text = f"Current user skills: {', '.join(user_skills_list)}" # Job profile context job_profile_text = "" if job_profile_name and job_profile_skills: job_skills_list = [] for skill in job_profile_skills: skill_name = skill.get('skill_name', 'Unknown') skill_level = get_skill_level_name(int(skill.get('skill_type', 1))) job_skills_list.append(f"{skill_name} ({skill_level})") job_profile_text = f"Current job profile '{job_profile_name}' requires: {', '.join(job_skills_list)}" designation_text = f"Current designation: {designation}" if designation else "" prompt = f""" ADVANCED CAREER SKILL ANALYSIS REQUEST User Query: "{user_query}" {designation_text} {job_profile_text} {user_skills_text} INSTRUCTIONS: Analyze the user's query intelligently and provide skill analysis recommendations in EXACT JSON format below. CRITICAL ANALYSIS RULES: 1. If user asks to transition to a NEW ROLE (e.g., "become sales manager"), focus ONLY on skills needed for that target role 2. Include user's existing skills ONLY if they are relevant to the target role from the query 3. If user asks general skill analysis, include both current role skills and growth opportunities 4. Always prioritize skills mentioned or implied in the user's specific query 5. Generate 8-12 relevant skills maximum for the target role/query 6. Skill levels: 1=Beginner, 2=Intermediate, 3=Advanced EXACT OUTPUT FORMAT (JSON only, no explanations): {{ "target_role_extracted": "extracted role from query or null", "analysis_type": "role_transition|skill_enhancement|general_analysis", "recommended_skills": [ {{ "skill_name": "Skill Name", "current_user_level": 0-3, "target_level": 1-3, "priority": "critical|high|medium", "relevance_reason": "brief reason why this skill is needed" }} ], "user_relevant_skills": [ {{ "skill_name": "User Skill Name", "current_level": 1-3, "target_enhancement_level": 1-3, "relevance_to_query": "how this existing skill relates to the query" }} ] }} """ return prompt def parse_llm_skill_analysis_response(llm_response): """Parse LLM response and extract structured skill analysis data""" try: # Clean the response - remove any text before/after JSON llm_response = llm_response.strip() # Find JSON content start_idx = llm_response.find('{') end_idx = llm_response.rfind('}') + 1 if start_idx == -1 or end_idx == 0: return None json_content = llm_response[start_idx:end_idx] parsed_data = json.loads(json_content) return parsed_data except (json.JSONDecodeError, Exception) as e: print(f"Error parsing LLM response: {e}") return None def generate_advanced_skill_analysis_with_llm(user_skills, job_profile_skills=None, job_profile_name=None, designation=None, user_query=""): """Generate advanced skill analysis using LLM intelligence""" # Build LLM prompt for intelligent analysis llm_prompt = build_llm_skill_analysis_prompt( user_query=user_query, user_skills=user_skills, job_profile_skills=job_profile_skills, job_profile_name=job_profile_name, designation=designation ) # Query LLM for intelligent skill analysis llm_response = query_ollama(llm_prompt) parsed_analysis = parse_llm_skill_analysis_response(llm_response) if not parsed_analysis: # Fallback to existing logic if LLM fails return analyze_skill_gaps_with_target_role(user_skills, job_profile_skills, job_profile_name, user_query) # Create a set of user skill names for quick lookup user_skill_names = {skill.get('skill_name', '').lower() for skill in user_skills} # Process LLM recommendations into chart format all_skills = {} # Process LLM recommended skills (highest priority) for skill_rec in parsed_analysis.get('recommended_skills', []): skill_name = skill_rec.get('skill_name', '') if skill_name: skill_key = skill_name.lower() current_user_level = skill_rec.get('current_user_level', 0) all_skills[skill_key] = { 'name': skill_name, 'current_level': current_user_level, 'target_level': int(skill_rec.get('target_level', 3)), 'is_user_skill': skill_name.lower() in user_skill_names and current_user_level > 0, 'is_llm_recommended': True, 'priority': skill_rec.get('priority', 'medium'), 'relevance_reason': skill_rec.get('relevance_reason', ''), 'gap': 0 # Will be calculated } # Process user's relevant existing skills for user_skill_rec in parsed_analysis.get('user_relevant_skills', []): skill_name = user_skill_rec.get('skill_name', '') if skill_name: skill_key = skill_name.lower() current_level = user_skill_rec.get('current_level', 0) if skill_key in all_skills: # Update existing skill entry all_skills[skill_key]['current_level'] = current_level all_skills[skill_key]['target_level'] = max( all_skills[skill_key]['target_level'], int(user_skill_rec.get('target_enhancement_level', 2)) ) all_skills[skill_key]['is_user_skill'] = True all_skills[skill_key]['relevance_reason'] = user_skill_rec.get('relevance_to_query', '') else: # Add new relevant user skill all_skills[skill_key] = { 'name': skill_name, 'current_level': current_level, 'target_level': int(user_skill_rec.get('target_enhancement_level', 2)), 'is_user_skill': True, 'is_llm_recommended': False, 'priority': 'medium', 'relevance_reason': user_skill_rec.get('relevance_to_query', ''), 'gap': 0 # Will be calculated } # Calculate gaps and prepare final analysis skills_analysis = [] for skill_data in all_skills.values(): skill_data['gap'] = max(skill_data['target_level'] - skill_data['current_level'], 0) # Assign priority scores for sorting if skill_data['priority'] == 'critical': skill_data['priority_score'] = 1 elif skill_data['priority'] == 'high': skill_data['priority_score'] = 2 else: skill_data['priority_score'] = 3 # Boost priority for skills with large gaps if skill_data['gap'] >= 2: skill_data['priority_score'] -= 0.5 skills_analysis.append(skill_data) # Sort by priority and gap size skills_analysis.sort(key=lambda x: (x['priority_score'], -x['gap'], x['name'])) # Select top skills for visualization top_skills = skills_analysis[:12] # Prepare chart data skill_names = [skill["name"] for skill in top_skills] current_levels = [skill["current_level"] for skill in top_skills] target_levels = [skill["target_level"] for skill in top_skills] gap_values = [skill["gap"] for skill in top_skills] # Create color coding based on priority and LLM recommendations bar_colors = [] for skill in top_skills: if skill['current_level'] == 0: # New skills needed if skill['priority'] == 'critical': bar_colors.append("rgba(220, 53, 69, 0.9)") # Bright red for critical new skills else: bar_colors.append("rgba(255, 107, 107, 0.8)") # Light red for new skills elif skill['is_llm_recommended']: if skill['priority'] == 'critical': bar_colors.append("rgba(220, 53, 69, 0.7)") # Red for critical skills elif skill['priority'] == 'high': bar_colors.append("rgba(255, 193, 7, 0.8)") # Yellow for high priority else: bar_colors.append("rgba(13, 202, 240, 0.7)") # Blue for medium priority else: bar_colors.append("rgba(108, 117, 125, 0.6)") # Gray for existing skills # Get target role from LLM analysis target_role = parsed_analysis.get('target_role_extracted') or extract_target_role_from_query(user_query) analysis_type = parsed_analysis.get('analysis_type', 'general_analysis') chart_data = { "radar": { "labels": skill_names, "datasets": [ { "label": "Current Skills", "data": current_levels, "backgroundColor": "rgba(54, 162, 235, 0.2)", "borderColor": "rgba(54, 162, 235, 1)", "pointBackgroundColor": "rgba(54, 162, 235, 1)" }, { "label": f"Target Skills{' (' + target_role + ')' if target_role else ''}", "data": target_levels, "backgroundColor": "rgba(255, 99, 132, 0.2)", "borderColor": "rgba(255, 99, 132, 1)", "pointBackgroundColor": "rgba(255, 99, 132, 1)" } ] }, "bar": { "labels": skill_names, "datasets": [ { "label": "Skill Gap", "data": gap_values, "backgroundColor": bar_colors } ] } } # Generate categorized skill lists critical_gaps = [skill for skill in top_skills if skill['priority'] == 'critical' and skill['gap'] > 0] high_priority_gaps = [skill for skill in top_skills if skill['priority'] == 'high' and skill['gap'] > 0] medium_gaps = [skill for skill in top_skills if skill['priority'] == 'medium' and skill['gap'] > 0] # Combine for other_gaps based on analysis type if analysis_type == 'role_transition': other_gaps = critical_gaps + high_priority_gaps + medium_gaps job_profile_gaps = [] # Focus on target role, not current job else: # For general analysis, separate current job vs growth skills job_profile_gaps = [skill for skill in top_skills if skill.get('is_job_profile_skill', False) and skill['gap'] > 0] other_gaps = [skill for skill in top_skills if not skill.get('is_job_profile_skill', False) and skill['gap'] > 0] strengths = [skill for skill in top_skills if skill['gap'] == 0 and skill['current_level'] >= 2] # Generate summary based on LLM analysis summary_parts = [] if critical_gaps: critical_names = [skill['name'] for skill in critical_gaps[:3]] summary_parts.append(f"CRITICAL SKILLS NEEDED: {', '.join(critical_names)}") if high_priority_gaps: high_names = [skill['name'] for skill in high_priority_gaps[:3]] summary_parts.append(f"HIGH PRIORITY: {', '.join(high_names)}") if target_role and analysis_type == 'role_transition': new_skills_needed = len([s for s in critical_gaps + high_priority_gaps if s['current_level'] == 0]) if new_skills_needed > 0: summary_parts.append(f"For {target_role} transition: {new_skills_needed} new skills to develop") if strengths: summary_parts.append(f"Strong foundation: {len(strengths)} advanced skills") summary = ". ".join(summary_parts) if summary_parts else "Skill analysis completed based on your query requirements." return { "chart_data": chart_data, "summary": summary, "job_profile_gaps": job_profile_gaps, "other_gaps": other_gaps, "strengths": strengths, "total_skills_analyzed": len(skills_analysis), "llm_analysis_type": analysis_type, "target_role_detected": target_role } def generate_scenario_appropriate_skill_analysis(user_context, user_query=""): """Updated function to use advanced LLM-based skill analysis""" scenario = user_context['scenario'] current_job_profile_skills = user_context['current_job_profile_skills'] user_skills = user_context['user_skills'] current_job_profile_name = user_context['current_job_profile_name'] designation = user_context.get('designation', '') # Always use advanced LLM analysis for better query understanding if scenario == "scenario_1": # Even with no data, LLM can analyze query and suggest skills return generate_advanced_skill_analysis_with_llm( user_skills=[], job_profile_skills=[], job_profile_name=None, designation=designation, user_query=user_query ) elif scenario == "scenario_2": # Only designation available return generate_advanced_skill_analysis_with_llm( user_skills=[], job_profile_skills=[], job_profile_name=None, designation=designation, user_query=user_query ) else: # Full data available - use comprehensive LLM analysis return generate_advanced_skill_analysis_with_llm( user_skills=user_skills, job_profile_skills=current_job_profile_skills, job_profile_name=current_job_profile_name, designation=designation, user_query=user_query ) def extract_target_role_from_query(user_query): """Extract target role from user query with better parsing - UPDATED""" if not user_query: return None query_lower = user_query.lower().strip() # Enhanced role extraction patterns with more variations role_patterns = [ r'(?:want to become|become a|become an|transition to|move to|switch to)\s+(?:a\s+|an\s+)?([a-zA-Z\s]+?)(?:\?|$|\.|,)', r'(?:career in|job as|role as|position as|work as)\s+(?:a\s+|an\s+)?([a-zA-Z\s]+?)(?:\?|$|\.|,)', r'(?:interested in|pursuing|targeting)\s+(?:a\s+|an\s+)?([a-zA-Z\s]+?)\s+(?:role|position|career|job)(?:\?|$|\.|,)', r'(?:how to become|steps to become)\s+(?:a\s+|an\s+)?([a-zA-Z\s]+?)(?:\?|$|\.|,)', r'(?:path to|roadmap to)\s+(?:a\s+|an\s+)?([a-zA-Z\s]+?)(?:\?|$|\.|,)', ] for pattern in role_patterns: match = re.search(pattern, query_lower) if match: extracted_role = match.group(1).strip() # Clean and validate the extracted role # Remove common filler words filler_words = ['very', 'good', 'successful', 'better', 'great', 'excellent'] words = [word for word in extracted_role.split() if word not in filler_words] extracted_role = ' '.join(words) if len(extracted_role) > 2 and len(extracted_role.split()) <= 4: return extracted_role.title() return None def build_scenario_appropriate_reasoning_with_target_role(user_context, course_details, course_name, user_query): """Build reasoning that focuses on target role from user query - UPDATED""" target_role = extract_target_role_from_query(user_query) designation = user_context['designation'] current_job_profile_name = user_context['current_job_profile_name'] if target_role: # Check if course skills align with target role course_skills = course_details.get('skills', []) target_role_skills = get_target_role_required_skills(target_role) # Check alignment alignment_found = False if course_skills and target_role_skills: course_skill_names = [skill.get('skill_name', '').lower() for skill in course_skills] target_skill_names = [skill['skill_name'].lower() for skill in target_role_skills] for course_skill in course_skill_names: for target_skill in target_skill_names: if course_skill in target_skill or target_skill in course_skill: alignment_found = True break if alignment_found: break if alignment_found: return f"[CRITICAL FOR {target_role.upper()}] {course_name} develops essential skills required for {target_role} role and supports your career transition from {designation} background." else: return f"[CAREER TRANSITION] {course_name} builds foundational skills for {target_role} role and supports your career transition from {designation} background." else: return f"[PROFESSIONAL DEVELOPMENT] {course_name} enhances your capabilities as {designation} and aligns with your career development objectives." def enhanced_match_skills_for_target_role(user_skills, course_skills, job_profile_skills=None, designation=None, target_role=None): """Updated enhanced skill matching with LLM-aware target role analysis""" # Use LLM to analyze if course is relevant to target role if target_role and course_skills: llm_relevance_prompt = f""" COURSE RELEVANCE ANALYSIS Target Role: {target_role} Course Skills: {[skill.get('skill_name', '') for skill in course_skills]} User Query Context: Transition to {target_role} Rate relevance (0-100) of this course for the target role. Consider: 1. Direct skill alignment with target role requirements 2. Career transition value 3. Skill gap filling for the target role Respond with just a number (0-100): """ llm_relevance_response = query_ollama(llm_relevance_prompt) try: llm_relevance_score = float(re.search(r'\d+', llm_relevance_response).group()) llm_relevance_score = min(max(llm_relevance_score, 0), 100) except: llm_relevance_score = 0 # Use LLM score as primary factor for target role scenarios base_score = match_skills(user_skills, course_skills) * 0.2 llm_score = llm_relevance_score * 0.8 return min(base_score + llm_score, 100) # Fallback to original logic base_score = match_skills(user_skills, course_skills) # Job profile alignment bonus job_profile_bonus = 0 if job_profile_skills: job_profile_bonus = calculate_job_profile_skill_priority_score( user_skills, job_profile_skills, course_skills ) # Career progression bonus designation_bonus = calculate_designation_progression_bonus( designation, course_skills, user_skills ) # Skill gap filling bonus skill_gap_bonus = calculate_skill_gap_bonus(user_skills, course_skills) total_score = ( base_score * 0.25 + job_profile_bonus * 0.45 + designation_bonus * 0.20 + skill_gap_bonus * 0.10 ) return min(total_score, 100) def calculate_target_role_alignment_score(target_role, course_skills, user_skills): """ Calculate alignment score based on target role requirements """ if not target_role or not course_skills: return 0 target_role_lower = target_role.lower() # Define skill requirements for common target roles role_skill_requirements = { 'sales manager': ['leadership', 'communication', 'sales', 'negotiation', 'team management', 'customer relationship'], 'product manager': ['product management', 'strategy', 'analytics', 'communication', 'leadership', 'market research'], 'data scientist': ['machine learning', 'python', 'statistics', 'data analysis', 'sql', 'deep learning'], 'software engineer': ['programming', 'software development', 'algorithms', 'system design', 'debugging'], 'project manager': ['project management', 'leadership', 'planning', 'risk management', 'communication'], 'marketing manager': ['marketing', 'digital marketing', 'brand management', 'analytics', 'communication'], 'business analyst': ['business analysis', 'data analysis', 'requirements gathering', 'sql', 'process improvement'], 'tech lead': ['technical leadership', 'architecture', 'mentoring', 'programming', 'system design'], 'consultant': ['consulting', 'problem solving', 'communication', 'analytical thinking', 'presentation skills'] } # Find matching role requirements required_skills = [] for role_key, skills in role_skill_requirements.items(): if role_key in target_role_lower: required_skills = skills break if not required_skills: # Generic management/leadership skills for unknown roles required_skills = ['leadership', 'communication', 'management', 'problem solving', 'strategic thinking'] # Calculate alignment score course_skill_names = [skill.get('skill_name', '').lower() for skill in course_skills] alignment_score = 0 for required_skill in required_skills: for course_skill_name in course_skill_names: if required_skill in course_skill_name or any(word in course_skill_name for word in required_skill.split()): alignment_score += 15 # High score for target role relevant skills break return min(alignment_score, 75) # Cap the bonus def calculate_target_role_priority_score(target_role, course_skills, user_skills): """ Calculate priority score specifically for target role requirements CRITICAL priority for missing target role skills """ if not target_role or not course_skills: return 0 target_role_skills = get_target_role_required_skills(target_role) if not target_role_skills: return 0 # Create user skill maps user_skill_name_map = { skill.get('skill_name', '').lower(): { 'current_level': int(skill.get('skill_type', 1)) } for skill in (user_skills or []) if skill.get('skill_name') } course_skill_name_map = { skill.get('skill_name', '').lower(): { 'course_level': int(skill.get('skill_type', 1)) } for skill in course_skills if skill.get('skill_name') } priority_score = 0 for target_skill_info in target_role_skills: skill_name = target_skill_info['skill_name'].lower() required_level = target_skill_info['skill_type'] skill_priority = target_skill_info['priority'] # Check if course teaches this target role skill if skill_name in course_skill_name_map or any( skill_name in course_skill_name.lower() or course_skill_name.lower() in skill_name for course_skill_name in course_skill_name_map.keys() ): # Get user's current level user_current_level = user_skill_name_map.get(skill_name, {}).get('current_level', 0) # Priority scoring based on skill importance and user's current level if skill_priority == 'critical': if user_current_level == 0: priority_score += 30 # CRITICAL: Missing critical skill elif user_current_level < required_level: priority_score += 25 # HIGH: Below required level for critical skill else: priority_score += 10 # MEDIUM: Enhancement of critical skill elif skill_priority == 'high': if user_current_level == 0: priority_score += 20 # HIGH: Missing high-priority skill elif user_current_level < required_level: priority_score += 15 # MEDIUM-HIGH: Below required level else: priority_score += 8 # MEDIUM: Enhancement else: # medium priority if user_current_level == 0: priority_score += 12 # MEDIUM: Missing medium-priority skill elif user_current_level < required_level: priority_score += 10 # MEDIUM: Below required level else: priority_score += 5 # LOW: Enhancement return min(priority_score, 100) def get_skill_level_name(level): """Convert numeric skill level to readable name""" level_map = { 0: "None", 1: "Beginner", 2: "Intermediate", 3: "Advanced" } return level_map.get(level, "None")