diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -1,4 +1,4 @@
-# filename: app_openai_serper_v4.py
+# filename: app_groq_serper_v5.py
 import gradio as gr
 import pandas as pd
 import numpy as np
@@ -10,14 +10,14 @@ import json
 import os
 import time
 import requests # For Serper API
-from typing import List, Dict, Any, Optional
+from typing import List, Dict, Any, Optional, Generator
 import logging
 from dotenv import load_dotenv
 import uuid
 import re
 
-# --- OpenAI Integration ---
-import openai
+# --- Groq Integration ---
+from groq import Groq, RateLimitError, APIError, APIConnectionError, APITimeoutError, AuthenticationError
 
 # --- Load environment variables ---
 load_dotenv()
@@ -28,65 +28,56 @@ logging.basicConfig(level=logging.INFO,
 logger = logging.getLogger(__name__)
 
 # --- Configure API keys ---
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
 SERPER_API_KEY = os.getenv("SERPER_API_KEY")
 
-if not OPENAI_API_KEY:
-    logger.warning("OPENAI_API_KEY not found. AI features will not work.")
+if not GROQ_API_KEY:
+    logger.warning("GROQ_API_KEY not found. AI features will not work.")
 else:
-    logger.info("OpenAI API Key found.")
+    logger.info("Groq API Key found.")
 if not SERPER_API_KEY:
     logger.warning("SERPER_API_KEY not found. Live web search features will not work.")
 else:
     logger.info("Serper API Key found.")
 
 
-# --- Initialize the OpenAI client ---
+# --- Initialize the Groq client ---
 try:
-    # Ensure the API key is not None before initializing
-    if OPENAI_API_KEY:
-        client = openai.OpenAI(api_key=OPENAI_API_KEY)
-        logger.info("OpenAI client initialized successfully.")
+    if GROQ_API_KEY:
+        client = Groq(api_key=GROQ_API_KEY)
+        logger.info("Groq client initialized successfully.")
     else:
         client = None
-        logger.error("Failed to initialize OpenAI client: API key is missing.")
+        logger.error("Failed to initialize Groq client: API key is missing.")
 except Exception as e:
-    logger.error(f"Failed to initialize OpenAI client: {e}")
+    logger.error(f"Failed to initialize Groq client: {e}")
     client = None
 
 # --- Model configuration ---
-MODEL_ID = "gpt-4o" # Using OpenAI's GPT-4o model
+MODEL_ID = "llama-3.1-70b-versatile" # Using Groq's Llama 3.1 70B model
 
 # --- Constants ---
-# Using the same enhanced constants from v3
+# Using the same enhanced constants from previous versions
 EMOTIONS = ["Unmotivated 😩", "Anxious 😥", "Confused 🤔", "Excited 🎉", "Overwhelmed 🤯", "Discouraged 😔", "Hopeful ✨", "Focused 😎", "Stuck 🧱"]
 GOAL_TYPES = [
     "Get a job (Big Company) 🏢", "Get a job (Startup) 🌱", "Find an Internship 🎓", "Freelance/Contract Work 💼",
     "Change Careers 🚀", "Improve Specific Skills 💡", "Build Professional Network 🤝", "Leadership Development 📈", "Explore Options 🤔"
 ]
-USER_DB_PATH = "user_database_v4.json" # New DB file for this version
-RESUME_FOLDER = "user_resumes_v4"
-PORTFOLIO_FOLDER = "user_portfolios_v4"
+USER_DB_PATH = "user_database_v5.json" # New DB file for this version
+RESUME_FOLDER = "user_resumes_v5"
+PORTFOLIO_FOLDER = "user_portfolios_v5"
 os.makedirs(RESUME_FOLDER, exist_ok=True)
 os.makedirs(PORTFOLIO_FOLDER, exist_ok=True)
 
-# --- Tool Definitions for OpenAI ---
-# Format matches the structure expected by the OpenAI API
-tools_list_openai = [
+# --- Tool Definitions for Groq API (Mirrors OpenAI format) ---
+# Groq generally uses the OpenAI-compatible tool format.
+tools_list_groq = [
     {
         "type": "function",
         "function": {
             "name": "generate_document_template",
             "description": "Generate a document template (like a resume or cover letter) based on type, career field, and experience level.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "document_type": {"type": "string", "description": "e.g., Resume, Cover Letter, LinkedIn Summary"},
-                    "career_field": {"type": "string", "description": "Target industry or field"},
-                    "experience_level": {"type": "string", "description": "e.g., Entry, Mid, Senior, Student"}
-                },
-                "required": ["document_type"]
-            },
+            "parameters": { "type": "object", "properties": { "document_type": {"type": "string", "description": "e.g., Resume, Cover Letter, LinkedIn Summary"}, "career_field": {"type": "string", "description": "Target industry or field"}, "experience_level": {"type": "string", "description": "e.g., Entry, Mid, Senior, Student"} }, "required": ["document_type"] },
         }
     },
     {
@@ -94,16 +85,7 @@ tools_list_openai = [
         "function": {
             "name": "create_personalized_routine",
             "description": "Create a personalized daily or weekly career development routine based on the user's current emotion, goals, and available time.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "emotion": {"type": "string", "description": "User's current primary emotion"},
-                    "goal": {"type": "string", "description": "User's primary career goal"},
-                    "available_time_minutes": {"type": "integer", "description": "Average minutes per day user can dedicate"},
-                    "routine_length_days": {"type": "integer", "description": "Desired length of the routine in days (e.g., 7 for weekly)"}
-                },
-                "required": ["emotion", "goal"]
-            },
+            "parameters": { "type": "object", "properties": { "emotion": {"type": "string", "description": "User's current primary emotion"}, "goal": {"type": "string", "description": "User's primary career goal"}, "available_time_minutes": {"type": "integer", "description": "Average minutes per day user can dedicate"}, "routine_length_days": {"type": "integer", "description": "Desired length of the routine in days (e.g., 7 for weekly)"} }, "required": ["emotion", "goal"] },
         }
     },
     {
@@ -111,14 +93,7 @@ tools_list_openai = [
         "function": {
             "name": "analyze_resume",
             "description": "Analyze the provided resume text and provide feedback, comparing it against the user's stated career goal. Provides strengths, weaknesses, and suggestions.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "resume_text": {"type": "string", "description": "The full text content of the user's resume"},
-                    "career_goal": {"type": "string", "description": "The specific career goal to analyze against"}
-                },
-                "required": ["resume_text", "career_goal"]
-            },
+            "parameters": { "type": "object", "properties": { "resume_text": {"type": "string", "description": "The full text content of the user's resume"}, "career_goal": {"type": "string", "description": "The specific career goal to analyze against"} }, "required": ["resume_text", "career_goal"] },
         }
     },
     {
@@ -126,15 +101,7 @@ tools_list_openai = [
         "function": {
             "name": "analyze_portfolio",
             "description": "Analyze a user's portfolio based on a URL (if provided) and a description, offering feedback relative to their career goal.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "portfolio_url": {"type": "string", "description": "URL link to the online portfolio (optional)"},
-                    "portfolio_description": {"type": "string", "description": "User's description of the portfolio content and purpose"},
-                    "career_goal": {"type": "string", "description": "The specific career goal to analyze against"}
-                },
-                "required": ["portfolio_description", "career_goal"]
-            },
+            "parameters": { "type": "object", "properties": { "portfolio_url": {"type": "string", "description": "URL link to the online portfolio (optional)"}, "portfolio_description": {"type": "string", "description": "User's description of the portfolio content and purpose"}, "career_goal": {"type": "string", "description": "The specific career goal to analyze against"} }, "required": ["portfolio_description", "career_goal"] },
         }
     },
     {
@@ -142,14 +109,7 @@ tools_list_openai = [
         "function": {
             "name": "extract_and_rate_skills_from_resume",
             "description": "Extracts key skills from resume text and rates them on a scale of 1-10 based on apparent proficiency shown in the resume. Useful for identifying strengths and gaps.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "resume_text": {"type": "string", "description": "The full text content of the user's resume"},
-                    "max_skills": {"type": "integer", "description": "Maximum number of skills to extract (default 8)"}
-                },
-                "required": ["resume_text"]
-            },
+            "parameters": { "type": "object", "properties": { "resume_text": {"type": "string", "description": "The full text content of the user's resume"}, "max_skills": {"type": "integer", "description": "Maximum number of skills to extract (default 8)"} }, "required": ["resume_text"] },
         }
     },
     {
@@ -157,140 +117,93 @@ tools_list_openai = [
         "function": {
             "name": "search_jobs_courses_skills",
             "description": "Search the web using Serper API for relevant job openings, online courses, or skills development resources based on the user's goals, location, and potentially identified skill gaps.",
-            "parameters": {
-                "type": "object",
-                "properties": {
-                    "search_query": {"type": "string", "description": "The specific search query (e.g., 'remote data analyst jobs in California', 'online Python courses for beginners', 'project management certifications')"},
-                    "search_type": {"type": "string", "description": "Type of search: 'jobs', 'courses', 'skills', or 'general'"},
-                    "location": {"type": "string", "description": "Geographical location for the search (if applicable, e.g., 'London, UK')"}
-                },
-                "required": ["search_query", "search_type"]
-            },
+            "parameters": { "type": "object", "properties": { "search_query": {"type": "string", "description": "The specific search query (e.g., 'remote data analyst jobs in California', 'online Python courses for beginners', 'project management certifications')"}, "search_type": {"type": "string", "description": "Type of search: 'jobs', 'courses', 'skills', or 'general'"}, "location": {"type": "string", "description": "Geographical location for the search (if applicable, e.g., 'London, UK')"} }, "required": ["search_query", "search_type"] },
         }
     }
 ]
 
-# --- User Database Functions (Enhanced Profile - Adapted for OpenAI History) ---
+# --- User Database Functions (Using OpenAI/Groq-compatible format) ---
+# Keep the load/save/get/update functions from v4 as the chat history format is compatible.
 def load_user_database():
+    # (Identical to v4 - handles OpenAI/Groq compatible format)
     try:
         with open(USER_DB_PATH, 'r', encoding='utf-8') as file: db = json.load(file)
-        # Validation for chat history (OpenAI format: role='user'/'assistant'/'system'/'tool', content=str, tool_calls=list[dict])
         for user_id in db.get('users', {}):
             profile = db['users'][user_id]
-            if 'chat_history' not in profile or not isinstance(profile['chat_history'], list):
-                profile['chat_history'] = []
+            if 'chat_history' not in profile or not isinstance(profile['chat_history'], list): profile['chat_history'] = []
             else:
                 fixed_history = []
                 for msg in profile['chat_history']:
-                    if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
-                        # Basic check for standard messages
+                    if isinstance(msg, dict) and 'role' in msg:
                         if msg['role'] in ['user', 'assistant', 'system'] and isinstance(msg.get('content'), (str, type(None))):
-                             # Allow None content for assistant messages that only have tool calls
                             if msg['role'] == 'assistant' or msg.get('content') is not None:
-                                # Check for tool_calls structure if present
                                 if 'tool_calls' in msg:
-                                    if isinstance(msg['tool_calls'], list) and all(isinstance(tc, dict) and 'id' in tc and 'type' in tc and 'function' in tc for tc in msg['tool_calls']):
-                                         fixed_history.append(msg)
-                                    else:
-                                         logger.warning(f"Skipping message with invalid tool_calls for user {user_id}: {msg}")
-                                else:
-                                    fixed_history.append(msg) # Valid user/system/assistant message without tool calls
-                        else:
-                             logger.warning(f"Skipping message with invalid role/content type for user {user_id}: {msg}")
-                    elif isinstance(msg, dict) and msg.get('role') == 'tool':
-                        # Check for tool response structure
-                        if 'tool_call_id' in msg and 'content' in msg and isinstance(msg.get('content'), str):
-                             # Note: OpenAI API expects 'name' in the tool call, but the response message uses 'tool_call_id'. Content should be stringified JSON result.
-                            fixed_history.append(msg)
-                        else:
-                             logger.warning(f"Skipping invalid tool message structure for user {user_id}: {msg}")
-                    else:
-                        logger.warning(f"Skipping unrecognized message structure for user {user_id}: {msg}")
+                                    if isinstance(msg['tool_calls'], list) and all(isinstance(tc, dict) and 'id' in tc and 'type' in tc and 'function' in tc for tc in msg['tool_calls']): fixed_history.append(msg)
+                                    else: logger.warning(f"Skipping message with invalid tool_calls for user {user_id}: {msg}")
+                                else: fixed_history.append(msg)
+                        elif msg.get('role') == 'tool':
+                            if 'tool_call_id' in msg and 'content' in msg and isinstance(msg.get('content'), str): fixed_history.append(msg)
+                            else: logger.warning(f"Skipping invalid tool message structure for user {user_id}: {msg}")
+                        else: logger.warning(f"Skipping message with invalid role/content type for user {user_id}: {msg}")
+                    else: logger.warning(f"Skipping unrecognized message structure for user {user_id}: {msg}")
                 profile['chat_history'] = fixed_history
-
-            # Ensure other lists/fields exist (same as v3)
             for key in ['recommendations', 'daily_emotions', 'completed_tasks', 'routine_history', 'strengths', 'areas_for_development', 'values']:
-                 if key not in profile or not isinstance(profile.get(key), list):
-                     profile[key] = []
+                 if key not in profile or not isinstance(profile.get(key), list): profile[key] = []
             for key in ['name', 'location', 'current_emotion', 'career_goal', 'industry', 'preferred_work_style', 'long_term_aspirations', 'resume_path', 'portfolio_path']:
-                 if key not in profile:
-                     profile[key] = ""
+                 if key not in profile: profile[key] = ""
             if 'progress_points' not in profile: profile['progress_points'] = 0
             if 'experience_level' not in profile: profile['experience_level'] = "Not specified"
-
         return db
     except (FileNotFoundError, json.JSONDecodeError): logger.info(f"DB file '{USER_DB_PATH}' not found/invalid. Creating new."); db = {'users': {}}; save_user_database(db); return db
     except Exception as e: logger.error(f"Error loading DB from {USER_DB_PATH}: {e}"); return {'users': {}}
 
 def save_user_database(db):
-    # (Identical to v3)
+    # (Identical to v4)
     try:
         with open(USER_DB_PATH, 'w', encoding='utf-8') as file: json.dump(db, file, indent=4, ensure_ascii=False)
     except Exception as e: logger.error(f"Error saving DB to {USER_DB_PATH}: {e}")
 
 def get_user_profile(user_id):
