Update app.py

app.py

@@ -3,80 +3,182 @@ import json
 from typing import Dict, List, Any
 import re
 
-def format_project_response(project: dict, include_status: bool = True) -> str:
-    """Format a project description with proper status handling"""
-    response = [f"• {project['name']}:"]
-    response.append(f"  - {project['description']}")
+def format_project_response(project: dict, indent_level: int = 0) -> str:
+    """Format project details with proper indentation and spacing"""
+    indent = "  " * indent_level
+    
+    response = [f"{indent}• {project['name']}"]
+    response.append(f"{indent}  {project['description']}")
     
     if 'skills_used' in project:
-        response.append(f"  - Technologies: {', '.join(project['skills_used'])}")
+        response.append(f"{indent}  Technologies: {', '.join(project['skills_used'])}")
     
-    if include_status and 'status' in project:
-        if 'development' in project['status'].lower() or 'progress' in project['status'].lower():
-            response.append(f"  - Currently {project['status']}")
+    if 'status' in project:
+        status = project['status']
+        if 'development' in status.lower() or 'progress' in status.lower():
+            response.append(f"{indent}  Status: {status}")
             if 'confidentiality_note' in project:
-                response.append(f"  - Note: {project['confidentiality_note']}")
+                response.append(f"{indent}  Note: {project['confidentiality_note']}")
+    
+    return '\n'.join(response) + '\n'  # Add extra newline for spacing
+
+def format_skills_response(skills: dict) -> str:
+    """Format skills with proper hierarchy and spacing"""
+    response = ["My Technical Expertise:\n"]
+    
+    categories = {
+        'Machine Learning & AI': ['core', 'frameworks', 'focus_areas'],
+        'Programming': ['primary', 'libraries', 'tools'],
+        'Data & Analytics': ['databases', 'visualization', 'processing']
+    }
+    
+    for category, subcategories in categories.items():
+        response.append(f"• {category}")
+        for subcat in subcategories:
+            if subcat in skills['machine_learning']:
+                items = skills['machine_learning'][subcat]
+                response.append(f"  - {subcat.title()}: {', '.join(items)}")
+        response.append("")  # Add spacing between categories
     
     return '\n'.join(response)
 
-def analyze_job_requirements(text: str, knowledge_base: dict) -> Dict[str, List[str]]:
-    """Analyze job requirements and match with skills"""
-    text_lower = text.lower()
+def analyze_job_description(text: str, knowledge_base: dict) -> str:
+    """Analyze job description and provide detailed alignment"""
+    # Extract key requirements
+    requirements = {
+        'technical_tools': set(),
+        'soft_skills': set(),
+        'responsibilities': set()
+    }
     
