Create app.py

app.py

@@ -0,0 +1,773 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime
+import json
+import random
+import re
+from PIL import Image
+import io
+import base64
+
+# Page configuration
+st.set_page_config(
+    page_title="AI & Data Science Learning Platform",
+    page_icon="🤖",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize session state
+if 'user_progress' not in st.session_state:
+    st.session_state.user_progress = {
+        'completed_lessons': [],
+        'quiz_scores': {},
+        'projects_completed': [],
+        'skill_level': 'Beginner'
+    }
+
+if 'current_quiz' not in st.session_state:
+    st.session_state.current_quiz = None
+
+# Custom CSS
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        color: #1e3d59;
+        text-align: center;
+        margin-bottom: 2rem;
+    }
+    .sub-header {
+        font-size: 1.5rem;
+        color: #ff6e40;
+        margin-top: 1rem;
+    }
+    .info-box {
+        background-color: #f5f5f5;
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+    .success-box {
+        background-color: #d4edda;
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+    .warning-box {
+        background-color: #fff3cd;
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 1rem 0;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Learning content database
+LEARNING_MODULES = {
+    "Beginner": {
+        "Python Fundamentals": {
+            "topics": ["Variables & Data Types", "Control Flow", "Functions", "Data Structures"],
+            "duration": "2 weeks",
+            "projects": ["Calculator App", "To-Do List Manager"]
+        },
+        "Data Science Basics": {
+            "topics": ["NumPy", "Pandas", "Data Visualization", "Statistics"],
+            "duration": "3 weeks",
+            "projects": ["EDA on Titanic Dataset", "Sales Data Analysis"]
+        },
+        "Machine Learning Introduction": {
+            "topics": ["Supervised Learning", "Regression", "Classification", "Model Evaluation"],
+            "duration": "4 weeks",
+            "projects": ["House Price Prediction", "Iris Classification"]
+        }
+    },
+    "Intermediate": {
+        "Advanced ML": {
+            "topics": ["Ensemble Methods", "Feature Engineering", "Cross-Validation", "Hyperparameter Tuning"],
+            "duration": "4 weeks",
+            "projects": ["Customer Churn Prediction", "Credit Risk Assessment"]
+        },
+        "Deep Learning": {
+            "topics": ["Neural Networks", "CNNs", "RNNs", "Transfer Learning"],
+            "duration": "6 weeks",
+            "projects": ["Image Classification", "Text Sentiment Analysis"]
+        },
+        "NLP Fundamentals": {
+            "topics": ["Text Processing", "Word Embeddings", "Named Entity Recognition", "Topic Modeling"],
+            "duration": "4 weeks",
+            "projects": ["Spam Detection", "Document Clustering"]
+        }
+    },
+    "Advanced": {
+        "Advanced Deep Learning": {
+            "topics": ["GANs", "Autoencoders", "Transformers", "BERT/GPT"],
+            "duration": "8 weeks",
+            "projects": ["Image Generation", "Custom Chatbot"]
+        },
+        "MLOps": {
+            "topics": ["Model Deployment", "Docker", "CI/CD", "Model Monitoring"],
+            "duration": "4 weeks",
+            "projects": ["End-to-End ML Pipeline", "Model API Development"]
+        },
+        "Research & Innovation": {
+            "topics": ["Research Papers", "State-of-the-art Models", "Custom Architectures"],
+            "duration": "Ongoing",
+            "projects": ["Research Paper Implementation", "Novel Model Development"]
+        }
+    }
+}
+
+# Quiz questions database
+QUIZ_DATABASE = {
+    "Python Fundamentals": [
+        {
+            "question": "What is the output of: print(type([1, 2, 3]))?",
+            "options": ["<class 'list'>", "<class 'tuple'>", "<class 'dict'>", "<class 'set'>"],
+            "correct": 0
+        },
+        {
+            "question": "Which method is used to add an element to a list?",
+            "options": ["add()", "append()", "insert_end()", "push()"],
+            "correct": 1
+        }
+    ],
+    "Machine Learning": [
+        {
+            "question": "Which metric is best for imbalanced classification?",
+            "options": ["Accuracy", "F1-Score", "MSE", "MAE"],
+            "correct": 1
+        },
+        {
+            "question": "What does overfitting mean?",
+            "options": [
+                "Model performs poorly on training data",
+                "Model performs well on training but poorly on test data",
+                "Model performs well on both training and test data",
+                "Model has too few parameters"
+            ],
+            "correct": 1
+        }
+    ]
+}
+
+# Job application templates
+JOB_TEMPLATES = {
+    "Data Scientist": {
+        "skills": ["Python", "Machine Learning", "Statistics", "SQL", "Data Visualization"],
+        "keywords": ["predictive modeling", "statistical analysis", "A/B testing", "data pipeline"]
+    },
+    "ML Engineer": {
+        "skills": ["Python", "TensorFlow/PyTorch", "MLOps", "Docker", "Cloud Platforms"],
+        "keywords": ["model deployment", "scalability", "optimization", "production systems"]
+    },
+    "Data Analyst": {
+        "skills": ["SQL", "Excel", "Tableau/PowerBI", "Python/R", "Statistics"],
+        "keywords": ["data insights", "reporting", "dashboards", "business intelligence"]
+    }
+}
+
+def create_mind_map(topic, concepts):
+    """Create an interactive mind map visualization"""
+    fig = go.Figure()
+    
+    # Center node
+    fig.add_trace(go.Scatter(
+        x=[0], y=[0],
+        mode='markers+text',
+        marker=dict(size=30, color='#ff6e40'),
+        text=[topic],
+        textposition="middle center",
+        textfont=dict(size=14, color='white'),
+        hoverinfo='text',
+        hovertext=topic
+    ))
+    
+    # Concept nodes
+    n = len(concepts)
+    angles = np.linspace(0, 2*np.pi, n, endpoint=False)
+    
+    for i, (concept, details) in enumerate(concepts.items()):
+        x = 2 * np.cos(angles[i])
+        y = 2 * np.sin(angles[i])
+        
+        # Add edge
+        fig.add_trace(go.Scatter(
+            x=[0, x], y=[0, y],
+            mode='lines',
+            line=dict(color='#e0e0e0', width=2),
+            hoverinfo='none',
+            showlegend=False
+        ))
+        
+        # Add concept node
+        fig.add_trace(go.Scatter(
+            x=[x], y=[y],
+            mode='markers+text',
+            marker=dict(size=25, color='#1e3d59'),
+            text=[concept],
+            textposition="top center",
+            textfont=dict(size=10),
+            hoverinfo='text',
+            hovertext=f"{concept}: {details}",
+            showlegend=False
+        ))
+    
+    fig.update_layout(
+        showlegend=False,
+        height=400,
+        xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        yaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+        paper_bgcolor='white',
+        plot_bgcolor='white',
+        margin=dict(l=0, r=0, t=0, b=0)
+    )
+    
+    return fig
+
+def analyze_resume_ats(resume_text, job_role):
+    """Analyze resume for ATS compatibility"""
+    template = JOB_TEMPLATES.get(job_role, JOB_TEMPLATES["Data Scientist"])
+    
+    # Check for keywords
+    found_skills = []
+    missing_skills = []
+    
+    for skill in template["skills"]:
+        if skill.lower() in resume_text.lower():
+            found_skills.append(skill)
+        else:
+            missing_skills.append(skill)
+    
+    # Check for action keywords
+    found_keywords = []
+    for keyword in template["keywords"]:
+        if keyword.lower() in resume_text.lower():
+            found_keywords.append(keyword)
+    
+    # Calculate ATS score
+    skill_score = len(found_skills) / len(template["skills"]) * 50
+    keyword_score = min(len(found_keywords) / len(template["keywords"]) * 50, 50)
+    total_score = skill_score + keyword_score
+    
+    return {
+        "score": total_score,
+        "found_skills": found_skills,
+        "missing_skills": missing_skills,
+        "found_keywords": found_keywords,
+        "recommendations": generate_recommendations(missing_skills, found_keywords, template["keywords"])
+    }
+
+def generate_recommendations(missing_skills, found_keywords, all_keywords):
+    """Generate resume improvement recommendations"""
+    recommendations = []
+    
+    if missing_skills:
+        recommendations.append(f"Add these skills to your resume: {', '.join(missing_skills[:3])}")
+    
+    missing_keywords = [k for k in all_keywords if k not in found_keywords]
+    if missing_keywords:
+        recommendations.append(f"Include keywords like: {', '.join(missing_keywords[:3])}")
+    
+    if len(found_keywords) < 2:
+        recommendations.append("Use more action verbs and industry-specific terminology")
+    
+    recommendations.append("Quantify your achievements with numbers and percentages")
+    recommendations.append("Keep resume format simple and ATS-friendly (avoid complex formatting)")
+    
+    return recommendations
+
+def generate_quiz(topic, num_questions=5):
+    """Generate quiz questions for a topic"""
+    # For demo, using predefined questions or generating random ones
+    if topic in QUIZ_DATABASE:
+        return QUIZ_DATABASE[topic][:num_questions]
+    else:
+        # Generate generic questions
+        questions = []
+        for i in range(num_questions):
+            questions.append({
+                "question": f"Sample question {i+1} about {topic}?",
+                "options": ["Option A", "Option B", "Option C", "Option D"],
+                "correct": random.randint(0, 3)
+            })
+        return questions
+
+def calculate_learning_path(current_level, target_role):
+    """Calculate personalized learning path"""
+    path = []
+    
+    if current_level == "Beginner":
+        path.extend(["Python Fundamentals", "Data Science Basics", "Machine Learning Introduction"])
+    elif current_level == "Intermediate":
+        path.extend(["Advanced ML", "Deep Learning"])
+    
+    # Add role-specific modules
+    if "Engineer" in target_role:
+        path.append("MLOps")
+    elif "Scientist" in target_role:
+        path.append("Advanced Statistics")
+    elif "Analyst" in target_role:
+        path.append("Business Intelligence")
+    
+    return path
+
+# Sidebar navigation
+with st.sidebar:
+    st.markdown("## 🎓 Learning Platform")
+    
+    menu = st.selectbox(
+        "Navigation",
+        ["Dashboard", "Learn", "Practice", "Projects", "Quizzes", 
+         "Career Guide", "Resume Builder", "Mind Maps", "Progress"]
+    )
+    
+    st.markdown("---")
+    
+    # User profile
+    st.markdown("### 👤 User Profile")
+    skill_level = st.selectbox("Skill Level", ["Beginner", "Intermediate", "Advanced"])
+    st.session_state.user_progress['skill_level'] = skill_level
+    
+    target_role = st.selectbox(
+        "Target Role",
+        ["Data Scientist", "ML Engineer", "Data Analyst", "AI Researcher"]
+    )
+    
+    st.markdown("---")
+    st.markdown("### 📊 Quick Stats")
+    st.metric("Completed Lessons", len(st.session_state.user_progress['completed_lessons']))
+    st.metric("Projects Done", len(st.session_state.user_progress['projects_completed']))
+    
+    avg_score = np.mean(list(st.session_state.user_progress['quiz_scores'].values())) if st.session_state.user_progress['quiz_scores'] else 0
+    st.metric("Avg Quiz Score", f"{avg_score:.1f}%")
+
+# Main content area
+if menu == "Dashboard":
+    st.markdown("<h1 class='main-header'>🚀 AI & Data Science Learning Platform</h1>", unsafe_allow_html=True)
+    
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.markdown("### 📚 Learning Modules")
+        modules_count = sum(len(modules) for modules in LEARNING_MODULES.values())
+        st.metric("Total Modules", modules_count)
+        st.markdown("Comprehensive curriculum from basics to advanced")
+    
+    with col2:
+        st.markdown("### 🎯 Projects")
+        projects_count = sum(
+            len(module_info.get("projects", [])) 
+            for level_modules in LEARNING_MODULES.values() 
+            for module_info in level_modules.values()
+        )
+        st.metric("Hands-on Projects", projects_count)
+        st.markdown("Real-world projects to build your portfolio")
+    
+    with col3:
+        st.markdown("### 💼 Career Support")
+        st.metric("Job Roles Covered", len(JOB_TEMPLATES))
+        st.markdown("Resume optimization and interview prep")
+    
+    # Learning path recommendation
+    st.markdown("---")
+    st.markdown("### 🗺️ Your Personalized Learning Path")
+    
+    learning_path = calculate_learning_path(skill_level, target_role)
+    
+    progress_cols = st.columns(len(learning_path))
+    for i, module in enumerate(learning_path):
+        with progress_cols[i]:
+            if module in st.session_state.user_progress['completed_lessons']:
+                st.success(f"✅ {module}")
+            else:
+                st.info(f"📘 {module}")
+    
+    # Recent achievements
+    st.markdown("---")
+    st.markdown("### 🏆 Recent Achievements")
+    
+    if st.session_state.user_progress['completed_lessons']:
+        for lesson in st.session_state.user_progress['completed_lessons'][-3:]:
+            st.markdown(f"- Completed: **{lesson}**")
+    else:
+        st.markdown("Start learning to earn achievements!")
+
+elif menu == "Learn":
+    st.markdown("<h1 class='main-header'>📚 Learning Modules</h1>", unsafe_allow_html=True)
+    
+    selected_level = st.selectbox("Select Level", ["Beginner", "Intermediate", "Advanced"])
+    
+    modules = LEARNING_MODULES[selected_level]
+    
+    for module_name, module_info in modules.items():
+        with st.expander(f"📘 {module_name} - {module_info['duration']}"):
+            st.markdown("**Topics Covered:**")
+            for topic in module_info['topics']:
+                st.markdown(f"- {topic}")
+            
+            st.markdown("**Projects:**")
+            for project in module_info['projects']:
+                st.markdown(f"- 🛠️ {project}")
+            
+            col1, col2 = st.columns(2)
+            with col1:
+                if st.button(f"Start Learning", key=f"learn_{module_name}"):
+                    st.session_state.user_progress['completed_lessons'].append(module_name)
+                    st.success(f"Started learning {module_name}!")
+            
+            with col2:
+                if st.button(f"View Resources", key=f"resources_{module_name}"):
+                    st.info("Resources: Documentation, Videos, Articles, Code Examples")
+
+elif menu == "Practice":
+    st.markdown("<h1 class='main-header'>💻 Practice Coding</h1>", unsafe_allow_html=True)
+    
+    practice_type = st.selectbox(
+        "Select Practice Type",
+        ["Python Basics", "Data Manipulation", "Machine Learning", "Deep Learning", "SQL"]
+    )
+    
+    st.markdown("### 📝 Coding Challenge")
+    
+    challenges = {
+        "Python Basics": {
+            "title": "List Comprehension",
+            "problem": "Create a list of squares for numbers 1 to 10 using list comprehension",
+            "hint": "Use [x**2 for x in range(1, 11)]"
+        },
+        "Data Manipulation": {
+            "title": "Pandas DataFrame Operations",
+            "problem": "Filter a DataFrame to show only rows where 'age' > 25 and 'salary' > 50000",
+            "hint": "Use df[(df['age'] > 25) & (df['salary'] > 50000)]"
+        },
+        "Machine Learning": {
+            "title": "Train-Test Split",
+            "problem": "Split your data into 80% training and 20% testing sets",
+            "hint": "Use train_test_split from sklearn.model_selection"
+        }
+    }
+    
+    if practice_type in challenges:
+        challenge = challenges[practice_type]
+        st.markdown(f"**Challenge:** {challenge['title']}")
+        st.markdown(f"**Problem:** {challenge['problem']}")
+        
+        code_input = st.text_area("Write your code here:", height=200)
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("Run Code"):
+                st.success("Code executed successfully! (Simulation)")
+                st.code("Output: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]")
+        
+        with col2:
+            if st.button("Show Hint"):
+                st.info(f"Hint: {challenge['hint']}")
+
+elif menu == "Projects":
+    st.markdown("<h1 class='main-header'>🛠️ Hands-on Projects</h1>", unsafe_allow_html=True)
+    
+    project_category = st.selectbox(
+        "Select Project Category",
+        ["Beginner Projects", "Intermediate Projects", "Advanced Projects", "Portfolio Projects"]
+    )
+    
+    projects = {
+        "Beginner Projects": [
+            {
+                "name": "Titanic Survival Prediction",
+                "description": "Predict passenger survival using logistic regression",
+                "skills": ["Pandas", "Scikit-learn", "Data Visualization"],
+                "difficulty": "⭐⭐"
+            },
+            {
+                "name": "Stock Price Analysis",
+                "description": "Analyze and visualize stock market trends",
+                "skills": ["Pandas", "Matplotlib", "Time Series"],
+                "difficulty": "⭐⭐"
+            }
+        ],
+        "Intermediate Projects": [
+            {
+                "name": "Customer Segmentation",
+                "description": "Segment customers using clustering algorithms",
+                "skills": ["K-Means", "PCA", "Feature Engineering"],
+                "difficulty": "⭐⭐⭐"
+            },
+            {
+                "name": "Sentiment Analysis",
+                "description": "Analyze sentiment from product reviews",
+                "skills": ["NLP", "NLTK", "Classification"],
+                "difficulty": "⭐⭐⭐"
+            }
+        ]
+    }
+    
+    if project_category in projects:
+        for project in projects[project_category]:
+            with st.expander(f"📁 {project['name']} - {project['difficulty']}"):
+                st.markdown(f"**Description:** {project['description']}")
+                st.markdown("**Skills you'll learn:**")
+                for skill in project['skills']:
+                    st.markdown(f"- {skill}")
+                
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    if st.button(f"Start Project", key=f"start_{project['name']}"):
+                        st.session_state.user_progress['projects_completed'].append(project['name'])
+                        st.success("Project started!")
+                
+                with col2:
+                    if st.button(f"View Solution", key=f"solution_{project['name']}"):
+                        st.code("""
+# Sample solution structure
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+
+# Load data
+data = pd.read_csv('data.csv')
+
+# Preprocessing
+# ... your code here
+
+# Model training
+model = LogisticRegression()
+model.fit(X_train, y_train)
+
+# Evaluation
+accuracy = model.score(X_test, y_test)
+print(f'Accuracy: {accuracy}')
+                        """)
+                
+                with col3:
+                    if st.button(f"Download Dataset", key=f"data_{project['name']}"):
+                        st.info("Dataset downloaded! (Simulation)")
+
+elif menu == "Quizzes":
+    st.markdown("<h1 class='main-header'>📝 Knowledge Assessment</h1>", unsafe_allow_html=True)
+    
+    quiz_topic = st.selectbox(
+        "Select Quiz Topic",
+        ["Python Fundamentals", "Machine Learning", "Deep Learning", "Statistics", "SQL"]
+    )
+    
+    if st.button("Start Quiz"):
+        st.session_state.current_quiz = generate_quiz(quiz_topic, 5)
+        st.session_state.quiz_answers = {}
+    
+    if st.session_state.current_quiz:
+        st.markdown(f"### Quiz: {quiz_topic}")
+        
+        for i, q in enumerate(st.session_state.current_quiz):
+            st.markdown(f"**Question {i+1}:** {q['question']}")
+            answer = st.radio(
+                "Select your answer:",
+                q['options'],
+                key=f"q_{i}"
+            )
+            st.session_state.quiz_answers[i] = q['options'].index(answer) if answer else None
+        
+        if st.button("Submit Quiz"):
+            score = 0
+            for i, q in enumerate(st.session_state.current_quiz):
+                if st.session_state.quiz_answers.get(i) == q['correct']:
+                    score += 1
+            
+            percentage = (score / len(st.session_state.current_quiz)) * 100
+            st.session_state.user_progress['quiz_scores'][quiz_topic] = percentage
+            
+            if percentage >= 80:
+                st.success(f"Excellent! You scored {percentage:.0f}%")
+            elif percentage >= 60:
+                st.warning(f"Good job! You scored {percentage:.0f}%")
+            else:
+                st.error(f"Keep practicing! You scored {percentage:.0f}%")
+            
+            # Show correct answers
+            st.markdown("### Correct Answers:")
+            for i, q in enumerate(st.session_state.current_quiz):
+                st.markdown(f"Q{i+1}: {q['options'][q['correct']]}")
+
+elif menu == "Career Guide":
+    st.markdown("<h1 class='main-header'>💼 Career Guidance</h1>", unsafe_allow_html=True)
+    
+    tab1, tab2, tab3 = st.tabs(["Career Paths", "Skills Roadmap", "Interview Prep"])
+    
+    with tab1:
+        st.markdown("### 🎯 AI/Data Science Career Paths")
+        
+        careers = {
+            "Data Scientist": {
+                "salary": "$120,000 - $180,000",
+                "skills": "Python, ML, Statistics, Communication",
+                "description": "Analyze complex data to help companies make decisions"
+            },
+            "ML Engineer": {
+                "salary": "$130,000 - $200,000",
+                "skills": "Python, MLOps, Cloud, Software Engineering",
+                "description": "Build and deploy ML models at scale"
+            },
+            "Data Analyst": {
+                "salary": "$70,000 - $110,000",
+                "skills": "SQL, Excel, Visualization, Business Acumen",
+                "description": "Transform data into actionable insights"
+            },
+            "AI Research Scientist": {
+                "salary": "$150,000 - $300,000",
+                "skills": "Deep Learning, Research, Mathematics, Publishing",
+                "description": "Push the boundaries of AI technology"
+            }
+        }
+        
+        for role, info in careers.items():
+            with st.expander(f"👔 {role}"):
+                st.markdown(f"**Salary Range:** {info['salary']}")
+                st.markdown(f"**Key Skills:** {info['skills']}")
+                st.markdown(f"**Description:** {info['description']}")
+                
+                if st.button(f"View Learning Path", key=f"path_{role}"):
+                    path = calculate_learning_path(skill_level, role)
+                    st.markdown("**Recommended Learning Path:**")
+                    for i, module in enumerate(path, 1):
+                        st.markdown(f"{i}. {module}")
+    
+    with tab2:
+        st.markdown("### 🗺️ Skills Roadmap")
+        
+        skill_timeline = {
+            "Month 1-2": ["Python Basics", "Git/GitHub", "SQL Fundamentals"],
+            "Month 3-4": ["Data Analysis", "Statistics", "Visualization"],
+            "Month 5-6": ["Machine Learning", "Feature Engineering", "Model Evaluation"],
+            "Month 7-9": ["Deep Learning", "NLP/Computer Vision", "Cloud Platforms"],
+            "Month 10-12": ["MLOps", "Production Systems", "Advanced Topics"]
+        }
+        
+        for period, skills in skill_timeline.items():
+            st.markdown(f"**{period}:**")
+            for skill in skills:
+                st.markdown(f"- {skill}")
+    
+    with tab3:
+        st.markdown("### 🎤 Interview Preparation")
+        
+        interview_topics = {
+            "Technical Questions": [
+                "Explain the bias-variance tradeoff",
+                "What is gradient descent?",
+                "Difference between L1 and L2 regularization",
+                "How do you handle imbalanced datasets?"
+            ],
+            "Behavioral Questions": [
+                "Tell me about a challenging project",
+                "How do you handle conflicting priorities?",
+                "Describe a time you worked with stakeholders",
+                "How do you stay updated with AI trends?"
+            ],
+            "Case Studies": [
+                "Design a recommendation system",
+                "Predict customer churn",
+                "Detect fraudulent transactions",
+                "Optimize marketing campaigns"
+            ]
+        }
+        
+        for category, questions in interview_topics.items():
+            with st.expander(f"📚 {category}"):
+                for q in questions:
+                    st.markdown(f"• {q}")
+                
+                if st.button(f"Practice {category}", key=f"practice_{category}"):
+                    st.info("Practice session started! Prepare your answers and time yourself.")
+
+elif menu == "Resume Builder":
+    st.markdown("<h1 class='main-header'>📄 ATS-Optimized Resume Builder</h1>", unsafe_allow_html=True)
+    
+    tab1, tab2, tab3 = st.tabs(["Resume Analysis", "LinkedIn Optimizer", "Cover Letter"])
+    
+    with tab1:
+        st.markdown("### 🔍 ATS Resume Analyzer")
+        
+        job_role = st.selectbox(
+            "Select Target Role",
+            list(JOB_TEMPLATES.keys())
+        )
+        
+        resume_text = st.text_area(
+            "Paste your resume text here:",
+            height=300,
+            placeholder="Copy and paste your entire resume content..."
+        )
+        
+        if st.button("Analyze Resume"):
+            if resume_text:
+                analysis = analyze_resume_ats(resume_text, job_role)
+                
+                # Display ATS Score
+                col1, col2 = st.columns(2)
+                with col1:
+                    score_color = "green" if analysis['score'] >= 80 else "orange" if analysis['score'] >= 60 else "red"
+                    st.markdown(f"### ATS Score: <span style='color:{score_color}'>{analysis['score']:.0f}%</span>", unsafe_allow_html=True)
+                
+                with col2:
+                    st.metric("Skills Match", f"{len(analysis['found_skills'])}/{len(JOB_TEMPLATES[job_role]['skills'])}")
+                
+                # Found skills
+                if analysis['found_skills']:
+                    st.success("✅ **Skills Found:**")
+                    st.write(", ".join(analysis['found_skills']))
+                
+                # Missing skills
+                if analysis['missing_skills']:
+                    st.warning("⚠️ **Missing Skills:**")
+                    st.write(", ".join(analysis['missing_skills']))
+                
+                # Recommendations
+                st.markdown("### 💡 Recommendations:")
+                for rec in analysis['recommendations']:
+                    st.markdown(f"• {rec}")
+            else:
+                st.error("Please paste your resume text")
+    
+    with tab2:
+        st.markdown("### 🔗 LinkedIn Profile Optimizer")
+        
+        linkedin_sections = {
+            "Headline": "Data Scientist | Machine Learning | Python | Transforming Data into Insights",
+            "Summary": "Passionate data scientist with 3+ years of experience in building ML models that drive business value. Skilled in Python, TensorFlow, and cloud deployment.",
+            "Skills": ["Python", "Machine Learning", "Deep Learning", "SQL", "TensorFlow", "PyTorch", "AWS", "Docker"]
+        }
+        
+        for section, content in linkedin_sections.items():
+            st.markdown(f"**{section} Template:**")
+            if isinstance(content, list):
+                st.write(", ".join(content))
+            else:
+                st.write(content)
+        
+        st.markdown("### 🎯 LinkedIn Tips:")
+        tips = [
+            "Use keywords from job descriptions in your headline and summary",
+            "Add 50+ skills and get endorsements for top skills",
+            "Write detailed descriptions for each role with quantified achievements",
+            "Add relevant certifications and courses",
+            "Engage with content in your field regularly"
+        ]
+        
+        for tip in tips:
+            st.markdown(f"• {tip}")
+    
+    with tab3:
+        st.markdown("### ✉️ Cover Letter Generator")
+        
+        company_name = st.text_input("Company Name")
+        position = st.text_input("Position")
+        
+        if st.button("Generate Cover Letter Template"):
+            if company_name and position:
+                cover_letter = f"""
+Dear Hiring Manager at {company_name