-    # (Mostly identical to v3, ensures profile exists)
+    # (Identical to v4)
     db = load_user_database()
     if user_id not in db.get('users', {}):
         db['users'] = db.get('users', {})
-        # Initialize enhanced profile structure
-        db['users'][user_id] = {
-            "user_id": user_id, "name": "", "location": "", "industry": "",
-            "experience_level": "Not specified", "preferred_work_style": "Any",
-            "values": [], "strengths": [], "areas_for_development": [],
-            "long_term_aspirations": "", "current_emotion": "", "career_goal": "",
-            "progress_points": 0, "completed_tasks": [], "upcoming_events": [],
-            "routine_history": [], "daily_emotions": [], "resume_path": "",
-            "portfolio_path": "", "recommendations": [],
-            "chat_history": [], # Stores history in OpenAI format {role: 'user'/'assistant'/'system'/'tool', content: str, tool_calls?: list, tool_call_id?: str}
-            "joined_date": datetime.now().isoformat()
-        }
+        db['users'][user_id] = { "user_id": user_id, "name": "", "location": "", "industry": "", "experience_level": "Not specified", "preferred_work_style": "Any", "values": [], "strengths": [], "areas_for_development": [], "long_term_aspirations": "", "current_emotion": "", "career_goal": "", "progress_points": 0, "completed_tasks": [], "upcoming_events": [], "routine_history": [], "daily_emotions": [], "resume_path": "", "portfolio_path": "", "recommendations": [], "chat_history": [], "joined_date": datetime.now().isoformat() }
         save_user_database(db)
-
     profile = db.get('users', {}).get(user_id, {})
-    # Ensure critical lists exist after loading (handled mostly in load_user_database)
-    if 'chat_history' not in profile or not isinstance(profile.get('chat_history'), list):
-        profile['chat_history'] = []
+    if 'chat_history' not in profile or not isinstance(profile.get('chat_history'), list): profile['chat_history'] = []
     for key in ['recommendations', 'daily_emotions', 'completed_tasks', 'routine_history', 'strengths', 'areas_for_development', 'values']:
          if key not in profile: profile[key] = []
-
     return profile
 
-# --- Database Update Functions (Adjust chat message structure for OpenAI) ---
+# --- Database Update Functions (Identical to v4) ---
 def update_user_profile(user_id, updates):
-    # (Identical to v3)
-    db = load_user_database()
-    if user_id in db.get('users', {}):
-        profile = db['users'][user_id]
+    db = load_user_database(); profile = db.get('users', {}).get(user_id)
+    if profile:
         for key, value in updates.items(): profile[key] = value
         save_user_database(db); return profile
     else: logger.warning(f"Attempted update non-existent profile: {user_id}"); return None
 
 def add_task_to_user(user_id, task):
-    # (Identical to v3)
     db = load_user_database(); profile = db.get('users', {}).get(user_id)
     if profile:
         if 'completed_tasks' not in profile or not isinstance(profile['completed_tasks'], list): profile['completed_tasks'] = []
-        task_with_date = { "task": task, "date": datetime.now().isoformat(), "points": random.randint(10, 25) } # Add points here
-        profile['completed_tasks'].append(task_with_date)
-        profile['progress_points'] = profile.get('progress_points', 0) + task_with_date["points"] # Update total points
+        task_with_date = { "task": task, "date": datetime.now().isoformat(), "points": random.randint(10, 25) }
+        profile['completed_tasks'].append(task_with_date); profile['progress_points'] = profile.get('progress_points', 0) + task_with_date["points"]
         save_user_database(db); return profile
     return None
 
 def add_emotion_record(user_id, emotion):
-    # (Identical to v3)
     cleaned_emotion = emotion.split(" ")[0] if " " in emotion else emotion
     db = load_user_database(); profile = db.get('users', {}).get(user_id)
     if profile:
         if 'daily_emotions' not in profile or not isinstance(profile['daily_emotions'], list): profile['daily_emotions'] = []
         emotion_record = { "emotion": cleaned_emotion, "date": datetime.now().isoformat() }
-        profile['daily_emotions'].append(emotion_record)
-        profile['current_emotion'] = cleaned_emotion
+        profile['daily_emotions'].append(emotion_record); profile['current_emotion'] = cleaned_emotion
         save_user_database(db); return profile
     return None
 
 def add_routine_to_user(user_id, routine):
-    # (Identical to v3)
     db = load_user_database(); profile = db.get('users', {}).get(user_id)
     if profile:
         if 'routine_history' not in profile or not isinstance(profile['routine_history'], list): profile['routine_history'] = []
@@ -303,28 +216,23 @@ def add_routine_to_user(user_id, routine):
     return None
 
 def save_user_resume(user_id, resume_text):
-    # (Identical to v3)
     if not resume_text: return None
     filename, filepath = f"{user_id}_resume.txt", os.path.join(RESUME_FOLDER, f"{user_id}_resume.txt")
     try:
         with open(filepath, 'w', encoding='utf-8') as file: file.write(resume_text)
-        update_user_profile(user_id, {"resume_path": filepath})
-        logger.info(f"Resume saved: {filepath}"); return filepath
+        update_user_profile(user_id, {"resume_path": filepath}); logger.info(f"Resume saved: {filepath}"); return filepath
     except Exception as e: logger.error(f"Error saving resume {filepath}: {e}"); return None
 
 def save_user_portfolio(user_id, portfolio_url, portfolio_description):
-    # (Identical to v3)
     if not portfolio_description: return None
     filename, filepath = f"{user_id}_portfolio.json", os.path.join(PORTFOLIO_FOLDER, f"{user_id}_portfolio.json")
     portfolio_content = {"url": portfolio_url, "description": portfolio_description, "saved_date": datetime.now().isoformat()}
     try:
         with open(filepath, 'w', encoding='utf-8') as file: json.dump(portfolio_content, file, indent=4, ensure_ascii=False)
-        update_user_profile(user_id, {"portfolio_path": filepath})
-        logger.info(f"Portfolio saved: {filepath}"); return filepath
+        update_user_profile(user_id, {"portfolio_path": filepath}); logger.info(f"Portfolio saved: {filepath}"); return filepath
     except Exception as e: logger.error(f"Error saving portfolio {filepath}: {e}"); return None
 
 def add_recommendation_to_user(user_id, recommendation):
-    # (Identical to v3)
     db = load_user_database(); profile = db.get('users', {}).get(user_id)
     if profile:
         if 'recommendations' not in profile or not isinstance(profile['recommendations'], list): profile['recommendations'] = []
@@ -334,192 +242,109 @@ def add_recommendation_to_user(user_id, recommendation):
     return None
 
 def add_chat_message(user_id, role, message_content):
-    """Adds a message to the user's chat history using OpenAI format."""
-    db = load_user_database()
-    profile = db.get('users', {}).get(user_id)
-    if not profile:
-        logger.warning(f"Profile not found for {user_id} when adding chat message.")
-        return None
-
-    if 'chat_history' not in profile or not isinstance(profile['chat_history'], list):
-        profile['chat_history'] = []
-
-    if role not in ['user', 'assistant', 'system', 'tool']:
-        logger.warning(f"Invalid role '{role}' for OpenAI chat history.")
-        return profile
-
+    # (Identical to v4 - handles OpenAI/Groq compatible format)
+    db = load_user_database(); profile = db.get('users', {}).get(user_id)
+    if not profile: logger.warning(f"Profile not found for {user_id} when adding chat message."); return None
+    if 'chat_history' not in profile or not isinstance(profile['chat_history'], list): profile['chat_history'] = []
+    if role not in ['user', 'assistant', 'system', 'tool']: logger.warning(f"Invalid role '{role}' for chat history."); return profile
     message = {"role": role}
-
     if role == 'user' or role == 'system':
-        if isinstance(message_content, str):
-            message['content'] = message_content
-        else:
-            logger.warning(f"Invalid content type for role {role}: {type(message_content)}. Expected string.")
-            return profile
+        if isinstance(message_content, str): message['content'] = message_content
+        else: logger.warning(f"Invalid content type for role {role}: {type(message_content)}."); return profile
     elif role == 'assistant':
-        # Assistant message can have content (string/None) and/or tool_calls (list)
         if isinstance(message_content, dict):
-            message['content'] = message_content.get('content') # Can be None if only tool calls
+            message['content'] = message_content.get('content')
             if 'tool_calls' in message_content:
-                # Basic validation of tool_calls structure
-                if isinstance(message_content['tool_calls'], list) and all(isinstance(tc, dict) and 'id' in tc and 'type' in tc and 'function' in tc for tc in message_content['tool_calls']):
-                    message['tool_calls'] = message_content['tool_calls']
-                else:
-                    logger.warning(f"Invalid tool_calls structure in assistant message: {message_content.get('tool_calls')}")
-                    # Decide whether to store without tool_calls or skip
-                    if message['content'] is None: return profile # Skip if no content and invalid tool_calls
-                    # else store with content only
-            # Ensure content is string or None
-            if not isinstance(message['content'], (str, type(None))):
-                 logger.warning(f"Invalid content type in assistant message dict: {type(message['content'])}")
-                 message['content'] = str(message['content']) # Attempt conversion or handle error
-        elif isinstance(message_content, str):
-            message['content'] = message_content # Simple text response
-        else:
-             logger.warning(f"Invalid content type for role {role}: {type(message_content)}. Expected dict or string.")
-             return profile
+                if isinstance(message_content['tool_calls'], list) and all(isinstance(tc, dict) and 'id' in tc and 'type' in tc and 'function' in tc for tc in message_content['tool_calls']): message['tool_calls'] = message_content['tool_calls']
+                else: logger.warning(f"Invalid tool_calls structure: {message_content.get('tool_calls')}")
+            if not isinstance(message['content'], (str, type(None))): logger.warning(f"Invalid content type: {type(message['content'])}"); message['content'] = str(message['content'])
+        elif isinstance(message_content, str): message['content'] = message_content
+        else: logger.warning(f"Invalid content type for role {role}: {type(message_content)}."); return profile
     elif role == 'tool':
-        # Tool message needs tool_call_id and content (stringified result)
         if isinstance(message_content, dict) and 'tool_call_id' in message_content and 'content' in message_content:
             message['tool_call_id'] = message_content['tool_call_id']
-            # Ensure content is stringified JSON or simple string
-            if isinstance(message_content['content'], str):
-                 message['content'] = message_content['content']
+            if isinstance(message_content['content'], str): message['content'] = message_content['content']
             else:
-                 try:
-                     message['content'] = json.dumps(message_content['content'])
-                 except Exception as e:
-                     logger.error(f"Could not stringify tool content: {e}")
-                     message['content'] = json.dumps({"error": "Failed to serialize tool result."})
-        else:
-            logger.warning(f"Invalid content format for role {role}: {message_content}. Expected dict with 'tool_call_id' and 'content'.")
-            return profile
-
-    # Add timestamp for potential future use (optional)
-    # message['timestamp'] = datetime.now().isoformat()
-
+                try: message['content'] = json.dumps(message_content['content'])
+                except Exception as e: logger.error(f"Could not stringify tool content: {e}"); message['content'] = json.dumps({"error": "Failed to serialize tool result."})
+        else: logger.warning(f"Invalid content format for role {role}: {message_content}."); return profile
     profile['chat_history'].append(message)
-
-    # Limit history size (keep system prompt implicit for now)
-    max_history_turns = 25 # Keep last 25 pairs (user + assistant/tool)
+    max_history_turns = 25
     if len(profile['chat_history']) > max_history_turns * 2:
-        # Find first non-system message index if system message exists
         first_non_system = 0
-        if profile['chat_history'] and profile['chat_history'][0]['role'] == 'system':
-            first_non_system = 1
-        # Keep system message + last N turns
+        if profile['chat_history'] and profile['chat_history'][0]['role'] == 'system': first_non_system = 1
         profile['chat_history'] = profile['chat_history'][:first_non_system] + profile['chat_history'][-(max_history_turns * 2):]
+    save_user_database(db); return profile
 
 
-    save_user_database(db)
-    return profile
-
-
-# --- Basic Routine Fallback Function (keep as is) ---
+# --- Basic Routine Fallback Function (Identical to v4) ---
 def generate_basic_routine(emotion, goal, available_time=60, days=7):
-    # (Code identical to the provided v3 version - a good fallback)
+    # (Code identical to the provided v3/v4 version)
     logger.info(f"Generating basic fallback routine for emotion={emotion}, goal={goal}")
     routine_types = { "job_search": [ {"name": "Research Target Companies", "points": 15, "duration": 20, "description": "Identify 3 potential employers aligned with your goal."}, {"name": "Update LinkedIn Section", "points": 15, "duration": 25, "description": "Refine one section of your LinkedIn profile (e.g., summary, experience)."}, {"name": "Practice STAR Method", "points": 20, "duration": 15, "description": "Outline one experience using the STAR method for interviews."}, {"name": "Find Networking Event", "points": 10, "duration": 10, "description": "Look for one relevant online or local networking event."} ], "skill_building": [ {"name": "Online Tutorial (1 Module)", "points": 25, "duration": 45, "description": "Complete one module of a relevant online course/tutorial."}, {"name": "Read Industry Blog/Article", "points": 10, "duration": 15, "description": "Read and summarize one article about trends in your field."}, {"name": "Small Project Task", "points": 30, "duration": 60, "description": "Dedicate time to a specific task within a personal project."}, {"name": "Review Skill Documentation", "points": 15, "duration": 30, "description": "Read documentation or examples for a skill you're learning."} ], "motivation_wellbeing": [ {"name": "Mindful Reflection", "points": 10, "duration": 10, "description": "Spend 10 minutes reflecting on progress and challenges without judgment."}, {"name": "Set 1-3 Daily Intentions", "points": 10, "duration": 5, "description": "Define small, achievable goals for the day."}, {"name": "Short Break/Walk", "points": 15, "duration": 15, "description": "Take a brief break away from screens, preferably with light movement."}, {"name": "Connect with Support", "points": 20, "duration": 20, "description": "Briefly chat with a friend, mentor, or peer about your journey."} ] }