-    # Extract skills from knowledge base
-    my_skills = {
-        'technical': [skill.lower() for skill in knowledge_base['skills']['technical_skills']['machine_learning']['core'] +
-                     knowledge_base['skills']['technical_skills']['programming']['primary'] +
-                     knowledge_base['skills']['technical_skills']['data']['databases']],
-        'tools': [tool.lower() for tool in knowledge_base['skills']['technical_skills']['programming']['tools'] +
-                 knowledge_base['skills']['technical_skills']['deployment']['web']],
-        'soft_skills': [skill['skill'].lower() for skill in knowledge_base['skills']['soft_skills']]
+    # Common technical tools and skills
+    tech_keywords = {
+        'data science', 'analytics', 'visualization', 'tableau', 'python', 
+        'machine learning', 'modeling', 'automation', 'sql', 'data analysis'
     }
     
-    # Find matching skills in job description
-    matches = {
-        'technical_matches': [skill for skill in my_skills['technical'] if skill in text_lower],
-        'tool_matches': [tool for tool in my_skills['tools'] if tool in text_lower],
-        'soft_skill_matches': [skill for skill in my_skills['soft_skills'] if skill in text_lower]
+    # Common soft skills
+    soft_keywords = {
+        'collaborate', 'communicate', 'analyze', 'design', 'implement',
+        'produce insights', 'improve', 'support'
     }
     
-    return matches
+    text_lower = text.lower()
+    
+    # Extract company name if present
+    companies = ['rbc', 'shopify', 'google', 'microsoft', 'amazon']
+    company_name = next((company.upper() for company in companies if company in text_lower), None)
+    
+    # Extract requirements
+    for word in tech_keywords:
+        if word in text_lower:
+            requirements['technical_tools'].add(word)
+    
+    for word in soft_keywords:
+        if word in text_lower:
+            requirements['soft_skills'].add(word)
+            
+    # Build response
+    response_parts = []
+    
+    # Company-specific introduction if applicable
+    if company_name:
+        response_parts.append(f"Here's how I align with {company_name}'s requirements:\n")
+    else:
+        response_parts.append("Based on the job requirements, here's how I align:\n")
 
-def find_relevant_projects(requirements: str, projects: List[dict]) -> List[dict]:
-    """Find projects relevant to job requirements"""
-    req_lower = requirements.lower()
+    # Technical Skills Alignment
+    response_parts.append("• Technical Skills Match:")
+    my_relevant_skills = []
+    if 'visualization' in requirements['technical_tools'] or 'tableau' in requirements['technical_tools']:
+        my_relevant_skills.append("  - Proficient in Tableau and data visualization (used in multiple projects)")
+    if 'data analysis' in requirements['technical_tools']:
+        my_relevant_skills.append("  - Strong data analysis skills demonstrated in projects like LoanTap Credit Assessment")
+    if 'machine learning' in requirements['technical_tools'] or 'modeling' in requirements['technical_tools']:
+        my_relevant_skills.append("  - Experienced in building ML models from scratch (demonstrated in algorithm practice projects)")
+    
+    response_parts.extend(my_relevant_skills)
+    response_parts.append("")  # Add spacing
+    
+    # Business Understanding
+    response_parts.append("• Business Acumen:")
+    response_parts.append("  - Commerce background provides strong understanding of business requirements")
+    response_parts.append("  - Experience in translating business needs into technical solutions")
+    response_parts.append("  - Proven ability to communicate technical findings to business stakeholders")
+    response_parts.append("")  # Add spacing
+    
+    # Project Experience
+    response_parts.append("• Relevant Project Experience:")
     relevant_projects = []
+    if 'automation' in requirements['technical_tools']:
+        relevant_projects.append("  - Developed AI-powered POS system with automated operations")
+    if 'data analysis' in requirements['technical_tools']:
+        relevant_projects.append("  - Built credit assessment model for LoanTap using comprehensive data analysis")
+    if 'machine learning' in requirements['technical_tools']:
+        relevant_projects.append("  - Created multiple ML models from scratch, including predictive analytics for Ola")
+    
+    response_parts.extend(relevant_projects)
+    response_parts.append("")  # Add spacing
+    
+    # Education and Additional Qualifications
+    response_parts.append("• Additional Strengths:")
+    response_parts.append("  - Currently pursuing advanced AI/ML education in Canada")
+    response_parts.append("  - Strong foundation in both technical implementation and business analysis")
+    response_parts.append("  - Experience in end-to-end project delivery and deployment")
+    
+    return '\n'.join(response_parts)
+
+def format_story_response(knowledge_base: dict) -> str:
+    """Format background story with proper structure"""
+    response_parts = ["My Journey from Commerce to ML/AI:\n"]
     
-    for project in projects:
-        # Check if project skills or description match requirements
-        if any(skill.lower() in req_lower for skill in project['skills_used']) or \
-           any(word in project['description'].lower() for word in req_lower.split()):
-            relevant_projects.append(project)
+    # Education Background
+    response_parts.append("• Education Background:")
+    response_parts.append(f"  - Commerce degree from {knowledge_base['education']['undergraduate']['institution']}")
+    response_parts.append(f"  - Currently at {knowledge_base['education']['postgraduate'][0]['institution']}")
+    response_parts.append(f"  - Also enrolled at {knowledge_base['education']['postgraduate'][1]['institution']}")
+    response_parts.append("")  # Add spacing
     
-    return relevant_projects[:2]  # Return top 2 most relevant projects
+    # Career Transition
+    response_parts.append("• Career Transition:")
+    transition = next((qa['answer'] for qa in knowledge_base['frequently_asked_questions'] 
+                      if 'transition' in qa['question'].lower()), '')
+    response_parts.append(f"  - {transition[:200]}...")  # Truncate for readability
+    response_parts.append("")  # Add spacing
+    
+    # Current Focus
+    response_parts.append("• Current Focus:")
+    response_parts.append("  - Building practical ML projects")
+    response_parts.append("  - Advancing AI/ML education in Canada")
+    response_parts.append("")  # Add spacing
+    
+    # Goals
+    response_parts.append("• Future Goals:")
+    response_parts.append("  - Secure ML Engineering role in Canada")
+    response_parts.append("  - Develop innovative AI solutions")
+    response_parts.append("  - Contribute to cutting-edge ML projects")
+    
+    return '\n'.join(response_parts)
 
 def add_relevant_links(response: str, query: str, knowledge_base: dict) -> str:
     """Add relevant links based on query context"""
     query_lower = query.lower()
     links = []
     
-    # Add portfolio link for project-related queries
+    # Add links strategically based on context
     if any(word in query_lower for word in ['project', 'portfolio', 'work']):
         links.append(f"\nView my complete portfolio: {knowledge_base['personal_details']['online_presence']['portfolio']}")
     
-    # Add blog link for technical queries
-    if any(word in query_lower for word in ['machine learning', 'ml', 'algorithm', 'knn']):
-        for post in knowledge_base['personal_details']['online_presence']['blog_posts']:
-            if 'link' in post and any(word in post['title'].lower() for word in query_lower.split()):
-                links.append(f"\nRelated blog post: {post['link']}")
-                break
-    
-    # Add LinkedIn for professional background queries
     if any(word in query_lower for word in ['background', 'experience', 'work']):
         links.append(f"\nConnect with me: {knowledge_base['personal_details']['online_presence']['linkedin']}")
     
+    for post in knowledge_base['personal_details']['online_presence']['blog_posts']:
+        if 'link' in post and any(word in query_lower for word in post['title'].lower().split()):
+            links.append(f"\nRelated blog post: {post['link']}")
+            break
+    
     if links:
-        response += '\n\n' + '\n'.join(links)
+        response += '\n' + '\n'.join(links)
     
     return response
 
@@ -86,17 +188,17 @@ def generate_response(query: str, knowledge_base: dict) -> str:
     
     # Handle project listing requests
     if any(word in query_lower for word in ['list', 'project', 'portfolio', 'built', 'created', 'developed']):
-        response_parts = ["Here are my key projects:"]
+        response_parts = ["Here are my key projects:\n"]
         
         # Major Projects (under development)
-        response_parts.append("\nMajor Projects (In Development):")
+        response_parts.append("Major Projects (In Development):")
         for project in knowledge_base['projects']['major_projects']:
-            response_parts.append(format_project_response(project))
-            
-        # Algorithm Implementation Projects (completed)
-        response_parts.append("\nCompleted Algorithm Implementation Projects:")
+            response_parts.append(format_project_response(project, indent_level=1))
+        
+        # Algorithm Implementation Projects
+        response_parts.append("Completed Algorithm Implementation Projects:")
         for project in knowledge_base['projects']['algorithm_practice_projects']:
-            response_parts.append(format_project_response(project, include_status=False))
+            response_parts.append(format_project_response(project, indent_level=1))
         
         response = '\n'.join(response_parts)
         return add_relevant_links(response, query, knowledge_base)
@@ -104,89 +206,42 @@ def generate_response(query: str, knowledge_base: dict) -> str:
     # Handle job description analysis
     elif len(query.split()) > 20 and any(phrase in query_lower for phrase in 
         ['requirements', 'qualifications', 'looking for', 'job description']):
-        
-        skill_matches = analyze_job_requirements(query, knowledge_base)
-        relevant_projects = find_relevant_projects(query, knowledge_base['projects']['major_projects'])
-        
-        response_parts = ["Based on the job requirements, here's how my profile aligns:"]
-        
-        # Technical Skills Match
-        if skill_matches['technical_matches']:
-            response_parts.append("\n• Technical Skills Match:")
-            for skill in skill_matches['technical_matches']:
-                response_parts.append(f"  - Strong proficiency in {skill}")
-        
-        # Tools and Technologies
-        if skill_matches['tool_matches']:
-            response_parts.append("\n• Relevant Tools/Technologies:")
-            for tool in skill_matches['tool_matches']:
-                response_parts.append(f"  - Experience with {tool}")
-        
-        # Relevant Projects
-        if relevant_projects:
-            response_parts.append("\n• Relevant Project Experience:")
-            for project in relevant_projects:
-                response_parts.append(format_project_response(project))
-        
-        # Education and Background
-        response_parts.append("\n• Education and Background:")
-        response_parts.append("  - Currently pursuing advanced AI/ML education in Canada")
-        response_parts.append("  - Unique background combining commerce and technology")
-        response_parts.append("  - Strong foundation in practical ML implementation")
-        
-        response = '\n'.join(response_parts)
-        return add_relevant_links(response, query, knowledge_base)
+        return analyze_job_description(query, knowledge_base)
     
     # Handle background/story queries
     elif any(word in query_lower for word in ['background', 'journey', 'story', 'transition']):
-        transition_story = next((qa['answer'] for qa in knowledge_base['frequently_asked_questions'] 
-                               if 'transition' in qa['question'].lower()), '')
-        
-        response_parts = [
-            "My Journey from Commerce to ML/AI:",
-            "• Education Background:",
-            f"  - {knowledge_base['education']['undergraduate']['course_name']} from {knowledge_base['education']['undergraduate']['institution']}",
-            "• Career Transition:",
-            "  - Started as a Programmer Trainee at Cognizant",
-            f"  - {transition_story[:200]}...",
-            "• Current Path:",
-            "  - Pursuing AI/ML education in Canada",
-            "  - Building practical ML projects",
-            "• Future Goals:",
-            "  - Aiming to become an ML Engineer in Canada",
-            "  - Focus on innovative AI solutions"
-        ]
-        
-        response = '\n'.join(response_parts)
-        return add_relevant_links(response, query, knowledge_base)
+        return format_story_response(knowledge_base)
     
     # Handle skill-specific queries
     elif any(word in query_lower for word in ['skill', 'know', 'technology', 'stack']):
-        tech_skills = knowledge_base['skills']['technical_skills']
-        
-        response_parts = ["My Technical Expertise:"]
+        return format_skills_response(knowledge_base['skills']['technical_skills'])
+    
+    # Handle standout/unique qualities queries
+    elif any(word in query_lower for word in ['stand out', 'unique', 'different', 'special']):
+        response_parts = ["What Makes Me Stand Out:\n"]
+        response_parts.append("• Unique Background:")
+        response_parts.append("  - Successfully transitioned from commerce to tech")
+        response_parts.append("  - Blend of business acumen and technical expertise")
+        response_parts.append("")
         
-        # ML/AI Skills
-        response_parts.append("\n• Machine Learning & AI:")
-        response_parts.append(f"  - Core: {', '.join(tech_skills['machine_learning']['core'])}")
-        response_parts.append(f"  - Frameworks: {', '.join(tech_skills['machine_learning']['frameworks'])}")
+        response_parts.append("• Practical Experience:")
+        response_parts.append("  - Built multiple ML projects from scratch")
+        response_parts.append("  - Focus on real-world applications")
+        response_parts.append("")
         
-        # Programming & Tools
-        response_parts.append("\n• Programming & Development:")
-        response_parts.append(f"  - Languages: {', '.join(tech_skills['programming']['primary'])}")
-        response_parts.append(f"  - Tools: {', '.join(tech_skills['programming']['tools'])}")
+        response_parts.append("• Technical Depth:")
+        response_parts.append("  - Strong foundation in ML/AI principles")
+        response_parts.append("  - Experience with end-to-end project implementation")
+        response_parts.append("")
         
-        # Data & Analytics
-        response_parts.append("\n• Data & Analytics:")
-        response_parts.append(f"  - Databases: {', '.join(tech_skills['data']['databases'])}")
-        response_parts.append(f"  - Visualization: {', '.join(tech_skills['data']['visualization'])}")
+        response_parts.append("• Innovation Focus:")
+        response_parts.append("  - Developing novel solutions in ML/AI")
+        response_parts.append("  - Emphasis on practical impact")
         
-        response = '\n'.join(response_parts)
-        return add_relevant_links(response, query, knowledge_base)
+        return '\n'.join(response_parts)
     
-    # Handle default/unknown queries
-    return (f"I'm {knowledge_base['personal_details']['full_name']}, "
-            f"{knowledge_base['personal_details']['professional_summary']}\n\n"
+    # Default response
+    return (f"I'm {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"
@@ -202,7 +257,7 @@ def main():
         st.session_state.messages = []
     if "knowledge_base" not in st.session_state:
         try:
-            with open('knowledge_base.json', 'r', encoding='utf-8') as f:
+            with open('manny_knowledge_base.json', 'r', encoding='utf-8') as f:
                 st.session_state.knowledge_base = json.load(f)
         except FileNotFoundError:
             st.error("Knowledge base file not found.")
@@ -218,10 +273,10 @@ def main():
         - You can also paste job descriptions to see how my profile matches!
         """)
         st.session_state.displayed_welcome = True
-
+    
     # Create two columns
     col1, col2 = st.columns([3, 1])
-
+    
     with col1:
         # Display chat messages
         for message in st.session_state.messages:
@@ -233,29 +288,32 @@ def main():
             # Add user message
             st.session_state.messages.append({"role": "user", "content": prompt})
             
-            # Generate and display response
-            with st.chat_message("assistant"):
-                response = generate_response(prompt, st.session_state.knowledge_base)
-                st.markdown(response)
-                st.session_state.messages.append({"role": "assistant", "content": response})
+            try:
+                # Generate and display response
+                with st.chat_message("assistant"):
+                    response = generate_response(prompt, st.session_state.knowledge_base)
+                    st.markdown(response)
+                    st.session_state.messages.append({"role": "assistant", "content": response})
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
             
             st.rerun()
-
+    
     with col2:
         st.subheader("Quick Questions")
         example_questions = [
             "Tell me about your ML projects",
             "What are your technical skills?",
-            "Why should we hire you as an ML Engineer?",
+            "What makes you stand out?",
             "What's your journey into ML?",
             "Paste a job description to see how I match!"
         ]
-
+        
         for question in example_questions:
             if st.button(question):
                 st.session_state.messages.append({"role": "user", "content": question})
                 st.rerun()
-
+        
         st.markdown("---")
         if st.button("Clear Chat"):
             st.session_state.messages = []