Update app.py

app.py

@@ -1,6 +1,7 @@
 import streamlit as st
 import json
-import openai
+from typing import Dict, List, Any
+import re
 
 # Initialize Streamlit page configuration
 st.set_page_config(
@@ -9,113 +10,156 @@ st.set_page_config(
     layout="wide"
 )
 
-# Secret management
-def get_openai_api_token():
-    try:
-        return st.secrets["OPENAI_API_KEY"]
-    except KeyError:
-        st.error("OpenAI API key not found in secrets.")
-        return None
-
-# Load and cache OpenAI client
-@st.cache_resource
-def get_openai_client():
-    openai.api_key = get_openai_api_token()
-    return openai
+def extract_key_requirements(text: str) -> Dict[str, List[str]]:
+    """Extract key requirements from text"""
+    text_lower = text.lower()
+    
+    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'
+        ]
+    }
+    
+    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)
+    
+    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'])
+    
+    # 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)]
+    
+    # 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)]
+    
+    # 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):
+            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,
+        'relevant_projects': relevant_projects[:2],
+        'education_matches': education_matches,
+        'background_story': knowledge_base['frequently_asked_questions'][0]['answer']  # Transition story
+    }
+
+def generate_response(query: str, knowledge_base: dict) -> str:
+    """Generate enhanced responses using the knowledge base"""
+    query_lower = query.lower()
+    
+    # Handle job descriptions or role requirements
+    if len(query.split()) > 20 or any(phrase in query_lower for phrase in 
+        ['requirements', 'qualifications', 'looking for', 'job description', 'responsibilities']):
+        
+        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)
+    
+    # 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."
+    
+    # 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']}"
 
 # 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.")
         return {}
 
-def get_context(query: str, knowledge_base: dict) -> str:
-    """Get relevant context for the query"""
-    query_lower = query.lower()
-    contexts = []
-
-    # Project-related queries
-    if any(word in query_lower for word in ["project", "build", "develop", "create"]):
-        if "projects" in knowledge_base:
-            for name, details in knowledge_base["projects"].items():
-                contexts.append(f"Project - {name}: {details.get('description', '')}")
-
-    # Skills and expertise
-    elif any(word in query_lower for word in ["skill", "know", "experience", "expert"]):
-        if "skills" in knowledge_base.get("personal_details", {}):
-            contexts.extend([
-                f"Skill - {skill}: {desc}"
-                for skill, desc in knowledge_base["personal_details"]["skills"].items()
-            ])
-
-    # Role fit and career
-    elif any(word in query_lower for word in ["role", "fit", "job", "position", "career"]):
-        contexts.append(knowledge_base.get("professional_journey", {}).get("mindset", ""))
-        contexts.extend(knowledge_base.get("goals_and_aspirations", {}).get("short_term", []))
-
-    # Background and journey
-    elif any(word in query_lower for word in ["background", "journey", "story"]):
-        faq = knowledge_base.get("frequently_asked_questions", [])
-        for qa in faq:
-            if "background" in qa["question"].lower():
-                contexts.append(qa["answer"])
-
-    # Default context
-    if not contexts:
-        contexts = [
-            f"I am {knowledge_base.get('personal_details', {}).get('full_name', 'Manyue')}",
-            knowledge_base.get('personal_details', {}).get('professional_summary', '')
-        ]
-
-    return "\n".join(contexts)
-
-def generate_openai_prompt(query: str, context: str) -> str:
-    """Generate prompt for OpenAI model"""
-    return f"""You are Manyue's AI assistant. Use this context to answer questions about Manyue:
-
-Context:
-{context}
-
-Question: {query}
-
-Instructions:
-- Use information from the context
-- Speak in first person as Manyue
-- Be specific about technical details and achievements
-- Keep responses concise but informative
-- Focus on relevant experience and skills
-- Maintain a professional tone"""
-
-def get_chat_response(query: str, knowledge_base: dict) -> str:
-    """Get response from OpenAI API"""
-    try:
-        # Get context
-        context = get_context(query, knowledge_base)
-
-        # Generate prompt
-        prompt = generate_openai_prompt(query, context)
-
-        # Generate response
-        response = openai.ChatCompletion.create(
-            model="gpt-3.5-turbo",
-            messages=[{"role": "user", "content": prompt}],
-            max_tokens=200,
-            temperature=0.7
-        )
-
-        # Extract and clean response
-        response_text = response['choices'][0]['message']['content'].strip()
-
-        return response_text
-
-    except Exception as e:
-        st.error(f"Error generating response: {str(e)}")
-        return "I apologize, but I encountered an error. Please try asking again."
-
 def initialize_session_state():
     """Initialize session state variables"""
     if "messages" not in st.session_state:
@@ -123,15 +167,15 @@ def initialize_session_state():
     if "knowledge_base" not in st.session_state:
         st.session_state.knowledge_base = load_knowledge_base()
 
-def display_chat_interface():
-    """Display main chat interface"""
-    for message in st.session_state.messages:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-
 def main():
     st.title("💬 Chat with Manyue's Portfolio")
-    st.write("Ask me about my skills, projects, experience, or career goals!")
+    st.write("""
+    Hi! I'm Manyue's AI assistant. I can tell you about:
+    - My journey from commerce to ML/AI
+    - My technical skills and projects
+    - My fit for ML/AI roles
+    - You can also paste job descriptions, and I'll show how my profile matches!
+    """)
 
     # Initialize session state
     initialize_session_state()
@@ -140,34 +184,32 @@ def main():
     col1, col2 = st.columns([3, 1])
 
     with col1:
-        # Display chat interface
-        display_chat_interface()
+        # Display chat messages
+        for message in st.session_state.messages:
+            with st.chat_message(message["role"]):
+                st.markdown(message["content"])
 
         # Chat input
-        if prompt := st.chat_input("What would you like to know?"):
+        if prompt := st.chat_input("Ask me anything about Manyue's experience or paste a job description..."):
             # Add user message
             st.session_state.messages.append({"role": "user", "content": prompt})
-
-            # Display user message
             with st.chat_message("user"):
                 st.markdown(prompt)
 
             # Generate and display response
             with st.chat_message("assistant"):
-                with st.spinner("Thinking..."):
-                    response = get_chat_response(prompt, st.session_state.knowledge_base)
+                response = generate_response(prompt, st.session_state.knowledge_base)
                 st.markdown(response)
-
-            # Add assistant response to history
-            st.session_state.messages.append({"role": "assistant", "content": response})
+                st.session_state.messages.append({"role": "assistant", "content": response})
 
     with col2:
         st.subheader("Quick Questions")
         example_questions = [
             "Tell me about your ML projects",
             "What are your technical skills?",
-            "Why are you suitable for ML roles?",
-            "What is your educational background?"
+            "Why should we hire you as an ML Engineer?",
+            "What's your journey into ML?",
+            "Paste a job description to see how I match!"
         ]
 
         for question in example_questions:
@@ -181,4 +223,4 @@ def main():
             st.experimental_rerun()
 
 if __name__ == "__main__":
-    main()
+    main()