-    cleaned_emotion = emotion.split(" ")[0].lower() if " " in emotion else emotion.lower()
-    negative_emotions = ["unmotivated", "anxious", "confused", "overwhelmed", "discouraged", "stuck"]
+    cleaned_emotion = emotion.split(" ")[0].lower() if " " in emotion else emotion.lower(); negative_emotions = ["unmotivated", "anxious", "confused", "overwhelmed", "discouraged", "stuck"]
     if any(term in goal.lower() for term in ["job", "internship", "company", "freelance", "contract"]): base_type = "job_search"
     elif any(term in goal.lower() for term in ["skill", "learn", "development"]): base_type = "skill_building"
-    elif "network" in goal.lower(): base_type = "job_search"
-    else: base_type = "skill_building"
-    include_wellbeing = cleaned_emotion in negative_emotions or "overwhelmed" in cleaned_emotion
-    daily_tasks_list = []
+    elif "network" in goal.lower(): base_type = "job_search"; else: base_type = "skill_building"
+    include_wellbeing = cleaned_emotion in negative_emotions or "overwhelmed" in cleaned_emotion; daily_tasks_list = []
     for day in range(1, days + 1):
-        day_tasks, remaining_time, tasks_added_count = [], available_time, 0
-        possible_tasks = routine_types[base_type].copy()
-        if include_wellbeing: possible_tasks.extend(routine_types["motivation_wellbeing"])
-        random.shuffle(possible_tasks)
+        day_tasks, remaining_time, tasks_added_count = [], available_time, 0; possible_tasks = routine_types[base_type].copy()
+        if include_wellbeing: possible_tasks.extend(routine_types["motivation_wellbeing"]); random.shuffle(possible_tasks)
         for task in possible_tasks:
-            if task.get("duration", 0) > 0 and task["duration"] <= remaining_time and tasks_added_count < 3:
-                day_tasks.append(task); remaining_time -= task["duration"]; tasks_added_count += 1
+            if task.get("duration", 0) > 0 and task["duration"] <= remaining_time and tasks_added_count < 3: day_tasks.append(task); remaining_time -= task["duration"]; tasks_added_count += 1
             if remaining_time < 10 or tasks_added_count >= 3: break
         daily_tasks_list.append({"day": day, "tasks": day_tasks})
     routine = {"name": f"{days}-Day Focus Plan", "description": f"A focused {days}-day plan to help you with '{goal}', especially while feeling {cleaned_emotion}. We'll do this step-by-step!", "days": days, "daily_tasks": daily_tasks_list, "support_message": f"Hey, I know feeling {cleaned_emotion} while aiming for '{goal}' can be tough. We've got this routine to help break it down. One step at a time, okay? You're doing great just by planning!"}
-    return routine # Return dict directly
-
-# --- Tool Implementation Functions (Return JSON strings or dicts for OpenAI) ---
-# These functions remain largely the same internally but ensure output is serializable.
+    return routine
 
+# --- Tool Implementation Functions (Return JSON strings - Identical to v4) ---
 def generate_document_template(document_type: str, career_field: str = "", experience_level: str = "") -> str:
-    """Generates a basic markdown template. Returns JSON string."""
     logger.info(f"Executing tool: generate_document_template(type='{document_type}', field='{career_field}', exp='{experience_level}')")
-    template = f"## Basic Template: {document_type}\n\n"
-    template += f"**Target Field:** {career_field or 'Not specified'}\n"
-    template += f"**Experience Level:** {experience_level or 'Not specified'}\n\n---\n\n"
-    # (Keep the template content from v3/previous version)
+    template = f"## Basic Template: {document_type}\n\n**Target Field:** {career_field or 'Not specified'}\n**Experience Level:** {experience_level or 'Not specified'}\n\n---\n\n"
     if "resume" in document_type.lower(): template += """### Contact Information\n* Name:\n* Phone:\n* Email:\n* LinkedIn URL:\n* Portfolio URL (Optional):\n\n### Summary/Objective\n* _[ 2-3 sentences summarizing your key skills, experience, and career goals, tailored to the job/field. Make it impactful! ]_\n\n### Experience\n**Company Name | Location | Job Title | Start Date – End Date**\n* Accomplishment 1 (Use action verbs: Led, Managed, Developed, Increased X by Y%. Quantify results!)\n* Accomplishment 2\n* _[ Repeat for other relevant positions ]_\n\n### Education\n**University/Institution Name | Degree | Graduation Date (or Expected)**\n* Relevant coursework, honors, activities (Optional)\n\n### Skills\n* **Technical Skills:** [ e.g., Python, Java, SQL, MS Excel, Google Analytics, Figma, AWS ]\n* **Languages:** [ e.g., English (Native), Spanish (Fluent) ]\n* **Other:** [ Certifications, relevant tools, methodologies like Agile/Scrum ]\n"""
     elif "cover letter" in document_type.lower(): template += """[Your Name]\n[Your Address]\n[Your Phone]\n[Your Email]\n\n[Date]\n\n[Hiring Manager Name (if known), or 'Hiring Team']\n[Hiring Manager Title (if known)]\n[Company Name]\n[Company Address]\n\n**Subject: Application for [Job Title] Position - [Your Name]**\n\nDear [Mr./Ms./Mx. Last Name or Hiring Team],\n\n**Introduction:** State the position you're applying for and where you saw it. Express genuine enthusiasm for the role *and* the company. Briefly highlight 1-2 key qualifications that make you a perfect fit right from the start.\n* _[ Example: I am writing to express my strong interest in the [Job Title] position advertised on [Platform]. With my background in [Relevant Field] and proven ability to [Key Skill Relevant to Job], I am confident I can bring significant value to [Company Name]'s mission in [Specific Area Company Works In]. ]_\n\n**Body Paragraph(s):** This is where you connect your experience to the job description. Don't just list duties; show *impact*. Use examples (think STAR method: Situation, Task, Action, Result). Explain *why* you're drawn to *this specific company* – mention their values, projects, or recent news. Show you've done your homework!\n* _[ Example: In my previous role at [Previous Company], I spearheaded a project that [Quantifiable achievement relevant to new job], demonstrating my expertise in [Skill required by new job]. I admire [Company Name]'s innovative approach to [Specific Company Initiative], and I believe my skills in [Another Relevant Skill] align perfectly with the requirements of this role and your company culture. ]_\n\n**Conclusion:** Reiterate your strong interest and suitability. Briefly summarize your key selling points. State your call to action confidently (e.g., "I am eager to discuss how my skills can benefit [Company Name]..."). Thank the reader for their time and consideration.\n* _[ Example: Thank you for considering my application. My attached resume provides further detail on my qualifications. I am excited about the potential to contribute to your team and look forward to hearing from you soon regarding an interview. ]_\n\nSincerely,\n\n[Your Typed Name]\n"""
     elif "linkedin summary" in document_type.lower(): template += """### LinkedIn Summary / About Section Template\n\n**Headline:** [ Make this keyword-rich and concise! Who are you professionally? What's your focus? e.g., 'Software Engineer specializing in AI & Cloud | Python | Ex-Google | Building Innovative Solutions' OR 'Marketing Manager | Driving Growth for SaaS Startups | Content Strategy & Demand Generation' ]\n\n**About Section:**\n\n* **[ Paragraph 1: Hook & Overview ]** Start with a compelling statement about your passion, mission, or core expertise. Who are you, what do you do, and what drives you? Use keywords relevant to your target roles/industry. Think of this as your elevator pitch.\n* **[ Paragraph 2: Key Skills & Experience Highlights ]** Detail your core competencies, both technical and soft skills. Mention significant experiences, types of projects, or industries you've worked in. Quantify achievements whenever possible (e.g., 'Managed budgets up to $X', 'Increased user engagement by Y%'). Tailor this to attract your desired audience (recruiters, clients, collaborators).\n* **[ Paragraph 3: Career Goals & What You're Seeking (Optional but Recommended) ]** Briefly state your current career aspirations. What kind of opportunities, connections, or challenges are you looking for? Be specific if possible (e.g., 'Seeking opportunities in AI ethics', 'Open to collaborating on open-source projects').\n* **[ Paragraph 4: Call to Action / Personality (Optional) ]** You might invite relevant connections, mention personal interests related to your field, or add a touch of personality to make you more memorable. What makes you, you?\n* **[ Specialties/Keywords: ]** _[ List 5-15 key terms separated by commas or bullet points that recruiters might search for. e.g., Project Management, Data Analysis, Agile Methodologies, Content Strategy, Python, Java, Cloud Security, UX/UI Design, B2B Marketing ]_\n"""
     else: template += "[ Template structure for this document type will be provided here. Let me know what you need! ]"
-    return json.dumps({"template_markdown": template}) # Return JSON string
+    return json.dumps({"template_markdown": template})
 
 def create_personalized_routine(emotion: str, goal: str, available_time_minutes: int = 60, routine_length_days: int = 7) -> str:
-    """Creates a personalized routine using fallback. Returns JSON string."""
     logger.info(f"Executing tool: create_personalized_routine(emo='{emotion}', goal='{goal}', time={available_time_minutes}, days={routine_length_days})")
     logger.warning("Using basic fallback for create_personalized_routine for robustness.")
     try:
         routine_dict = generate_basic_routine(emotion, goal, available_time_minutes, routine_length_days)
-        if not routine_dict or not isinstance(routine_dict, dict):
-             raise ValueError("Basic routine generation failed to return a valid dictionary.")
-        return json.dumps(routine_dict) # Return JSON string
-    except Exception as e:
-        logger.error(f"Error in create_personalized_routine fallback: {e}")
-        return json.dumps({"error": f"Couldn't create a routine right now due to an error: {e}. Maybe try simplifying the goal or adjusting the time?"})
+        if not routine_dict or not isinstance(routine_dict, dict): raise ValueError("Basic routine generation failed.")
+        return json.dumps(routine_dict)
+    except Exception as e: logger.error(f"Error in create_personalized_routine fallback: {e}"); return json.dumps({"error": f"Couldn't create routine: {e}."})
 
 def analyze_resume(resume_text: str, career_goal: str) -> str:
-    """Provides analysis of the resume (Simulated). Returns JSON string."""
-    logger.info(f"Executing tool: analyze_resume(goal='{career_goal}', len={len(resume_text)})")
-    logger.warning("Using placeholder analysis for analyze_resume tool.")
-    analysis = { "strengths": ["Clear contact information.", "Uses some action verbs.", f"Mentions skills potentially relevant to '{career_goal}'."], "areas_for_improvement": ["Quantify achievements more (e.g., 'Increased X by Y%').", f"Tailor skills section specifically for '{career_goal}' roles.", "Check for consistent formatting and tense.", "Add a compelling summary/objective statement."], "format_feedback": "Overall format seems clean, check consistency.", "content_feedback": f"Content shows potential relevance to '{career_goal}', but needs more specific examples and quantified results.", "keyword_suggestions": ["Review job descriptions for "+ career_goal +" and incorporate relevant keywords like 'Keyword1', 'Keyword2', 'Keyword3'."], "next_steps": ["Revise 'Experience' bullet points with measurable results.", "Tailor Summary/Objective and Skills sections per application.", "Proofread carefully."] }
-    return json.dumps({"analysis": analysis}) # Return JSON string
+    logger.info(f"Executing tool: analyze_resume(goal='{career_goal}', len={len(resume_text)})"); logger.warning("Using placeholder analysis for analyze_resume tool.")
+    analysis = { "strengths": ["Clear contact info.", "Uses action verbs.", f"Mentions skills relevant to '{career_goal}'."], "areas_for_improvement": ["Quantify achievements.", f"Tailor skills section for '{career_goal}'.", "Check formatting consistency.", "Add compelling summary."], "format_feedback": "Clean format, check consistency.", "content_feedback": f"Potentially relevant to '{career_goal}', needs more specific examples/results.", "keyword_suggestions": ["Review job descriptions for "+ career_goal +" and add keywords like 'Keyword1', 'Keyword2'."], "next_steps": ["Revise 'Experience' bullets with measurable results.", "Tailor Summary/Skills per application.", "Proofread."] }
+    return json.dumps({"analysis": analysis})
 
 def analyze_portfolio(portfolio_description: str, career_goal: str, portfolio_url: str = "") -> str:
-    """Provides analysis of the portfolio (Simulated). Returns JSON string."""
-    logger.info(f"Executing tool: analyze_portfolio(goal='{career_goal}', url='{portfolio_url}', desc_len={len(portfolio_description)})")
-    logger.warning("Using placeholder analysis for analyze_portfolio tool.")
-    analysis = { "alignment_with_goal": f"Based on description, seems moderately aligned with '{career_goal}'. Review specific projects.", "strengths": ["Includes a variety of projects (based on description).", "Clear description provided helps context."] + (["URL provided."] if portfolio_url else []), "areas_for_improvement": [f"Ensure project descriptions clearly link skills used to '{career_goal}' requirements.", "Consider adding 1-2 detailed case studies.", "Check navigation is intuitive (if URL provided)."], "presentation_feedback": "Description helpful. " + (f"Review URL ({portfolio_url}) for visual appeal/clarity." if portfolio_url else "Consider creating an online portfolio."), "next_steps": ["Highlight 2-3 projects most relevant to '{career_goal}' prominently.", "Get feedback from peers/mentors.", "Ensure contact info is easily accessible."] }
-    return json.dumps({"analysis": analysis}) # Return JSON string
+    logger.info(f"Executing tool: analyze_portfolio(goal='{career_goal}', url='{portfolio_url}', desc_len={len(portfolio_description)})"); logger.warning("Using placeholder analysis for analyze_portfolio tool.")
+    analysis = { "alignment_with_goal": f"Moderately aligned with '{career_goal}'. Review projects.", "strengths": ["Project variety.", "Clear description."] + (["URL provided."] if portfolio_url else []), "areas_for_improvement": [f"Link project skills to '{career_goal}'.", "Add case studies.", "Check navigation (if URL)."], "presentation_feedback": "Description helpful. " + (f"Review URL ({portfolio_url}) for appeal/clarity." if portfolio_url else "Consider creating online portfolio."), "next_steps": ["Highlight 2-3 relevant projects.", "Get peer feedback.", "Ensure contact info accessible."] }
+    return json.dumps({"analysis": analysis})
 
 def extract_and_rate_skills_from_resume(resume_text: str, max_skills: int = 8) -> str:
