🚀 Add LinkedIn Profile Enhancer Streamlit app with all agents and dependencies

.env.example

@@ -0,0 +1,14 @@
+# Environment Variables for LinkedIn Profile Enhancer
+
+# OpenAI API Configuration
+OPENAI_API_KEY=your_openai_api_key_here
+
+# Apify API Configuration  
+APIFY_API_TOKEN=your_apify_api_token_here
+
+# Optional: Custom model settings
+OPENAI_MODEL=gpt-4o-mini
+TEMPERATURE=0.7
+
+# Optional: Debugging
+DEBUG=False

requirements.txt

@@ -1,3 +1,14 @@
 altair
+streamlit
 pandas
-streamlit
+requests
+beautifulsoup4
+selenium
+numpy
+python-dotenv
+pydantic
+openai
+anthropic
+apify-client
+plotly
+Pillow

src/agents/__init__.py

@@ -0,0 +1 @@
+# Agents package initialization

src/agents/analyzer_agent.py

@@ -0,0 +1,265 @@
+# Profile Analysis Agent
+import re
+from typing import Dict, Any, List
+from collections import Counter
+
+class AnalyzerAgent:
+    """Agent responsible for analyzing LinkedIn profiles and providing insights"""
+    
+    def __init__(self):
+        self.action_words = [
+            'led', 'managed', 'developed', 'created', 'implemented', 'designed',
+            'built', 'improved', 'increased', 'reduced', 'optimized', 'delivered',
+            'achieved', 'launched', 'established', 'coordinated', 'executed'
+        ]
+    
+    def analyze_profile(self, profile_data: Dict[str, Any], job_description: str = "") -> Dict[str, Any]:
+        """
+        Analyze a LinkedIn profile and provide comprehensive insights
+        
+        Args:
+            profile_data (Dict[str, Any]): Extracted profile data
+            job_description (str): Optional job description for matching analysis
+            
+        Returns:
+            Dict[str, Any]: Analysis results with scores and recommendations
+        """
+        if not profile_data:
+            return self._empty_analysis()
+        
+        try:
+            # Calculate completeness score
+            completeness_score = self._calculate_completeness(profile_data)
+            
+            # Analyze keywords
+            keyword_analysis = self._analyze_keywords(profile_data, job_description)
+            
+            # Assess content quality
+            content_quality = self._assess_content_quality(profile_data)
+            
+            # Identify strengths and weaknesses
+            strengths = self._identify_strengths(profile_data)
+            weaknesses = self._identify_weaknesses(profile_data)
+            
+            # Calculate job match if job description provided
+            job_match_score = 0
+            if job_description:
+                job_match_score = self._calculate_job_match(profile_data, job_description)
+            
+            return {
+                'completeness_score': completeness_score,
+                'keyword_analysis': keyword_analysis,
+                'content_quality': content_quality,
+                'strengths': strengths,
+                'weaknesses': weaknesses,
+                'job_match_score': job_match_score,
+                'recommendations': self._generate_recommendations(profile_data, weaknesses),
+                'overall_rating': self._calculate_overall_rating(completeness_score, content_quality, job_match_score)
+            }
+            
+        except Exception as e:
+            print(f"Error in profile analysis: {str(e)}")
+            return self._empty_analysis()
+    
+    def _calculate_completeness(self, profile_data: Dict[str, Any]) -> float:
+        """Calculate profile completeness percentage"""
+        score = 0
+        total_points = 10
+        
+        # Basic information (2 points)
+        if profile_data.get('name'): score += 1
+        if profile_data.get('headline'): score += 1
+        
+        # About section (2 points)
+        about = profile_data.get('about', '')
+        if about and len(about) > 50: score += 1
+        if about and len(about) > 200: score += 1
+        
+        # Experience (2 points)
+        experience = profile_data.get('experience', [])
+        if len(experience) >= 1: score += 1
+        if len(experience) >= 2: score += 1
+        
+        # Education (1 point)
+        if profile_data.get('education'): score += 1
+        
+        # Skills (2 points)
+        skills = profile_data.get('skills', [])
+        if len(skills) >= 5: score += 1
+        if len(skills) >= 10: score += 1
+        
+        # Location (1 point)
+        if profile_data.get('location'): score += 1
+        
+        return (score / total_points) * 100
+    
+    def _analyze_keywords(self, profile_data: Dict[str, Any], job_description: str) -> Dict[str, Any]:
+        """Analyze keywords in profile vs job description"""
+        profile_text = self._extract_all_text(profile_data).lower()
+        
+        # Extract common tech keywords
+        tech_keywords = [
+            'python', 'javascript', 'react', 'node.js', 'sql', 'mongodb',
+            'aws', 'docker', 'kubernetes', 'git', 'agile', 'scrum'
+        ]
+        
+        found_keywords = []
+        for keyword in tech_keywords:
+            if keyword.lower() in profile_text:
+                found_keywords.append(keyword)
+        
+        # Analyze job description keywords if provided
+        missing_keywords = []
+        if job_description:
+            job_keywords = re.findall(r'\b[a-zA-Z]{3,}\b', job_description.lower())
+            job_keyword_freq = Counter(job_keywords)
+            
+            for keyword, freq in job_keyword_freq.most_common(10):
+                if keyword not in profile_text and len(keyword) > 3:
+                    missing_keywords.append(keyword)
+        
+        return {
+            'found_keywords': found_keywords,
+            'missing_keywords': missing_keywords[:5],  # Top 5 missing
+            'keyword_density': len(found_keywords)
+        }
+    
+    def _assess_content_quality(self, profile_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Assess the quality of content"""
+        about_section = profile_data.get('about', '')
+        headline = profile_data.get('headline', '')
+        
+        return {
+            'headline_length': len(headline),
+            'about_length': len(about_section),
+            'has_quantified_achievements': self._has_numbers(about_section),
+            'uses_action_words': self._has_action_words(about_section)
+        }
+    
+    def _identify_strengths(self, profile_data: Dict[str, Any]) -> List[str]:
+        """Identify profile strengths"""
+        strengths = []
+        
+        if len(profile_data.get('experience', [])) >= 3:
+            strengths.append("Good work experience history")
+        
+        if len(profile_data.get('skills', [])) >= 10:
+            strengths.append("Comprehensive skills list")
+        
+        if len(profile_data.get('about', '')) > 200:
+            strengths.append("Detailed about section")
+        
+        return strengths
+    
+    def _identify_weaknesses(self, profile_data: Dict[str, Any]) -> List[str]:
+        """Identify areas for improvement"""
+        weaknesses = []
+        
+        if not profile_data.get('about') or len(profile_data.get('about', '')) < 100:
+            weaknesses.append("About section needs improvement")
+        
+        if len(profile_data.get('skills', [])) < 5:
+            weaknesses.append("Limited skills listed")
+        
+        if not self._has_numbers(profile_data.get('about', '')):
+            weaknesses.append("Lacks quantified achievements")
+        
+        return weaknesses
+    
+    def _calculate_job_match(self, profile_data: Dict[str, Any], job_description: str) -> float:
+        """Calculate how well profile matches job description"""
+        if not job_description:
+            return 0
+        
+        profile_text = self._extract_all_text(profile_data).lower()
+        job_text = job_description.lower()
+        
+        # Extract keywords from job description
+        job_keywords = set(re.findall(r'\b[a-zA-Z]{4,}\b', job_text))
+        
+        # Count matches
+        matches = 0
+        for keyword in job_keywords:
+            if keyword in profile_text:
+                matches += 1
+        
+        return min((matches / len(job_keywords)) * 100, 100) if job_keywords else 0
+    
+    def _extract_all_text(self, profile_data: Dict[str, Any]) -> str:
+        """Extract all text from profile for analysis"""
+        text_parts = []
+        
+        # Add basic info
+        text_parts.append(profile_data.get('headline', ''))
+        text_parts.append(profile_data.get('about', ''))
+        
+        # Add experience descriptions
+        for exp in profile_data.get('experience', []):
+            text_parts.append(exp.get('description', ''))
+            text_parts.append(exp.get('title', ''))
+        
+        # Add skills
+        text_parts.extend(profile_data.get('skills', []))
+        
+        return ' '.join(text_parts)
+    
+    def _has_numbers(self, text: str) -> bool:
+        """Check if text contains numbers/metrics"""
+        return bool(re.search(r'\d+', text))
+    
+    def _has_action_words(self, text: str) -> bool:
+        """Check if text contains action words"""
+        text_lower = text.lower()
+        return any(word in text_lower for word in self.action_words)
+    
+    def _generate_recommendations(self, profile_data: Dict[str, Any], weaknesses: List[str]) -> List[str]:
+        """Generate specific recommendations based on analysis"""
+        recommendations = []
+        
+        for weakness in weaknesses:
+            if "about section" in weakness.lower():
+                recommendations.append("Add a compelling about section with 150-300 words describing your expertise")
+            elif "skills" in weakness.lower():
+                recommendations.append("Add more relevant skills to reach at least 10 skills")
+            elif "quantified" in weakness.lower():
+                recommendations.append("Include specific numbers and metrics in your descriptions")
+        
+        return recommendations
+    
+    def _calculate_overall_rating(self, completeness: float, content_quality: Dict[str, Any], job_match: float) -> str:
+        """Calculate overall profile rating"""
+        score = completeness * 0.4
+        
+        # Add content quality score
+        if content_quality.get('has_quantified_achievements'):
+            score += 10
+        if content_quality.get('uses_action_words'):
+            score += 10
+        if content_quality.get('about_length', 0) > 150:
+            score += 10
+        
+        # Add job match if available
+        if job_match > 0:
+            score += job_match * 0.3
+        
+        if score >= 80:
+            return "Excellent"
+        elif score >= 60:
+            return "Good"
+        elif score >= 40:
+            return "Fair"
+        else:
+            return "Needs Improvement"
+    
+    def _empty_analysis(self) -> Dict[str, Any]:
+        """Return empty analysis structure"""
+        return {
+            'completeness_score': 0,
+            'keyword_analysis': {'found_keywords': [], 'missing_keywords': [], 'keyword_density': 0},
+            'content_quality': {'headline_length': 0, 'about_length': 0, 'has_quantified_achievements': False, 'uses_action_words': False},
+            'strengths': [],
+            'weaknesses': ['Profile data not available'],
+            'job_match_score': 0,
+            'recommendations': ['Please provide valid profile data'],
+            'overall_rating': 'Unknown'
+        }

src/agents/content_agent.py

@@ -0,0 +1,347 @@
+# Content Generation Agent
+import os
+from typing import Dict, Any, List
+from prompts.agent_prompts import ContentPrompts
+from openai import OpenAI
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class ContentAgent:
+    """Agent responsible for generating content suggestions and improvements using OpenAI"""
+    
+    def __init__(self):
+        self.prompts = ContentPrompts()
+        
+        # Initialize OpenAI client
+        api_key = os.getenv('OPENAI_API_KEY')
+        if not api_key:
+            print("Warning: OPENAI_API_KEY not found. Using fallback content generation.")
+            self.openai_client = None
+        else:
+            self.openai_client = OpenAI(api_key=api_key)
+    
+    def generate_suggestions(self, analysis: Dict[str, Any], job_description: str = "") -> Dict[str, Any]:
+        """
+        Generate enhancement suggestions based on analysis
+        
+        Args:
+            analysis (Dict[str, Any]): Profile analysis results
+            job_description (str): Optional job description for tailored suggestions
+            
+        Returns:
+            Dict[str, Any]: Enhancement suggestions
+        """
+        try:
+            suggestions = {
+                'headline_improvements': self._suggest_headline_improvements(analysis, job_description),
+                'about_section': self._suggest_about_improvements(analysis, job_description),
+                'experience_optimization': self._suggest_experience_improvements(analysis),
+                'skills_enhancement': self._suggest_skills_improvements(analysis, job_description),
+                'keyword_optimization': self._suggest_keyword_improvements(analysis),
+                'content_quality': self._suggest_content_quality_improvements(analysis)
+            }
+            
+            # Add AI-generated content if OpenAI is available
+            if self.openai_client:
+                suggestions['ai_generated_content'] = self._generate_ai_content(analysis, job_description)
+            
+            return suggestions
+            
+        except Exception as e:
+            raise Exception(f"Failed to generate suggestions: {str(e)}")
+    
+    def _generate_ai_content(self, analysis: Dict[str, Any], job_description: str) -> Dict[str, Any]:
+        """Generate AI-powered content using OpenAI"""
+        ai_content = {}
+        
+        try:
+            # Generate AI headline suggestions
+            ai_content['ai_headlines'] = self._generate_ai_headlines(analysis, job_description)
+            
+            # Generate AI about section
+            ai_content['ai_about_section'] = self._generate_ai_about_section(analysis, job_description)
+            
+            # Generate AI experience descriptions
+            ai_content['ai_experience_descriptions'] = self._generate_ai_experience_descriptions(analysis)
+            
+        except Exception as e:
+            print(f"Error generating AI content: {str(e)}")
+            ai_content['error'] = "AI content generation temporarily unavailable"
+        
+        return ai_content
+    
+    def _generate_ai_headlines(self, analysis: Dict[str, Any], job_description: str) -> List[str]:
+        """Generate AI-powered headline suggestions"""
+        if not self.openai_client:
+            return []
+        
+        prompt = f"""
+        Generate 5 compelling LinkedIn headlines for this professional profile:
+        
+        Current analysis: {analysis.get('summary', 'No analysis available')}
+        Target job (if any): {job_description[:200] if job_description else 'General optimization'}
+        
+        Requirements:
+        - Maximum 120 characters each
+        - Include relevant keywords
+        - Professional and engaging tone        - Show value proposition
+        - Vary the style (some formal, some creative)
+        
+        Return only the headlines, numbered 1-5:
+        """
+        
+        try:
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=300,
+                temperature=0.7
+            )
+            
+            headlines = response.choices[0].message.content.strip().split('\n')
+            return [h.strip() for h in headlines if h.strip()][:5]
+            
+        except Exception as e:
+            print(f"Error generating AI headlines: {str(e)}")
+            return []
+    
+    def _generate_ai_about_section(self, analysis: Dict[str, Any], job_description: str) -> str:
+        """Generate AI-powered about section"""
+        if not self.openai_client:
+            return ""
+        
+        prompt = f"""
+        Write a compelling LinkedIn About section for this professional:
+        
+        Profile Analysis: {analysis.get('summary', 'No analysis available')}
+        Strengths: {', '.join(analysis.get('strengths', []))}
+        Target Role: {job_description[:300] if job_description else 'Career advancement'}
+        
+        Requirements:
+        - 150-300 words
+        - Professional yet personable tone
+        - Include quantified achievements
+        - Strong opening hook
+        - Clear value proposition
+        - Call to action at the end
+        - Use bullet points for key skills/achievements        
+        Write the complete About section:
+        """
+        
+        try:
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=500,
+                temperature=0.7
+            )
+            
+            return response.choices[0].message.content.strip()
+            
+        except Exception as e:
+            print(f"Error generating AI about section: {str(e)}")
+            return ""
+    
+    def _generate_ai_experience_descriptions(self, analysis: Dict[str, Any]) -> List[str]:
+        """Generate AI-powered experience descriptions"""
+        if not self.openai_client:
+            return []
+        
+        # This would ideally take specific experience entries
+        # For now, return general improvement suggestions
+        
+        prompt = """
+        Generate 3 example bullet points for LinkedIn experience descriptions that:
+        - Start with strong action verbs
+        - Include quantified achievements
+        - Show business impact        - Are relevant for tech professionals
+        
+        Format: Return only the bullet points, one per line with • prefix
+        """
+        
+        try:
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": prompt}],
+                max_tokens=200,
+                temperature=0.7
+            )
+            
+            descriptions = response.choices[0].message.content.strip().split('\n')
+            return [d.strip() for d in descriptions if d.strip()]
+            
+        except Exception as e:
+            print(f"Error generating AI experience descriptions: {str(e)}")
+            return []
+    
+    def _suggest_headline_improvements(self, analysis: Dict[str, Any], job_description: str = "") -> List[str]:
+        """Generate headline improvement suggestions"""
+        suggestions = []
+        
+        content_quality = analysis.get('content_quality', {})
+        headline_length = content_quality.get('headline_length', 0)
+        
+        if headline_length < 50:
+            suggestions.append("Expand your headline to include more keywords and value proposition")
+        elif headline_length > 120:
+            suggestions.append("Shorten your headline to be more concise and impactful")
+        
+        suggestions.extend([
+            "Include specific technologies or skills you specialize in",
+            "Mention your years of experience or seniority level",
+            "Add a unique value proposition that sets you apart",
+            "Use action-oriented language to show what you do"
+        ])
+        
+        return suggestions
+    
+    def _suggest_about_improvements(self, analysis: Dict[str, Any], job_description: str = "") -> List[str]:
+        """Generate about section improvement suggestions"""
+        suggestions = []
+        
+        content_quality = analysis.get('content_quality', {})
+        about_length = content_quality.get('about_length', 0)
+        has_numbers = content_quality.get('has_quantified_achievements', False)
+        has_action_words = content_quality.get('uses_action_words', False)
+        
+        if about_length < 100:
+            suggestions.append("Expand your about section to at least 2-3 paragraphs")
+        
+        if not has_numbers:
+            suggestions.append("Add quantified achievements (e.g., 'Increased sales by 30%')")
+        
+        if not has_action_words:
+            suggestions.append("Use more action verbs to describe your accomplishments")
+        
+        suggestions.extend([
+            "Start with a compelling hook that grabs attention",
+            "Include your professional mission or passion",
+            "Mention specific technologies, tools, or methodologies you use",
+            "End with a call-to-action for potential connections"
+        ])
+        
+        return suggestions
+    
+    def _suggest_experience_improvements(self, analysis: Dict[str, Any]) -> List[str]:
+        """Generate experience section improvement suggestions"""
+        suggestions = [
+            "Use bullet points to highlight key achievements in each role",
+            "Start each bullet point with an action verb",
+            "Include metrics and numbers to quantify your impact",
+            "Focus on results rather than just responsibilities",
+            "Tailor descriptions to align with your target role"
+        ]
+        
+        return suggestions
+    
+    def _suggest_skills_improvements(self, analysis: Dict[str, Any], job_description: str) -> List[str]:
+        """Generate skills section improvement suggestions"""
+        suggestions = []
+        
+        keyword_analysis = analysis.get('keyword_analysis', {})
+        missing_keywords = keyword_analysis.get('missing_keywords', [])
+        
+        if missing_keywords and job_description:
+            suggestions.append(f"Consider adding these relevant skills: {', '.join(missing_keywords[:5])}")
+        
+        suggestions.extend([
+            "Prioritize your most relevant skills at the top",
+            "Include both technical and soft skills",
+            "Get endorsements from colleagues for your key skills",
+            "Add skills that are trending in your industry"
+        ])
+        
+        return suggestions
+    
+    def _suggest_keyword_improvements(self, analysis: Dict[str, Any]) -> List[str]:
+        """Generate keyword optimization suggestions"""
+        suggestions = []
+        
+        keyword_analysis = analysis.get('keyword_analysis', {})
+        keyword_density = keyword_analysis.get('keyword_density', 0)
+        missing_keywords = keyword_analysis.get('missing_keywords', [])
+        
+        if keyword_density < 50:
+            suggestions.append("Increase keyword density by incorporating more relevant terms")
+        
+        if missing_keywords:
+            suggestions.append(f"Consider adding these keywords: {', '.join(missing_keywords[:3])}")
+        
+        suggestions.extend([
+            "Use industry-specific terminology naturally throughout your profile",
+            "Include location-based keywords if relevant",
+            "Add keywords related to your target roles"
+        ])
+        
+        return suggestions
+    
+    def _suggest_content_quality_improvements(self, analysis: Dict[str, Any]) -> List[str]:
+        """Generate general content quality improvement suggestions"""
+        completeness_score = analysis.get('completeness_score', 0)
+        
+        suggestions = []
+        
+        if completeness_score < 80:
+            suggestions.append("Complete all sections of your profile for better visibility")
+        
+        suggestions.extend([
+            "Use a professional headshot as your profile photo",
+            "Add a background image that reflects your industry",
+            "Keep your profile updated with recent achievements",
+            "Engage regularly by posting and commenting on relevant content",
+            "Ask for recommendations from colleagues and clients"
+        ])
+        
+        return suggestions
+    
+    def generate_headline_examples(self, current_headline: str, job_description: str = "") -> List[str]:
+        """Generate example headlines"""
+        examples = [
+            "Senior Software Engineer | Full-Stack Developer | React & Node.js Expert",
+            "Data Scientist | Machine Learning Engineer | Python & AI Specialist",
+            "Digital Marketing Manager | SEO Expert | Growth Hacker",
+            "Product Manager | Agile Expert | B2B SaaS Specialist"
+        ]
+        
+        return examples
+    
+    def generate_about_template(self, analysis: Dict[str, Any]) -> str:
+        """Generate an about section template"""
+        template = """
+🚀 [Opening Hook - What makes you unique]
+
+💼 [Years] years of experience in [Industry/Field], specializing in [Key Skills/Technologies]. I'm passionate about [What drives you professionally].
+
+🎯 **What I do:**
+• [Key responsibility/achievement 1]
+• [Key responsibility/achievement 2] 
+• [Key responsibility/achievement 3]
+
+📊 **Recent achievements:**
+• [Quantified achievement 1]
+• [Quantified achievement 2]
+• [Quantified achievement 3]
+
+🛠️ **Technical expertise:** [List 5-8 key skills/technologies]
+
+🤝 **Let's connect** if you're interested in [collaboration opportunity/your goals]        """
+        
+        return template.strip()
+    
+    def test_openai_connection(self) -> bool:
+        """Test if OpenAI connection is working"""
+        if not self.openai_client:
+            return False
+        
+        try:
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[{"role": "user", "content": "Test connection"}],
+                max_tokens=10
+            )
+            return True
+        except Exception as e:
+            print(f"OpenAI connection test failed: {str(e)}")
+            return False

src/agents/orchestrator.py

@@ -0,0 +1,186 @@
+# Main Agent Coordinator
+import time
+from .scraper_agent import ScraperAgent
+from .analyzer_agent import AnalyzerAgent
+from .content_agent import ContentAgent
+from memory.memory_manager import MemoryManager
+
+class ProfileOrchestrator:
+    """Main coordinator for all LinkedIn profile enhancement agents"""
+    
+    def __init__(self):
+        self.scraper = ScraperAgent()
+        self.analyzer = AnalyzerAgent()
+        self.content_generator = ContentAgent()
+        self.memory = MemoryManager()
+    
+    def enhance_profile(self, linkedin_url, job_description="", force_refresh=True):
+        """
+        Main workflow for enhancing a LinkedIn profile
+        
+        Args:
+            linkedin_url (str): LinkedIn profile URL
+            job_description (str): Optional job description for tailored suggestions
+            force_refresh (bool): Force fresh scraping instead of using cache
+            
+        Returns:
+            str: Enhancement suggestions and analysis
+        """
+        try:
+            print(f"🎯 Starting profile enhancement for: {linkedin_url}")
+            
+            # Always clear cache for fresh data extraction
+            if force_refresh:
+                print("🗑️ Clearing all cached data...")
+                self.memory.force_refresh_session(linkedin_url)
+                # Clear any session data for this URL
+                self.memory.clear_session_cache(linkedin_url)
+                # Also clear any general cache
+                self.memory.clear_session_cache()  # Clear all sessions
+            
+            # Step 1: Scrape LinkedIn profile data
+            print("📡 Step 1: Scraping profile data...")
+            print(f"🔗 Target URL: {linkedin_url}")
+            profile_data = self.scraper.extract_profile_data(linkedin_url)
+            
+            # Verify we got data for the correct URL
+            if profile_data.get('url') != linkedin_url:
+                print(f"⚠️ URL mismatch detected!")
+                print(f"   Expected: {linkedin_url}")
+                print(f"   Got: {profile_data.get('url', 'Unknown')}")
+            
+            # Step 2: Analyze the profile
+            print("🔍 Step 2: Analyzing profile...")
+            analysis = self.analyzer.analyze_profile(profile_data, job_description)
+            
+            # Step 3: Generate enhancement suggestions
+            print("💡 Step 3: Generating suggestions...")
+            suggestions = self.content_generator.generate_suggestions(analysis, job_description)
+            
+            # Step 4: Store in memory for future reference
+            session_data = {
+                'profile_data': profile_data,
+                'analysis': analysis,
+                'suggestions': suggestions,
+                'job_description': job_description,
+                'timestamp': time.strftime('%Y-%m-%d %H:%M:%S')
+            }
+            self.memory.store_session(linkedin_url, session_data)
+            
+            print("✅ Profile enhancement completed!")
+            return self._format_output(analysis, suggestions)
+            
+        except Exception as e:
+            return f"Error in orchestration: {str(e)}"
+    
+    def _format_output(self, analysis, suggestions):
+        """Format the final output for display"""
+        output = []
+        
+        # Profile Analysis Section
+        output.append("## 📊 Profile Analysis")
+        output.append("")
+        output.append(f"**📈 Completeness Score:** {analysis.get('completeness_score', 0):.1f}%")
+        output.append(f"**⭐ Overall Rating:** {analysis.get('overall_rating', 'Unknown')}")
+        output.append(f"**🎯 Job Match Score:** {analysis.get('job_match_score', 0):.1f}%")
+        output.append("")
+        
+        # Strengths
+        strengths = analysis.get('strengths', [])
+        if strengths:
+            output.append("### 🌟 Profile Strengths")
+            for strength in strengths:
+                output.append(f"✅ {strength}")
+            output.append("")
+        
+        # Areas for Improvement
+        weaknesses = analysis.get('weaknesses', [])
+        if weaknesses:
+            output.append("### 🔧 Areas for Improvement")
+            for weakness in weaknesses:
+                output.append(f"🔸 {weakness}")
+            output.append("")
+        
+        # Keyword Analysis
+        keyword_analysis = analysis.get('keyword_analysis', {})
+        if keyword_analysis:
+            found_keywords = keyword_analysis.get('found_keywords', [])
+            missing_keywords = keyword_analysis.get('missing_keywords', [])
+            
+            output.append("### � Keyword Analysis")
+            output.append(f"**Keywords Found ({len(found_keywords)}):** {', '.join(found_keywords[:10])}")
+            if missing_keywords:
+                output.append(f"**Missing Keywords:** {', '.join(missing_keywords[:5])}")
+            output.append("")
+        
+        # Enhancement Suggestions Section
+        output.append("## 🎯 Enhancement Suggestions")
+        output.append("")
+        
+        for category, items in suggestions.items():
+            if category == 'ai_generated_content':
+                # Special formatting for AI content
+                output.append("### 🤖 AI-Generated Content Suggestions")
+                ai_content = items if isinstance(items, dict) else {}
+                
+                if 'ai_headlines' in ai_content and ai_content['ai_headlines']:
+                    output.append("")
+                    output.append("#### ✨ Professional Headlines")
+                    for i, headline in enumerate(ai_content['ai_headlines'], 1):
+                        # Clean up the headline format
+                        cleaned_headline = headline.strip('"').replace('\\"', '"')
+                        if cleaned_headline.startswith(('1.', '2.', '3.', '4.', '5.')):
+                            cleaned_headline = cleaned_headline[2:].strip()
+                        output.append(f"{i}. {cleaned_headline}")
+                    output.append("")
+                
+                if 'ai_about_section' in ai_content and ai_content['ai_about_section']:
+                    output.append("#### 📝 Enhanced About Section")
+                    output.append("```")
+                    about_content = ai_content['ai_about_section']
+                    # Clean up the about section
+                    about_lines = about_content.split('\n')
+                    for line in about_lines:
+                        if line.strip():
+                            output.append(line.strip())
+                    output.append("```")
+                    output.append("")
+                
+                if 'ai_experience_descriptions' in ai_content and ai_content['ai_experience_descriptions']:
+                    output.append("#### 💼 Experience Description Ideas")
+                    for desc in ai_content['ai_experience_descriptions']:
+                        output.append(f"• {desc}")
+                    output.append("")
+            else:
+                # Standard formatting for other categories
+                category_name = category.replace('_', ' ').title()
+                output.append(f"### {category_name}")
+                if isinstance(items, list):
+                    for item in items:
+                        output.append(f"• {item}")
+                else:
+                    output.append(f"• {items}")
+                output.append("")
+        
+        # Next Steps Section
+        output.append("## 📈 Implementation Roadmap")
+        output.append("")
+        recommendations = analysis.get('recommendations', [])
+        if recommendations:
+            output.append("### 🎯 Priority Actions")
+            for i, rec in enumerate(recommendations[:5], 1):
+                output.append(f"{i}. {rec}")
+            output.append("")
+        
+        output.append("### 📊 General Best Practices")
+        output.append("🔸 Update your profile regularly with new achievements")
+        output.append("🔸 Use professional keywords relevant to your industry")
+        output.append("🔸 Engage with your network by sharing valuable content")
+        output.append("🔸 Ask for recommendations from colleagues and clients")
+        output.append("🔸 Monitor profile views and connection requests")
+        output.append("")
+        
+        output.append("---")
+        output.append("*Analysis powered by AI • Data scraped with respect to LinkedIn's ToS*")
+        
+        return "\n".join(output)

src/agents/scraper_agent.py

@@ -0,0 +1,284 @@
+import os
+import time
+import json
+import requests
+from typing import Dict, Any
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv()
+
+class ScraperAgent:
+    """Agent responsible for extracting data from LinkedIn profiles using Apify REST API"""
+    
+    def __init__(self):
+        self.apify_token = os.getenv('APIFY_API_TOKEN')
+        if not self.apify_token:
+            raise ValueError("APIFY_API_TOKEN not found in environment variables")
+        
+        # Validate token format
+        if not self.apify_token.startswith('apify_api_'):
+            print(f"⚠️ Warning: Token doesn't start with 'apify_api_'. Current token starts with: {self.apify_token[:10]}...")
+        
+        # Use the new actor API endpoint
+        self.api_url = f"https://api.apify.com/v2/acts/dev_fusion~linkedin-profile-scraper/run-sync-get-dataset-items?token={self.apify_token}"
+        
+        print(f"🔑 Using Apify token: {self.apify_token[:15]}...")  # Show first 15 chars for debugging
+    
+    def extract_profile_data(self, linkedin_url: str) -> Dict[str, Any]:
+        """
+        Extract profile data from LinkedIn URL using Apify REST API
+        
+        Args:
+            linkedin_url (str): LinkedIn profile URL
+            
+        Returns:
+            Dict[str, Any]: Extracted profile data
+        """
+        try:
+            print(f"🔍 Starting scraping for: {linkedin_url}")
+            print(f"🔗 URL being processed: {linkedin_url}")
+            print(f"⏰ Timestamp: {time.strftime('%Y-%m-%d %H:%M:%S')}")
+            
+            # Clean and validate URL
+            original_url = linkedin_url
+            linkedin_url = linkedin_url.strip()
+            if not linkedin_url.startswith('http'):
+                linkedin_url = 'https://' + linkedin_url
+            
+            print(f"🧹 Cleaned URL: {linkedin_url}")
+            
+            # Verify URL consistency
+            if original_url != linkedin_url:
+                print(f"🔄 URL normalized: {original_url} → {linkedin_url}")
+            
+            # Configure the run input with fresh URL
+            run_input = {
+                "profileUrls": [linkedin_url],  # This actor expects profileUrls, not startUrls
+                "slowDown": True,  # To avoid being blocked
+                "includeSkills": True,
+                "includeExperience": True,
+                "includeEducation": True,
+                "includeRecommendations": False,  # Optional, can be slow
+                "saveHtml": False,
+                "saveMarkdown": False
+            }
+            
+            print(f"📋 Apify input: {json.dumps(run_input, indent=2)}")
+            
+            # Make the API request
+            print("🚀 Running Apify scraper via REST API...")
+            response = requests.post(
+                self.api_url,
+                json=run_input,
+                headers={'Content-Type': 'application/json'},
+                timeout=180  # 3 minutes timeout
+            )
+            
+            if response.status_code in [200, 201]:  # 201 is also success for Apify
+                results = response.json()
+                print(f"✅ API Response received: {len(results)} items")
+                
+                if results and len(results) > 0:
+                    # Process the first result (since we're scraping one profile)
+                    raw_data = results[0]
+                    processed_data = self._process_apify_data(raw_data, linkedin_url)
+                    print("✅ Successfully extracted and processed profile data")
+                    return processed_data
+                else:
+                    error_msg = "No data returned from Apify API. The profile may be private or the scraper encountered an issue."
+                    print(f"❌ {error_msg}")
+                    raise ValueError(error_msg)
+            else:
+                error_details = ""
+                try:
+                    error_response = response.json()
+                    error_details = f" - {error_response.get('error', {}).get('message', response.text)}"
+                except:
+                    error_details = f" - {response.text}"
+                
+                if response.status_code == 401:
+                    error_msg = f"Authentication failed (401): Invalid or expired API token{error_details}"
+                    print(f"❌ {error_msg}")
+                    print(f"🔑 Token being used: {self.apify_token[:15]}...")
+                    print(f"💡 Please check your APIFY_API_TOKEN in your .env file")
+                elif response.status_code == 404:
+                    error_msg = f"Actor not found (404): The actor 'dev_fusion~linkedin-profile-scraper' may not exist{error_details}"
+                    print(f"❌ {error_msg}")
+                elif response.status_code == 429:
+                    error_msg = f"Rate limit exceeded (429): Too many requests{error_details}"
+                    print(f"❌ {error_msg}")
+                else:
+                    error_msg = f"API request failed with status {response.status_code}{error_details}"
+                    print(f"❌ {error_msg}")
+                
+                raise requests.RequestException(error_msg)
+                
+        except requests.Timeout:
+            error_msg = "Request timed out. The scraping operation took too long to complete."
+            print(f"⏰ {error_msg}")
+            raise requests.Timeout(error_msg)
+        except Exception as e:
+            error_msg = f"Error extracting profile data: {str(e)}"
+            print(f"❌ {error_msg}")
+            raise Exception(error_msg)
+    
+    def test_apify_connection(self) -> bool:
+        """Test if Apify connection is working"""
+        try:
+            # Test with the actor endpoint
+            test_url = f"https://api.apify.com/v2/acts/dev_fusion~linkedin-profile-scraper?token={self.apify_token}"
+            print(f"🔗 Testing connection to: {test_url[:50]}...")
+            
+            response = requests.get(test_url, timeout=10)
+            
+            if response.status_code == 200:
+                actor_info = response.json()
+                print(f"✅ Successfully connected to Apify actor: {actor_info.get('name', 'LinkedIn Profile Scraper')}")
+                return True
+            elif response.status_code == 401:
+                print(f"❌ Authentication failed (401): Invalid or expired API token")
+                print(f"🔑 Token being used: {self.apify_token[:15]}...")
+                print(f"💡 Please check your APIFY_API_TOKEN in your .env file")
+                return False
+            elif response.status_code == 404:
+                print(f"❌ Actor not found (404): The actor 'dev_fusion~linkedin-profile-scraper' may not exist or be accessible")
+                return False
+            else:
+                print(f"❌ Failed to connect to Apify: {response.status_code} - {response.text}")
+                return False
+        except Exception as e:
+            print(f"❌ Failed to connect to Apify: {str(e)}")
+            return False
+    
+    def _process_apify_data(self, raw_data: Dict[str, Any], url: str) -> Dict[str, Any]:
+        """Process raw Apify data into standardized format"""
+        
+        print(f"📊 Processing data for URL: {url}")
+        print(f"📋 Raw data keys: {list(raw_data.keys())}")
+        
+        # Extract basic information - using the correct field names from API
+        profile_data = {
+            'name': raw_data.get('fullName', ''),
+            'headline': raw_data.get('headline', ''),
+            'location': raw_data.get('addressWithCountry', raw_data.get('addressWithoutCountry', '')),
+            'about': raw_data.get('about', ''),  # API uses 'about' not 'summary'
+            'connections': raw_data.get('connections', 0),
+            'followers': raw_data.get('followers', 0),
+            'email': raw_data.get('email', ''),
+            'url': url,  # Use the URL that was actually requested
+            'profile_image': raw_data.get('profilePic', ''),
+            'profile_image_hq': raw_data.get('profilePicHighQuality', ''),
+            'scraped_at': time.strftime('%Y-%m-%d %H:%M:%S'),
+            'job_title': raw_data.get('jobTitle', ''),
+            'company_name': raw_data.get('companyName', ''),
+            'company_industry': raw_data.get('companyIndustry', ''),
+            'company_website': raw_data.get('companyWebsite', ''),
+            'company_size': raw_data.get('companySize', ''),
+            'current_job_duration': raw_data.get('currentJobDuration', ''),
+            'top_skills': raw_data.get('topSkillsByEndorsements', '')
+        }
+        
+        print(f"✅ Extracted profile for: {profile_data.get('name', 'Unknown')}")
+        print(f"🔗 Profile URL stored: {profile_data['url']}")
+        
+        # Process experience - API uses 'experiences' array
+        experience_list = []
+        for exp in raw_data.get('experiences', []):
+            experience_item = {
+                'title': exp.get('title', ''),
+                'company': exp.get('subtitle', '').replace(' · Full-time', '').replace(' · Part-time', ''),
+                'duration': exp.get('caption', ''),
+                'description': '',  # Extract from subComponents if available
+                'location': exp.get('metadata', ''),
+                'company_logo': exp.get('logo', ''),
+                'is_current': 'Present' in exp.get('caption', '') or '·' not in exp.get('caption', '')
+            }
+            
+            # Extract description from subComponents
+            if 'subComponents' in exp and exp['subComponents']:
+                for sub in exp['subComponents']:
+                    if 'description' in sub and sub['description']:
+                        descriptions = []
+                        for desc in sub['description']:
+                            if isinstance(desc, dict) and desc.get('text'):
+                                descriptions.append(desc['text'])
+                        experience_item['description'] = ' '.join(descriptions)
+            
+            experience_list.append(experience_item)
+        profile_data['experience'] = experience_list
+        
+        # Process education - API uses 'educations' array
+        education_list = []
+        for edu in raw_data.get('educations', []):
+            education_item = {
+                'degree': edu.get('subtitle', ''),
+                'school': edu.get('title', ''),
+                'field': '',  # Extract from subtitle
+                'year': edu.get('caption', ''),
+                'logo': edu.get('logo', ''),
+                'grade': ''  # Extract from subComponents if available
+            }
+            
+            # Split degree and field from subtitle
+            subtitle = edu.get('subtitle', '')
+            if ' - ' in subtitle:
+                parts = subtitle.split(' - ', 1)
+                education_item['degree'] = parts[0]
+                education_item['field'] = parts[1] if len(parts) > 1 else ''
+            elif ', ' in subtitle:
+                parts = subtitle.split(', ', 1)
+                education_item['degree'] = parts[0]
+                education_item['field'] = parts[1] if len(parts) > 1 else ''
+            
+            # Extract grade from subComponents
+            if 'subComponents' in edu and edu['subComponents']:
+                for sub in edu['subComponents']:
+                    if 'description' in sub and sub['description']:
+                        for desc in sub['description']:
+                            if isinstance(desc, dict) and desc.get('text', '').startswith('Grade:'):
+                                education_item['grade'] = desc['text']
+            
+            education_list.append(education_item)
+        profile_data['education'] = education_list
+        
+        # Process skills - API uses 'skills' array with title
+        skills_list = []
+        for skill in raw_data.get('skills', []):
+            if isinstance(skill, dict) and 'title' in skill:
+                skills_list.append(skill['title'])
+            elif isinstance(skill, str):
+                skills_list.append(skill)
+        profile_data['skills'] = skills_list
+        
+        # Process certifications - API uses 'licenseAndCertificates'
+        certifications_list = []
+        for cert in raw_data.get('licenseAndCertificates', []):
+            cert_item = {
+                'title': cert.get('title', ''),
+                'issuer': cert.get('subtitle', ''),
+                'date': cert.get('caption', ''),
+                'credential_id': cert.get('metadata', ''),
+                'logo': cert.get('logo', '')
+            }
+            certifications_list.append(cert_item)
+        profile_data['certifications'] = certifications_list
+        
+        # Process languages (if available)
+        profile_data['languages'] = raw_data.get('languages', [])
+        
+        # Process volunteer experience (if available)
+        volunteer_list = []
+        for vol in raw_data.get('volunteerAndAwards', []):
+            if isinstance(vol, dict):
+                volunteer_list.append(vol)
+        profile_data['volunteer_experience'] = volunteer_list
+        
+        # Additional rich data
+        profile_data['honors_awards'] = raw_data.get('honorsAndAwards', [])
+        profile_data['projects'] = raw_data.get('projects', [])
+        profile_data['publications'] = raw_data.get('publications', [])
+        profile_data['recommendations'] = raw_data.get('recommendations', [])
+        profile_data['interests'] = raw_data.get('interests', [])
+        
+        return profile_data

src/memory/__init__.py

@@ -0,0 +1 @@
+# Memory package initialization

src/memory/memory_manager.py

@@ -0,0 +1,241 @@
+# Session & Persistent Memory Manager
+import json
+import os
+from datetime import datetime
+from typing import Dict, Any, Optional
+
+class MemoryManager:
+    """Manages session data and persistent storage for the LinkedIn enhancer"""
+    
+    def __init__(self, storage_dir: str = "data"):
+        self.storage_dir = storage_dir
+        self.session_data = {}
+        self.persistent_file = os.path.join(storage_dir, "persistent_data.json")
+        
+        # Create storage directory if it doesn't exist
+        os.makedirs(storage_dir, exist_ok=True)
+        
+        # Load existing persistent data
+        self.persistent_data = self._load_persistent_data()
+    
+    def store_session(self, profile_url: str, data: Dict[str, Any]) -> None:
+        """
+        Store session data for a specific profile
+        
+        Args:
+            profile_url (str): LinkedIn profile URL as key
+            data (Dict[str, Any]): Session data to store
+        """
+        session_key = self._create_session_key(profile_url)
+        
+        self.session_data[session_key] = {
+            'timestamp': datetime.now().isoformat(),
+            'profile_url': profile_url,
+            'data': data
+        }
+    
+    def get_session(self, profile_url: str) -> Optional[Dict[str, Any]]:
+        """
+        Retrieve session data for a specific profile
+        
+        Args:
+            profile_url (str): LinkedIn profile URL
+            
+        Returns:
+            Optional[Dict[str, Any]]: Session data if exists
+        """
+        session_key = self._create_session_key(profile_url)
+        return self.session_data.get(session_key)
+    
+    def store_persistent(self, key: str, data: Any) -> None:
+        """
+        Store data persistently to disk
+        
+        Args:
+            key (str): Storage key
+            data (Any): Data to store
+        """
+        self.persistent_data[key] = {
+            'timestamp': datetime.now().isoformat(),
+            'data': data
+        }
+        
+        self._save_persistent_data()
+    
+    def get_persistent(self, key: str) -> Optional[Any]:
+        """
+        Retrieve persistent data
+        
+        Args:
+            key (str): Storage key
+            
+        Returns:
+            Optional[Any]: Stored data if exists
+        """
+        stored_item = self.persistent_data.get(key)
+        return stored_item['data'] if stored_item else None
+    
+    def store_user_preferences(self, user_id: str, preferences: Dict[str, Any]) -> None:
+        """
+        Store user preferences
+        
+        Args:
+            user_id (str): User identifier
+            preferences (Dict[str, Any]): User preferences
+        """
+        pref_key = f"user_preferences_{user_id}"
+        self.store_persistent(pref_key, preferences)
+    
+    def get_user_preferences(self, user_id: str) -> Dict[str, Any]:
+        """
+        Retrieve user preferences
+        
+        Args:
+            user_id (str): User identifier
+            
+        Returns:
+            Dict[str, Any]: User preferences
+        """
+        pref_key = f"user_preferences_{user_id}"
+        preferences = self.get_persistent(pref_key)
+        return preferences if preferences else {}
+    
+    def store_analysis_history(self, profile_url: str, analysis: Dict[str, Any]) -> None:
+        """
+        Store analysis history for tracking improvements
+        
+        Args:
+            profile_url (str): LinkedIn profile URL
+            analysis (Dict[str, Any]): Analysis results
+        """
+        history_key = f"analysis_history_{self._create_session_key(profile_url)}"
+        
+        # Get existing history
+        history = self.get_persistent(history_key) or []
+        
+        # Add new analysis with timestamp
+        history.append({
+            'timestamp': datetime.now().isoformat(),
+            'analysis': analysis
+        })
+        
+        # Keep only last 10 analyses
+        history = history[-10:]
+        
+        self.store_persistent(history_key, history)
+    
+    def get_analysis_history(self, profile_url: str) -> list:
+        """
+        Retrieve analysis history for a profile
+        
+        Args:
+            profile_url (str): LinkedIn profile URL
+            
+        Returns:
+            list: Analysis history
+        """
+        history_key = f"analysis_history_{self._create_session_key(profile_url)}"
+        return self.get_persistent(history_key) or []
+    
+    def clear_session(self, profile_url: str = None) -> None:
+        """
+        Clear session data
+        
+        Args:
+            profile_url (str, optional): Specific profile to clear, or all if None
+        """
+        if profile_url:
+            session_key = self._create_session_key(profile_url)
+            self.session_data.pop(session_key, None)
+        else:
+            self.session_data.clear()
+    
+    def clear_session_cache(self, profile_url: str = None) -> None:
+        """
+        Clear session cache for a specific profile or all profiles
+        
+        Args:
+            profile_url (str, optional): URL to clear cache for. If None, clears all.
+        """
+        if profile_url:
+            session_key = self._create_session_key(profile_url)
+            if session_key in self.session_data:
+                del self.session_data[session_key]
+                print(f"🗑️ Cleared session cache for: {profile_url}")
+        else:
+            self.session_data.clear()
+            print("🗑️ Cleared all session cache")
+    
+    def force_refresh_session(self, profile_url: str) -> None:
+        """
+        Force refresh by clearing cache for a specific profile
+        
+        Args:
+            profile_url (str): LinkedIn profile URL
+        """
+        self.clear_session_cache(profile_url)
+        print(f"🔄 Forced refresh for: {profile_url}")
+
+    def get_session_summary(self) -> Dict[str, Any]:
+        """
+        Get summary of current session data
+        
+        Returns:
+            Dict[str, Any]: Session summary
+        """
+        return {
+            'active_sessions': len(self.session_data),
+            'sessions': list(self.session_data.keys()),
+            'storage_location': self.storage_dir
+        }
+    
+    def _create_session_key(self, profile_url: str) -> str:
+        """Create a clean session key from profile URL"""
+        # Extract username or create a hash-like key
+        import hashlib
+        return hashlib.md5(profile_url.encode()).hexdigest()[:16]
+    
+    def _load_persistent_data(self) -> Dict[str, Any]:
+        """Load persistent data from disk"""
+        if os.path.exists(self.persistent_file):
+            try:
+                with open(self.persistent_file, 'r', encoding='utf-8') as f:
+                    return json.load(f)
+            except (json.JSONDecodeError, IOError):
+                return {}
+        return {}
+    
+    def _save_persistent_data(self) -> None:
+        """Save persistent data to disk"""
+        try:
+            with open(self.persistent_file, 'w', encoding='utf-8') as f:
+                json.dump(self.persistent_data, f, indent=2, ensure_ascii=False)
+        except IOError as e:
+            print(f"Warning: Could not save persistent data: {e}")
+    
+    def export_data(self, filename: str = None) -> str:
+        """
+        Export all data to a JSON file
+        
+        Args:
+            filename (str, optional): Custom filename
+            
+        Returns:
+            str: Path to exported file
+        """
+        if not filename:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"linkedin_enhancer_export_{timestamp}.json"
+        
+        export_path = os.path.join(self.storage_dir, filename)
+        
+        export_data = {
+            'session_data': self.session_data,
+            'persistent_data': self.persistent_data,
+            'export_timestamp': datetime.now().isoformat()
+        }
+        
+        with open(export_path, 'w', encoding='utf-8') as f:
+            json.dump(export_data, f, indent=2, ensure_ascii=False)
+        
+        return export_path

src/prompts/__init__.py

@@ -0,0 +1 @@
+# Prompts package initialization

src/prompts/agent_prompts.py

@@ -0,0 +1,243 @@
+# Agent Prompts for LinkedIn Profile Enhancer
+
+class ContentPrompts:
+    """Collection of prompts for content generation agents"""
+    
+    def __init__(self):
+        self.headline_prompts = HeadlinePrompts()
+        self.about_prompts = AboutPrompts()
+        self.experience_prompts = ExperiencePrompts()
+        self.general_prompts = GeneralPrompts()
+
+class HeadlinePrompts:
+    """Prompts for headline optimization"""
+    
+    HEADLINE_ANALYSIS = """
+    Analyze this LinkedIn headline and provide improvement suggestions:
+    
+    Current headline: "{headline}"
+    Target role: "{target_role}"
+    Key skills: {skills}
+    
+    Consider:
+    1. Keyword optimization for the target role
+    2. Value proposition clarity
+    3. Professional branding
+    4. Character limit (120 chars max)
+    5. Industry-specific terms
+    
+    Provide 3-5 alternative headline suggestions.
+    """
+    
+    HEADLINE_TEMPLATES = [
+        "{title} | {specialization} | {key_skills}",
+        "{seniority} {title} specializing in {domain} | {achievement}",
+        "{title} | Helping {target_audience} with {solution} | {technologies}",
+        "{role} with {years}+ years in {industry} | {unique_value_prop}"
+    ]
+
+class AboutPrompts:
+    """Prompts for about section optimization"""
+    
+    ABOUT_STRUCTURE = """
+    Create an engaging LinkedIn About section with this structure:
+    
+    Profile info:
+    - Name: {name}
+    - Current role: {current_role}
+    - Years of experience: {experience_years}
+    - Key skills: {key_skills}
+    - Notable achievements: {achievements}
+    - Target audience: {target_audience}
+    
+    Structure:
+    1. Hook (compelling opening line)
+    2. Professional summary (2-3 sentences)
+    3. Key expertise and skills
+    4. Notable achievements with metrics
+    5. Call to action
+    
+    Keep it conversational, professional, and under 2000 characters.
+    """
+    
+    ABOUT_HOOKS = [
+        "🚀 Passionate about transforming {industry} through {technology}",
+        "💡 {Years} years of turning complex {domain} challenges into simple solutions",
+        "🎯 Helping {target_audience} achieve {outcome} through {approach}",
+        "⚡ {Achievement} specialist with a track record of {impact}"
+    ]
+
+class ExperiencePrompts:
+    """Prompts for experience section optimization"""
+    
+    EXPERIENCE_ENHANCEMENT = """
+    Enhance this work experience entry:
+    
+    Current description: "{description}"
+    Role: {title}
+    Company: {company}
+    Duration: {duration}
+    
+    Improve by:
+    1. Starting with strong action verbs
+    2. Adding quantified achievements
+    3. Highlighting relevant skills used
+    4. Showing business impact
+    5. Using bullet points for readability
+    
+    Target the experience for: {target_role}
+    """    
+    ACTION_VERBS = {
+        "Leadership": ["led", "managed", "directed", "coordinated", "supervised"],
+        "Achievement": ["achieved", "delivered", "exceeded", "accomplished", "attained"],
+        "Development": ["developed", "created", "built", "designed", "implemented"],
+        "Improvement": ["optimized", "enhanced", "streamlined", "upgraded", "modernized"],
+        "Problem-solving": ["resolved", "troubleshot", "analyzed", "diagnosed", "solved"]
+    }
+
+class GeneralPrompts:
+    """General prompts for profile enhancement"""
+    
+    SKILLS_OPTIMIZATION = """
+    Optimize this skills list for the target role:
+    
+    Current skills: {current_skills}
+    Target role: {target_role}
+    Job description keywords: {job_keywords}
+    
+    Provide:
+    1. Priority ranking of current skills
+    2. Missing skills to add
+    3. Skills to remove or deprioritize
+    4. Skill categories organization
+    """
+    
+    KEYWORD_OPTIMIZATION = """
+    Analyze keyword optimization for this profile:
+    
+    Profile content: {profile_content}
+    Target job description: {job_description}
+    
+    Identify:
+    1. Current keyword density
+    2. Missing important keywords
+    3. Over-optimized keywords
+    4. Natural integration suggestions
+    5. Industry-specific terminology gaps
+    """
+    
+    PROFILE_AUDIT = """
+    Conduct a comprehensive LinkedIn profile audit:
+    
+    Profile data: {profile_data}
+    Target role: {target_role}
+    Industry: {industry}
+    
+    Audit areas:
+    1. Profile completeness (%)
+    2. Keyword optimization
+    3. Content quality and engagement potential
+    4. Professional branding consistency
+    5. Call-to-action effectiveness
+    6. Visual elements (photo, banner) recommendations
+    
+    Provide actionable improvement suggestions with priority levels.
+    """
+
+class AnalysisPrompts:
+    """Prompts for profile analysis"""
+    
+    COMPETITIVE_ANALYSIS = """
+    Compare this profile against industry standards:
+    
+    Profile: {profile_data}
+    Industry: {industry}
+    Seniority level: {seniority}
+    
+    Analyze:
+    1. Profile completeness vs industry average
+    2. Keyword usage vs competitors
+    3. Content quality benchmarks
+    4. Engagement potential indicators
+    5. Areas of competitive advantage
+    6. Improvement opportunities
+    """
+    
+    CONTENT_QUALITY = """
+    Assess content quality across this LinkedIn profile:
+    
+    Profile sections: {profile_sections}
+    
+    Evaluate:
+    1. Clarity and readability
+    2. Professional tone consistency
+    3. Value proposition strength
+    4. Quantified achievements presence
+    5. Industry relevance
+    6. Call-to-action effectiveness
+    
+    Rate each section 1-10 and provide specific improvement suggestions.
+    """
+
+class JobMatchingPrompts:
+    """Prompts for job matching analysis"""
+    
+    JOB_MATCH_ANALYSIS = """
+    Analyze how well this profile matches the job requirements:
+    
+    Profile: {profile_data}
+    Job description: {job_description}
+    
+    Match analysis:
+    1. Skills alignment (%)
+    2. Experience relevance
+    3. Keyword overlap
+    4. Education/certification fit
+    5. Overall match score
+    
+    Provide specific recommendations to improve match score.
+    """
+    
+    TAILORING_SUGGESTIONS = """
+    Suggest profile modifications to better match this opportunity:
+    
+    Current profile: {profile_data}
+    Target job: {job_description}
+    Match score: {current_match_score}
+    
+    Prioritized suggestions:
+    1. High-impact changes (immediate wins)
+    2. Medium-impact improvements
+    3. Long-term development areas
+    4. Skills to highlight/add
+    5. Content restructuring recommendations
+    """
+
+# Utility functions for prompt formatting
+def format_prompt(template: str, **kwargs) -> str:
+    """Format prompt template with provided variables"""
+    try:
+        return template.format(**kwargs)
+    except KeyError as e:
+        return f"Error formatting prompt: Missing variable {e}"
+
+def get_prompt_by_category(category: str, prompt_name: str) -> str:
+    """Get a specific prompt by category and name"""
+    prompt_classes = {
+        'headline': HeadlinePrompts(),
+        'about': AboutPrompts(),
+        'experience': ExperiencePrompts(),
+        'general': GeneralPrompts(),
+        'analysis': AnalysisPrompts(),
+        'job_matching': JobMatchingPrompts()
+    }
+    
+    prompt_class = prompt_classes.get(category.lower())
+    if not prompt_class:
+        return f"Category '{category}' not found"
+    
+    prompt = getattr(prompt_class, prompt_name.upper(), None)
+    if not prompt:
+        return f"Prompt '{prompt_name}' not found in category '{category}'"
+    
+    return prompt

src/streamlit_app.py

@@ -1,40 +1,723 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import json
+import pandas as pd
+from agents.orchestrator import ProfileOrchestrator
+from agents.scraper_agent import ScraperAgent
+from agents.content_agent import ContentAgent
+import plotly.express as px
+import plotly.graph_objects as go
+from datetime import datetime
+
+# Configure Streamlit page
+st.set_page_config(
+    page_title="🚀 LinkedIn Profile Enhancer",
+    page_icon="🚀",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+        padding: 2rem;
+        border-radius: 10px;
+        color: white;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    
+    .metric-card {
+        background: #f8f9fa;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #667eea;
+        margin: 0.5rem 0;
+    }
+    
+    .success-card {
+        background: #d4edda;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #28a745;
+        margin: 0.5rem 0;
+    }
+    
+    .warning-card {
+        background: #fff3cd;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #ffc107;
+        margin: 0.5rem 0;
+    }
+    
+    .info-card {
+        background: #e7f3ff;
+        padding: 1rem;
+        border-radius: 8px;
+        border-left: 4px solid #17a2b8;
+        margin: 0.5rem 0;
+    }
+    
+    .stTabs > div > div > div > div {
+        padding: 1rem;
+    }
+    
+    .profile-section {
+        background: white;
+        padding: 1.5rem;
+        border-radius: 10px;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+def initialize_session_state():
+    """Initialize session state variables"""
+    if 'orchestrator' not in st.session_state:
+        st.session_state.orchestrator = ProfileOrchestrator()
+    if 'analysis_results' not in st.session_state:
+        st.session_state.analysis_results = None
+    if 'profile_data' not in st.session_state:
+        st.session_state.profile_data = None
+    if 'suggestions' not in st.session_state:
+        st.session_state.suggestions = None
+    if 'current_url' not in st.session_state:
+        st.session_state.current_url = None
+
+def clear_results_if_url_changed(linkedin_url):
+    """Clear cached results if URL has changed"""
+    if st.session_state.current_url != linkedin_url:
+        st.session_state.analysis_results = None
+        st.session_state.profile_data = None
+        st.session_state.suggestions = None
+        st.session_state.current_url = linkedin_url
+        st.cache_data.clear()  # Clear any Streamlit cache
+        print(f"🔄 URL changed to: {linkedin_url} - Clearing cached data")
+
+def create_header():
+    """Create the main header"""
+    st.markdown("""
+    <div class="main-header">
+        <h1>🚀 LinkedIn Profile Enhancer</h1>
+        <p style="font-size: 1.2em; margin: 1rem 0;">AI-powered LinkedIn profile analysis and enhancement suggestions</p>
+        <div style="display: flex; justify-content: center; gap: 2rem; margin-top: 1rem;">
+            <div style="text-align: center;">
+                <div style="font-size: 2em;">🔍</div>
+                <div>Real Scraping</div>
+            </div>
+            <div style="text-align: center;">
+                <div style="font-size: 2em;">🤖</div>
+                <div>AI Analysis</div>
+            </div>
+            <div style="text-align: center;">
+                <div style="font-size: 2em;">🎯</div>
+                <div>Smart Suggestions</div>
+            </div>
+            <div style="text-align: center;">
+                <div style="font-size: 2em;">📊</div>
+                <div>Data Insights</div>
+            </div>
+        </div>
+    </div>
+    """, unsafe_allow_html=True)
+
+def create_sidebar():
+    """Create the sidebar with input controls"""
+    with st.sidebar:
+        st.header("📝 Configuration")
+        
+        # LinkedIn URL input
+        linkedin_url = st.text_input(
+            "🔗 LinkedIn Profile URL",
+            placeholder="https://linkedin.com/in/your-profile",
+            help="Enter the full LinkedIn profile URL to analyze"
+        )
+        
+        # Job description input
+        job_description = st.text_area(
+            "🎯 Target Job Description (Optional)",
+            placeholder="Paste the job description here for tailored suggestions...",
+            height=150,
+            help="Include job description for personalized optimization"
+        )
+        
+        # API Status
+        st.subheader("🔌 API Status")
+        
+        # Test API connections
+        if st.button("🔄 Test Connections"):
+            with st.spinner("Testing API connections..."):
+                # Test Apify
+                try:
+                    scraper = ScraperAgent()
+                    apify_status = scraper.test_apify_connection()
+                    if apify_status:
+                        st.success("✅ Apify: Connected")
+                    else:
+                        st.error("❌ Apify: Failed")
+                except Exception as e:
+                    st.error(f"❌ Apify: Error - {str(e)}")
+                
+                # Test OpenAI
+                try:
+                    content_agent = ContentAgent()
+                    openai_status = content_agent.test_openai_connection()
+                    if openai_status:
+                        st.success("✅ OpenAI: Connected")
+                    else:
+                        st.error("❌ OpenAI: Failed")
+                except Exception as e:
+                    st.error(f"❌ OpenAI: Error - {str(e)}")
+        
+        # Examples
+        st.subheader("💡 Example URLs")
+        example_urls = [
+            "https://linkedin.com/in/example-profile",
+            "https://www.linkedin.com/in/sample-user"
+        ]
+        
+        for url in example_urls:
+            if st.button(f"📋 {url.split('/')[-1]}", key=url):
+                st.session_state.example_url = url
+        
+        return linkedin_url, job_description
+
+def create_metrics_display(analysis):
+    """Create metrics display"""
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric(
+            "📈 Completeness Score",
+            f"{analysis.get('completeness_score', 0):.1f}%",
+            delta=None
+        )
+    
+    with col2:
+        rating = analysis.get('overall_rating', 'Unknown')
+        st.metric(
+            "⭐ Overall Rating",
+            rating,
+            delta=None
+        )
+    
+    with col3:
+        st.metric(
+            "🎯 Job Match Score",
+            f"{analysis.get('job_match_score', 0):.1f}%",
+            delta=None
+        )
+    
+    with col4:
+        keywords = analysis.get('keyword_analysis', {})
+        found_count = len(keywords.get('found_keywords', []))
+        st.metric(
+            "🔍 Keywords Found",
+            found_count,
+            delta=None
+        )
+
+def create_analysis_charts(analysis):
+    """Create analysis charts"""
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        # Completeness breakdown
+        scores = {
+            'Profile Info': 20,
+            'About Section': 25,
+            'Experience': 25,
+            'Skills': 15,
+            'Education': 15
+        }
+        
+        fig_pie = px.pie(
+            values=list(scores.values()),
+            names=list(scores.keys()),
+            title="Profile Section Weights",
+            color_discrete_sequence=px.colors.qualitative.Set3
+        )
+        fig_pie.update_layout(height=400)
+        st.plotly_chart(fig_pie, use_container_width=True)
+    
+    with col2:
+        # Score comparison
+        current_score = analysis.get('completeness_score', 0)
+        target_score = 90
+        
+        fig_gauge = go.Figure(go.Indicator(
+            mode = "gauge+number+delta",
+            value = current_score,
+            domain = {'x': [0, 1], 'y': [0, 1]},
+            title = {'text': "Profile Completeness"},
+            delta = {'reference': target_score, 'increasing': {'color': "green"}},
+            gauge = {
+                'axis': {'range': [None, 100]},
+                'bar': {'color': "darkblue"},
+                'steps': [
+                    {'range': [0, 50], 'color': "lightgray"},
+                    {'range': [50, 80], 'color': "gray"},
+                    {'range': [80, 100], 'color': "lightgreen"}
+                ],
+                'threshold': {
+                    'line': {'color': "red", 'width': 4},
+                    'thickness': 0.75,
+                    'value': 90
+                }
+            }
+        ))
+        fig_gauge.update_layout(height=400)
+        st.plotly_chart(fig_gauge, use_container_width=True)
+
+def display_profile_data(profile_data):
+    """Display scraped profile data in a structured format"""
+    if not profile_data:
+        st.warning("No profile data available")
+        return
+    
+    # Profile Header with Image
+    st.subheader("👤 Profile Overview")
+    
+    # Create columns for profile image and basic info
+    col1, col2, col3 = st.columns([1, 2, 2])
+    
+    with col1:
+        # Display profile image
+        profile_image = profile_data.get('profile_image_hq') or profile_data.get('profile_image')
+        if profile_image:
+            st.image(profile_image, width=150, caption="Profile Picture")
+        else:
+            st.markdown("""
+            <div style="width: 150px; height: 150px; background-color: #f0f0f0; border-radius: 50%; 
+                        display: flex; align-items: center; justify-content: center; font-size: 48px;">
+                👤
+            </div>
+            """, unsafe_allow_html=True)
+    
+    with col2:
+        st.markdown(f"""
+        <div class="info-card">
+            <strong>Name:</strong> {profile_data.get('name', 'N/A')}<br>
+            <strong>Headline:</strong> {profile_data.get('headline', 'N/A')}<br>
+            <strong>Location:</strong> {profile_data.get('location', 'N/A')}<br>
+            <strong>Connections:</strong> {profile_data.get('connections', 'N/A')}<br>
+            <strong>Followers:</strong> {profile_data.get('followers', 'N/A')}
+        </div>
+        """, unsafe_allow_html=True)
+    
+    with col3:
+        st.markdown(f"""
+        <div class="info-card">
+            <strong>Current Job:</strong> {profile_data.get('job_title', 'N/A')}<br>
+            <strong>Company:</strong> {profile_data.get('company_name', 'N/A')}<br>
+            <strong>Industry:</strong> {profile_data.get('company_industry', 'N/A')}<br>
+            <strong>Email:</strong> {profile_data.get('email', 'N/A')}<br>
+            <strong>Profile URL:</strong> <a href="{profile_data.get('url', '#')}" target="_blank">View Profile</a>
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # About Section
+    if profile_data.get('about'):
+        st.subheader("📝 About Section")
+        st.markdown(f"""
+        <div class="profile-section">
+            {profile_data.get('about', 'No about section available')}
+        </div>
+        """, unsafe_allow_html=True)
+    
+    # Experience
+    if profile_data.get('experience'):
+        st.subheader("💼 Experience")
+        for i, exp in enumerate(profile_data.get('experience', [])):
+            with st.expander(f"{exp.get('title', 'Position')} at {exp.get('company', 'Company')}", expanded=i==0):
+                col1, col2 = st.columns([2, 1])
+                with col1:
+                    st.write(f"**Duration:** {exp.get('duration', 'N/A')}")
+                    st.write(f"**Location:** {exp.get('location', 'N/A')}")
+                    if exp.get('description'):
+                        st.write("**Description:**")
+                        st.write(exp.get('description'))
+                with col2:
+                    st.write(f"**Current Role:** {'Yes' if exp.get('is_current') else 'No'}")
+    
+    # Skills
+    if profile_data.get('skills'):
+        st.subheader("🛠️ Skills")
+        skills = profile_data.get('skills', [])
+        if skills:
+            # Create a DataFrame for better display
+            skills_df = pd.DataFrame({'Skills': skills})
+            st.dataframe(skills_df, use_container_width=True)
+    
+    # Education
+    if profile_data.get('education'):
+        st.subheader("🎓 Education")
+        for edu in profile_data.get('education', []):
+            st.markdown(f"""
+            <div class="info-card">
+                <strong>{edu.get('degree', 'Degree')}</strong><br>
+                {edu.get('school', 'School')} | {edu.get('field', 'Field')}<br>
+                <em>{edu.get('year', 'Year')}</em>
+            </div>
+            """, unsafe_allow_html=True)
+    
+    # Raw Data (collapsible)
+    with st.expander("🔍 Raw JSON Data"):
+        st.json(profile_data)
 
+def display_analysis_results(analysis):
+    """Display analysis results"""
+    if not analysis:
+        st.warning("No analysis results available")
+        return
+    
+    # Metrics
+    create_metrics_display(analysis)
+    
+    # Charts
+    st.subheader("📊 Analysis Visualization")
+    create_analysis_charts(analysis)
+    
+    # Strengths and Weaknesses
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        st.subheader("🌟 Profile Strengths")
+        strengths = analysis.get('strengths', [])
+        if strengths:
+            for strength in strengths:
+                st.markdown(f"""
+                <div class="success-card">
+                    ✅ {strength}
+                </div>
+                """, unsafe_allow_html=True)
+        else:
+            st.info("No specific strengths identified")
+    
+    with col2:
+        st.subheader("🔧 Areas for Improvement")
+        weaknesses = analysis.get('weaknesses', [])
+        if weaknesses:
+            for weakness in weaknesses:
+                st.markdown(f"""
+                <div class="warning-card">
+                    🔸 {weakness}
+                </div>
+                """, unsafe_allow_html=True)
+        else:
+            st.success("No major areas for improvement identified")
+    
+    # Keyword Analysis
+    keyword_analysis = analysis.get('keyword_analysis', {})
+    if keyword_analysis:
+        st.subheader("🔍 Keyword Analysis")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            found_keywords = keyword_analysis.get('found_keywords', [])
+            if found_keywords:
+                st.write("**Keywords Found:**")
+                st.write(", ".join(found_keywords[:10]))
+        
+        with col2:
+            missing_keywords = keyword_analysis.get('missing_keywords', [])
+            if missing_keywords:
+                st.write("**Missing Keywords:**")
+                st.write(", ".join(missing_keywords[:5]))
+
+def generate_suggestions_markdown(suggestions, profile_data=None):
+    """Generate markdown content from suggestions"""
+    if not suggestions:
+        return "# LinkedIn Profile Enhancement Suggestions\n\nNo suggestions available."
+    
+    # Get profile name for personalization
+    profile_name = profile_data.get('name', 'Your Profile') if profile_data else 'Your Profile'
+    current_date = datetime.now().strftime("%B %d, %Y")
+    
+    markdown_content = f"""# LinkedIn Profile Enhancement Suggestions
+
+**Profile:** {profile_name}  
+**Generated on:** {current_date}  
+**Powered by:** LinkedIn Profile Enhancer AI
+
+---
+
+## 📋 Table of Contents
 """
-# Welcome to Streamlit!
+    
+    # Add table of contents
+    toc_items = []
+    for category in suggestions.keys():
+        if category == 'ai_generated_content':
+            toc_items.append("- [🤖 AI-Generated Content Suggestions](#ai-generated-content-suggestions)")
+        else:
+            category_name = category.replace('_', ' ').title()
+            toc_items.append(f"- [📋 {category_name}](#{category.replace('_', '-').lower()})")
+    
+    markdown_content += "\n".join(toc_items) + "\n\n---\n\n"
+    
+    # Add suggestions content
+    for category, items in suggestions.items():
+        if category == 'ai_generated_content':
+            markdown_content += "## 🤖 AI-Generated Content Suggestions\n\n"
+            ai_content = items if isinstance(items, dict) else {}
+            
+            # Headlines
+            if 'ai_headlines' in ai_content and ai_content['ai_headlines']:
+                markdown_content += "### ✨ Professional Headlines\n\n"
+                for i, headline in enumerate(ai_content['ai_headlines'], 1):
+                    cleaned_headline = headline.strip('"').replace('\\"', '"')
+                    if cleaned_headline.startswith(('1.', '2.', '3.', '4.', '5.')):
+                        cleaned_headline = cleaned_headline[2:].strip()
+                    markdown_content += f"{i}. {cleaned_headline}\n"
+                markdown_content += "\n"
+            
+            # About Section
+            if 'ai_about_section' in ai_content and ai_content['ai_about_section']:
+                markdown_content += "### 📝 Enhanced About Section\n\n"
+                markdown_content += f"```\n{ai_content['ai_about_section']}\n```\n\n"
+            
+            # Experience Descriptions
+            if 'ai_experience_descriptions' in ai_content and ai_content['ai_experience_descriptions']:
+                markdown_content += "### 💼 Experience Description Ideas\n\n"
+                for desc in ai_content['ai_experience_descriptions']:
+                    markdown_content += f"- {desc}\n"
+                markdown_content += "\n"
+        else:
+            # Standard categories
+            category_name = category.replace('_', ' ').title()
+            markdown_content += f"## 📋 {category_name}\n\n"
+            if isinstance(items, list):
+                for item in items:
+                    markdown_content += f"- {item}\n"
+            else:
+                markdown_content += f"- {items}\n"
+            markdown_content += "\n"
+    
+    # Add footer
+    markdown_content += """---
+
+## 📚 Implementation Tips
+
+### Getting Started
+1. **Prioritize High-Impact Changes**: Start with headline and about section improvements
+2. **Use Keywords Strategically**: Incorporate industry-relevant keywords naturally
+3. **Maintain Authenticity**: Ensure all changes reflect your genuine experience and personality
+4. **Regular Updates**: Keep your profile fresh with recent achievements and experiences
 
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+### Best Practices
+- **Professional Photo**: Use a high-quality, professional headshot
+- **Active Engagement**: Regularly share industry insights and engage with your network
+- **Skills Endorsements**: Ask colleagues to endorse your key skills
+- **Recommendations**: Request recommendations from supervisors and colleagues
+- **Content Strategy**: Share articles, insights, and achievements regularly
 
-In the meantime, below is an example of what you can do with just a few lines of code:
+### Measuring Success
+- Monitor profile views and connection requests
+- Track engagement on your posts and content
+- Observe changes in recruiter outreach
+- Measure network growth and quality
+
+---
+
+*This report was generated by LinkedIn Profile Enhancer AI. For best results, implement changes gradually and monitor their impact on your profile performance.*
+
+**Need Help?** Contact support or revisit the LinkedIn Profile Enhancer tool for updated suggestions.
 """
+    
+    return markdown_content
+
+def display_suggestions(suggestions):
+    """Display enhancement suggestions with download option"""
+    if not suggestions:
+        st.warning("No suggestions available")
+        return
+    
+    # Add download button at the top
+    col1, col2 = st.columns([1, 4])
+    
+    with col1:
+        # Generate markdown content
+        markdown_content = generate_suggestions_markdown(
+            suggestions, 
+            st.session_state.get('profile_data')
+        )
+        
+        # Create filename with timestamp
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        profile_name = ""
+        if st.session_state.get('profile_data'):
+            name = st.session_state.profile_data.get('name', '')
+            if name:
+                # Clean name for filename
+                profile_name = "".join(c for c in name if c.isalnum() or c in (' ', '_')).rstrip()
+                profile_name = profile_name.replace(' ', '_') + "_"
+        
+        filename = f"linkedin_suggestions_{profile_name}{timestamp}.md"
+        
+        st.download_button(
+            label="📥 Download Suggestions",
+            data=markdown_content,
+            file_name=filename,
+            mime="text/markdown",
+            help="Download all suggestions as a markdown file",
+            use_container_width=True
+        )
+    
+    with col2:
+        st.markdown("*💡 Click the download button to save all suggestions as a markdown file for easy reference and implementation.*")
+    
+    st.markdown("---")
+    
+    # Display suggestions as before
+    for category, items in suggestions.items():
+        if category == 'ai_generated_content':
+            st.subheader("🤖 AI-Generated Content Suggestions")
+            ai_content = items if isinstance(items, dict) else {}
+            
+            # Headlines
+            if 'ai_headlines' in ai_content and ai_content['ai_headlines']:
+                st.write("**✨ Professional Headlines:**")
+                for i, headline in enumerate(ai_content['ai_headlines'], 1):
+                    cleaned_headline = headline.strip('"').replace('\\"', '"')
+                    if cleaned_headline.startswith(('1.', '2.', '3.', '4.', '5.')):
+                        cleaned_headline = cleaned_headline[2:].strip()
+                    st.write(f"{i}. {cleaned_headline}")
+                st.write("")
+            
+            # About Section
+            if 'ai_about_section' in ai_content and ai_content['ai_about_section']:
+                st.write("**📝 Enhanced About Section:**")
+                st.code(ai_content['ai_about_section'], language='text')
+                st.write("")
+            
+            # Experience Descriptions
+            if 'ai_experience_descriptions' in ai_content and ai_content['ai_experience_descriptions']:
+                st.write("**💼 Experience Description Ideas:**")
+                for desc in ai_content['ai_experience_descriptions']:
+                    st.write(f"• {desc}")
+                st.write("")
+        else:
+            # Standard categories
+            category_name = category.replace('_', ' ').title()
+            st.subheader(f"📋 {category_name}")
+            if isinstance(items, list):
+                for item in items:
+                    st.write(f"• {item}")
+            else:
+                st.write(f"• {items}")
+            st.write("")
+
+def main():
+    """Main Streamlit application"""
+    initialize_session_state()
+    create_header()
+    
+    # Sidebar
+    linkedin_url, job_description = create_sidebar()
+    
+    # Main content
+    if st.button("🚀 Enhance Profile", type="primary", use_container_width=True):
+        if not linkedin_url.strip():
+            st.error("Please enter a LinkedIn profile URL")
+        elif not any(pattern in linkedin_url.lower() for pattern in ['linkedin.com/in/', 'www.linkedin.com/in/']):
+            st.error("Please enter a valid LinkedIn profile URL")
+        else:
+            # Clear cached data if URL has changed
+            clear_results_if_url_changed(linkedin_url)
+            
+            with st.spinner("🔍 Analyzing LinkedIn profile..."):
+                try:
+                    st.info(f"🔍 Extracting data from: {linkedin_url}")
+                    
+                    # Get profile data and analysis (force fresh extraction)
+                    profile_data = st.session_state.orchestrator.scraper.extract_profile_data(linkedin_url)
+                    
+                    st.info(f"✅ Profile data extracted for: {profile_data.get('name', 'Unknown')}")
+                    
+                    analysis = st.session_state.orchestrator.analyzer.analyze_profile(profile_data, job_description)
+                    suggestions = st.session_state.orchestrator.content_generator.generate_suggestions(analysis, job_description)
+                    
+                    # Store in session state
+                    st.session_state.profile_data = profile_data
+                    st.session_state.analysis_results = analysis
+                    st.session_state.suggestions = suggestions
+                    
+                    st.success("✅ Profile analysis completed!")
+                    
+                except Exception as e:
+                    st.error(f"❌ Error analyzing profile: {str(e)}")
+    
+    # Display results if available
+    if st.session_state.profile_data or st.session_state.analysis_results:
+        st.markdown("---")
+        
+        # Create tabs for different views
+        tab1, tab2, tab3, tab4 = st.tabs(["📊 Analysis", "🔍 Scraped Data", "🎯 Suggestions", "📈 Implementation"])
+        
+        with tab1:
+            st.header("📊 Profile Analysis")
+            if st.session_state.analysis_results:
+                display_analysis_results(st.session_state.analysis_results)
+            else:
+                st.info("No analysis results available yet")
+        
+        with tab2:
+            st.header("🔍 Scraped Profile Data")
+            if st.session_state.profile_data:
+                display_profile_data(st.session_state.profile_data)
+            else:
+                st.info("No profile data available yet")
+        
+        with tab3:
+            st.header("🎯 Enhancement Suggestions")
+            if st.session_state.suggestions:
+                display_suggestions(st.session_state.suggestions)
+            else:
+                st.info("No suggestions available yet")
+        
+        with tab4:
+            st.header("📈 Implementation Roadmap")
+            if st.session_state.analysis_results:
+                recommendations = st.session_state.analysis_results.get('recommendations', [])
+                if recommendations:
+                    st.subheader("🎯 Priority Actions")
+                    for i, rec in enumerate(recommendations[:5], 1):
+                        st.markdown(f"""
+                        <div class="metric-card">
+                            <strong>{i}.</strong> {rec}
+                        </div>
+                        """, unsafe_allow_html=True)
+                
+                st.subheader("📊 General Best Practices")
+                best_practices = [
+                    "Update your profile regularly with new achievements",
+                    "Use professional keywords relevant to your industry",
+                    "Engage with your network by sharing valuable content",
+                    "Ask for recommendations from colleagues and clients",
+                    "Monitor profile views and connection requests"
+                ]
+                
+                for practice in best_practices:
+                    st.markdown(f"""
+                    <div class="info-card">
+                        🔸 {practice}
+                    </div>
+                    """, unsafe_allow_html=True)
+            else:
+                st.info("Complete the analysis first to see implementation suggestions")
+    
+    # Footer
+    st.markdown("---")
+    st.markdown("""
+    <div style="text-align: center; color: #666; margin-top: 2rem;">
+        <p>🚀 <strong>LinkedIn Profile Enhancer</strong> | Powered by AI | Data scraped with respect to LinkedIn's ToS</p>
+        <p>Built with ❤️ using Streamlit, OpenAI GPT-4o-mini, and Apify</p>
+    </div>
+    """, unsafe_allow_html=True)
 
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+if __name__ == "__main__":
+    main()

src/utils/__init__.py

@@ -0,0 +1 @@
+# Utils package initialization

src/utils/job_matcher.py

@@ -0,0 +1,353 @@
+# Job Matching Logic
+from typing import Dict, Any, List, Tuple
+import re
+from collections import Counter
+
+class JobMatcher:
+    """Utility class for matching LinkedIn profiles with job descriptions"""
+    
+    def __init__(self):
+        self.weight_config = {
+            'skills': 0.4,
+            'experience': 0.3,
+            'keywords': 0.2,
+            'education': 0.1
+        }
+        
+        self.skill_synonyms = {
+            'javascript': ['js', 'ecmascript', 'node.js', 'nodejs'],
+            'python': ['py', 'django', 'flask', 'fastapi'],
+            'react': ['reactjs', 'react.js'],
+            'angular': ['angularjs', 'angular.js'],
+            'machine learning': ['ml', 'ai', 'artificial intelligence'],
+            'database': ['db', 'sql', 'mysql', 'postgresql', 'mongodb']
+        }
+    
+    def calculate_match_score(self, profile_data: Dict[str, Any], job_description: str) -> Dict[str, Any]:
+        """
+        Calculate comprehensive match score between profile and job
+        
+        Args:
+            profile_data (Dict[str, Any]): Cleaned profile data
+            job_description (str): Job description text
+            
+        Returns:
+            Dict[str, Any]: Match analysis with scores and details
+        """
+        job_requirements = self._parse_job_requirements(job_description)
+        
+        # Calculate individual scores
+        skills_score = self._calculate_skills_match(
+            profile_data.get('skills', []), 
+            job_requirements['skills']
+        )
+        
+        experience_score = self._calculate_experience_match(
+            profile_data.get('experience', []), 
+            job_requirements
+        )
+        
+        keywords_score = self._calculate_keywords_match(
+            profile_data, 
+            job_requirements['keywords']
+        )
+        
+        education_score = self._calculate_education_match(
+            profile_data.get('education', []), 
+            job_requirements
+        )
+        
+        # Calculate weighted overall score
+        overall_score = (
+            skills_score['score'] * self.weight_config['skills'] +
+            experience_score['score'] * self.weight_config['experience'] +
+            keywords_score['score'] * self.weight_config['keywords'] +
+            education_score['score'] * self.weight_config['education']
+        )
+        
+        return {
+            'overall_score': round(overall_score, 2),
+            'breakdown': {
+                'skills': skills_score,
+                'experience': experience_score,
+                'keywords': keywords_score,
+                'education': education_score
+            },
+            'recommendations': self._generate_match_recommendations(
+                skills_score, experience_score, keywords_score, education_score
+            ),
+            'job_requirements': job_requirements
+        }
+    
+    def find_skill_gaps(self, profile_skills: List[str], job_requirements: List[str]) -> Dict[str, List[str]]:
+        """
+        Identify skill gaps between profile and job requirements
+        
+        Args:
+            profile_skills (List[str]): Current profile skills
+            job_requirements (List[str]): Required job skills
+            
+        Returns:
+            Dict[str, List[str]]: Missing and matching skills
+        """
+        profile_skills_lower = [skill.lower() for skill in profile_skills]
+        job_skills_lower = [skill.lower() for skill in job_requirements]
+        
+        # Find exact matches
+        matching_skills = []
+        missing_skills = []
+        
+        for job_skill in job_skills_lower:
+            if job_skill in profile_skills_lower:
+                matching_skills.append(job_skill)
+            else:
+                # Check for synonyms
+                found_synonym = False
+                for profile_skill in profile_skills_lower:
+                    if self._are_skills_similar(profile_skill, job_skill):
+                        matching_skills.append(job_skill)
+                        found_synonym = True
+                        break
+                
+                if not found_synonym:
+                    missing_skills.append(job_skill)
+        
+        return {
+            'matching_skills': matching_skills,
+            'missing_skills': missing_skills,
+            'match_percentage': len(matching_skills) / max(len(job_skills_lower), 1) * 100
+        }
+    
+    def suggest_profile_improvements(self, match_analysis: Dict[str, Any]) -> List[str]:
+        """
+        Generate specific improvement suggestions based on match analysis
+        
+        Args:
+            match_analysis (Dict[str, Any]): Match analysis results
+            
+        Returns:
+            List[str]: Improvement suggestions
+        """
+        suggestions = []
+        breakdown = match_analysis['breakdown']
+        
+        # Skills suggestions
+        if breakdown['skills']['score'] < 70:
+            missing_skills = breakdown['skills']['details']['missing_skills'][:3]
+            if missing_skills:
+                suggestions.append(
+                    f"Add these high-priority skills: {', '.join(missing_skills)}"
+                )
+        
+        # Experience suggestions
+        if breakdown['experience']['score'] < 60:
+            suggestions.append(
+                "Highlight more relevant experience in your current/previous roles"
+            )
+            suggestions.append(
+                "Add quantified achievements that demonstrate impact"
+            )
+        
+        # Keywords suggestions
+        if breakdown['keywords']['score'] < 50:
+            suggestions.append(
+                "Incorporate more industry-specific keywords throughout your profile"
+            )
+        
+        # Education suggestions
+        if breakdown['education']['score'] < 40:
+            suggestions.append(
+                "Consider adding relevant certifications or courses"
+            )
+        
+        return suggestions
+    
+    def _parse_job_requirements(self, job_description: str) -> Dict[str, Any]:
+        """Parse job description to extract requirements"""
+        requirements = {
+            'skills': [],
+            'keywords': [],
+            'experience_years': 0,
+            'education_level': '',
+            'industry': '',
+            'role_type': ''
+        }
+        
+        # Extract skills (common technical skills)
+        skill_patterns = [
+            r'\b(python|javascript|java|react|angular|node\.?js|sql|aws|docker|kubernetes)\b',
+            r'\b(machine learning|ai|data science|devops|full.?stack)\b',
+            r'\b(project management|agile|scrum|leadership)\b'
+        ]
+        
+        for pattern in skill_patterns:
+            matches = re.findall(pattern, job_description, re.IGNORECASE)
+            requirements['skills'].extend([match.lower() for match in matches])
+        
+        # Extract experience years
+        exp_pattern = r'(\d+)\+?\s*years?\s*(?:of\s*)?experience'
+        exp_matches = re.findall(exp_pattern, job_description, re.IGNORECASE)
+        if exp_matches:
+            requirements['experience_years'] = int(exp_matches[0])
+        
+        # Extract keywords (all meaningful words)
+        keywords = re.findall(r'\b[a-zA-Z]{3,}\b', job_description)
+        stop_words = {'the', 'and', 'for', 'with', 'you', 'will', 'are', 'have'}
+        requirements['keywords'] = [
+            word.lower() for word in keywords 
+            if word.lower() not in stop_words
+        ]
+        
+        # Remove duplicates
+        requirements['skills'] = list(set(requirements['skills']))
+        requirements['keywords'] = list(set(requirements['keywords']))
+        
+        return requirements
+    
+    def _calculate_skills_match(self, profile_skills: List[str], job_skills: List[str]) -> Dict[str, Any]:
+        """Calculate skills match score"""
+        if not job_skills:
+            return {'score': 100, 'details': {'matching_skills': [], 'missing_skills': []}}
+        
+        skill_gap_analysis = self.find_skill_gaps(profile_skills, job_skills)
+        
+        return {
+            'score': skill_gap_analysis['match_percentage'],
+            'details': skill_gap_analysis
+        }
+    
+    def _calculate_experience_match(self, profile_experience: List[Dict], job_requirements: Dict) -> Dict[str, Any]:
+        """Calculate experience match score"""
+        score = 0
+        details = {
+            'relevant_roles': 0,
+            'total_experience': 0,
+            'required_experience': job_requirements.get('experience_years', 0)
+        }
+        
+        # Calculate total years of experience
+        total_years = 0
+        relevant_roles = 0
+        
+        for exp in profile_experience:
+            duration_info = exp.get('duration_info', {})
+            if duration_info.get('duration_months'):
+                total_years += duration_info['duration_months'] / 12
+            
+            # Check if role is relevant (simple keyword matching)
+            role_text = f"{exp.get('title', '')} {exp.get('description', '')}".lower()
+            job_keywords = job_requirements.get('keywords', [])
+            
+            if any(keyword in role_text for keyword in job_keywords[:10]):
+                relevant_roles += 1
+        
+        details['total_experience'] = round(total_years, 1)
+        details['relevant_roles'] = relevant_roles
+        
+        # Calculate score based on experience and relevance
+        if job_requirements.get('experience_years', 0) > 0:
+            exp_ratio = min(total_years / job_requirements['experience_years'], 1.0)
+            score = exp_ratio * 70 + (relevant_roles / max(len(profile_experience), 1)) * 30
+        else:
+            score = 80  # Default good score if no specific experience required
+        
+        return {
+            'score': round(score, 2),
+            'details': details
+        }
+    
+    def _calculate_keywords_match(self, profile_data: Dict, job_keywords: List[str]) -> Dict[str, Any]:
+        """Calculate keywords match score"""
+        if not job_keywords:
+            return {'score': 100, 'details': {'matched': 0, 'total': 0}}
+        
+        # Extract all text from profile
+        profile_text = ""
+        for key, value in profile_data.items():
+            if isinstance(value, str):
+                profile_text += f" {value}"
+            elif isinstance(value, list):
+                for item in value:
+                    if isinstance(item, dict):
+                        profile_text += f" {' '.join(str(v) for v in item.values())}"
+                    else:
+                        profile_text += f" {item}"
+        
+        profile_text = profile_text.lower()
+        
+        # Count keyword matches
+        matched_keywords = 0
+        for keyword in job_keywords:
+            if keyword.lower() in profile_text:
+                matched_keywords += 1
+        
+        score = (matched_keywords / len(job_keywords)) * 100
+        
+        return {
+            'score': round(score, 2),
+            'details': {
+                'matched': matched_keywords,
+                'total': len(job_keywords),
+                'percentage': round(score, 2)
+            }
+        }
+    
+    def _calculate_education_match(self, profile_education: List[Dict], job_requirements: Dict) -> Dict[str, Any]:
+        """Calculate education match score"""
+        score = 70  # Default score
+        details = {
+            'has_degree': len(profile_education) > 0,
+            'degree_count': len(profile_education)
+        }
+        
+        if profile_education:
+            score = 85  # Boost for having education
+            
+            # Check for relevant fields
+            job_keywords = job_requirements.get('keywords', [])
+            for edu in profile_education:
+                edu_text = f"{edu.get('degree', '')} {edu.get('field', '')}".lower()
+                if any(keyword in edu_text for keyword in job_keywords[:5]):
+                    score = 95
+                    break
+        
+        return {
+            'score': score,
+            'details': details
+        }
+    
+    def _are_skills_similar(self, skill1: str, skill2: str) -> bool:
+        """Check if two skills are similar using synonyms"""
+        skill1_lower = skill1.lower()
+        skill2_lower = skill2.lower()
+        
+        # Check direct synonyms
+        for main_skill, synonyms in self.skill_synonyms.items():
+            if ((skill1_lower == main_skill or skill1_lower in synonyms) and
+                (skill2_lower == main_skill or skill2_lower in synonyms)):
+                return True
+        
+        # Check partial matches
+        if skill1_lower in skill2_lower or skill2_lower in skill1_lower:
+            return True
+        
+        return False
+    
+    def _generate_match_recommendations(self, skills_score: Dict, experience_score: Dict, 
+                                      keywords_score: Dict, education_score: Dict) -> List[str]:
+        """Generate recommendations based on individual scores"""
+        recommendations = []
+        
+        if skills_score['score'] < 60:
+            recommendations.append("Focus on developing missing technical skills")
+        
+        if experience_score['score'] < 50:
+            recommendations.append("Highlight more relevant work experience")
+        
+        if keywords_score['score'] < 40:
+            recommendations.append("Optimize profile with job-specific keywords")
+        
+        if education_score['score'] < 60:
+            recommendations.append("Consider additional certifications or training")
+        
+        return recommendations

src/utils/linkedin_parser.py

@@ -0,0 +1,288 @@
+# LinkedIn Data Parser
+import re
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+
+class LinkedInParser:
+    """Utility class for parsing and cleaning LinkedIn profile data"""
+    
+    def __init__(self):
+        self.skill_categories = {
+            'technical': ['python', 'javascript', 'java', 'react', 'node.js', 'sql', 'aws', 'docker'],
+            'management': ['leadership', 'project management', 'team management', 'agile', 'scrum'],
+            'marketing': ['seo', 'social media', 'content marketing', 'digital marketing', 'analytics'],
+            'design': ['ui/ux', 'photoshop', 'figma', 'adobe', 'design thinking']
+        }
+    
+    def clean_profile_data(self, raw_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Clean and standardize raw profile data
+        
+        Args:
+            raw_data (Dict[str, Any]): Raw scraped data
+            
+        Returns:
+            Dict[str, Any]: Cleaned profile data
+        """
+        cleaned_data = {}
+        
+        # Clean basic info
+        cleaned_data['name'] = self._clean_text(raw_data.get('name', ''))
+        cleaned_data['headline'] = self._clean_text(raw_data.get('headline', ''))
+        cleaned_data['location'] = self._clean_text(raw_data.get('location', ''))
+        cleaned_data['about'] = self._clean_text(raw_data.get('about', ''))
+        
+        # Clean experience
+        cleaned_data['experience'] = self._clean_experience_list(
+            raw_data.get('experience', [])
+        )
+        
+        # Clean education
+        cleaned_data['education'] = self._clean_education_list(
+            raw_data.get('education', [])
+        )
+        
+        # Clean and categorize skills
+        cleaned_data['skills'] = self._clean_skills_list(
+            raw_data.get('skills', [])
+        )
+        
+        # Parse additional info
+        cleaned_data['connections'] = self._parse_connections(
+            raw_data.get('connections', '')
+        )
+        
+        cleaned_data['url'] = raw_data.get('url', '')
+        cleaned_data['parsed_at'] = datetime.now().isoformat()
+        
+        return cleaned_data
+    
+    def extract_keywords(self, text: str, min_length: int = 3) -> List[str]:
+        """
+        Extract meaningful keywords from text
+        
+        Args:
+            text (str): Input text
+            min_length (int): Minimum keyword length
+            
+        Returns:
+            List[str]: Extracted keywords
+        """
+        # Remove special characters and convert to lowercase
+        clean_text = re.sub(r'[^\w\s]', ' ', text.lower())
+        
+        # Split into words and filter
+        words = clean_text.split()
+        
+        # Common stop words to exclude
+        stop_words = {
+            'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for', 'of', 'with',
+            'by', 'from', 'up', 'about', 'into', 'through', 'during', 'before',
+            'after', 'above', 'below', 'between', 'among', 'within', 'without',
+            'under', 'over', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+            'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+            'should', 'may', 'might', 'must', 'can', 'this', 'that', 'these',
+            'those', 'i', 'you', 'he', 'she', 'it', 'we', 'they', 'me', 'him',
+            'her', 'us', 'them', 'my', 'your', 'his', 'her', 'its', 'our', 'their'
+        }
+        
+        # Filter keywords
+        keywords = [
+            word for word in words 
+            if len(word) >= min_length and word not in stop_words
+        ]
+        
+        # Remove duplicates while preserving order
+        unique_keywords = []
+        seen = set()
+        for keyword in keywords:
+            if keyword not in seen:
+                unique_keywords.append(keyword)
+                seen.add(keyword)
+        
+        return unique_keywords
+    
+    def parse_duration(self, duration_str: str) -> Dict[str, Any]:
+        """
+        Parse duration strings like "2020 - Present" or "Jan 2020 - Dec 2022"
+        
+        Args:
+            duration_str (str): Duration string
+            
+        Returns:
+            Dict[str, Any]: Parsed duration info
+        """
+        duration_info = {
+            'raw': duration_str,
+            'start_date': None,
+            'end_date': None,
+            'is_current': False,
+            'duration_months': 0
+        }
+        
+        if not duration_str:
+            return duration_info
+        
+        # Check if current position
+        if 'present' in duration_str.lower():
+            duration_info['is_current'] = True
+        
+        # Extract years using regex
+        year_pattern = r'\b(19|20)\d{2}\b'
+        years = re.findall(year_pattern, duration_str)
+        
+        if years:
+            duration_info['start_date'] = years[0] if len(years) > 0 else None
+            duration_info['end_date'] = years[1] if len(years) > 1 else None
+        
+        return duration_info
+    
+    def categorize_skills(self, skills: List[str]) -> Dict[str, List[str]]:
+        """
+        Categorize skills into different types
+        
+        Args:
+            skills (List[str]): List of skills
+            
+        Returns:
+            Dict[str, List[str]]: Categorized skills
+        """
+        categorized = {
+            'technical': [],
+            'management': [],
+            'marketing': [],
+            'design': [],
+            'other': []
+        }
+        
+        for skill in skills:
+            skill_lower = skill.lower()
+            categorized_flag = False
+            
+            for category, keywords in self.skill_categories.items():
+                if any(keyword in skill_lower for keyword in keywords):
+                    categorized[category].append(skill)
+                    categorized_flag = True
+                    break
+            
+            if not categorized_flag:
+                categorized['other'].append(skill)
+        
+        return categorized
+    
+    def extract_achievements(self, text: str) -> List[str]:
+        """
+        Extract achievements with numbers/metrics from text
+        
+        Args:
+            text (str): Input text
+            
+        Returns:
+            List[str]: List of achievements
+        """
+        achievements = []
+        
+        # Patterns for achievements with numbers
+        patterns = [
+            r'[^.]*\b\d+%[^.]*',  # Percentage achievements
+            r'[^.]*\b\d+[kK]\+?[^.]*',  # Numbers with K (thousands)
+            r'[^.]*\b\d+[mM]\+?[^.]*',  # Numbers with M (millions)
+            r'[^.]*\$\d+[^.]*',  # Money amounts
+            r'[^.]*\b\d+\s*(years?|months?)[^.]*',  # Time periods
+        ]
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, text, re.IGNORECASE)
+            achievements.extend([match.strip() for match in matches])
+        
+        return achievements
+    
+    def _clean_text(self, text: str) -> str:
+        """Clean and normalize text"""
+        if not text:
+            return ""
+        
+        # Remove extra whitespace
+        text = re.sub(r'\s+', ' ', text).strip()
+        
+        # Remove special characters but keep basic punctuation
+        text = re.sub(r'[^\w\s\-.,!?()&/]', '', text)
+        
+        return text
+    
+    def _clean_experience_list(self, experience_list: List[Dict]) -> List[Dict]:
+        """Clean experience entries"""
+        cleaned_experience = []
+        
+        for exp in experience_list:
+            if isinstance(exp, dict):
+                cleaned_exp = {
+                    'title': self._clean_text(exp.get('title', '')),
+                    'company': self._clean_text(exp.get('company', '')),
+                    'duration': self._clean_text(exp.get('duration', '')),
+                    'description': self._clean_text(exp.get('description', '')),
+                    'location': self._clean_text(exp.get('location', '')),
+                }
+                
+                # Parse duration
+                cleaned_exp['duration_info'] = self.parse_duration(cleaned_exp['duration'])
+                
+                # Extract achievements
+                cleaned_exp['achievements'] = self.extract_achievements(
+                    cleaned_exp['description']
+                )
+                
+                cleaned_experience.append(cleaned_exp)
+        
+        return cleaned_experience
+    
+    def _clean_education_list(self, education_list: List[Dict]) -> List[Dict]:
+        """Clean education entries"""
+        cleaned_education = []
+        
+        for edu in education_list:
+            if isinstance(edu, dict):
+                cleaned_edu = {
+                    'degree': self._clean_text(edu.get('degree', '')),
+                    'school': self._clean_text(edu.get('school', '')),
+                    'year': self._clean_text(edu.get('year', '')),
+                    'field': self._clean_text(edu.get('field', '')),
+                }
+                cleaned_education.append(cleaned_edu)
+        
+        return cleaned_education
+    
+    def _clean_skills_list(self, skills_list: List[str]) -> List[str]:
+        """Clean and deduplicate skills"""
+        if not skills_list:
+            return []
+        
+        cleaned_skills = []
+        seen_skills = set()
+        
+        for skill in skills_list:
+            cleaned_skill = self._clean_text(str(skill))
+            skill_lower = cleaned_skill.lower()
+            
+            if cleaned_skill and skill_lower not in seen_skills:
+                cleaned_skills.append(cleaned_skill)
+                seen_skills.add(skill_lower)
+        
+        return cleaned_skills
+    
+    def _parse_connections(self, connections_str: str) -> int:
+        """Parse connection count from string"""
+        if not connections_str:
+            return 0
+        
+        # Extract numbers from connection string
+        numbers = re.findall(r'\d+', connections_str)
+        
+        if numbers:
+            return int(numbers[0])
+        
+        # Handle "500+" format
+        if '500+' in connections_str:
+            return 500
+        
+        return 0