Update app.py

app.py

@@ -1,7 +1,6 @@
 import streamlit as st
 import json
 from typing import Dict, List, Any
-import re
 
 # Initialize Streamlit page configuration
 st.set_page_config(
@@ -10,151 +9,177 @@ st.set_page_config(
     layout="wide"
 )
 
-def extract_key_requirements(text: str) -> Dict[str, List[str]]:
-    """Extract key requirements from text"""
-    text_lower = text.lower()
+# Helper functions for formatting responses
+def get_project_details(project: dict) -> str:
+    """Format project details in a clear, structured way"""
+    return (
+        f"• {project['name']}\n"
+        f"  Description: {project['description']}\n"
+        f"  Skills: {', '.join(project['skills_used'])}\n"
+        f"  Status: {project['status']}"
+    )
+
+def get_skills_by_category(knowledge_base: dict) -> Dict[str, List[str]]:
+    """Organize skills by category with examples"""
+    skills = knowledge_base['skills']
+    projects = knowledge_base['professional_experience']['projects']
     
-    categories = {
-        'technical_skills': [
-            'python', 'machine learning', 'deep learning', 'nlp', 'neural networks',
-            'data science', 'sql', 'tensorflow', 'pytorch', 'scikit-learn', 'data analysis'
-        ],
-        'soft_skills': [
-            'communication', 'teamwork', 'leadership', 'problem solving', 'analytical',
-            'collaborative', 'independent', 'innovative'
-        ],
-        'education': [
-            'master', 'phd', 'bachelor', 'degree', 'computer science', 'statistics',
-            'mathematics', 'post graduate', 'certification'
-        ],
-        'experience': [
-            'year', 'experience', 'background', 'industry', 'startup', 'enterprise'
-        ]
-    }
+    skill_examples = {}
+    for skill in skills['technical_skills']:
+        related_projects = [p['name'] for p in projects 
+                          if skill.lower() in [s.lower() for s in p['skills_used']]]
+        if related_projects:
+            skill_examples[skill] = related_projects[0]
+    return skill_examples
+
+def format_story_response(knowledge_base: dict) -> str:
+    """Format the background story in a clear, structured way"""
+    education = knowledge_base['education']
     
-    found = {category: [] for category in categories}
-    for category, keywords in categories.items():
-        for keyword in keywords:
-            if keyword in text_lower:
-                found[category].append(keyword)
+    story = [
+        "Here's my journey from commerce to ML/AI:",
+        "• Education Background:",
+        f"  - Graduated with a Commerce degree from {education['Undergraduate'][0]['institution']}",
+        "• Career Transition:",
+        "  - Started as a Programmer Trainee at Cognizant despite no prior coding experience",
+        "  - Excelled in development roles and discovered passion for technology",
+        "• Current Path:",
+        f"  - Pursuing {education['postgraduate'][0]['course_name']} at {education['postgraduate'][0]['institution']}",
+        f"  - Also enrolled in {education['postgraduate'][1]['course_name']} at {education['postgraduate'][1]['institution']}",
+        "• Goal:",
+        "  - Combining business acumen with ML/AI expertise to create impactful solutions"
+    ]
+    return '\n'.join(story)
+
+def format_project_list(knowledge_base: dict) -> str:
+    """Format project list in a clear, structured way"""
+    projects = knowledge_base['professional_experience']['projects']
     
-    return found
-
-def analyze_profile_match(requirements: Dict[str, List[str]], knowledge_base: dict) -> Dict[str, Any]:
-    """Analyze how well the profile matches requirements"""
-    my_skills = set(s.lower() for s in knowledge_base['skills']['technical_skills'])
-    my_soft_skills = set(s.lower() for s in knowledge_base['skills']['soft_skills'])
+    response = ["My Portfolio Projects:"]
+    for project in projects:
+        response.extend([
+            f"\n{project['name']}",
+            f"• Description: {project['description']}",
+            f"• Technologies: {', '.join(project['skills_used'])}",
+            f"• Current Status: {project['status']}",
+            "---"
+        ])
+    return '\n'.join(response)
+
+def format_standout_qualities(knowledge_base: dict) -> str:
+    """Format standout qualities in a clear, structured way"""
+    qualities = [
+        "What Makes Me Stand Out:",
+        "\n1. Unique Background",
+        "   • Successfully transitioned from commerce to tech",
+        "   • Bring both business acumen and technical expertise",
+        "\n2. Practical Experience",
+        f"   • Developed {len(knowledge_base['professional_experience']['projects'])} significant ML projects",
+        "   • Real-world implementation experience from Cognizant",
+        "\n3. Canadian Education",
+        "   • Advanced AI/ML education in Canada",
+        "   • Up-to-date with latest industry practices",
+        "\n4. Technical Expertise",
+        f"   • Strong foundation in {', '.join(knowledge_base['skills']['technical_skills'][:3])}",
+        "   • Hands-on experience with ML model deployment",
+        "\n5. Business Perspective",
+        "   • Understanding of both technical and business requirements",
+        "   • Can bridge gap between technical and business teams"
+    ]
+    return '\n'.join(qualities)
+
+def analyze_job_description(text: str, knowledge_base: dict) -> dict:
+    """Analyze job description and match with candidate's profile"""
+    text_lower = text.lower()
     
-    # Match technical skills
-    matching_tech_skills = [skill for skill in requirements['technical_skills'] 
-                          if any(my_skill in skill or skill in my_skill 
-                                for my_skill in my_skills)]
+    # Extract key skills from knowledge base
+    my_skills = set(s.lower() for s in knowledge_base['skills']['technical_skills'])
     
-    # Match soft skills
-    matching_soft_skills = [skill for skill in requirements['soft_skills'] 
-                          if any(my_skill in skill or skill in my_skill 
-                                for my_skill in my_soft_skills)]
+    # Common ML/AI job related keywords
+    ml_keywords = {
+        'machine learning', 'deep learning', 'artificial intelligence', 'ai', 'ml',
+        'neural networks', 'nlp', 'computer vision', 'data science',
+        'python', 'pytorch', 'tensorflow', 'scikit-learn'
+    }
     
+    # Find mentioned skills in JD
+    found_skills = []
+    for skill in my_skills:
+        if skill in text_lower:
+            found_skills.append(skill)
+            
     # Find relevant projects
     relevant_projects = []
     for project in knowledge_base['professional_experience']['projects']:
         project_skills = set(s.lower() for s in project['skills_used'])
-        if any(skill in ' '.join(requirements['technical_skills']) for skill in project_skills):
+        if any(skill in text_lower for skill in project_skills):
             relevant_projects.append(project)
-    
-    # Check education match
-    education_matches = []
-    for edu in knowledge_base['education']['postgraduate']:
-        if any(req in edu['course_name'].lower() for req in requirements['education']):
-            education_matches.append(edu)
-    
+            
     return {
-        'matching_tech_skills': matching_tech_skills,
-        'matching_soft_skills': matching_soft_skills,
+        'matching_skills': found_skills,
         'relevant_projects': relevant_projects[:2],
-        'education_matches': education_matches,
-        'background_story': knowledge_base['frequently_asked_questions'][0]['answer']  # Transition story
+        'is_ml_role': any(keyword in text_lower for keyword in ml_keywords)
     }
 
 def generate_response(query: str, knowledge_base: dict) -> str:
     """Generate enhanced responses using the knowledge base"""
     query_lower = query.lower()
     
+    # Handle project listing requests
+    if any(word in query_lower for word in ['list', 'project', 'portfolio', 'built', 'created', 'developed']):
+        return format_project_list(knowledge_base)
+    
+    # Handle background/journey queries
+    elif any(word in query_lower for word in ['background', 'journey', 'story', 'transition']):
+        return format_story_response(knowledge_base)
+    
+    # Handle standout/unique qualities queries
+    elif any(word in query_lower for word in ['stand out', 'unique', 'different', 'special']):
+        return format_standout_qualities(knowledge_base)
+    
     # Handle job descriptions or role requirements
-    if len(query.split()) > 20 or any(phrase in query_lower for phrase in 
+    elif len(query.split()) > 20 or any(phrase in query_lower for phrase in 
         ['requirements', 'qualifications', 'looking for', 'job description', 'responsibilities']):
+        analysis = analyze_job_description(query, knowledge_base)
         
-        requirements = extract_key_requirements(query)
-        match_analysis = analyze_profile_match(requirements, knowledge_base)
-        
-        response_parts = []
-        
-        # Start with unique background if it's an ML role
-        if any(skill in query_lower for skill in ['machine learning', 'ml', 'ai', 'data science']):
-            transition_story = match_analysis['background_story']
-            response_parts.append(f"With my unique transition from commerce to ML/AI, {transition_story[:200]}...")
-        
-        # Add technical alignment
-        if match_analysis['matching_tech_skills']:
-            response_parts.append(f"I have hands-on experience with key technical requirements including {', '.join(match_analysis['matching_tech_skills'])}.")
-        
-        # Highlight relevant project
-        if match_analysis['relevant_projects']:
-            project = match_analysis['relevant_projects'][0]
-            response_parts.append(f"My project '{project['name']}' demonstrates my capabilities as {project['description']}")
-        
-        # Add education and Canadian context
-        response_parts.append("I'm completing advanced AI/ML education in Canada through Georgian College and George Brown College, gaining cutting-edge knowledge in ML engineering and practical implementation.")
-        
-        # Add forward-looking statement
-        response_parts.append("I'm actively expanding my ML expertise through hands-on projects and am ready to contribute to innovative ML solutions in the Canadian tech industry.")
-        
-        return ' '.join(response_parts)
-    
-    # Handle specific company/role queries
-    elif any(word in query_lower for word in ['role', 'fit', 'job', 'position', 'company']):
-        company_name = None
-        words = query.split()
-        for word in words:
-            if word[0].isupper() and word.lower() not in ['i', 'ml', 'ai', 'nlp']:
-                company_name = word
-                break
-        
-        projects = knowledge_base['professional_experience']['projects']
-        skills = knowledge_base['skills']['technical_skills']
-        goals = knowledge_base['goals_and_aspirations']['short_term']
-        
-        response = [
-            f"{'As a candidate for ' + company_name if company_name else 'As an ML engineer candidate'}, I bring a unique combination of technical expertise and business understanding from my commerce background.",
-            f"My strongest project is my {projects[0]['name']}, where {projects[0]['description']}",
-            f"I've developed expertise in {', '.join(skills[:3])}, applying these skills in real-world projects.",
-            "With my Canadian AI/ML education and practical project experience, I'm well-prepared to contribute to innovative ML solutions.",
-            f"I'm actively {goals[0].lower()} and expanding my portfolio with industry-relevant projects."
-        ]
-        
-        return ' '.join(response)
+        if analysis['is_ml_role']:
+            response_parts = []
+            response_parts.append("Based on the job description, here's how my profile aligns:")
+            
+            if analysis['matching_skills']:
+                response_parts.append(f"\n• Technical Skills Match:\n  - I have experience with: {', '.join(analysis['matching_skills'])}")
+            
+            if analysis['relevant_projects']:
+                project = analysis['relevant_projects'][0]
+                response_parts.append(f"\n• Relevant Project Experience:\n  - {project['name']}: {project['description']}")
+            
+            response_parts.append("\n• Additional Qualifications:\n  - Advanced AI/ML education in Canada\n  - Unique background combining business and technical expertise")
+            
+            return '\n'.join(response_parts)
     
     # Handle specific skill queries
     elif any(word in query_lower for word in ['skill', 'know', 'experience', 'expert']):
-        tech_skills = knowledge_base['skills']['technical_skills']
-        projects = knowledge_base['professional_experience']['projects']
-        
-        return f"My core technical stack includes {', '.join(tech_skills[:5])}. I've applied these skills in real-world projects like my {projects[0]['name']}, which {projects[0]['description']}. I'm currently enhancing my ML expertise through advanced studies in Canada and practical project implementation."
-    
-    # Handle background/journey queries
-    elif any(word in query_lower for word in ['background', 'journey', 'story']):
-        transition = next((qa['answer'] for qa in knowledge_base['frequently_asked_questions'] 
-                         if 'transition' in qa['question'].lower()), '')
-        return f"{transition[:300]}... This unique journey gives me both technical expertise and business understanding, valuable for ML engineering roles."
+        skill_examples = get_skills_by_category(knowledge_base)
+        response = ["My Technical Skills:"]
+        for skill, project in skill_examples.items():
+            response.append(f"• {skill} - Applied in {project}")
+        return '\n'.join(response)
     
     # Default response
-    return f"I'm {knowledge_base['personal_details']['full_name']}, a Machine Learning Engineer candidate with a unique background in commerce and technology. {knowledge_base['personal_details']['professional_summary']}"
+    return (f"I'm {knowledge_base['personal_details']['full_name']}, "
+            f"{knowledge_base['personal_details']['professional_summary']}\n\n"
+            "You can ask me about:\n"
+            "• My projects and portfolio\n"
+            "• My journey from commerce to ML/AI\n"
+            "• My technical skills and experience\n"
+            "• My fit for ML/AI roles\n"
+            "Or paste a job description to see how my profile matches!")
 
 # Load and cache knowledge base
 @st.cache_data
 def load_knowledge_base():
     try:
-        with open('knowledge_base.json', 'r', encoding='utf-8') as f:
+        with open('manny_knowledge_base.json', 'r', encoding='utf-8') as f:
             return json.load(f)
     except FileNotFoundError:
         st.error("Knowledge base file not found.")