-    """Extracts and rates skills from resume text (Simulated). Returns JSON string."""
-    logger.info(f"Executing tool: extract_skills(len={len(resume_text)}, max={max_skills})")
-    logger.warning("Using placeholder skill extraction for extract_and_rate_skills_from_resume tool.")
+    logger.info(f"Executing tool: extract_skills(len={len(resume_text)}, max={max_skills})"); logger.warning("Using placeholder skill extraction.")
     possible = ["Python", "Java", "JavaScript", "Project Management", "Communication", "Data Analysis", "Teamwork", "Leadership", "SQL", "React", "Customer Service", "Problem Solving", "Cloud Computing", "AWS", "Azure", "GCP", "Agile Methodologies", "Machine Learning", "Marketing", "SEO", "Content Creation"]
-    found = []
-    resume_lower = resume_text.lower()
+    found = []; resume_lower = resume_text.lower()
     for skill in possible:
         if re.search(r'\b' + re.escape(skill.lower()) + r'\b', resume_lower):
-             score = random.randint(4, 9)
-             if "lead" in resume_lower or "manage" in resume_lower or "develop" in resume_lower: score = min(10, score + random.randint(0, 1))
-             found.append({"name": skill, "score": score})
+             score = random.randint(4, 9); found.append({"name": skill, "score": score})
         if len(found) >= max_skills: break
     if not found and len(resume_text) > 100: found = [ {"name": "Communication", "score": random.randint(5,8)}, {"name": "Teamwork", "score": random.randint(5,8)}, {"name": "Problem Solving", "score": random.randint(5,8)}, ]
     logger.info(f"Extracted skills (placeholder): {[s['name'] for s in found]}")
-    return json.dumps({"skills": found[:max_skills]}) # Return JSON string
+    return json.dumps({"skills": found[:max_skills]})
 
-
-# --- Serper Web Search Implementation (Returns JSON string) ---
 def search_web_serper(search_query: str, search_type: str = 'general', location: str = None) -> str:
-    """Performs a web search using Serper API. Returns JSON string."""
+    # (Identical to v4)
     logger.info(f"Executing tool: search_web_serper(query='{search_query}', type='{search_type}', loc='{location}')")
-    if not SERPER_API_KEY:
-        logger.error("SERPER_API_KEY not configured.")
-        return json.dumps({"error": "Web search functionality is not configured."})
-
-    api_url = "https://google.serper.dev/search"
-    payload = json.dumps({"q": search_query,"location": location if location else None})
-    headers = {'X-API-KEY': SERPER_API_KEY,'Content-Type': 'application/json'}
-
+    if not SERPER_API_KEY: logger.error("SERPER_API_KEY not configured."); return json.dumps({"error": "Web search functionality is not configured."})
+    api_url = "https://google.serper.dev/search"; payload = json.dumps({"q": search_query,"location": location if location else None}); headers = {'X-API-KEY': SERPER_API_KEY,'Content-Type': 'application/json'}
     try:
-        response = requests.post(api_url, headers=headers, data=payload, timeout=10)
-        response.raise_for_status()
-        results = response.json()
-        extracted_results = []
-        # (Keep the extraction logic from v3)
+        response = requests.post(api_url, headers=headers, data=payload, timeout=10); response.raise_for_status(); results = response.json(); extracted_results = []
         if search_type == 'jobs':
             if 'jobs' in results:
                  for job in results['jobs'][:5]: extracted_results.append({"title": job.get('title'),"company": job.get('company_name'),"location": job.get('location'),"link": job.get('link')})
@@ -529,187 +354,118 @@ def search_web_serper(search_query: str, search_type: str = 'general', location:
         elif search_type in ['courses', 'skills']:
              if 'organic' in results:
                   for item in results['organic'][:5]: extracted_results.append({"title": item.get('title'),"snippet": item.get('snippet'),"link": item.get('link')})
-        else: # General search
+        else:
              if 'organic' in results:
                   for item in results['organic'][:3]: extracted_results.append({"title": item.get('title'),"snippet": item.get('snippet'),"link": item.get('link')})
              if 'answerBox' in results: extracted_results.insert(0, {"type": "Answer Box","title": results['answerBox'].get('title'),"snippet": results['answerBox'].get('snippet') or results['answerBox'].get('answer'),"link": results['answerBox'].get('link')})
-
         logger.info(f"Serper search successful for '{search_query}'. Found {len(extracted_results)} relevant items.")
-        return json.dumps({"search_results": extracted_results}) # Return JSON string
+        return json.dumps({"search_results": extracted_results})
+    except requests.exceptions.RequestException as e: logger.error(f"Serper API request failed: {e}"); return json.dumps({"error": f"Web search failed: {e}"})
+    except Exception as e: logger.error(f"Error processing Serper response: {e}"); return json.dumps({"error": "Failed to process web search results."})
 
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Serper API request failed: {e}")
-        return json.dumps({"error": f"Web search failed: {e}"})
-    except Exception as e:
-        logger.error(f"Error processing Serper response: {e}")
-        return json.dumps({"error": "Failed to process web search results."})
 
-
-# --- AI Interaction Logic (Using OpenAI GPT-4o) ---
-def get_ai_response(user_id: str, user_input: str) -> str:
-    """Gets response from OpenAI GPT-4o, handling context, system prompt, and tool calls."""
-    logger.info(f"Getting OpenAI response for user {user_id}. Input: '{user_input[:100]}...'")
+# --- AI Interaction Logic (Using Groq Llama 3.1 with Streaming) ---
+def get_ai_response_stream(user_id: str, user_input: str) -> Generator[str, None, None]:
+    """
+    Gets response from Groq, handling context, system prompt, tool calls,
+    and streams the final text response.
+    Yields chunks of the response text.
+    """
+    logger.info(f"Getting Groq stream response for user {user_id}. Input: '{user_input[:100]}...'")
 
     if not client:
-        logger.error("OpenAI client not initialized.")
-        return "I'm sorry, my AI core isn't available right now. Please check the configuration."
+        logger.error("Groq client not initialized.")
+        yield "I'm sorry, my AI core isn't available right now. Please check the configuration."
+        return
 
     try:
         user_profile = get_user_profile(user_id)
         if not user_profile:
              logger.error(f"Failed profile retrieval for {user_id}.")
-             return "Uh oh, I couldn't access your profile details right now. Let's try again in a moment?"
-
-        # **INVESTOR NOTE:** The system prompt defines Aishura's unique empathetic persona and strategic approach, now adapted for OpenAI.
-        current_emotion_display = user_profile.get('current_emotion', 'how you feel')
-        user_name = user_profile.get('name', 'there')
-        career_goal = user_profile.get('career_goal', 'your goals')
-        location = user_profile.get('location', 'your area')
-        industry = user_profile.get('industry', 'your field')
-        exp_level = user_profile.get('experience_level', 'your experience level')
-
-        system_prompt = f"""
-        You are Aishura, an advanced AI career assistant powered by OpenAI's GPT-4o. Your core mission is to provide **empathetic, supportive, and highly personalized career guidance**. You are talking to {user_name}.
-
-        **Your Persona & Communication Style:**
-        * **Empathetic & Validating:** ALWAYS acknowledge the user's feelings ({current_emotion_display}). Use phrases like "I hear you," "It sounds like things are tough/exciting," "That makes total sense," "I get it." Validate their experience.
-        * **Collaborative & Supportive:** Use "we," "us," "together." Frame guidance as a partnership. Phrases: "Okay, let's figure this out together.", "We can tackle this step-by-step.", "I'm here to help you navigate this."
-        * **Positive & Action-Oriented:** While validating struggles, gently guide towards positive next steps. Focus on what *can* be done. Be realistic but hopeful.
-        * **Personalized:** Reference the user's profile details subtly: name ({user_name}), goal ({career_goal}), location ({location}), industry ({industry}), experience ({exp_level}).
-        * **Concise & Clear:** Use markdown for readability (lists, bolding). Avoid jargon. Get to the point while remaining warm.
-
-        **Core Functionality - How to Respond:**
-        1.  **Acknowledge & Empathize:** Start by acknowledging their input and expressed emotion (e.g., "Hey {user_name}, I hear that you're feeling {current_emotion_display}. It's completely understandable given [mention context from user input or goal].").
-        2.  **Address the Query Directly:** Answer their specific question or respond to their statement clearly.
-        3.  **Leverage Tools Strategically:**
-            * **Proactive Suggestions:** If they mention needing a resume, cover letter, or LinkedIn help, suggest using `generate_document_template`. If they feel stuck or need structure, suggest `create_personalized_routine`. If they mention their resume or portfolio, offer to analyze it (`analyze_resume`, `analyze_portfolio`). If they want to understand their skills better from their resume, suggest `extract_and_rate_skills_from_resume`.
-            * **Web Search (`search_jobs_courses_skills`):**
-                * **Use ONLY when the user explicitly asks for job openings, courses, skill resources, or specific company information.**
-                * Construct a specific `search_query` based on their request, `career_goal`, `location`, `industry`, etc.
-                * Specify `search_type` ('jobs', 'courses', 'skills', 'general').
-                * Include `location` if relevant.
-                * **Crucially:** Present the search results clearly. Summarize findings, don't just dump links. E.g., "Okay, I ran a search using Serper and found a few promising [type] results for you:"
-            * **Do NOT Use Tools If:** The user is just chatting, venting, or asking for general advice not mapping to a tool. Handle these conversationally.
-        4.  **Synthesize Tool Results:** Explain *why* tool results are relevant. Integrate findings into your response.
-        5.  **Maintain Context:** Remember the conversation flow and profile.
-        6.  **Handle Errors Gracefully:** Apologize and explain simply if a tool fails (e.g., "Hmm, I couldn't fetch the [tool purpose] just now. Maybe we can try searching differently, or focus on [alternative action]?"). No technical errors to user.
-        """
-
-        # Prepare message history for OpenAI API
-        # Convert stored format to API format {role: '...', content: '...'}
+             yield "Uh oh, I couldn't access your profile details right now. Let's try again in a moment?"
+             return
+
+        # System prompt (identical persona to v4)
+        current_emotion_display = user_profile.get('current_emotion', 'how you feel'); user_name = user_profile.get('name', 'there'); career_goal = user_profile.get('career_goal', 'your goals'); location = user_profile.get('location', 'your area'); industry = user_profile.get('industry', 'your field'); exp_level = user_profile.get('experience_level', 'your experience level')
+        system_prompt = f"""You are Aishura, an advanced AI career assistant powered by Groq's Llama 3.1 model. Your core mission is to provide **empathetic, supportive, and highly personalized career guidance**. You are talking to {user_name}. **Persona & Style:** Empathetic, validating (acknowledge {current_emotion_display}), collaborative ("we", "us"), positive, action-oriented, personalized (use {user_name}, {career_goal}, {location}, {industry}, {exp_level}), concise, clear (markdown). **Functionality:** 1. Acknowledge & Empathize. 2. Address Query Directly. 3. Leverage Tools Strategically: Suggest `generate_document_template`, `create_personalized_routine`, `analyze_resume`, `analyze_portfolio`, `extract_and_rate_skills_from_resume` proactively. Use `search_jobs_courses_skills` ONLY when explicitly asked for jobs/courses/skills/company info (use profile details for query, specify type, present results clearly). Do NOT use tools for general chat. 4. Synthesize Tool Results: Explain relevance. 5. Maintain Context. 6. Handle Errors Gracefully: Apologize simply, suggest alternatives."""
+
+        # Prepare message history (OpenAI/Groq compatible format)
         messages = [{"role": "system", "content": system_prompt}]
         chat_history = user_profile.get('chat_history', [])
         for msg in chat_history:
-             # Basic validation before appending
+            # Append validated messages from history (using logic from load_user_database)
             if isinstance(msg, dict) and 'role' in msg:
                 api_msg = {"role": msg["role"]}
                 if msg["role"] in ["user", "assistant", "system"]:
-                     # Handle messages with content and potentially tool_calls (for assistant)
-                     if 'content' in msg and isinstance(msg.get('content'), (str, type(None))):
-                         api_msg['content'] = msg.get('content') # Can be None for assistant msg with only tool_calls
+                     if 'content' in msg and isinstance(msg.get('content'), (str, type(None))): api_msg['content'] = msg.get('content')
                      else:
-                         # If content is missing or wrong type for user/system, skip or log error
-                         if msg["role"] != 'assistant':
-                             logger.warning(f"Skipping message with missing/invalid content for role {msg['role']}: {msg}")
-                             continue
-                         else: # Assistant role, content can be None if tool_calls exist
-                              api_msg['content'] = None
-
+                         if msg["role"] != 'assistant': continue
+                         else: api_msg['content'] = None
                      if msg["role"] == 'assistant' and 'tool_calls' in msg and isinstance(msg['tool_calls'], list):
-                          # Validate tool_calls structure before adding
                           valid_tool_calls = all(isinstance(tc, dict) and 'id' in tc and 'type' in tc and 'function' in tc for tc in msg['tool_calls'])
-                          if valid_tool_calls:
-                               api_msg['tool_calls'] = msg['tool_calls']
+                          if valid_tool_calls: api_msg['tool_calls'] = msg['tool_calls']
                           else:
-                               logger.warning(f"Invalid tool_calls structure found in history: {msg['tool_calls']}")
-                               # Decide: skip message, or add without tool_calls if content exists?
-                               if api_msg['content'] is None: continue # Skip if no content either
-
-                     # Only append if content is not None OR tool_calls are present
-                     if api_msg.get('content') is not None or api_msg.get('tool_calls'):
-                          messages.append(api_msg)
-
+                               if api_msg['content'] is None: continue
+                     if api_msg.get('content') is not None or api_msg.get('tool_calls'): messages.append(api_msg)
                 elif msg["role"] == "tool":
-                     # Handle tool responses
                      if 'tool_call_id' in msg and 'content' in msg and isinstance(msg.get('content'), str):
-                         api_msg['tool_call_id'] = msg['tool_call_id']
-                         api_msg['content'] = msg['content'] # Content is the stringified result
-                         messages.append(api_msg)
-                     else:
-                         logger.warning(f"Skipping invalid tool message structure in history: {msg}")
-                         continue
-                else:
-                     logger.warning(f"Skipping message with unknown role: {msg['role']}")
-                     continue
-            else:
-                 logger.warning(f"Skipping invalid message format in history: {msg}")
-                 continue
-
+                         api_msg['tool_call_id'] = msg['tool_call_id']; api_msg['content'] = msg['content']; messages.append(api_msg)
+                     else: continue
+                else: continue
+            else: continue
 
         # Add current user input
         messages.append({"role": "user", "content": user_input})
 
         # --- Make the initial API Call ---
-        logger.info(f"Sending {len(messages)} messages to OpenAI model {MODEL_ID}.")
+        logger.info(f"Sending {len(messages)} messages to Groq model {MODEL_ID}.")
         try:
             response = client.chat.completions.create(
                 model=MODEL_ID,
                 messages=messages,
-                tools=tools_list_openai,
-                tool_choice="auto", # Let model decide when to call functions
-                temperature=0.7,
-                max_tokens=1500
+                tools=tools_list_groq,
+                tool_choice="auto",
+                temperature=0.7, # Adjust temperature as needed
+                max_tokens=1500, # Max tokens for the completion
+                top_p=1,
+                stream=False # First call is not streamed to check for tool calls
             )
             response_message = response.choices[0].message
             finish_reason = response.choices[0].finish_reason
 
-        except openai.APIError as e: logger.error(f"OpenAI API Error: {e.status_code} - {e.response}"); return f"AI service error (Code: {e.status_code}). Try again."
-        except openai.APITimeoutError: logger.error("OpenAI timed out."); return "AI service request timed out. Try again."
-        except openai.APIConnectionError as e: logger.error(f"OpenAI Connection Error: {e}"); return "Cannot connect to AI service."
-        except openai.RateLimitError: logger.error("OpenAI Rate Limit Exceeded."); return "AI service busy. Try again shortly."
-        except openai.AuthenticationError: logger.error("OpenAI Authentication Error. Check API Key."); return "AI Authentication failed. Please check configuration."
-        except Exception as e: logger.exception(f"Unexpected error during OpenAI API call: {e}"); return "Oh dear, something unexpected happened on my end. Let's pause and retry?"
+        # --- Handle Groq API Errors ---
+        except APIError as e: logger.error(f"Groq API Error: {e.status_code} - {e.response}"); yield f"AI service error ({e.message}). Try again." ; return
+        except APITimeoutError: logger.error("Groq timed out."); yield "AI service request timed out. Try again."; return
+        except APIConnectionError as e: logger.error(f"Groq Connection Error: {e}"); yield "Cannot connect to AI service."; return
+        except RateLimitError: logger.error("Groq Rate Limit Exceeded."); yield "AI service busy (Rate Limit). Try again shortly."; return
+        except AuthenticationError: logger.error("Groq Authentication Error. Check API Key."); yield "AI Authentication failed. Please check configuration."; return
+        except Exception as e: logger.exception(f"Unexpected error during Groq API call: {e}"); yield "Oh dear, something unexpected happened on my end. Let's pause and retry?"; return
 
         # --- Process the response ---
         tool_calls = response_message.tool_calls
 
-        # Store user message (already added to 'messages' list for API call)
+        # Store user message
         add_chat_message(user_id, "user", user_input)
 
         # Store the initial assistant message (might contain text and/or tool calls)
         assistant_message_for_db = {"content": response_message.content}
         if tool_calls:
-            # Convert ToolCall objects to dictionaries for JSON serialization
             assistant_message_for_db['tool_calls'] = [tc.model_dump() for tc in tool_calls]
         add_chat_message(user_id, "assistant", assistant_message_for_db)
 
-
         # --- Handle Tool Calls if any ---
         if tool_calls:
-            logger.info(f"OpenAI requested tool call(s): {[tc.function.name for tc in tool_calls]}")
-            messages.append(response_message) # Add assistant's msg with tool_calls to local list for next API call
-
-            available_functions = {
-                "generate_document_template": generate_document_template,
-                "create_personalized_routine": create_personalized_routine,
-                "analyze_resume": analyze_resume,
-                "analyze_portfolio": analyze_portfolio,
-                "extract_and_rate_skills_from_resume": extract_and_rate_skills_from_resume,
-                "search_jobs_courses_skills": search_web_serper,
-            }
+            logger.info(f"Groq requested tool call(s): {[tc.function.name for tc in tool_calls]}")
+            messages.append(response_message) # Add assistant's msg with tool_calls
+
+            available_functions = { "generate_document_template": generate_document_template, "create_personalized_routine": create_personalized_routine, "analyze_resume": analyze_resume, "analyze_portfolio": analyze_portfolio, "extract_and_rate_skills_from_resume": extract_and_rate_skills_from_resume, "search_jobs_courses_skills": search_web_serper, }
 
             # Execute functions and gather results
             for tool_call in tool_calls:
-                function_name = tool_call.function.name
-                function_to_call = available_functions.get(function_name)
-                tool_call_id = tool_call.id
-                function_response_content = None # Initialize
-
+                function_name = tool_call.function.name; function_to_call = available_functions.get(function_name); tool_call_id = tool_call.id; function_response_content = None
                 try:
                     function_args = json.loads(tool_call.function.arguments)
-
                     if function_to_call:
-                         # Special handling before calling
                         if function_name == "analyze_resume":
                             if 'career_goal' not in function_args: function_args['career_goal'] = career_goal
                             save_user_resume(user_id, function_args.get('resume_text', ''))
@@ -717,197 +473,220 @@ def get_ai_response(user_id: str, user_input: str) -> str:
                             if 'career_goal' not in function_args: function_args['career_goal'] = career_goal
                             save_user_portfolio(user_id, function_args.get('portfolio_url', ''), function_args.get('portfolio_description', ''))
                         elif function_name == "search_jobs_courses_skills":
-                            if 'location' not in function_args or not function_args['location']:
-                                function_args['location'] = location if location != 'your area' else None
-
+                            if 'location' not in function_args or not function_args['location']: function_args['location'] = location if location != 'your area' else None
                         logger.info(f"Calling function '{function_name}' with args: {function_args}")
-                        # Functions return JSON strings
-                        function_response_content = function_to_call(**function_args)
+                        function_response_content = function_to_call(**function_args) # Expecting JSON string
                         logger.info(f"Function '{function_name}' returned: {function_response_content[:200]}...")
-                    else:
-                        logger.warning(f"Function {function_name} not implemented.")
-                        function_response_content = json.dumps({"error": f"Tool '{function_name}' not available."})
-
-                except json.JSONDecodeError as e:
-                     logger.error(f"Error decoding args for {function_name}: {tool_call.function.arguments} - {e}")
-                     function_response_content = json.dumps({"error": f"Invalid arguments received for tool '{function_name}'."})
-                except TypeError as e:
-                     logger.error(f"Argument mismatch for function {function_name}. Args: {function_args}, Error: {e}")
-                     function_response_content = json.dumps({"error": f"Internal error: Tool '{function_name}' called with incorrect arguments."})
-                except Exception as e:
-                    logger.exception(f"Error executing function {function_name}: {e}")
-                    function_response_content = json.dumps({"error": f"Sorry, I encountered an error while trying to use the '{function_name}' tool."})
-
-                # Append tool response to messages list for API
-                messages.append({
-                    "tool_call_id": tool_call_id,
-                    "role": "tool",
-                    "content": function_response_content, # Content is the JSON string result
-                })
-                # Store tool response in DB
+                    else: logger.warning(f"Function {function_name} not implemented."); function_response_content = json.dumps({"error": f"Tool '{function_name}' not available."})
+                except json.JSONDecodeError as e: logger.error(f"Error decoding args for {function_name}: {tool_call.function.arguments} - {e}"); function_response_content = json.dumps({"error": f"Invalid arguments for tool '{function_name}'."})
+                except TypeError as e: logger.error(f"Argument mismatch for {function_name}. Args: {function_args}, Error: {e}"); function_response_content = json.dumps({"error": f"Internal error: Tool '{function_name}' called incorrectly."})
+                except Exception as e: logger.exception(f"Error executing function {function_name}: {e}"); function_response_content = json.dumps({"error": f"Error using the '{function_name}' tool."})
+                messages.append({"tool_call_id": tool_call_id, "role": "tool", "content": function_response_content})
                 add_chat_message(user_id, "tool", {"tool_call_id": tool_call_id, "content": function_response_content})
 
-
-            # --- Make the second API Call with tool results ---
-            logger.info(f"Sending {len(messages)} messages to OpenAI (incl. tool results).")
+            # --- Make the second API Call (Streaming this time) ---
+            logger.info(f"Sending {len(messages)} messages to Groq (incl. tool results) for streaming response.")
             try:
-                second_response = client.chat.completions.create(
+                stream = client.chat.completions.create(
                     model=MODEL_ID,
-                    messages=messages, # Send history including system, user, assistant tool_call, and tool responses
+                    messages=messages,
                     temperature=0.7,
-                    max_tokens=1500
+                    max_tokens=1500,
+                    top_p=1,
+                    stream=True, # Enable streaming
                 )
-                final_response_text = second_response.choices[0].message.content
-                logger.info("Received final response after tool calls.")
 
-                # Store final assistant text response
-                add_chat_message(user_id, "assistant", {"content": final_response_text})
-                return final_response_text
+                # Yield chunks and accumulate the full response for DB
+                full_response_content = ""
+                for chunk in stream:
+                    delta_content = chunk.choices[0].delta.content
+                    if delta_content:
+                        yield delta_content # Yield the text chunk to the caller (Gradio)
+                        full_response_content += delta_content
+
+                logger.info("Finished streaming final response after tool calls.")
+                # Store the complete final assistant response in DB
+                add_chat_message(user_id, "assistant", {"content": full_response_content})
+                return # End the generator
+
+            # --- Handle Groq API Errors for the streaming call ---
+            except APIError as e: logger.error(f"Groq API Error (stream): {e.status_code} - {e.response}"); yield f"AI service error ({e.message}) processing tool results." ; return
+            except RateLimitError: logger.error("Groq Rate Limit Exceeded (stream)."); yield "AI service busy processing results. Try again shortly."; return
+            except Exception as e: logger.exception(f"Unexpected error during Groq stream: {e}"); yield "Oh dear, something went wrong while generating the response."; return
+
+        else: # No tool calls were made, stream the initial response
+            logger.info("No tool calls requested by Groq. Streaming initial response.")
+            # Need to make the call again with stream=True
+            try:
+                stream = client.chat.completions.create(
+                    model=MODEL_ID,
+                    messages=messages, # History includes system + previous + user
+                    temperature=0.7,
+                    max_tokens=1500,
+                    top_p=1,
+                    stream=True,
+                )
 
-            except openai.APIError as e: logger.error(f"OpenAI API Error on second call: {e.status_code} - {e.response}"); return f"AI service error processing tool results (Code: {e.status_code})."
-            except openai.RateLimitError: logger.error("OpenAI Rate Limit Exceeded on second call."); return "AI service busy processing results. Try again shortly."
-            except Exception as e: logger.exception(f"Unexpected error during second OpenAI call: {e}"); return "Oh dear, something went wrong while processing the tool's results. Could we try that step again?"
+                # Yield chunks and accumulate full response for DB update
+                full_response_content = ""
+                for chunk in stream:
+                    delta_content = chunk.choices[0].delta.content
+                    if delta_content:
+                        yield delta_content
+                        full_response_content += delta_content
+
+                logger.info("Finished streaming initial response.")
+                # Update the assistant message stored earlier with the full streamed content
+                # This is tricky as we stored the non-streamed response first.
+                # A better approach might be to only store AFTER streaming is complete.
+                # Let's update the last message if it was the placeholder assistant message.
+                if profile['chat_history'][-1]['role'] == 'assistant':
+                     profile['chat_history'][-1]['content'] = full_response_content
+                     save_user_database(load_user_database()) # Save the updated history
+                else: # Should not happen, but fallback to adding a new message
+                     add_chat_message(user_id, "assistant", {"content": full_response_content})
+
+                return # End the generator
+
+            # --- Handle Groq API Errors for the streaming call ---
+            except APIError as e: logger.error(f"Groq API Error (stream): {e.status_code} - {e.response}"); yield f"AI service error ({e.message})." ; return
+            except RateLimitError: logger.error("Groq Rate Limit Exceeded (stream)."); yield "AI service busy. Try again shortly."; return
+            except Exception as e: logger.exception(f"Unexpected error during Groq stream: {e}"); yield "Oh dear, something went wrong generating the response."; return
 
-        else: # No tool calls were made
-            logger.info("No tool calls requested by OpenAI.")
-            final_response_text = response_message.content
-            # Assistant message already stored above
-            if not final_response_text:
-                 final_response_text = "Okay, consider it done. How else can I assist you?" # Fallback if content is empty
-            return final_response_text
 
     except Exception as e:
-        logger.exception(f"Critical error in get_ai_response: {e}")
-        return "A critical error occurred. Please try again later."
+        logger.exception(f"Critical error in get_ai_response_stream: {e}")
+        yield "A critical error occurred. Please try again later."
+        return
 
 
 # --- Recommendation Generation (Simple version - unchanged) ---
 def gen_recommendations_simple(user_id):
-    # (Identical to v3)
+    # (Identical to v4)
     logger.info(f"Generating simple recommendations for user {user_id}")
-    profile = get_user_profile(user_id); recs = []
-    goal = profile.get('career_goal', '').lower(); emotion = profile.get('current_emotion', '').lower()
-    if 'job' in goal or 'internship' in goal: recs.append({"title": "Refine Resume", "description": f"Tailor your resume for '{goal}' roles. Use keywords from job descriptions.", "priority": "High", "action_type": "Job Application"}); recs.append({"title": "Practice Interviewing", "description": "Use the STAR method to prepare answers for common behavioral questions.", "priority": "Medium", "action_type": "Skill Building"}); recs.append({"title": "Network Actively", "description": f"Connect with people in '{profile.get('industry', 'your')}' industry on LinkedIn or attend virtual events.", "priority": "Medium", "action_type": "Networking"})
-    if 'skill' in goal: recs.append({"title": "Identify Learning Resources", "description": f"Find online courses (Coursera, Udemy, edX) or tutorials for the skills needed for '{goal}'.", "priority": "High", "action_type": "Skill Building"}); recs.append({"title": "Start a Small Project", "description": f"Apply newly learned skills in a personal project to build portfolio evidence.", "priority": "Medium", "action_type": "Skill Building"})
-    if emotion in ["anxious", "overwhelmed", "stuck", "unmotivated", "discouraged"]: recs.append({"title": "Focus on Small Wins", "description": "Break down larger tasks into very small, achievable steps. Celebrate completing them!", "priority": "High", "action_type": "Wellbeing"}); recs.append({"title": "Schedule Breaks", "description": "Ensure you take regular short breaks to avoid burnout. Step away from the screen.", "priority": "Medium", "action_type": "Wellbeing"})
+    profile = get_user_profile(user_id); recs = []; goal = profile.get('career_goal', '').lower(); emotion = profile.get('current_emotion', '').lower()
+    if 'job' in goal or 'internship' in goal: recs.append({"title": "Refine Resume", "description": f"Tailor resume for '{goal}'.", "priority": "High", "action_type": "Job Application"}); recs.append({"title": "Practice Interviewing", "description": "Use STAR method.", "priority": "Medium", "action_type": "Skill Building"}); recs.append({"title": "Network Actively", "description": f"Connect in '{profile.get('industry', 'your')}' industry.", "priority": "Medium", "action_type": "Networking"})
+    if 'skill' in goal: recs.append({"title": "Identify Learning Resources", "description": f"Find courses/tutorials for '{goal}'.", "priority": "High", "action_type": "Skill Building"}); recs.append({"title": "Start a Small Project", "description": f"Apply skills in a project.", "priority": "Medium", "action_type": "Skill Building"})
+    if emotion in ["anxious", "overwhelmed", "stuck", "unmotivated", "discouraged"]: recs.append({"title": "Focus on Small Wins", "description": "Break tasks into small steps.", "priority": "High", "action_type": "Wellbeing"}); recs.append({"title": "Schedule Breaks", "description": "Take regular short breaks.", "priority": "Medium", "action_type": "Wellbeing"})
     if recs:
         current_recs = profile.get('recommendations', []); pending_titles = {r['recommendation'].get('title') for r in current_recs if r.get('status') == 'pending'}; new_recs_to_add = [r for r in recs if r.get('title') not in pending_titles]
         for rec in new_recs_to_add[:3]: add_recommendation_to_user(user_id, rec)
     return
 
-# --- Chart and Visualization Functions (Identical to v3) ---
-# (create_emotion_chart, create_progress_chart, create_routine_completion_gauge, create_skill_radar_chart functions are identical to v3)
+# --- Chart and Visualization Functions (Identical to v4) ---
 def create_emotion_chart(user_id):
     user_profile = get_user_profile(user_id); records = user_profile.get('daily_emotions', [])
-    if not records: fig = go.Figure(); fig.add_annotation(text="No emotion data yet. How are you feeling today?", showarrow=False); fig.update_layout(title="Your Emotional Journey"); return fig
+    if not records: fig = go.Figure(); fig.add_annotation(text="No emotion data yet.", showarrow=False); fig.update_layout(title="Your Emotional Journey"); return fig
     vals = {"Unmotivated": 1, "Discouraged": 1.5, "Stuck": 2, "Anxious": 2.5, "Confused": 3, "Overwhelmed": 3.5, "Hopeful": 4.5, "Focused": 5, "Excited": 6}
     dates = [datetime.fromisoformat(r['date']) for r in records]; scores = [vals.get(r['emotion'], 3) for r in records]; names = [r['emotion'] for r in records]
     df = pd.DataFrame({'Date': dates, 'Score': scores, 'Emotion': names}).sort_values('Date')
-    fig = px.line(df, x='Date', y='Score', markers=True, labels={"Score": "State"}, title="Your Emotional Journey")
-    fig.update_traces(hovertemplate='%{x|%Y-%m-%d %H:%M}<br>Feeling: %{text}<extra></extra>', text=df['Emotion']); fig.update_yaxes(tickvals=list(vals.values()), ticktext=list(vals.keys())); return fig
+    fig = px.line(df, x='Date', y='Score', markers=True, labels={"Score": "State"}, title="Your Emotional Journey"); fig.update_traces(hovertemplate='%{x|%Y-%m-%d %H:%M}<br>Feeling: %{text}<extra></extra>', text=df['Emotion']); fig.update_yaxes(tickvals=list(vals.values()), ticktext=list(vals.keys())); return fig
 
 def create_progress_chart(user_id):
     user_profile = get_user_profile(user_id); tasks = user_profile.get('completed_tasks', [])
-    if not tasks: fig = go.Figure(); fig.add_annotation(text="No tasks completed yet. Let's add one!", showarrow=False); fig.update_layout(title="Progress Points"); return fig
-    tasks.sort(key=lambda x: datetime.fromisoformat(x['date']))
-    task_dates = {}
-    for task in tasks:
-        task_date_str = datetime.fromisoformat(task['date']).strftime('%Y-%m-%d')
-        pts = task.get('points', random.randint(10, 25))
-        if task_date_str not in task_dates: task_dates[task_date_str] = {'date': datetime.fromisoformat(task['date']).date(), 'points': 0, 'tasks': []}
-        task_dates[task_date_str]['points'] += pts
-        task_dates[task_date_str]['tasks'].append(task['task'])
+    if not tasks: fig = go.Figure(); fig.add_annotation(text="No tasks completed yet.", showarrow=False); fig.update_layout(title="Progress Points"); return fig
+    tasks.sort(key=lambda x: datetime.fromisoformat(x['date'])); task_dates = {}
+    for task in tasks: task_date_str = datetime.fromisoformat(task['date']).strftime('%Y-%m-%d'); pts = task.get('points', 15); task_dates.setdefault(task_date_str, {'date': datetime.fromisoformat(task['date']).date(), 'points': 0, 'tasks': []}); task_dates[task_date_str]['points'] += pts; task_dates[task_date_str]['tasks'].append(task['task'])
     sorted_dates = sorted(task_dates.keys()); cumulative_points = 0; chart_dates, chart_points, chart_tasks = [], [], []
-    for date_str in sorted_dates:
-        day_data = task_dates[date_str]; cumulative_points += day_data['points']; chart_dates.append(day_data['date']); chart_points.append(cumulative_points); chart_tasks.append("<br>".join(day_data['tasks']))
+    for date_str in sorted_dates: day_data = task_dates[date_str]; cumulative_points += day_data['points']; chart_dates.append(day_data['date']); chart_points.append(cumulative_points); chart_tasks.append("<br>".join(day_data['tasks']))
     if not chart_dates: fig = go.Figure(); fig.add_annotation(text="Error processing task data.", showarrow=False); fig.update_layout(title="Progress Points"); return fig
     df = pd.DataFrame({'Date': chart_dates, 'Points': chart_points, 'Tasks': chart_tasks})
     fig = px.line(df, x='Date', y='Points', markers=True, title="Progress Journey"); fig.update_traces(hovertemplate='%{x|%Y-%m-%d}<br>Points: %{y}<br>Tasks:<br>%{text}<extra></extra>', text=df['Tasks']); return fig
 
 def create_routine_completion_gauge(user_id):
     user_profile = get_user_profile(user_id); routines = user_profile.get('routine_history', [])
-    if not routines: fig = go.Figure(go.Indicator(mode="gauge", value=0, title={'text': "Active Routine"})); fig.add_annotation(text="No routine active. Create one?", showarrow=False); return fig
+    if not routines: fig = go.Figure(go.Indicator(mode="gauge", value=0, title={'text': "Active Routine"})); fig.add_annotation(text="No routine active.", showarrow=False); return fig
     latest = routines[0]; completion = latest.get('completion', 0); name = latest.get('routine', {}).get('name', 'Routine')
     fig = go.Figure(go.Indicator(mode="gauge+number", value=completion, domain={'x': [0, 1], 'y': [0, 1]}, title={'text': f"{name} (%)"}, gauge={'axis': {'range': [0, 100]}, 'bar': {'color': "cornflowerblue"}, 'bgcolor': "white", 'steps': [{'range': [0, 50], 'color': 'whitesmoke'}, {'range': [50, 80], 'color': 'lightgray'}], 'threshold': {'line': {'color': "green", 'width': 4}, 'thickness': 0.75, 'value': 90}})); return fig
 
 def create_skill_radar_chart(user_id):
     logger.info(f"Creating skill chart for {user_id}"); user_profile = get_user_profile(user_id); path = user_profile.get('resume_path')
-    if not path or not os.path.exists(path): logger.warning("No resume found for skill chart."); fig = go.Figure(); fig.add_annotation(text="Upload or Analyze Resume for Skill Chart", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
+    if not path or not os.path.exists(path): logger.warning("No resume found for skill chart."); fig = go.Figure(); fig.add_annotation(text="Upload Resume for Skill Chart", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
     try:
         with open(path, 'r', encoding='utf-8') as f: text = f.read()
-        skills_json_str = extract_and_rate_skills_from_resume(resume_text=text) # Returns JSON string
-        skills_data = json.loads(skills_json_str) # Parse JSON string
+        skills_json_str = extract_and_rate_skills_from_resume(resume_text=text); skills_data = json.loads(skills_json_str)
         if 'skills' in skills_data and skills_data['skills']:
             skills = skills_data['skills'][:8]; cats = [s['name'] for s in skills]; vals = [s['score'] for s in skills]
-            if len(cats) < 3: fig = go.Figure(); fig.add_annotation(text="Need at least 3 skills identified for radar chart.", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
+            if len(cats) < 3: fig = go.Figure(); fig.add_annotation(text="Need >= 3 skills for radar.", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
             if len(cats) > 2: cats.append(cats[0]); vals.append(vals[0])
             fig = go.Figure(); fig.add_trace(go.Scatterpolar(r=vals, theta=cats, fill='toself', name='Skills', hovertemplate='Skill: %{theta}<br>Score: %{r}<extra></extra>'))
             fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 10], showline=False, ticksuffix=' pts')), showlegend=False, title="Skill Assessment (from Resume)")
             logger.info(f"Created radar chart with {len(skills)} skills."); return fig
-        else: logger.warning("No skills extracted for chart."); fig = go.Figure(); fig.add_annotation(text="No skills extracted from resume yet.", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
+        else: logger.warning("No skills extracted."); fig = go.Figure(); fig.add_annotation(text="No skills extracted yet.", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
     except Exception as e: logger.exception(f"Error creating skill chart: {e}"); fig = go.Figure(); fig.add_annotation(text="Error analyzing skills.", showarrow=False); fig.update_layout(title="Identified Skills"); return fig
 
 
-# --- Gradio Interface Components (Mostly identical to v3, ensure compatibility) ---
+# --- Gradio Interface Components (Adapting Chat for Streaming) ---
 def create_interface():
-    """Create the Gradio interface for Aishura v4 (OpenAI)"""
+    """Create the Gradio interface for Aishura v5 (Groq Streaming)"""
     session_user_id = str(uuid.uuid4())
-    logger.info(f"Initializing Gradio interface v4 for session user ID: {session_user_id}")
+    logger.info(f"Initializing Gradio interface v5 for session user ID: {session_user_id}")
     get_user_profile(session_user_id) # Initialize profile
 
-    # --- Event Handlers (Adapted slightly if needed) ---
+    # --- Event Handlers ---
     def welcome(name, location, emotion, goal, industry, exp_level, work_style):
-        # (Logic identical to v3 welcome handler)
-        logger.info(f"Welcome v4: name='{name}', loc='{location}', emo='{emotion}', goal='{goal}', industry='{industry}', exp='{exp_level}', work='{work_style}'")
-        if not all([name, location, emotion, goal]): return ("Please fill in your Name, Location, Emotion, and Goal to get started!", gr.update(visible=True), gr.update(visible=False), gr.update(), gr.update(), gr.update(), gr.update(), gr.update())
+        # (Logic mostly identical to v4, but calls streaming AI function)
+        logger.info(f"Welcome v5: name='{name}', loc='{location}', emo='{emotion}', goal='{goal}', industry='{industry}', exp='{exp_level}', work='{work_style}'")
+        if not all([name, location, emotion, goal]): return ("Fill Name, Location, Emotion, Goal!", gr.update(visible=True), gr.update(visible=False), gr.update(), gr.update(), gr.update(), gr.update(), gr.update())
         cleaned_goal = goal.rsplit(" ", 1)[0] if goal[-1].isnumeric() == False and goal[-2] == " " else goal
         profile_updates = {"name": name, "location": location, "career_goal": cleaned_goal, "industry": industry, "experience_level": exp_level, "preferred_work_style": work_style}
-        update_user_profile(session_user_id, profile_updates)
-        add_emotion_record(session_user_id, emotion)
-        initial_input = f"Hi Aishura! I'm {name} from {location}. I'm focusing on '{cleaned_goal}' in the {industry} industry ({exp_level}, preferring {work_style} work). Right now, I'm feeling {emotion}. Can you help me get started?"
-        ai_response = get_ai_response(session_user_id, initial_input) # Calls the OpenAI version
-        # Convert DB history (OpenAI format) to Gradio format [[user, assistant], ...]
-        # For initial display, it's just the first exchange
-        initial_chat_display = [[initial_input, ai_response]]
-        e_fig, p_fig, r_fig, s_fig = create_emotion_chart(session_user_id), create_progress_chart(session_user_id), create_routine_completion_gauge(session_user_id), create_skill_radar_chart(session_user_id)
-        gen_recommendations_simple(session_user_id) # Generate initial recommendations
-        recs_md = display_recommendations(session_user_id)
-        return (gr.update(value=initial_chat_display), gr.update(visible=False), gr.update(visible=True), gr.update(value=e_fig), gr.update(value=p_fig), gr.update(value=r_fig), gr.update(value=s_fig), gr.update(value=recs_md))
+        update_user_profile(session_user_id, profile_updates); add_emotion_record(session_user_id, emotion)
+        initial_input = f"Hi Aishura! I'm {name} from {location}. Focusing on '{cleaned_goal}' in {industry} ({exp_level}, {work_style}). Feeling {emotion}. Help me start?"
 
-    def chat_submit(message_text, history_list_list):
-        # (Logic identical to v3 chat_submit handler)
-        logger.info(f"Chat submit v4 for {session_user_id}: '{message_text[:50]}...'")
-        if not message_text: yield history_list_list, gr.update() # No change if empty message
-        else:
-            history_list_list.append([message_text, None])
-            yield history_list_list, gr.update() # Update UI with user message, clear textbox handled by .then()
+        # Get the first response (streamed)
+        # For the welcome message, we might not need streaming complexity,
+        # but let's use the stream function for consistency and get the full message.
+        ai_response_full = ""
+        for chunk in get_ai_response_stream(session_user_id, initial_input):
+            ai_response_full += chunk
 
-            ai_response_text = get_ai_response(session_user_id, message_text) # Calls OpenAI version
-            history_list_list[-1][1] = ai_response_text # Update assistant response
+        initial_chat_display = [[initial_input, ai_response_full]]
+        e_fig, p_fig, r_fig, s_fig = create_emotion_chart(session_user_id), create_progress_chart(session_user_id), create_routine_completion_gauge(session_user_id), create_skill_radar_chart(session_user_id)
+        gen_recommendations_simple(session_user_id); recs_md = display_recommendations(session_user_id)
+        return (gr.update(value=initial_chat_display), gr.update(visible=False), gr.update(visible=True), gr.update(value=e_fig), gr.update(value=p_fig), gr.update(value=r_fig), gr.update(value=s_fig), gr.update(value=recs_md))
 
-            gen_recommendations_simple(session_user_id) # Generate recommendations
-            recs_md = display_recommendations(session_user_id)
+    def chat_submit_stream(message_text, history_list_list):
+        """Handles chatbot submission, yields streamed AI response chunks."""
+        logger.info(f"Chat submit stream v5 for {session_user_id}: '{message_text[:50]}...'")
+        if not message_text:
+            yield history_list_list, gr.update() # No change if empty message
+            return
+
+        # Append user message and placeholder for assistant response
+        history_list_list.append([message_text, ""])
+        yield history_list_list, gr.update() # Update UI immediately
+
+        # Stream AI response and update the placeholder chunk by chunk
+        full_response = ""
+        for chunk in get_ai_response_stream(session_user_id, message_text):
+            full_response += chunk
+            history_list_list[-1][1] = full_response # Update the last message in history
+            yield history_list_list, gr.update() # Yield updated history to Gradio
+
+        # After streaming finishes, generate recommendations
+        gen_recommendations_simple(session_user_id)
+        recs_md = display_recommendations(session_user_id)
 
-            yield history_list_list, gr.update(value=recs_md) # Update UI with assistant response and recommendations
+        # Yield final state with recommendations updated
+        yield history_list_list, gr.update(value=recs_md)
 
 
-    # --- Tool Interface Handlers (Call implementations directly) ---
+    # --- Tool Interface Handlers (Identical to v4) ---
     def generate_template_interface_handler(doc_type, career_field, experience):
-        logger.info(f"Manual Template UI v4: type='{doc_type}'")
+        logger.info(f"Manual Template UI v5: type='{doc_type}'")
         json_str = generate_document_template(doc_type, career_field, experience)
         try: return json.loads(json_str).get('template_markdown', "Error.")
         except: return "Error displaying template."
 
     def create_routine_interface_handler(emotion, goal, time_available, days):
-        logger.info(f"Manual Routine UI v4: emo='{emotion}', goal='{goal}'")
+        logger.info(f"Manual Routine UI v5: emo='{emotion}', goal='{goal}'")
         cleaned_emotion = emotion.split(" ")[0] if " " in emotion else emotion
         json_str = create_personalized_routine(cleaned_emotion, goal, int(time_available), int(days))
         try:
             data = json.loads(json_str)
             if "error" in data: return f"Error: {data['error']}", gr.update()
-            add_routine_to_user(session_user_id, data) # Save the dict structure
-            md = f"# {data.get('name', 'Your Routine')}\n\n"
-            md += f"_{data.get('support_message', data.get('description', ''))}_\n\n---\n\n"
+            add_routine_to_user(session_user_id, data)
+            md = f"# {data.get('name', 'Your Routine')}\n\n_{data.get('support_message', data.get('description', ''))}_\n\n---\n\n"
             for day in data.get('daily_tasks', []):
                 md += f"## Day {day.get('day', '?')}\n"; tasks = day.get('tasks', [])
                 if not tasks: md += "- Rest day or catch-up.\n"
@@ -919,89 +698,79 @@ def create_interface():
         except Exception as e: logger.exception("Error displaying routine"); return f"Error displaying routine: {e}", gr.update()
 
     def analyze_resume_interface_handler(resume_file):
-        # (Logic identical to v3, calls the updated tool function)
-        logger.info(f"Manual Resume Analysis UI v4: file={resume_file}")
-        if resume_file is None: return "Please upload a resume file.", gr.update(value=None), gr.update(value=None)
+        logger.info(f"Manual Resume Analysis UI v5: file={resume_file}")
+        if resume_file is None: return "Please upload resume.", gr.update(value=None), gr.update(value=None)
         try:
              with open(resume_file.name, 'r', encoding='utf-8') as f: resume_text = f.read()
-             logger.info(f"Read {len(resume_text)} characters from uploaded resume.")
-        except Exception as e: logger.error(f"Error reading uploaded resume file: {e}"); return f"Error reading file: {e}", gr.update(value=None), gr.update(value=None)
-        if not resume_text: return "Resume file seems empty.", gr.update(value=None), gr.update(value=None)
+        except Exception as e: logger.error(f"Error reading file: {e}"); return f"Error reading file: {e}", gr.update(value=None), gr.update(value=None)
+        if not resume_text: return "Resume empty.", gr.update(value=None), gr.update(value=None)
         profile = get_user_profile(session_user_id); goal = profile.get('career_goal', 'Not specified')
         resume_path = save_user_resume(session_user_id, resume_text)
-        if not resume_path: return "Could not save resume file.", gr.update(value=None), gr.update(value=None)
-        analysis_json_str = analyze_resume(resume_text, goal) # Returns JSON string
+        if not resume_path: return "Could not save resume.", gr.update(value=None), gr.update(value=None)
+        analysis_json_str = analyze_resume(resume_text, goal)
         try:
             analysis_result = json.loads(analysis_json_str); analysis = analysis_result.get('analysis', {})
-            md = f"## Resume Analysis (Simulated)\n\n**Analyzing for Goal:** '{goal}'\n\n"; md += "**Strengths Identified:**\n" + "\n".join([f"* {s}" for s in analysis.get('strengths', ["None identified."])]) + "\n\n"; md += "**Areas for Improvement:**\n" + "\n".join([f"* {s}" for s in analysis.get('areas_for_improvement', ["None identified."])]) + "\n\n"; md += f"**Format Feedback:** {analysis.get('format_feedback', 'N/A')}\n"; md += f"**Content Alignment:** {analysis.get('content_feedback', 'N/A')}\n"; md += f"**Suggested Keywords:** {', '.join(analysis.get('keyword_suggestions', ['N/A']))}\n\n"; md += "**Recommended Next Steps:**\n" + "\n".join([f"* {s}" for s in analysis.get('next_steps', ["Review suggestions."])])
+            md = f"## Resume Analysis (Simulated)\n\n**Goal:** '{goal}'\n\n**Strengths:**\n" + "\n".join([f"* {s}" for s in analysis.get('strengths', ["N/A"])]) + "\n\n**Improvements:**\n" + "\n".join([f"* {s}" for s in analysis.get('areas_for_improvement', ["N/A"])]) + f"\n\n**Format:** {analysis.get('format_feedback', 'N/A')}\n**Content:** {analysis.get('content_feedback', 'N/A')}\n**Keywords:** {', '.join(analysis.get('keyword_suggestions', []))}\n\n**Next Steps:**\n" + "\n".join([f"* {s}" for s in analysis.get('next_steps', [])])
             skill_fig = create_skill_radar_chart(session_user_id)
             return md, gr.update(value=skill_fig), gr.update(value=resume_path)
-        except Exception as e: logger.exception("Error formatting resume analysis results."); return "Error displaying analysis results.", gr.update(value=None), gr.update(value=None)
-
+        except Exception as e: logger.exception("Error formatting analysis."); return "Error displaying analysis.", gr.update(value=None), gr.update(value=None)
 
     def analyze_portfolio_interface_handler(portfolio_url, portfolio_description):
-        # (Logic identical to v3, calls the updated tool function)
-        logger.info(f"Manual Portfolio Analysis UI v4: url='{portfolio_url}'")
-        if not portfolio_description: return "Please provide a description of your portfolio."
+        logger.info(f"Manual Portfolio Analysis UI v5: url='{portfolio_url}'")
+        if not portfolio_description: return "Provide description."
         profile = get_user_profile(session_user_id); goal = profile.get('career_goal', 'Not specified')
         portfolio_path = save_user_portfolio(session_user_id, portfolio_url, portfolio_description)
-        if not portfolio_path: return "Could not save portfolio details."
-        analysis_json_str = analyze_portfolio(portfolio_description, goal, portfolio_url) # Returns JSON string
+        if not portfolio_path: return "Could not save details."
+        analysis_json_str = analyze_portfolio(portfolio_description, goal, portfolio_url)
         try:
             analysis_result = json.loads(analysis_json_str); analysis = analysis_result.get('analysis', {})
-            md = f"## Portfolio Analysis (Simulated)\n\n**Analyzing for Goal:** '{goal}'\n"; md += f"**URL:** {portfolio_url}\n\n" if portfolio_url else "\n"; md += f"**Alignment with Goal:** {analysis.get('alignment_with_goal', 'N/A')}\n\n"; md += "**Strengths Based on Description:**\n" + "\n".join([f"* {s}" for s in analysis.get('strengths', ["N/A"])]) + "\n\n"; md += "**Areas for Improvement:**\n" + "\n".join([f"* {s}" for s in analysis.get('areas_for_improvement', ["N/A"])]) + "\n\n"; md += f"**Presentation Feedback:** {analysis.get('presentation_feedback', 'N/A')}\n\n"; md += "**Recommended Next Steps:**\n" + "\n".join([f"* {s}" for s in analysis.get('next_steps', ["Review suggestions."])])
+            md = f"## Portfolio Analysis (Simulated)\n\n**Goal:** '{goal}'\n"; md += f"**URL:** {portfolio_url}\n\n" if portfolio_url else "\n"; md += f"**Alignment:** {analysis.get('alignment_with_goal', 'N/A')}\n\n**Strengths:**\n" + "\n".join([f"* {s}" for s in analysis.get('strengths', [])]) + "\n\n**Improvements:**\n" + "\n".join([f"* {s}" for s in analysis.get('areas_for_improvement', [])]) + f"\n\n**Presentation:** {analysis.get('presentation_feedback', 'N/A')}\n\n**Next Steps:**\n" + "\n".join([f"* {s}" for s in analysis.get('next_steps', [])])
             return md
-        except Exception as e: logger.exception("Error formatting portfolio analysis results."); return "Error displaying analysis results."
+        except Exception as e: logger.exception("Error formatting analysis."); return "Error displaying analysis."
 
-    # --- Progress Tracking Handlers (Identical to v3) ---
+    # --- Progress Tracking Handlers (Identical to v4) ---
     def complete_task_handler(task_name):
-        logger.info(f"Complete Task UI v4 for {session_user_id}: task='{task_name}'")
-        if not task_name: return ("Please enter the task you completed.", "", gr.update(), gr.update(), gr.update())
+        logger.info(f"Complete Task UI v5: task='{task_name}'")
+        if not task_name: return ("Enter task name.", "", gr.update(), gr.update(), gr.update())
         updated_profile = add_task_to_user(session_user_id, task_name)
         if updated_profile and updated_profile.get('routine_history'):
             db = load_user_database(); profile = db.get('users', {}).get(session_user_id)
-            if profile and profile.get('routine_history'):
-                 latest_routine = profile['routine_history'][0]; increment = random.randint(5, 15)
-                 latest_routine['completion'] = min(100, latest_routine.get('completion', 0) + increment); save_user_database(db)
+            if profile and profile.get('routine_history'): latest_routine = profile['routine_history'][0]; increment = random.randint(5, 15); latest_routine['completion'] = min(100, latest_routine.get('completion', 0) + increment); save_user_database(db)
         e_fig, p_fig, g_fig = create_emotion_chart(session_user_id), create_progress_chart(session_user_id), create_routine_completion_gauge(session_user_id)
-        return (f"Awesome job completing '{task_name}'! Keep up the great work!", "", gr.update(value=e_fig), gr.update(value=p_fig), gr.update(value=g_fig))
+        return (f"Great job on '{task_name}'!", "", gr.update(value=e_fig), gr.update(value=p_fig), gr.update(value=g_fig))
 
     def update_emotion_handler(emotion):
-        logger.info(f"Update Emotion UI v4 for {session_user_id}: emotion='{emotion}'")
-        if not emotion: return "Please select how you're feeling.", gr.update()
-        add_emotion_record(session_user_id, emotion)
-        e_fig = create_emotion_chart(session_user_id)
+        logger.info(f"Update Emotion UI v5: emotion='{emotion}'")
+        if not emotion: return "Select emotion.", gr.update()
+        add_emotion_record(session_user_id, emotion); e_fig = create_emotion_chart(session_user_id)
         cleaned_display = emotion.split(" ")[0] if " " in emotion else emotion
-        return f"Got it. Acknowledging how you feel ({cleaned_display}) is a great step.", gr.update(value=e_fig)
+        return f"Got it. Feeling ({cleaned_display}) acknowledged.", gr.update(value=e_fig)
 
     def display_recommendations(current_user_id):
-        # (Identical to v3)
-        logger.info(f"Displaying recommendations v4 for {current_user_id}")
+        # (Identical to v4)
+        logger.info(f"Displaying recommendations v5 for {current_user_id}")
         profile = get_user_profile(current_user_id); recs = profile.get('recommendations', [])
-        if not recs: return "Chat with me about your goals and challenges, and I can suggest some next steps! 😊"
+        if not recs: return "Chat with me for next steps! 😊"
         pending_recs = [r for r in recs if r.get('status') == 'pending'][:5]
-        if not pending_recs: return "No pending recommendations right now. Great job, or let's chat to find new ones!"
-        md = "### ✨ Here are a few things we could focus on:\n\n"
-        for i, entry in enumerate(pending_recs, 1):
-            rec = entry.get('recommendation', {})
-            md += f"**{i}. {rec.get('title', 'Recommendation')}**\n"; md += f"   - {rec.get('description', 'No description.')}\n"; md += f"   - *Priority: {rec.get('priority', 'Medium')} | Type: {rec.get('action_type', 'General')}*\n---\n"
+        if not pending_recs: return "No pending recommendations. Nice!"
+        md = "### ✨ Focus Areas:\n\n"
+        for i, entry in enumerate(pending_recs, 1): rec = entry.get('recommendation', {}); md += f"**{i}. {rec.get('title', 'Rec')}**\n   - {rec.get('description', '')}\n   - *Pri: {rec.get('priority', 'Med')} | Type: {rec.get('action_type', 'Gen')}*\n---\n"
         return md
 
-    # --- Build Gradio Interface (Structure identical to v3) ---
-    with gr.Blocks(theme=gr.themes.Soft(primary_hue="sky", secondary_hue="blue", font=[gr.themes.GoogleFont("Poppins"), "Arial", "sans-serif"]), title="Aishura v4 (OpenAI)") as app:
+    # --- Build Gradio Interface (Structure identical to v4) ---
+    with gr.Blocks(theme=gr.themes.Soft(primary_hue="sky", secondary_hue="blue", font=[gr.themes.GoogleFont("Poppins"), "Arial", "sans-serif"]), title="Aishura v5 (Groq)") as app:
         gr.Markdown("# Aishura - Your Empathetic AI Career Copilot 🚀")
-        gr.Markdown("_Powered by OpenAI GPT-4o & Real-Time Data_") # Updated subtitle
+        gr.Markdown("_Powered by Groq Llama 3.1 & Real-Time Data_") # Updated subtitle
 
-        # Welcome Screen (Identical structure)
+        # Welcome Screen
         with gr.Group(visible=True) as welcome_group:
-            gr.Markdown("## Welcome! Let's personalize your journey.")
-            gr.Markdown("Tell me a bit about yourself so I can help you better.")
+            gr.Markdown("## Welcome! Let's personalize your journey."); gr.Markdown("Tell me about yourself.")
             with gr.Row():
-                with gr.Column(): name_input = gr.Textbox(label="What's your first name?"); location_input = gr.Textbox(label="Where are you located (City, Country)?", placeholder="e.g., London, UK"); industry_input = gr.Textbox(label="What's your primary industry or field?", placeholder="e.g., Technology, Healthcare, Finance")
-                with gr.Column(): emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="How are you feeling right now?"); goal_dropdown = gr.Dropdown(choices=GOAL_TYPES, label="What's your main career goal currently?"); exp_level_dropdown = gr.Dropdown(choices=["Student", "Entry-Level (0-2 yrs)", "Mid-Level (3-7 yrs)", "Senior-Level (8+ yrs)", "Executive"], label="What's your experience level?"); work_style_dropdown = gr.Dropdown(choices=["On-site", "Hybrid", "Remote", "Any"], label="Preferred work style?", value="Any")
-            welcome_button = gr.Button("✨ Start My Journey with Aishura ✨", variant="primary"); welcome_output = gr.Markdown()
+                with gr.Column(): name_input = gr.Textbox(label="First name?"); location_input = gr.Textbox(label="Location (City, Country)?", placeholder="e.g., Jeddah, SA"); industry_input = gr.Textbox(label="Primary industry?", placeholder="e.g., Tech, Healthcare")
+                with gr.Column(): emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="How are you feeling?"); goal_dropdown = gr.Dropdown(choices=GOAL_TYPES, label="Main career goal?"); exp_level_dropdown = gr.Dropdown(choices=["Student", "Entry-Level (0-2 yrs)", "Mid-Level (3-7 yrs)", "Senior-Level (8+ yrs)", "Executive"], label="Experience level?"); work_style_dropdown = gr.Dropdown(choices=["On-site", "Hybrid", "Remote", "Any"], label="Preferred work style?", value="Any")
+            welcome_button = gr.Button("✨ Start My Journey ✨", variant="primary"); welcome_output = gr.Markdown()
 
-        # Main Interface (Identical structure)
+        # Main Interface
         with gr.Group(visible=False) as main_interface:
             with gr.Tabs():
                 # Chat Tab
@@ -1011,50 +780,55 @@ def create_interface():
                              chatbot_display = gr.Chatbot(label="Aishura", height=600, show_copy_button=True, bubble_full_width=False, avatar_images=(None, "https://img.icons8.com/external-those-icons-lineal-color-those-icons/96/external-AI-artificial-intelligence-those-icons-lineal-color-those-icons-9.png"))
                              msg_textbox = gr.Textbox(show_label=False, placeholder="Type your message here...", container=False, scale=1)
                         with gr.Column(scale=1):
-                            gr.Markdown("### Recommendations"); recommendation_output = gr.Markdown("Loading recommendations...")
+                            gr.Markdown("### Recommendations"); recommendation_output = gr.Markdown("Loading...")
                             refresh_recs_button = gr.Button("🔄 Refresh Recs"); gr.Markdown("---"); gr.Markdown("### Quick Actions")
 
                 # Analysis & Tools Tab
                 with gr.TabItem("🛠️ Analyze & Tools"):
                      with gr.Tabs():
                         with gr.TabItem("📄 Resume Hub"):
-                            gr.Markdown("### Analyze Your Resume"); gr.Markdown("Upload your resume (TXT or PDF - text readable) for analysis and skill identification.")
-                            resume_file_input = gr.File(label="Upload Resume (.txt, .pdf)", file_types=['.txt', '.pdf'])
-                            resume_path_display = gr.Textbox(label="Current Resume File", interactive=False)
-                            analyze_resume_button = gr.Button("Analyze Uploaded Resume", variant="primary")
-                            resume_analysis_output = gr.Markdown("Analysis will appear here...")
-                            gr.Markdown("---"); gr.Markdown("### Generate Document Templates")
-                            doc_type_dropdown = gr.Dropdown(choices=["Resume", "Cover Letter", "LinkedIn Summary", "Networking Email"], label="Document Type"); doc_field_input = gr.Textbox(label="Target Career Field (Optional)", placeholder="e.g., Software Engineering"); doc_exp_dropdown = gr.Dropdown(choices=["Student", "Entry-Level", "Mid-Level", "Senior-Level"], label="Experience Level")
-                            generate_template_button = gr.Button("Generate Template"); template_output_md = gr.Markdown("Template will appear here...")
+                            gr.Markdown("### Analyze Resume"); gr.Markdown("Upload resume (TXT/PDF) for analysis.")
+                            resume_file_input = gr.File(label="Upload Resume (.txt, .pdf)", file_types=['.txt', '.pdf']); resume_path_display = gr.Textbox(label="Current Resume File", interactive=False)
+                            analyze_resume_button = gr.Button("Analyze Uploaded Resume", variant="primary"); resume_analysis_output = gr.Markdown("Analysis...")
+                            gr.Markdown("---"); gr.Markdown("### Generate Templates")
+                            doc_type_dropdown = gr.Dropdown(choices=["Resume", "Cover Letter", "LinkedIn Summary", "Networking Email"], label="Doc Type"); doc_field_input = gr.Textbox(label="Field?", placeholder="e.g., SWE"); doc_exp_dropdown = gr.Dropdown(choices=["Student", "Entry-Level", "Mid-Level", "Senior-Level"], label="Level?")
+                            generate_template_button = gr.Button("Generate Template"); template_output_md = gr.Markdown("Template...")
                         with gr.TabItem("🎨 Portfolio Hub"):
-                            gr.Markdown("### Analyze Your Portfolio")
-                            portfolio_url_input = gr.Textbox(label="Portfolio URL (Optional)", placeholder="https://yourportfolio.com"); portfolio_desc_input = gr.Textbox(label="Describe your portfolio's content and purpose", lines=5, placeholder="e.g., Collection of web development projects...")
-                            analyze_portfolio_button = gr.Button("Analyze Portfolio Info", variant="primary"); portfolio_analysis_output = gr.Markdown("Analysis will appear here...")
+                            gr.Markdown("### Analyze Portfolio")
+                            portfolio_url_input = gr.Textbox(label="URL?", placeholder="https://yourportfolio.com"); portfolio_desc_input = gr.Textbox(label="Description?", lines=5, placeholder="e.g., Web dev projects...")
+                            analyze_portfolio_button = gr.Button("Analyze Portfolio Info", variant="primary"); portfolio_analysis_output = gr.Markdown("Analysis...")
                         with gr.TabItem("📅 Routine Builder"):
-                            gr.Markdown("### Create a Personalized Routine"); gr.Markdown("Feeling stuck? Let's build a manageable routine.")
-                            routine_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="How are you feeling?"); profile = get_user_profile(session_user_id); routine_goal_input = gr.Textbox(label="Main Goal for this Routine", value=profile.get('career_goal', ''))
-                            routine_time_slider = gr.Slider(15, 120, 45, step=15, label="Minutes you can dedicate per day"); routine_days_slider = gr.Slider(3, 21, 7, step=1, label="Length of routine (days)")
-                            create_routine_button = gr.Button("Create My Routine", variant="primary"); routine_output_md = gr.Markdown("Your personalized routine will appear here...")
+                            gr.Markdown("### Create Routine"); gr.Markdown("Build a manageable routine.")
+                            routine_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="Feeling?"); profile = get_user_profile(session_user_id); routine_goal_input = gr.Textbox(label="Goal?", value=profile.get('career_goal', ''))
+                            routine_time_slider = gr.Slider(15, 120, 45, step=15, label="Mins/day?"); routine_days_slider = gr.Slider(3, 21, 7, step=1, label="Days?")
+                            create_routine_button = gr.Button("Create Routine", variant="primary"); routine_output_md = gr.Markdown("Routine...")
 
                 # Progress Tab
                 with gr.TabItem("📈 Track Your Journey"):
-                    gr.Markdown("## Your Progress Dashboard")
+                    gr.Markdown("## Progress Dashboard")
                     with gr.Row():
                         with gr.Column(scale=1):
-                            gr.Markdown("### ✅ Log Completed Task"); task_input = gr.Textbox(label="What did you accomplish?", placeholder="e.g., Updated resume, Applied for job X...")
+                            gr.Markdown("### ✅ Log Task"); task_input = gr.Textbox(label="Accomplishment?", placeholder="e.g., Updated resume")
                             complete_button = gr.Button("Log Task", variant="primary"); task_output = gr.Markdown()
-                            gr.Markdown("---"); gr.Markdown("### 😊 How are you feeling now?")
-                            new_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="Select current emotion"); emotion_button = gr.Button("Update Emotion"); emotion_output = gr.Markdown()
+                            gr.Markdown("---"); gr.Markdown("### 😊 Feeling now?")
+                            new_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="Select emotion"); emotion_button = gr.Button("Update Emotion"); emotion_output = gr.Markdown()
                         with gr.Column(scale=2):
                             gr.Markdown("### Emotional Journey"); emotion_chart_output = gr.Plot(label="Emotion Trend")
-                            gr.Markdown("### Active Routine Progress"); routine_gauge_output = gr.Plot(label="Routine Completion")
+                            gr.Markdown("### Routine Progress"); routine_gauge_output = gr.Plot(label="Routine Completion")
                     with gr.Row():
-                         with gr.Column(scale=1): gr.Markdown("### Progress Points"); progress_chart_output = gr.Plot(label="Progress Points Over Time")
-                         with gr.Column(scale=1): gr.Markdown("### Skills Assessment (from Resume)"); skill_radar_chart_output = gr.Plot(label="Skills Radar")
+                         with gr.Column(scale=1): gr.Markdown("### Progress Points"); progress_chart_output = gr.Plot(label="Points Over Time")
+                         with gr.Column(scale=1): gr.Markdown("### Skills (from Resume)"); skill_radar_chart_output = gr.Plot(label="Skills Radar")
 
-        # --- Event Wiring (Identical logic, calls updated functions) ---
+        # --- Event Wiring (Using streaming chat submit) ---
         welcome_button.click(fn=welcome, inputs=[name_input, location_input, emotion_dropdown, goal_dropdown, industry_input, exp_level_dropdown, work_style_dropdown], outputs=[chatbot_display, welcome_group, main_interface, emotion_chart_output, progress_chart_output, routine_gauge_output, skill_radar_chart_output, recommendation_output])
-        msg_textbox.submit(fn=chat_submit, inputs=[msg_textbox, chatbot_display], outputs=[chatbot_display, recommendation_output]).then(lambda: gr.update(value=""), outputs=[msg_textbox])
+
+        # Use the streaming chat submit function
+        msg_textbox.submit(
+            fn=chat_submit_stream, # Use the streaming version
+            inputs=[msg_textbox, chatbot_display],
+            outputs=[chatbot_display, recommendation_output] # chatbot updates progressively, recs at end
+        ).then(lambda: gr.update(value=""), outputs=[msg_textbox]) # Clear textbox after submit
+
         refresh_recs_button.click(fn=lambda: display_recommendations(session_user_id), outputs=[recommendation_output])
         analyze_resume_button.click(fn=analyze_resume_interface_handler, inputs=[resume_file_input], outputs=[resume_analysis_output, skill_radar_chart_output, resume_path_display])
         analyze_portfolio_button.click(fn=analyze_portfolio_interface_handler, inputs=[portfolio_url_input, portfolio_desc_input], outputs=[portfolio_analysis_output])
@@ -1067,16 +841,17 @@ def create_interface():
 
 # --- Main Execution ---
 if __name__ == "__main__":
-    print("\n--- Aishura v4 (OpenAI) Configuration Check ---")
-    if not OPENAI_API_KEY: print("⚠️ WARNING: OPENAI_API_KEY not found. AI features DISABLED.")
-    else: print("✅ OPENAI_API_KEY found.")
+    print("\n--- Aishura v5 (Groq Streaming) Configuration Check ---")
+    if not GROQ_API_KEY: print("⚠️ WARNING: GROQ_API_KEY not found. AI features DISABLED.")
+    else: print("✅ GROQ_API_KEY found.")
     if not SERPER_API_KEY: print("⚠️ WARNING: SERPER_API_KEY not found. Live web search DISABLED.")
     else: print("✅ SERPER_API_KEY found.")
-    if not client: print("❌ ERROR: OpenAI client failed to initialize. AI features DISABLED.")
-    else: print(f"✅ OpenAI client initialized for model '{MODEL_ID}'.")
-    print("-------------------------------------------\n")
+    if not client: print("❌ ERROR: Groq client failed to initialize. AI features DISABLED.")
+    else: print(f"✅ Groq client initialized for model '{MODEL_ID}'.")
+    print("---------------------------------------------------\n")
 
-    logger.info("Starting Aishura v4 (OpenAI) Gradio application...")
+    logger.info("Starting Aishura v5 (Groq Streaming) Gradio application...")
     aishura_app = create_interface()
     aishura_app.launch(share=False, debug=False)
     logger.info("Aishura Gradio application stopped.")
+