diff --git "a/app.py" "b/app.py"
--- "a/app.py"
+++ "b/app.py"
@@ -1,4 +1,4 @@
-# filename: app_openai_corrected_v2.py
+# filename: app_gemini_serper_v3.py
import gradio as gr
import pandas as pd
import numpy as np
@@ -9,13 +9,16 @@ import random
import json
import os
import time
-import requests # Keep for potential future internal API calls
+import requests # For Serper API
from typing import List, Dict, Any, Optional
import logging
from dotenv import load_dotenv
import uuid
import re
-import openai
+
+# --- Google AI Integration ---
+import google.generativeai as genai
+from google.api_core import exceptions as google_exceptions
# --- Load environment variables ---
load_dotenv()
@@ -23,99 +26,197 @@ load_dotenv()
# --- Set up logging ---
logging.basicConfig(level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-logger = logging.getLogger(__name__)
+logger = logging.getLogger(__name__) # Use __name__ for logger
# --- Configure API keys ---
-OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-if not OPENAI_API_KEY:
- logger.warning("OPENAI_API_KEY not found. AI features will not work.")
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+SERPER_API_KEY = os.getenv("SERPER_API_KEY")
+
+if not GOOGLE_API_KEY:
+ logger.warning("GOOGLE_API_KEY not found. AI features will not work.")
+if not SERPER_API_KEY:
+ logger.warning("SERPER_API_KEY not found. Live web search features will not work.")
-# --- Initialize the OpenAI client ---
+# --- Initialize the Google AI client ---
try:
- client = openai.OpenAI(api_key=OPENAI_API_KEY)
- logger.info("OpenAI client initialized successfully.")
+ genai.configure(api_key=GOOGLE_API_KEY)
+ logger.info("Google AI client configured successfully.")
except Exception as e:
- logger.error(f"Failed to initialize OpenAI client: {e}")
- client = None
+ logger.error(f"Failed to configure Google AI client: {e}")
+ genai = None # Prevent further calls if config fails
# --- Model configuration ---
-MODEL_ID = "gpt-4o"
+# Using gemini-1.5-flash-latest as the state-of-the-art, fast model
+MODEL_ID = "gemini-1.5-flash-latest"
+if genai:
+ try:
+ gemini_model = genai.GenerativeModel(
+ MODEL_ID,
+ # System instruction is now passed during generation, not model init
+ # safety_settings adjusted for potentially sensitive career/emotion talk
+ safety_settings=[
+ {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+ {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+ {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_ONLY_HIGH"},
+ {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_MEDIUM_AND_ABOVE"},
+ ]
+ )
+ logger.info(f"Google AI Model '{MODEL_ID}' initialized.")
+ except Exception as e:
+ logger.error(f"Failed to initialize Google AI Model '{MODEL_ID}': {e}")
+ gemini_model = None
+else:
+ gemini_model = None
# --- Constants ---
-EMOTIONS = ["Unmotivated 😩", "Anxious 😥", "Confused 🤔", "Excited 🎉", "Overwhelmed 🤯", "Discouraged 😔"]
+# Enhanced emotions and goals for richer profile
+EMOTIONS = ["Unmotivated 😩", "Anxious 😥", "Confused 🤔", "Excited 🎉", "Overwhelmed 🤯", "Discouraged 😔", "Hopeful ✨", "Focused 😎", "Stuck 🧱"]
GOAL_TYPES = [
- "Get a job at a big company 🏢", "Find an internship 🎓", "Change careers 🚀",
- "Improve skills 💡", "Network better 🤝"
+ "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.json"
-RESUME_FOLDER = "user_resumes"
-PORTFOLIO_FOLDER = "user_portfolios"
+USER_DB_PATH = "user_database_v3.json" # New DB file for new structure
+RESUME_FOLDER = "user_resumes_v3"
+PORTFOLIO_FOLDER = "user_portfolios_v3"
os.makedirs(RESUME_FOLDER, exist_ok=True)
os.makedirs(PORTFOLIO_FOLDER, exist_ok=True)
-# --- Tool Definitions for OpenAI ---
-tools_list = [
- {
- "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"}, "career_field": {"type": "string"}, "experience_level": {"type": "string"} }, "required": ["document_type"] },
- }
- },
- {
- "type": "function",
- "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"}, "goal": {"type": "string"}, "available_time_minutes": {"type": "integer"}, "routine_length_days": {"type": "integer"} }, "required": ["emotion", "goal"] },
- }
- },
- {
- "type": "function",
- "function": {
- "name": "analyze_resume",
- "description": "Analyze the provided resume text and provide feedback, comparing it against the user's stated career goal.",
- "parameters": { "type": "object", "properties": { "resume_text": {"type": "string"}, "career_goal": {"type": "string"} }, "required": ["resume_text", "career_goal"] },
- }
- },
- {
- "type": "function",
- "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"}, "portfolio_description": {"type": "string"}, "career_goal": {"type": "string"} }, "required": ["portfolio_description", "career_goal"] },
- }
- },
- {
- "type": "function",
- "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.",
- "parameters": { "type": "object", "properties": { "resume_text": {"type": "string"}, "max_skills": {"type": "integer"} }, "required": ["resume_text"] },
- }
- }
+# --- Tool Definitions for Google AI (Gemini) ---
+# Note: Schema is slightly different from OpenAI's
+
+# 1. Document Template Generator
+generate_document_template_func = genai.protos.FunctionDeclaration(
+ name="generate_document_template",
+ description="Generate a document template (like a resume or cover letter) based on type, career field, and experience level.",
+ parameters=genai.protos.Schema(
+ type=genai.protos.Type.OBJECT,
+ properties={
+ "document_type": genai.protos.Schema(type=genai.protos.Type.STRING, description="e.g., Resume, Cover Letter, LinkedIn Summary"),
+ "career_field": genai.protos.Schema(type=genai.protos.Type.STRING, description="Target industry or field"),
+ "experience_level": genai.protos.Schema(type=genai.protos.Type.STRING, description="e.g., Entry, Mid, Senior, Student")
+ },
+ required=["document_type"]
+ )
+)
+
+# 2. Personalized Routine Creator
+create_personalized_routine_func = genai.protos.FunctionDeclaration(
+ 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=genai.protos.Schema(
+ type=genai.protos.Type.OBJECT,
+ properties={
+ "emotion": genai.protos.Schema(type=genai.protos.Type.STRING, description="User's current primary emotion"),
+ "goal": genai.protos.Schema(type=genai.protos.Type.STRING, description="User's primary career goal"),
+ "available_time_minutes": genai.protos.Schema(type=genai.protos.Type.INTEGER, description="Average minutes per day user can dedicate"),
+ "routine_length_days": genai.protos.Schema(type=genai.protos.Type.INTEGER, description="Desired length of the routine in days (e.g., 7 for weekly)")
+ },
+ required=["emotion", "goal"]
+ )
+)
+
+# 3. Resume Analyzer
+analyze_resume_func = genai.protos.FunctionDeclaration(
+ 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=genai.protos.Schema(
+ type=genai.protos.Type.OBJECT,
+ properties={
+ "resume_text": genai.protos.Schema(type=genai.protos.Type.STRING, description="The full text content of the user's resume"),
+ "career_goal": genai.protos.Schema(type=genai.protos.Type.STRING, description="The specific career goal to analyze against")
+ },
+ required=["resume_text", "career_goal"]
+ )
+)
+
+# 4. Portfolio Analyzer
+analyze_portfolio_func = genai.protos.FunctionDeclaration(
+ 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=genai.protos.Schema(
+ type=genai.protos.Type.OBJECT,
+ properties={
+ "portfolio_url": genai.protos.Schema(type=genai.protos.Type.STRING, description="URL link to the online portfolio (optional)"),
+ "portfolio_description": genai.protos.Schema(type=genai.protos.Type.STRING, description="User's description of the portfolio content and purpose"),
+ "career_goal": genai.protos.Schema(type=genai.protos.Type.STRING, description="The specific career goal to analyze against")
+ },
+ required=["portfolio_description", "career_goal"]
+ )
+)
+
+# 5. Skill Extractor & Rater (from Resume)
+extract_and_rate_skills_from_resume_func = genai.protos.FunctionDeclaration(
+ 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=genai.protos.Schema(
+ type=genai.protos.Type.OBJECT,
+ properties={
+ "resume_text": genai.protos.Schema(type=genai.protos.Type.STRING, description="The full text content of the user's resume"),
+ "max_skills": genai.protos.Schema(type=genai.protos.Type.INTEGER, description="Maximum number of skills to extract (default 8)")
+ },
+ required=["resume_text"]
+ )
+)
+
+# 6. NEW: Live Web Search for Opportunities (Serper API)
+search_web_serper_func = genai.protos.FunctionDeclaration(
+ name="search_jobs_courses_skills",
+ description="Search the web for relevant job openings, online courses, or skills development resources based on the user's goals, location, and potentially identified skill gaps.",
+ parameters=genai.protos.Schema(
+ type=genai.protos.Type.OBJECT,
+ properties={
+ "search_query": genai.protos.Schema(type=genai.protos.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": genai.protos.Schema(type=genai.protos.Type.STRING, description="Type of search: 'jobs', 'courses', 'skills', or 'general'"),
+ "location": genai.protos.Schema(type=genai.protos.Type.STRING, description="Geographical location for the search (if applicable, e.g., 'London, UK')")
+ },
+ required=["search_query", "search_type"]
+ )
+)
+
+
+# Combine all tool function declarations for the API call
+tools_list_gemini = [
+ generate_document_template_func,
+ create_personalized_routine_func,
+ analyze_resume_func,
+ analyze_portfolio_func,
+ extract_and_rate_skills_from_resume_func,
+ search_web_serper_func
]
-# --- User Database Functions ---
+# --- User Database Functions (Enhanced Profile) ---
def load_user_database():
try:
with open(USER_DB_PATH, 'r', encoding='utf-8') as file: db = json.load(file)
+ # Basic validation and migration for chat history (similar to previous)
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'] = []
else:
- fixed_history = []
- for msg in profile['chat_history']:
- if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
- if msg['role'] in ['user', 'assistant'] and msg['content'] is not None and not isinstance(msg['content'], str): msg['content'] = str(msg['content'])
- fixed_history.append(msg)
- elif isinstance(msg, dict) and msg.get('role') == 'tool' and all(k in msg for k in ['tool_call_id', 'name', 'content']):
- if not isinstance(msg['content'], str): msg['content'] = json.dumps(msg['content']) if msg['content'] is not None else ""
- fixed_history.append(msg)
- else: logger.warning(f"Skipping invalid chat message structure for user {user_id}: {msg}")
- profile['chat_history'] = fixed_history
- if 'recommendations' not in profile or not isinstance(profile['recommendations'], list): profile['recommendations'] = []
+ # Gemini uses 'parts' not 'content', and roles 'user'/'model'
+ fixed_history = []
+ for msg in profile['chat_history']:
+ if isinstance(msg, dict) and 'role' in msg and 'parts' in msg:
+ # Basic check, can be more robust
+ if msg['role'] in ['user', 'model'] and isinstance(msg['parts'], list):
+ fixed_history.append(msg)
+ elif isinstance(msg, dict) and 'role' == 'function': # Gemini uses role 'function' for tool responses
+ # Ensure it has necessary fields (name, response)
+ if 'name' in msg and 'response' in msg:
+ fixed_history.append(msg)
+ profile['chat_history'] = fixed_history
+
+ # Ensure other lists exist
+ 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] = []
+ # Ensure basic string fields exist
+ 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 'progress_points' not in profile: profile['progress_points'] = 0
+ if 'experience_level' not in profile: profile['experience_level'] = "Not specified" # Add experience level
+
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': {}}
@@ -129,46 +230,86 @@ def get_user_profile(user_id):
db = load_user_database()
if user_id not in db.get('users', {}):
db['users'] = db.get('users', {})
- db['users'][user_id] = { "user_id": user_id, "name": "", "location": "", "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() }
+ # Initialize enhanced profile structure
+ db['users'][user_id] = {
+ "user_id": user_id,
+ "name": "",
+ "location": "",
+ "industry": "", # NEW: Target industry
+ "experience_level": "Not specified", # NEW: e.g., Entry, Mid, Senior
+ "preferred_work_style": "Any", # NEW: Remote, Hybrid, On-site, Any
+ "values": [], # NEW: List of values (e.g., "work-life balance", "impact", "learning")
+ "strengths": [], # NEW: User-identified or AI-suggested strengths
+ "areas_for_development": [], # NEW: User-identified or AI-suggested areas
+ "long_term_aspirations": "", # NEW: Goals beyond the immediate one
+
+ "current_emotion": "",
+ "career_goal": "",
+ "progress_points": 0,
+ "completed_tasks": [],
+ "upcoming_events": [], # Consider adding events scheduling later
+ "routine_history": [],
+ "daily_emotions": [],
+ "resume_path": "",
+ "portfolio_path": "",
+ "recommendations": [],
+ "chat_history": [], # Stores history in Gemini format {role: 'user'/'model', parts: [{'text': '...'}]} or {role: 'function', name:'...', response:{...}}
+ "joined_date": datetime.now().isoformat()
+ }
save_user_database(db)
+
+ # Ensure lists and basic fields exist on subsequent loads (handled mostly in load_user_database)
profile = db.get('users', {}).get(user_id, {})
- if 'chat_history' not in profile or not isinstance(profile.get('chat_history'), list): profile['chat_history'] = []
- if 'recommendations' not in profile or not isinstance(profile.get('recommendations'), list): profile['recommendations'] = []
- if 'daily_emotions' not in profile or not isinstance(profile.get('daily_emotions'), list): profile['daily_emotions'] = []
- if 'completed_tasks' not in profile or not isinstance(profile.get('completed_tasks'), list): profile['completed_tasks'] = []
- if 'routine_history' not in profile or not isinstance(profile.get('routine_history'), list): profile['routine_history'] = []
+ # Add simple check for chat history format upon retrieval
+ if 'chat_history' not in profile or not isinstance(profile.get('chat_history'), list):
+ profile['chat_history'] = []
+ # Ensure other critical lists exist
+ 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 (largely similar, adjust chat message structure) ---
def update_user_profile(user_id, updates):
+ # (Keep existing logic, ensure keys match new profile)
db = load_user_database()
if user_id in db.get('users', {}):
profile = db['users'][user_id]
- 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
+ for key, value in updates.items():
+ # Maybe add some validation here later if needed
+ 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):
+ # (Keep existing logic)
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() }
profile['completed_tasks'].append(task_with_date)
- profile['progress_points'] = profile.get('progress_points', 0) + random.randint(10, 25)
+ profile['progress_points'] = profile.get('progress_points', 0) + random.randint(10, 25) # Gamification element
save_user_database(db); return profile
return None
def add_emotion_record(user_id, emotion):
+ # (Keep existing logic)
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['current_emotion'] = cleaned_emotion # Update current emotion too
save_user_database(db); return profile
return None
def add_routine_to_user(user_id, routine):
+ # (Keep existing logic)
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'] = []
@@ -176,12 +317,13 @@ def add_routine_to_user(user_id, routine):
except: days_delta = 7
end_date = (datetime.now() + timedelta(days=days_delta)).isoformat()
routine_with_date = { "routine": routine, "start_date": datetime.now().isoformat(), "end_date": end_date, "completion": 0 }
- profile['routine_history'].insert(0, routine_with_date)
- profile['routine_history'] = profile['routine_history'][:10]
+ profile['routine_history'].insert(0, routine_with_date) # Add to beginning
+ profile['routine_history'] = profile['routine_history'][:10] # Keep last 10 routines
save_user_database(db); return profile
return None
def save_user_resume(user_id, resume_text):
+ # (Keep existing logic)
if not resume_text: return None
filename, filepath = f"{user_id}_resume.txt", os.path.join(RESUME_FOLDER, f"{user_id}_resume.txt")
try:
@@ -191,6 +333,7 @@ def save_user_resume(user_id, resume_text):
except Exception as e: logger.error(f"Error saving resume {filepath}: {e}"); return None
def save_user_portfolio(user_id, portfolio_url, portfolio_description):
+ # (Keep existing logic)
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()}
@@ -201,63 +344,84 @@ def save_user_portfolio(user_id, portfolio_url, portfolio_description):
except Exception as e: logger.error(f"Error saving portfolio {filepath}: {e}"); return None
def add_recommendation_to_user(user_id, recommendation):
+ # (Keep existing logic - potentially refine recommendation structure later)
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'] = []
+ # Example structure: { 'title': 'Update LinkedIn', 'description': 'Focus on...', 'priority': 'High', 'action_type': 'Skill Building' }
recommendation_with_date = {"recommendation": recommendation, "date": datetime.now().isoformat(), "status": "pending"}
- profile['recommendations'].insert(0, recommendation_with_date)
- profile['recommendations'] = profile['recommendations'][:20]
+ profile['recommendations'].insert(0, recommendation_with_date) # Add to beginning
+ profile['recommendations'] = profile['recommendations'][:20] # Limit size
save_user_database(db); return profile
return None
-def add_chat_message(user_id, role, content_or_struct):
- db = load_user_database(); profile = db.get('users', {}).get(user_id)
- if profile:
- 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}'"); return profile
-
- # Prepare content based on role
- content = content_or_struct
- if role == 'assistant':
- # Handle the structure passed for assistant (potentially including tool calls)
- content = content_or_struct.get('content', '') if isinstance(content_or_struct, dict) else str(content_or_struct)
- if isinstance(content_or_struct, dict) and content_or_struct.get('tool_calls'):
- # Store the structure if there are tool calls
- content = content_or_struct # Keep the dict
- elif content is None: content = "" # Store empty string if no text and no tool calls
- elif role == 'tool':
- # Content should be the string result from the tool
- if not isinstance(content_or_struct.get('content'), str):
- content_or_struct['content'] = json.dumps(content_or_struct.get('content')) if content_or_struct.get('content') is not None else ""
- content = content_or_struct # Store the dict for tool message
- elif not content_or_struct and role == 'user': logger.warning("Empty user message."); return profile # Skip empty user messages
-
- chat_message = {"role": role, "content": content, "timestamp": datetime.now().isoformat()}
- profile['chat_history'].append(chat_message)
- # Limit history
- max_history = 50
- if len(profile['chat_history']) > max_history:
- system_msgs = [m for m in profile['chat_history'] if m['role'] == 'system']
- other_msgs = [m for m in profile['chat_history'] if m['role'] != 'system']
- profile['chat_history'] = system_msgs + other_msgs[-max_history:]
- save_user_database(db); return profile
- return None
+def add_chat_message(user_id, role, parts_or_func_response):
+ """Adds a message to the user's chat history using Gemini 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', 'model', 'function']: # Gemini roles: 'user', 'model' (for assistant), 'function' (for tool results)
+ logger.warning(f"Invalid role '{role}' for Gemini chat history.")
+ return profile
+
+ message = {"role": role}
+ if role == 'user' or role == 'model':
+ # Expecting parts_or_func_response to be a list of parts, e.g., [{'text': '...'}],
+ # but handle simple string input for convenience
+ if isinstance(parts_or_func_response, str):
+ message['parts'] = [{'text': parts_or_func_response}]
+ elif isinstance(parts_or_func_response, list):
+ # Basic validation: Ensure it's a list of dicts with 'text'
+ if all(isinstance(p, dict) and 'text' in p for p in parts_or_func_response):
+ message['parts'] = parts_or_func_response
+ else:
+ logger.warning(f"Invalid parts format for role {role}: {parts_or_func_response}")
+ return profile # Don't save invalid structure
+ else:
+ logger.warning(f"Invalid content type for role {role}: {type(parts_or_func_response)}")
+ return profile # Don't save invalid structure
+
+ elif role == 'function':
+ # Expecting parts_or_func_response to be a dict like {'name': 'func_name', 'response': {'content': ...}}
+ if isinstance(parts_or_func_response, dict) and 'name' in parts_or_func_response and 'response' in parts_or_func_response:
+ message.update(parts_or_func_response) # Merge the dict
+ else:
+ logger.warning(f"Invalid function response format: {parts_or_func_response}")
+ return profile # Don't save invalid structure
+
+ profile['chat_history'].append(message)
+
+ # Limit history size (keep system prompt implicit for now, or add explicitly if needed)
+ max_history_turns = 25 # Keep last 25 pairs (user + model/function)
+ if len(profile['chat_history']) > max_history_turns * 2:
+ profile['chat_history'] = profile['chat_history'][-(max_history_turns * 2):]
+
+ save_user_database(db)
+ return profile
+
-# --- Basic Routine Fallback Function ---
+# --- Basic Routine Fallback Function (keep as is, provides robustness) ---
def generate_basic_routine(emotion, goal, available_time=60, days=7):
- """Generate a basic routine as fallback."""
+ # (Code identical to the provided version - a good fallback)
logger.info(f"Generating basic fallback routine for emotion={emotion}, goal={goal}")
+ # ... (rest of the function code remains the same) ...
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"]
- if "job" in goal.lower() or "internship" in goal.lower() or "company" in goal.lower(): base_type = "job_search"
- elif "skill" in goal.lower() or "learn" in goal.lower(): 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
+ negative_emotions = ["unmotivated", "anxious", "confused", "overwhelmed", "discouraged", "stuck"] # Added '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" # Networking often related to job search
+ else: base_type = "skill_building" # Default
+ 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
@@ -265,53 +429,55 @@ def generate_basic_routine(emotion, goal, available_time=60, days=7):
if include_wellbeing: possible_tasks.extend(routine_types["motivation_wellbeing"])
random.shuffle(possible_tasks)
for task in possible_tasks:
- if task["duration"] <= remaining_time and tasks_added_count < 3:
+ # Ensure task has duration and check remaining time
+ if task.get("duration", 0) > 0 and task["duration"] <= remaining_time and tasks_added_count < 3: # Max 3 tasks/day
day_tasks.append(task); remaining_time -= task["duration"]; tasks_added_count += 1
- if remaining_time < 10 or tasks_added_count >= 3: break
+ if remaining_time < 10 or tasks_added_count >= 3: break # Stop if little time left or max tasks reached
daily_tasks_list.append({"day": day, "tasks": day_tasks})
- routine = {"name": f"{days}-Day Focus Plan", "description": f"A basic {days}-day plan focusing on '{goal}' while acknowledging feeling {cleaned_emotion}.", "days": days, "daily_tasks": daily_tasks_list}
- return routine
+ 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}
+ return routine # Return dict directly
# --- Tool Implementation Functions ---
-def generate_document_template(document_type: str, career_field: str = "", experience_level: str = "") -> str:
+# Note: These functions now return Python dicts/strings directly.
+# The main AI interaction logic will handle packaging them for Gemini API.
+
+def generate_document_template(document_type: str, career_field: str = "", experience_level: str = "") -> Dict[str, str]:
"""Generates a basic markdown template for the specified document type."""
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"
- # Use triple quotes for multi-line strings to fix syntax errors
+ # Using triple quotes correctly
if "resume" in document_type.lower():
- template += """
+ template += """
### Contact Information
-- Name:
-- Phone:
-- Email:
-- LinkedIn URL:
-- Portfolio URL (Optional):
+* Name:
+* Phone:
+* Email:
+* LinkedIn URL:
+* Portfolio URL (Optional):
### Summary/Objective
-_[ 2-3 sentences summarizing your key skills, experience, and career goals, tailored to the job/field. ]_
+* _[ 2-3 sentences summarizing your key skills, experience, and career goals, tailored to the job/field. Make it impactful! ]_
### Experience
-**Company Name** | Location | Job Title | _Start Date – End Date_
-- Accomplishment 1 (Use action verbs and quantify results, e.g., 'Increased sales by 15%...')
-- Accomplishment 2
-
-_[ Repeat for other relevant positions ]_
+**Company Name | Location | Job Title | Start Date – End Date**
+* Accomplishment 1 (Use action verbs: Led, Managed, Developed, Increased X by Y%. Quantify results!)
+* Accomplishment 2
+* _[ Repeat for other relevant positions ]_
### Education
-**University/Institution Name** | Degree | _Graduation Date (or Expected)_
-- Relevant coursework, honors, activities (Optional)
+**University/Institution Name | Degree | Graduation Date (or Expected)**
+* Relevant coursework, honors, activities (Optional)
### Skills
-- **Technical Skills:** [ e.g., Python, Java, SQL, MS Excel, Google Analytics ]
-- **Languages:** [ e.g., English (Native), Spanish (Fluent) ]
-- **Other:** [ Certifications, relevant tools ]
+* **Technical Skills:** [ e.g., Python, Java, SQL, MS Excel, Google Analytics, Figma, AWS ]
+* **Languages:** [ e.g., English (Native), Spanish (Fluent) ]
+* **Other:** [ Certifications, relevant tools, methodologies like Agile/Scrum ]
"""
elif "cover letter" in document_type.lower():
- # Corrected syntax using triple quotes
- template += """
+ template += """
[Your Name]
[Your Address]
[Your Phone]
@@ -328,14 +494,14 @@ _[ Repeat for other relevant positions ]_
Dear [Mr./Ms./Mx. Last Name or Hiring Team],
-**Introduction:** State the position you are applying for and where you saw the advertisement. Briefly express your enthusiasm for the role and the company. Mention 1-2 key qualifications that make you a strong fit.
-_[ 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], I am confident I possess the skills and experience necessary to excel in this role and contribute significantly to [Company Name]. ]_
+**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.
+* _[ 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]. ]_
-**Body Paragraph(s):** Elaborate on your qualifications and experiences, directly addressing the requirements listed in the job description. Provide specific examples (using the STAR method implicitly can be effective). Explain why you are interested in *this specific* company and role. Show you've done your research.
-_[ Example: In my previous role at [Previous Company], I was responsible for [Responsibility relevant to new job]. I successfully [Quantifiable achievement relevant to new job], demonstrating my ability to [Skill required by new job]. I am particularly drawn to [Company Name]'s work in [Specific area company works in], as described in [Source, e.g., recent news, company website], and I believe my [Relevant skill/experience] would be a valuable asset to your team. ]_
+**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!
+* _[ 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. ]_
-**Conclusion:** Reiterate your strong interest and suitability for the role. Briefly summarize your key strengths. State your call to action (e.g., "I am eager to discuss my qualifications further..."). Thank the reader for their time and consideration.
-_[ Example: Thank you for considering my application. My resume provides further detail on my qualifications. I am excited about the opportunity to contribute to [Company Name] and look forward to hearing from you soon. ]_
+**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.
+* _[ 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. ]_
Sincerely,
@@ -343,415 +509,1025 @@ Sincerely,
"""
elif "linkedin summary" in document_type.lower():
template += """
-### LinkedIn Summary/About Section Template
+### LinkedIn Summary / About Section Template
-**Headline:** [ A concise, keyword-rich description of your professional identity, e.g., 'Software Engineer specializing in AI | Python | Cloud Computing | Seeking Innovative Opportunities' ]
+**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' ]
**About Section:**
-_[ Paragraph 1: Hook & Overview. Start with a compelling statement about your passion, expertise, or career mission. Briefly introduce who you are professionally and your main areas of focus. Use keywords relevant to your field and desired roles. ]_
-
-_[ Paragraph 2: Key Skills & Experience Highlights. Detail your core competencies and technical/soft skills. Mention key experiences or types of projects you've worked on. Quantify achievements where possible. Tailor this to the audience you want to attract (recruiters, clients, peers). ]_
-
-_[ Paragraph 3: Career Goals & What You're Seeking (Optional but recommended). Briefly state your career aspirations or the types of opportunities, connections, or collaborations you are looking for. ]_
-
-_[ Paragraph 4: Call to Action / Personality (Optional). You might end with an invitation to connect, mention personal interests related to your field, or add a touch of personality. ]_
-**Specialties/Keywords:** [ List 5-10 key terms related to your skills and industry, e.g., Project Management, Data Analysis, Agile Methodologies, Content Strategy, Java, Cloud Security ]
+* **[ 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.
+* **[ 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).
+* **[ 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').
+* **[ 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?
+* **[ 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 ]_
"""
else:
- template += "_[ Basic structure for this document type will be provided here. ]_"
+ template += "[ Template structure for this document type will be provided here. Let me know what you need! ]"
- return json.dumps({"template_markdown": template})
+ # Return as a dictionary for Gemini function response
+ return {"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, falling back to basic generation if needed."""
- logger.info(f"Tool: create_personalized_routine(emo='{emotion}', goal='{goal}', time={available_time_minutes}, days={routine_length_days})")
+def create_personalized_routine(emotion: str, goal: str, available_time_minutes: int = 60, routine_length_days: int = 7) -> Dict[str, Any]:
+ """Creates a personalized routine, trying AI first, then falling back to basic."""
+ logger.info(f"Executing tool: create_personalized_routine(emo='{emotion}', goal='{goal}', time={available_time_minutes}, days={routine_length_days})")
+ # In a real scenario, you might try a *brief* internal AI call here first
+ # for a more nuanced routine before falling back. For now, use fallback directly.
+ logger.warning("Using basic fallback for create_personalized_routine for robustness.")
try:
- logger.warning("Using basic fallback for create_personalized_routine.")
routine = generate_basic_routine(emotion, goal, available_time_minutes, routine_length_days)
- if not routine: raise ValueError("Basic routine generation failed.")
- return json.dumps(routine)
+ if not routine or not isinstance(routine, dict): # generate_basic_routine returns a dict
+ raise ValueError("Basic routine generation failed to return a valid dictionary.")
+ # Add a supportive message within the routine data
+ routine['support_message'] = f"Hey, I know feeling {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 the dict directly
except Exception as e:
- logger.error(f"Error in create_personalized_routine: {e}")
- try: routine = generate_basic_routine(emotion, goal, available_time_minutes, routine_length_days); return json.dumps(routine) if routine else json.dumps({"error": "Failed."})
- except Exception as fallback_e: logger.error(f"Fallback failed: {fallback_e}"); return json.dumps({"error": f"Failed: {e}"})
-
-def analyze_resume(resume_text: str, career_goal: str) -> str:
- """Provides analysis of the resume using AI (Simulated)."""
- logger.info(f"Tool: analyze_resume(goal='{career_goal}', len={len(resume_text)})")
- logger.warning("Using placeholder for analyze_resume.")
- analysis = { "analysis": { "strengths": ["Placeholder: Clear summary.", "Placeholder: Action verbs used."], "areas_for_improvement": ["Placeholder: Quantify results more.", f"Placeholder: Tailor skills for '{career_goal}'."], "format_feedback": "Placeholder: Clean format.", "content_feedback": f"Placeholder: Content partially relevant to '{career_goal}'.", "keyword_suggestions": ["Placeholder: Add 'Keyword1', 'Keyword2'."], "next_steps": ["Placeholder: Refine role descriptions.", "Placeholder: Add project section?"] } }
- return json.dumps(analysis)
-
-def analyze_portfolio(portfolio_description: str, career_goal: str, portfolio_url: str = "") -> str:
- """Provides analysis of the portfolio using AI (Simulated)."""
- logger.info(f"Tool: analyze_portfolio(goal='{career_goal}', url='{portfolio_url}', desc_len={len(portfolio_description)})")
- logger.warning("Using placeholder for analyze_portfolio.")
- analysis = { "analysis": { "alignment_with_goal": f"Placeholder: Moderate alignment with '{career_goal}'.", "strengths": ["Placeholder: Project variety.", "Placeholder: Clear description."], "areas_for_improvement": ["Placeholder: Link projects to goal skills.", "Placeholder: Add case study depth?"], "presentation_feedback": f"Placeholder: Check URL ({portfolio_url}) if provided.", "next_steps": ["Placeholder: Feature 2-3 best projects.", "Placeholder: Get peer feedback."] } }
- return json.dumps(analysis)
-
-def extract_and_rate_skills_from_resume(resume_text: str, max_skills: int = 8) -> str:
- """Extracts and rates skills from resume text (Simulated)."""
- logger.info(f"Tool: extract_skills(len={len(resume_text)}, max={max_skills})")
- logger.warning("Using placeholder for extract_skills.")
- 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"]
+ logger.error(f"Error in create_personalized_routine fallback: {e}")
+ # Return an error structure
+ return {"error": f"Couldn't create a routine right now due to an error: {e}. Maybe try simplifying the goal or adjusting the time?"}
+
+def analyze_resume(resume_text: str, career_goal: str) -> Dict[str, Any]:
+ """Provides analysis of the resume (Simulated - AI analysis would replace this)."""
+ logger.info(f"Executing tool: analyze_resume(goal='{career_goal}', len={len(resume_text)})")
+ # !! Placeholder Analysis !! Replace with actual AI call in production if desired,
+ # but the main AI handles this via system prompt now. This function is for the TOOL call.
+ logger.warning("Using placeholder analysis for analyze_resume tool.")
+ analysis = {
+ "strengths": [
+ "Clear contact information.",
+ "Uses some action verbs.",
+ f"Mentions skills relevant to '{career_goal}' (needs verification)."
+ ],
+ "areas_for_improvement": [
+ "Quantify achievements more (e.g., 'Increased X by Y%').",
+ f"Ensure skills section is tailored specifically for '{career_goal}' roles.",
+ "Check for consistent formatting and tense.",
+ "Add a compelling summary/objective statement at the top."
+ ],
+ "format_feedback": "Overall format seems clean, but check for 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 bullet points under 'Experience' to include measurable results.",
+ "Tailor the Summary/Objective and Skills sections for each application.",
+ "Proofread carefully for any typos or grammatical errors."
+ ]
+ }
+ return {"analysis": analysis} # Return dict
+
+def analyze_portfolio(portfolio_description: str, career_goal: str, portfolio_url: str = "") -> Dict[str, Any]:
+ """Provides analysis of the portfolio (Simulated - AI analysis would replace this)."""
+ logger.info(f"Executing tool: analyze_portfolio(goal='{career_goal}', url='{portfolio_url}', desc_len={len(portfolio_description)})")
+ # !! Placeholder Analysis !!
+ logger.warning("Using placeholder analysis for analyze_portfolio tool.")
+ analysis = {
+ "alignment_with_goal": f"Based on the description, seems moderately aligned with '{career_goal}'. Review specific projects.",
+ "strengths": [
+ "Includes a variety of projects (based on description).",
+ "Clear description provided helps understand context."
+ ] + (["Portfolio URL provided for direct review."] 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 for key projects.",
+ "Make sure navigation is intuitive (if URL provided)."
+ ],
+ "presentation_feedback": "Description is helpful. " + (f"Review URL ({portfolio_url}) for visual appeal and clarity." if portfolio_url else "Consider creating an online portfolio if you don't have one."),
+ "next_steps": [
+ "Highlight 2-3 projects most relevant to '{career_goal}' prominently.",
+ "Get feedback from peers or mentors in your target field.",
+ "Ensure contact information is easily accessible."
+ ]
+ }
+ return {"analysis": analysis} # Return dict
+
+def extract_and_rate_skills_from_resume(resume_text: str, max_skills: int = 8) -> Dict[str, Any]:
+ """Extracts and rates skills from resume text (Simulated - AI could do this better)."""
+ logger.info(f"Executing tool: extract_skills(len={len(resume_text)}, max={max_skills})")
+ # !! Placeholder Extraction !!
+ logger.warning("Using placeholder skill extraction for extract_and_rate_skills_from_resume tool.")
+ 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()
+ # Basic keyword spotting
for skill in possible:
- if re.search(r'\b' + re.escape(skill.lower()) + r'\b', resume_lower): found.append({"name": skill, "score": random.randint(4, 9)})
+ # Use word boundaries to avoid matching substrings (e.g., 'java' in 'javascript')
+ if re.search(r'\b' + re.escape(skill.lower()) + r'\b', resume_lower):
+ # Simulate rating based on frequency or context (very basic here)
+ 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)) # Slightly boost if leadership words present
+ found.append({"name": skill, "score": score})
if len(found) >= max_skills: break
- if not found and len(resume_text) > 50: found = [ {"name": "Communication", "score": random.randint(5,8)}, {"name": "Teamwork", "score": random.randint(5,8)}, {"name": "Problem Solving", "score": random.randint(5,8)}, ]
+
+ # Fallback if nothing found but resume is substantial
+ 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 {"skills": found[:max_skills]} # Return dict
+
+
+# --- NEW: Serper Web Search Implementation ---
+def search_web_serper(search_query: str, search_type: str = 'general', location: str = None) -> Dict[str, Any]:
+ """Performs a web search using the Serper API."""
+ 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 {"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, # Add location if provided
+ # Add other params like 'num' for number of results if needed
+ })
+ headers = {
+ 'X-API-KEY': SERPER_API_KEY,
+ 'Content-Type': 'application/json'
+ }
+
+ try:
+ response = requests.post(api_url, headers=headers, data=payload, timeout=10) # Added timeout
+ response.raise_for_status() # Raise HTTPError for bad responses (4xx or 5xx)
+ results = response.json()
+
+ # Extract relevant information based on search type (simplified)
+ extracted_results = []
+ if search_type == 'jobs':
+ # Look for job postings, titles, companies
+ if 'jobs' in results: # Serper might have a dedicated jobs structure
+ for job in results['jobs'][:5]: # Limit to top 5
+ extracted_results.append({
+ "title": job.get('title'),
+ "company": job.get('company_name'),
+ "location": job.get('location'),
+ "link": job.get('link') # Assuming Serper provides a direct link
+ })
+ elif 'organic' in results: # Fallback to organic results
+ for item in results['organic'][:5]:
+ # Basic check if title sounds like a job
+ if any(kw in item.get('title', '').lower() for kw in ['hiring', 'job', 'career', 'vacancy']):
+ extracted_results.append({
+ "title": item.get('title'),
+ "snippet": item.get('snippet'),
+ "link": item.get('link')
+ })
+ elif search_type in ['courses', 'skills']:
+ # Extract organic results (titles, links, snippets)
+ 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
+ if 'organic' in results:
+ for item in results['organic'][:3]: # Limit general results
+ extracted_results.append({
+ "title": item.get('title'),
+ "snippet": item.get('snippet'),
+ "link": item.get('link')
+ })
+ # Maybe include answer box if relevant?
+ if 'answerBox' in results:
+ extracted_results.insert(0, { # Put answer box first
+ "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 {"search_results": extracted_results} # Return dict
+
+ except requests.exceptions.RequestException as e:
+ logger.error(f"Serper API request failed: {e}")
+ return {"error": f"Web search failed: {e}"}
+ except Exception as e:
+ logger.error(f"Error processing Serper response: {e}")
+ return {"error": "Failed to process web search results."}
-# --- AI Interaction Logic (Using OpenAI) ---
-def get_ai_response(user_id: str, user_input: str, generate_recommendations: bool = True) -> str:
- """Gets response from OpenAI, handling context, system prompt, and tool calls."""
+
+# --- AI Interaction Logic (Using Google Gemini) ---
+def get_ai_response(user_id: str, user_input: str) -> str:
+ """Gets response from Google Gemini, handling context, system prompt, and function calls."""
logger.info(f"Getting AI response for user {user_id}. Input: '{user_input[:100]}...'")
- if not client: return "AI service unavailable. Check configuration."
+
+ if not gemini_model:
+ logger.error("Gemini model not initialized.")
+ return "I'm sorry, my AI core isn't available right now. Please check the configuration."
try:
user_profile = get_user_profile(user_id)
- if not user_profile: logger.error(f"Failed profile retrieval for {user_id}."); return "Cannot access profile."
+ 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.
+ # This blend of emotional intelligence and career coaching is our key differentiator.
+ 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')
- current_emotion_display = user_profile.get('current_emotion', 'Not specified')
system_prompt = f"""
- You are Aishura, an emotionally intelligent AI career assistant. Goal: provide empathetic, realistic, actionable guidance. Steps:
- 1. Acknowledge message & emotion ("I understand you're feeling {current_emotion_display}..."). Be empathetic.
- 2. Address query directly.
- 3. Proactively offer support via tools: generate templates (`generate_document_template`), create routines (`create_personalized_routine`), analyze resume/portfolio (`analyze_resume`, `analyze_portfolio`) if relevant.
- 4. **Job Suggestions:** If asked for jobs, **DO NOT use a tool**. Generate 2-3 plausible job titles/roles based on goal ('{user_profile.get('career_goal', 'Not specified')}') and location ('{user_profile.get('location', 'Not specified')}'). Mention resume skill alignment (resume path: '{user_profile.get('resume_path', '')}'). State they are examples, not live listings.
- 5. Tailor to profile: Name: {user_profile.get('name', 'User')}, Location: {user_profile.get('location', 'N/A')}, Goal: {user_profile.get('career_goal', 'N/A')}.
- 6. If resume/portfolio uploaded, mention analysis possibility. User must ask or provide content.
- 7. Be concise, friendly, focus on next steps. Use markdown.
- 8. If a tool fails, inform user gracefully ("I couldn't generate the template...") & suggest alternatives. No raw errors.
+ You are Aishura, an advanced AI career assistant built on Google's Gemini model. 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`, and potentially `areas_for_development`.
+ * Specify `search_type` ('jobs', 'courses', 'skills', 'general').
+ * Include `location` if relevant and available.
+ * **Crucially:** Present the search results clearly. Mention they are *live* results but listings change quickly. Don't just dump links; summarize findings. E.g., "Okay, I found a few promising [type] results for you based on our search:"
+ * **Do NOT Use Tools If:** The user is just chatting, venting, or asking for general advice that doesn't map directly to a tool's function. Handle these conversationally.
+ 4. **Synthesize Tool Results:** When a tool (especially search) provides results, don't just output the raw data. Explain *why* these results are relevant to the user and their goals. Integrate the findings into your conversational response.
+ 5. **Maintain Context:** Remember the conversation flow and user profile details.
+ 6. **Handle Errors Gracefully:** If a tool fails or returns an error, apologize and explain simply (e.g., "Hmm, I couldn't fetch the [tool purpose] just now. Maybe we can try searching differently, or focus on [alternative action]?"). Do not show technical error messages to the user.
+
+ **Example Snippets:**
+ * "I got you. Feeling {emotion} is tough, but we'll break down this {goal} together."
+ * "Okay, based on your goal of {goal} and feeling {emotion}, how about we create a manageable routine? I can use the `create_personalized_routine` tool if you'd like."
+ * "Finding jobs can be draining. Want me to run a quick search for '{goal}' roles in {location} using the `search_jobs_courses_skills` tool?"
"""
- # Build Message History
- messages = [{"role": "system", "content": system_prompt}]
- chat_history = user_profile.get('chat_history', [])
- for msg in chat_history:
- # Ensure message structure is valid before appending
- if isinstance(msg, dict) and 'role' in msg and 'content' in msg:
- # Handle tool calls stored in content for assistant role
- content = msg['content']
- role = msg['role']
- tool_calls_in_msg = None
- if role == 'assistant' and isinstance(content, dict) and 'tool_calls' in content:
- tool_calls_in_msg = content['tool_calls']
- content = content.get('content', '') # Get text content part
-
- # Append message, reconstructing tool calls if needed
- msg_to_append = {"role": role, "content": content if content is not None else ""}
- if tool_calls_in_msg:
- msg_to_append['tool_calls'] = tool_calls_in_msg
-
- messages.append(msg_to_append)
-
- elif isinstance(msg, dict) and msg.get('role') == 'tool' and all(k in msg for k in ['tool_call_id', 'name', 'content']):
- tool_content = msg['content'] if isinstance(msg['content'], str) else json.dumps(msg['content'])
- messages.append({ "role": "tool", "tool_call_id": msg['tool_call_id'], "name": msg['name'], "content": tool_content })
-
- messages.append({"role": "user", "content": user_input})
-
- # Initial API Call
- logger.info(f"Sending {len(messages)} messages to OpenAI model {MODEL_ID}.")
- response = client.chat.completions.create( model=MODEL_ID, messages=messages, tools=tools_list, tool_choice="auto", temperature=0.7, max_tokens=1500 )
- response_message = response.choices[0].message
-
- # Prepare assistant's response for DB (might include tool calls)
- assistant_response_for_db = { "role": "assistant", "content": response_message.content }
- if response_message.tool_calls:
- assistant_response_for_db['tool_calls'] = [tc.model_dump() for tc in response_message.tool_calls]
-
- final_response_content = response_message.content
- tool_calls = response_message.tool_calls
-
- # Tool Call Handling
- if tool_calls:
- logger.info(f"AI 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
- 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, }
- tool_results_for_api = []
- tool_results_for_db = [] # To store separately for DB
-
- for tool_call in tool_calls:
- function_name = tool_call.function.name
- function_to_call = available_functions.get(function_name)
+
+ # Prepare message history for Gemini API
+ # Convert stored format {role: 'user'/'model'/'function', parts/response} to API format
+ gemini_history = []
+ for msg in user_profile.get('chat_history', []):
+ if msg['role'] == 'function':
+ # Convert tool/function response format
+ gemini_history.append(genai.protos.Content(
+ parts=[genai.protos.Part(
+ function_response=genai.protos.FunctionResponse(name=msg['name'], response=msg['response'])
+ )]
+ ))
+ elif 'parts' in msg: # Should be 'user' or 'model'
+ # Ensure parts format is correct (list of Part objects)
+ # Assuming stored parts are like [{'text': '...'}]
try:
- function_args = json.loads(tool_call.function.arguments)
- if function_to_call:
- if function_name == "analyze_resume":
- if 'career_goal' not in function_args: function_args['career_goal'] = user_profile.get('career_goal', 'N/A')
- save_user_resume(user_id, function_args.get('resume_text', ''))
- if function_name == "analyze_portfolio":
- if 'career_goal' not in function_args: function_args['career_goal'] = user_profile.get('career_goal', 'N/A')
- save_user_portfolio(user_id, function_args.get('portfolio_url', ''), function_args.get('portfolio_description', ''))
- logger.info(f"Calling function '{function_name}' with args: {function_args}")
- function_response = function_to_call(**function_args)
- logger.info(f"Function '{function_name}' returned: {function_response[:200]}...")
- tool_result = { "tool_call_id": tool_call.id, "role": "tool", "name": function_name, "content": function_response }
- else:
- logger.warning(f"Function {function_name} not implemented.")
- tool_result = { "tool_call_id": tool_call.id, "role": "tool", "name": function_name, "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}")
- tool_result = { "tool_call_id": tool_call.id, "role": "tool", "name": function_name, "content": json.dumps({"error": f"Invalid tool arguments."}) }
+ api_parts = [genai.protos.Part(text=p['text']) for p in msg.get('parts', []) if 'text' in p]
+ if api_parts: # Only add if there are valid parts
+ gemini_history.append(genai.protos.Content(role=msg['role'], parts=api_parts))
except Exception as e:
- logger.exception(f"Error executing {function_name}: {e}")
- tool_result = { "tool_call_id": tool_call.id, "role": "tool", "name": function_name, "content": json.dumps({"error": f"Failed tool {function_name}."}) }
- messages.append(tool_result) # Append full dict to local messages
- tool_results_for_db.append(tool_result) # Store for DB
-
- # Second API Call
- logger.info(f"Sending {len(messages)} messages to OpenAI (incl. tool results).")
- second_response = client.chat.completions.create( model=MODEL_ID, messages=messages, temperature=0.7, max_tokens=1500 )
- final_response_content = second_response.choices[0].message.content
- logger.info("Received final response after tool calls.")
-
- # Store Interaction Sequence in DB
- add_chat_message(user_id, "user", user_input)
- add_chat_message(user_id, "assistant", assistant_response_for_db) # Store first assistant msg (with tool calls)
- for res in tool_results_for_db: add_chat_message(user_id, "tool", res) # Store tool results
- add_chat_message(user_id, "assistant", {"role": "assistant", "content": final_response_content}) # Store final text response
+ logger.warning(f"Skipping invalid message structure in history: {msg} - Error: {e}")
+
+
+ # --- Main AI Interaction Loop (Handles Function Calling) ---
+ current_input_parts = [genai.protos.Part(text=user_input)]
+ prompt_content = genai.protos.Content(role='user', parts=current_input_parts)
+ full_prompt_history = gemini_history + [prompt_content]
+
+ logger.info(f"Sending {len(full_prompt_history)} history entries to Gemini model {MODEL_ID}.")
+
+ # **INVESTOR NOTE:** The use of Gemini 1.5 Flash ensures rapid responses, crucial for user engagement.
+ # The integrated function calling allows seamless access to specialized tools and live data (Serper).
+ try:
+ response = gemini_model.generate_content(
+ full_prompt_history,
+ generation_config=genai.types.GenerationConfig(temperature=0.7, max_output_tokens=1500),
+ tools=tools_list_gemini, # Pass the list of function declarations
+ tool_config=genai.types.ToolConfig(function_calling_config="AUTO"), # Let model decide when to call functions
+ system_instruction=genai.protos.Content(parts=[genai.protos.Part(text=system_prompt)]) # System prompt passed here
+ )
+
+ response_message = response.candidates[0].content
+ finish_reason = response.candidates[0].finish_reason
+
+ except google_exceptions.ResourceExhausted as e:
+ logger.error(f"Google API Quota Error: {e}")
+ return "I'm experiencing high demand right now. Let's try that again in a moment?"
+ except google_exceptions.GoogleAPIError as e:
+ logger.error(f"Google API Error: {e}")
+ return f"Sorry, there was an issue connecting to my AI brain ({e.message}). Could you try again?"
+ except Exception as e:
+ logger.exception(f"Unexpected error during Gemini API call: {e}")
+ return "Oh dear, something unexpected happened on my end. Let's pause and retry?"
+
+
+ # Check if the model decided to call a function
+ if response_message.parts[0].function_call.name:
+ function_call = response_message.parts[0].function_call
+ func_name = function_call.name
+ func_args = dict(function_call.args) # Arguments are provided as a dict
+
+ logger.info(f"Gemini requested tool call: '{func_name}' with args: {func_args}")
+
+ # Add the user message and the assistant's function call request to history
+ add_chat_message(user_id, "user", user_input) # Store user input as text
+ add_chat_message(user_id, "model", [{'text': f"Thinking... (using tool {func_name})"}]) # Placeholder text, real call stored below
+
+ # --- Call the appropriate Python function ---
+ 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, # Add Serper function
+ }
+
+ function_to_call = available_functions.get(func_name)
+ function_response_content = None
+
+ if function_to_call:
+ try:
+ # Special handling for functions needing profile context or saving files
+ if func_name == "analyze_resume":
+ if 'career_goal' not in func_args: func_args['career_goal'] = career_goal
+ save_user_resume(user_id, func_args.get('resume_text', '')) # Save resume if text provided
+ elif func_name == "analyze_portfolio":
+ if 'career_goal' not in func_args: func_args['career_goal'] = career_goal
+ save_user_portfolio(user_id, func_args.get('portfolio_url', ''), func_args.get('portfolio_description', ''))
+ elif func_name == "search_jobs_courses_skills":
+ # Ensure location from profile is used if not specified in args
+ if 'location' not in func_args or not func_args['location']:
+ func_args['location'] = location if location != 'your area' else None # Pass None if default
+
+ # Call the function with unpacked arguments
+ logger.info(f"Calling function '{func_name}' with args: {func_args}")
+ function_response_content = function_to_call(**func_args) # Expecting a dict or string
+ logger.info(f"Function '{func_name}' returned type: {type(function_response_content)}")
+
+ # Prepare response structure for Gemini
+ tool_response_for_api = genai.protos.Part(
+ function_response=genai.protos.FunctionResponse(
+ name=func_name,
+ response={'content': function_response_content} # Gemini expects response in a 'content' key
+ )
+ )
+ # Store tool call result in DB
+ add_chat_message(user_id, 'function', {'name': func_name, 'response': {'content': function_response_content}})
+
+
+ except TypeError as e:
+ logger.error(f"Argument mismatch for function {func_name}. Args: {func_args}, Error: {e}")
+ error_response = {"error": f"Internal error: Tool '{func_name}' called with incorrect arguments."}
+ tool_response_for_api = genai.protos.Part(function_response=genai.protos.FunctionResponse(name=func_name, response={'content': error_response}))
+ add_chat_message(user_id, 'function', {'name': func_name, 'response': {'content': error_response}})
+ except Exception as e:
+ logger.exception(f"Error executing function {func_name}: {e}")
+ error_response = {"error": f"Sorry, I encountered an error while trying to use the '{func_name}' tool. Please try again or ask differently."}
+ # Prepare error response for Gemini
+ tool_response_for_api = genai.protos.Part(
+ function_response=genai.protos.FunctionResponse(
+ name=func_name,
+ response={'content': error_response} # Send error back to model
+ )
+ )
+ # Store error result in DB
+ add_chat_message(user_id, 'function', {'name': func_name, 'response': {'content': error_response}})
- else: # No Tool Calls
- logger.info("No tool calls requested.")
+ else:
+ logger.warning(f"Function {func_name} not implemented.")
+ error_response = {"error": f"Tool '{func_name}' is not available."}
+ tool_response_for_api = genai.protos.Part(
+ function_response=genai.protos.FunctionResponse(
+ name=func_name,
+ response={'content': error_response}
+ )
+ )
+ add_chat_message(user_id, 'function', {'name': func_name, 'response': {'content': error_response}})
+
+
+ # --- Send function response back to the model ---
+ logger.info(f"Sending function response for '{func_name}' back to Gemini.")
+ try:
+ second_response = gemini_model.generate_content(
+ # History includes original user prompt, model's func call, and the func response part
+ gemini_history + [prompt_content, response_message, genai.protos.Content(parts=[tool_response_for_api])],
+ generation_config=genai.types.GenerationConfig(temperature=0.7, max_output_tokens=1500),
+ system_instruction=genai.protos.Content(parts=[genai.protos.Part(text=system_prompt)]) # Re-send system prompt
+ )
+ final_response_text = second_response.candidates[0].content.parts[0].text
+ logger.info("Received final response after tool call.")
+
+ except google_exceptions.GoogleAPIError as e:
+ logger.error(f"Google API Error on second call: {e}")
+ final_response_text = f"Sorry, there was an issue processing the results from the tool ({e.message}). Let's try again?"
+ except Exception as e:
+ logger.exception(f"Unexpected error during second Gemini call: {e}")
+ final_response_text = "Oh dear, something went wrong while processing the tool's results. Could we try that step again?"
+
+ # Store final assistant response
+ add_chat_message(user_id, "model", final_response_text)
+ return final_response_text
+
+ else: # No function call, just a text response
+ logger.info("No tool call requested by Gemini.")
+ final_response_text = response_message.parts[0].text
+ # Store user input and assistant response
add_chat_message(user_id, "user", user_input)
- add_chat_message(user_id, "assistant", assistant_response_for_db) # Store the only assistant response
-
- # Post-processing
- if not final_response_content: final_response_content = "Action complete. How else can I help?"
- # Skipping inline recommendation generation
- # if generate_recommendations: try: pass except Exception: pass
- return final_response_content
-
- 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 Exception as e: logger.exception(f"Unexpected error in get_ai_response: {e}"); return "Unexpected error occurred."
-
-# --- Recommendation Generation (Placeholder) ---
-def gen_recommendations_openai(user_id, user_input, ai_response):
- """Generate recommendations using OpenAI."""
- logger.info(f"Generating recommendations for user {user_id}")
- if not client: return []
- # (Keep implementation from previous version) ...
- return [] # Keep disabled for now
-
-# --- Chart and Visualization Functions ---
-# (Keep create_emotion_chart, create_progress_chart, create_routine_completion_gauge, create_skill_radar_chart - unchanged from previous corrected version)
+ add_chat_message(user_id, "model", final_response_text)
+ return final_response_text
+
+ except Exception as e:
+ logger.exception(f"Unexpected error in get_ai_response: {e}")
+ return "An unexpected error occurred. Please try again later."
+
+
+# --- Recommendation Generation (Placeholder - Keep disabled or implement simple keyword based) ---
+def gen_recommendations_simple(user_id):
+ """Generate simple recommendations based on profile keywords (Placeholder)."""
+ 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()
+
+ # Simple keyword triggers
+ 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"})
+
+ # Add recommendations to user profile (limited number)
+ if recs:
+ # Only add if substantially different from latest pending ones
+ 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 max 3 new ones
+ add_recommendation_to_user(user_id, rec)
+
+ return # Returns None, updates DB directly
+
+
+# --- Chart and Visualization Functions (Keep as is) ---
+# (create_emotion_chart, create_progress_chart, create_routine_completion_gauge, create_skill_radar_chart remain unchanged)
+# ... (Previous chart functions code - no changes needed here) ...
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.", showarrow=False); fig.update_layout(title="Emotion Tracking"); return fig
- vals = {"Unmotivated": 1, "Anxious": 2, "Confused": 3, "Discouraged": 4, "Overwhelmed": 5, "Excited": 6}
+ 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
+ # Added more emotions to map
+ 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="Emotional Journey")
+ 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}
Feeling: %{text}', 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.", showarrow=False); fig.update_layout(title="Progress"); return fig
+ 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']))
- dates, points, labels, cum_pts = [], [], [], 0; pts_task = 20
- for task in tasks: dates.append(datetime.fromisoformat(task['date'])); cum_pts += task.get('points', pts_task); points.append(cum_pts); labels.append(task['task'])
- df = pd.DataFrame({'Date': dates, 'Points': points, 'Task': labels})
- fig = px.line(df, x='Date', y='Points', markers=True, title="Progress Journey"); fig.update_traces(hovertemplate='%{x|%Y-%m-%d %H:%M}
Points: %{y}
Task: %{text}', text=df['Task']); return fig
+ dates, points, labels, cum_pts = [], [], [], 0; pts_task = user_profile.get('progress_points', 0) # Start from current total
+ task_dates = {} # Track points per day
+ for task in tasks:
+ task_date_str = datetime.fromisoformat(task['date']).strftime('%Y-%m-%d')
+ pts = task.get('points', random.randint(10, 25)) # Use stored points if available
+ 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'])
+
+ # Aggregate points daily for chart
+ 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("
".join(day_data['tasks'])) # Combine tasks for hover
+
+ if not chart_dates: # Handle case if somehow no dates processed
+ 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}
Points: %{y}
Tasks:
%{text}', 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': "Routine"})); fig.add_annotation(text="No routine.", 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. Create one?", 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 for skill chart."); fig = go.Figure(); fig.add_annotation(text="Analyze Resume for Skill Chart", showarrow=False); fig.update_layout(title="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 or Analyze 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 = extract_and_rate_skills_from_resume(resume_text=text); data = json.loads(skills_json)
- if 'skills' in data and data['skills']:
- skills = data['skills'][:8]; cats = [s['name'] for s in skills]; vals = [s['score'] for s in skills]
- 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'))
- fig.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 10])), showlegend=False, title="Skill Assessment (Simulated)")
+ # Use the tool function to get skills (even if simulated)
+ skills_data = extract_and_rate_skills_from_resume(resume_text=text) # Returns a dict
+ if 'skills' in skills_data and skills_data['skills']:
+ skills = skills_data['skills'][:8] # Limit to 8 for readability
+ cats = [s['name'] for s in skills]; vals = [s['score'] for s in skills]
+ if len(cats) < 3: # Radar needs >= 3 points
+ 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
+
+ # Ensure the plot loops back
+ 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}
Score: %{r}' # Custom hover
+ ))
+ fig.update_layout(
+ polar=dict(radialaxis=dict(visible=True, range=[0, 10], showline=False, ticksuffix=' pts')), # Added units
+ 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", showarrow=False); fig.update_layout(title="Skills"); return fig
- except Exception as e: logger.exception(f"Error creating skill chart: {e}"); fig = go.Figure(); fig.add_annotation(text="Error analyzing", showarrow=False); fig.update_layout(title="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
+ 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 ---
+# **INVESTOR NOTE:** The Gradio interface provides an accessible and interactive front-end.
+# We prioritize a clean UX, focusing on the chat interaction while making powerful tools easily accessible.
def create_interface():
- """Create the Gradio interface for Aishura"""
- session_user_id = str(uuid.uuid4())
+ """Create the Gradio interface for Aishura v3"""
+ # Use a persistent session ID or implement user login for production
+ session_user_id = str(uuid.uuid4()) # Simple session ID for demo purposes
logger.info(f"Initializing Gradio interface for session user ID: {session_user_id}")
- get_user_profile(session_user_id) # Initialize profile
+ get_user_profile(session_user_id) # Initialize profile if it doesn't exist
# --- Event Handlers ---
- def welcome(name, location, emotion, goal):
- logger.info(f"Welcome: name='{name}', loc='{location}', emo='{emotion}', goal='{goal}'")
- if not all([name, location, emotion, goal]): return ("Fill all fields.", gr.update(visible=True), gr.update(visible=False))
+ def welcome(name, location, emotion, goal, industry, exp_level, work_style):
+ logger.info(f"Welcome: name='{name}', loc='{location}', emo='{emotion}', goal='{goal}', industry='{industry}', exp='{exp_level}', work='{work_style}'")
+ if not all([name, location, emotion, goal]):
+ # Basic validation
+ 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())
+
+ # Clean goal text (remove emoji if present)
cleaned_goal = goal.rsplit(" ", 1)[0] if goal[-1].isnumeric() == False and goal[-2] == " " else goal
- update_user_profile(session_user_id, {"name": name, "location": location, "career_goal": cleaned_goal})
- add_emotion_record(session_user_id, emotion)
- initial_input = f"Hi Aishura! I'm {name} from {location}. I'm feeling {emotion}, and my main goal is '{cleaned_goal}'. Help me start?"
- ai_response = get_ai_response(session_user_id, initial_input, generate_recommendations=True)
- initial_chat = [{"role":"user", "content": initial_input}, {"role":"assistant", "content": ai_response}]
+
+ # Update profile with initial info
+ 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) # Add initial emotion
+
+ # **INVESTOR NOTE:** The initial interaction immediately personalizes the experience and sets an empathetic tone.
+ 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?"
+
+ # Get the first AI response
+ ai_response = get_ai_response(session_user_id, initial_input)
+
+ # Prepare chat history display for Gradio
+ # Gemini uses {role: 'user'/'model', parts: [{'text': '...'}]}
+ # Gradio chatbot expects [[user_msg, assistant_msg], ...]
+ initial_chat_display = [[initial_input, ai_response]]
+
+ # Update charts
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)
- # Correct Plot updates using value=
- return (gr.update(value=initial_chat), 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))
-
- def chat_submit(message_text, history_list_dicts):
- logger.info(f"Chat submit: '{message_text[:50]}...'")
- if not message_text: return history_list_dicts, "", gr.update()
- history_list_dicts.append({"role": "user", "content": message_text})
- ai_response_text = get_ai_response(session_user_id, message_text, generate_recommendations=True)
- history_list_dicts.append({"role": "assistant", "content": ai_response_text})
+ recs_md = display_recommendations(session_user_id) # Display initial recommendations
+
+ return (
+ gr.update(value=initial_chat_display), # Update chatbot
+ gr.update(visible=False), # Hide welcome group
+ gr.update(visible=True), # Show main interface
+ gr.update(value=e_fig), gr.update(value=p_fig), gr.update(value=r_fig), gr.update(value=s_fig), # Update plots
+ gr.update(value=recs_md) # Update recommendations markdown
+ )
+
+ def chat_submit(message_text, history_list_list):
+ """Handles chatbot submission, gets AI response, updates history and recommendations."""
+ logger.info(f"Chat submit for {session_user_id}: '{message_text[:50]}...'")
+ if not message_text:
+ return history_list_list, "" # Return current history and clear textbox
+
+ # Append user message to Gradio display history immediately
+ history_list_list.append([message_text, None]) # Add placeholder for assistant response
+ yield history_list_list, "" # Update UI immediately, clear textbox
+
+ # Get AI response (which also updates the internal DB history)
+ ai_response_text = get_ai_response(session_user_id, message_text)
+
+ # Update the placeholder in Gradio display history with the actual response
+ history_list_list[-1][1] = ai_response_text
+
+ # Generate and display recommendations
+ gen_recommendations_simple(session_user_id) # Generate based on latest interaction (simple version)
recs_md = display_recommendations(session_user_id)
- return history_list_dicts, "", gr.update(value=recs_md)
- # --- Tool Interface Handlers ---
+ # Update UI again with the final response and recommendations
+ yield history_list_list, gr.update(value=recs_md)
+
+
+ # --- Tool Interface Handlers (Manual Trigger from UI) ---
+ # These call the *implementation* functions directly, bypassing AI unless needed internally
def generate_template_interface_handler(doc_type, career_field, experience):
- logger.info(f"Manual Template UI: 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."
+ logger.info(f"Manual Template UI: type='{doc_type}'")
+ # Call implementation directly
+ result_dict = generate_document_template(doc_type, career_field, experience)
+ return result_dict.get('template_markdown', "Error generating template.")
def create_routine_interface_handler(emotion, goal, time_available, days):
- logger.info(f"Manual Routine UI: 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))
+ logger.info(f"Manual Routine UI: emo='{emotion}', goal='{goal}'")
+ cleaned_emotion = emotion.split(" ")[0] if " " in emotion else emotion
+ # Call implementation directly (uses fallback basic generator)
+ result_dict = create_personalized_routine(cleaned_emotion, goal, int(time_available), int(days))
+
+ if "error" in result_dict:
+ return f"Error: {result_dict['error']}", gr.update()
+
+ # Save routine to user profile
+ add_routine_to_user(session_user_id, result_dict)
+
+ # Format for display
+ md = f"# {result_dict.get('name', 'Your Routine')}\n\n"
+ md += f"_{result_dict.get('support_message', result_dict.get('description', ''))}_\n\n---\n\n" # Use support message
+ for day in result_dict.get('daily_tasks', []):
+ md += f"## Day {day.get('day', '?')}\n"
+ tasks = day.get('tasks', [])
+ if not tasks:
+ md += "- Rest day or catch-up.\n"
+ else:
+ for task in tasks:
+ md += f"- **{task.get('name', 'Task')}** ({task.get('duration', '?')} min)\n"
+ md += f" - _{task.get('description', '...')}_\n"
+ md += "\n"
+
+ gauge = create_routine_completion_gauge(session_user_id)
+ return md, gr.update(value=gauge) # Update markdown and gauge plot
+
+ def analyze_resume_interface_handler(resume_file):
+ logger.info(f"Manual Resume Analysis UI: file={resume_file}")
+ if resume_file is None:
+ return "Please upload a resume file.", gr.update(value=None), gr.update(value=None)
+
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)
- md = f"# {data.get('name', 'Routine')}\n\n{data.get('description', '')}\n\n"
- for day in data.get('daily_tasks', []):
- md += f"## Day {day.get('day', '?')}\n"
- tasks = day.get('tasks', []); md += "- Rest day.\n" if not tasks else ""
- for task in tasks: md += f"- **{task.get('name', 'Task')}** ({task.get('duration', '?')}m)\n *Why: {task.get('description', '...') }*\n"
- md += "\n"
- gauge = create_routine_completion_gauge(session_user_id)
- return md, gr.update(value=gauge) # Correct Plot update
- except: return "Error displaying routine.", gr.update()
-
- def analyze_resume_interface_handler(resume_text):
- logger.info(f"Manual Resume Analysis UI: len={len(resume_text)}")
- if not resume_text: return "Paste resume.", gr.update(value=None)
- profile = get_user_profile(session_user_id); goal = profile.get('career_goal', 'N/A')
- save_user_resume(session_user_id, resume_text)
- json_str = analyze_resume(resume_text, goal)
+ # Read text content from uploaded file object
+ 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)
+
+ profile = get_user_profile(session_user_id)
+ goal = profile.get('career_goal', 'Not specified')
+
+ # Save resume text to user profile (associates it)
+ resume_path = save_user_resume(session_user_id, resume_text)
+ if not resume_path:
+ return "Could not save resume file for analysis.", gr.update(value=None), gr.update(value=None)
+
+
+ # Call analysis tool implementation function
+ analysis_result = analyze_resume(resume_text, goal) # Returns dict
+
try:
- analysis = json.loads(json_str).get('analysis', {})
- md = f"## Resume Analysis (Simulated)\n\n**Goal:** '{goal}'\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**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', [])])
+ 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."])])
+
+ # Update skill chart based on the new resume analysis
skill_fig = create_skill_radar_chart(session_user_id)
- return md, gr.update(value=skill_fig) # Correct Plot update
- except: return "Error displaying analysis.", gr.update(value=None)
+
+ return md, gr.update(value=skill_fig), gr.update(value=resume_path) # Return analysis text, skill chart, and 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)
def analyze_portfolio_interface_handler(portfolio_url, portfolio_description):
logger.info(f"Manual Portfolio Analysis UI: url='{portfolio_url}'")
- if not portfolio_description: return "Provide description."
- profile = get_user_profile(session_user_id); goal = profile.get('career_goal', 'N/A')
- save_user_portfolio(session_user_id, portfolio_url, portfolio_description)
- json_str = analyze_portfolio(portfolio_description, goal, portfolio_url)
+ if not portfolio_description:
+ return "Please provide a description of your portfolio."
+
+ profile = get_user_profile(session_user_id)
+ goal = profile.get('career_goal', 'Not specified')
+
+ # Save portfolio info
+ portfolio_path = save_user_portfolio(session_user_id, portfolio_url, portfolio_description)
+ if not portfolio_path:
+ return "Could not save portfolio details."
+
+
+ # Call analysis tool implementation function
+ analysis_result = analyze_portfolio(portfolio_description, goal, portfolio_url) # Returns dict
+
try:
- analysis = json.loads(json_str).get('analysis', {})
- md = f"## Portfolio Analysis (Simulated)\n\n**Goal:** '{goal}'\n" + (f"**URL:** {portfolio_url}\n\n" if portfolio_url else "\n") + 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', [])])
+ analysis = analysis_result.get('analysis', {})
+ md = f"## Portfolio Analysis (Simulated)\n\n**Analyzing for Goal:** '{goal}'\n"
+ if portfolio_url: md += f"**URL:** {portfolio_url}\n\n"
+ else: md += "\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."])])
+
return md
- except: return "Error displaying analysis."
+
+ except Exception as e:
+ logger.exception("Error formatting portfolio analysis results.")
+ return "Error displaying analysis results."
# --- Progress Tracking Handlers ---
def complete_task_handler(task_name):
- logger.info(f"Complete Task UI: task='{task_name}'")
- if not task_name: return ("Enter task name.", "", gr.update(), gr.update(), gr.update())
- add_task_to_user(session_user_id, task_name)
- db = load_user_database(); profile = db.get('users', {}).get(session_user_id)
- if profile and profile.get('routine_history'):
- latest = profile['routine_history'][0]; inc = random.randint(5, 15)
- latest['completion'] = min(100, latest.get('completion', 0) + inc); save_user_database(db)
+ logger.info(f"Complete Task UI for {session_user_id}: task='{task_name}'")
+ if not task_name:
+ return ("Please enter the task you completed.", "", gr.update(), gr.update(), gr.update())
+
+ updated_profile = add_task_to_user(session_user_id, task_name)
+
+ # Update routine completion if a routine is active
+ if updated_profile and updated_profile.get('routine_history'):
+ db = load_user_database() # Reload DB after add_task potentially saved it
+ profile = db.get('users', {}).get(session_user_id)
+ if profile and profile.get('routine_history'): # Check again after reload
+ latest_routine = profile['routine_history'][0]
+ # Simple completion increment - could be smarter based on task type/routine content
+ increment = random.randint(5, 15)
+ latest_routine['completion'] = min(100, latest_routine.get('completion', 0) + increment)
+ save_user_database(db) # Save updated routine completion
+
+ # Update charts
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)
- # Correct Plot updates
- return (f"Great job on '{task_name}'!", "", gr.update(value=e_fig), gr.update(value=p_fig), gr.update(value=g_fig))
+
+ 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))
def update_emotion_handler(emotion):
- logger.info(f"Update Emotion UI: emotion='{emotion}'")
- if not emotion: return "Select emotion.", gr.update()
+ logger.info(f"Update Emotion UI 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)
cleaned_display = emotion.split(" ")[0] if " " in emotion else emotion
- # Correct Plot update
- return f"Emotion updated to '{cleaned_display}'.", gr.update(value=e_fig)
+
+ return f"Got it. Acknowledging how you feel ({cleaned_display}) is a great step.", gr.update(value=e_fig)
def display_recommendations(current_user_id):
- logger.info(f"Display recommendations for {current_user_id}")
- profile = get_user_profile(current_user_id); recs = profile.get('recommendations', [])
- if not recs: return "Chat for recommendations!"
- latest_recs = recs[:5]; md = "# Latest Recommendations\n\n"
- if not latest_recs: return md + "No recommendations."
- for i, entry in enumerate(latest_recs, 1):
+ """Formats latest recommendations into Markdown for display."""
+ logger.info(f"Displaying recommendations 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! 😊"
+
+ # Show only pending recommendations, most recent first
+ pending_recs = [r for r in recs if r.get('status') == 'pending'][:5] # Get latest 5 pending
+
+ 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', 'N/A')}\n{rec.get('description', 'N/A')}\n"
- md += f"**Priority:** {rec.get('priority', 'N/A').title()} | **Type:** {rec.get('action_type', 'N/A').replace('_', ' ').title()}\n---\n"
+ 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"
return md
# --- Build Gradio Interface ---
- with gr.Blocks(theme=gr.themes.Soft(primary_hue="sky", secondary_hue="blue")) as app:
- gr.Markdown("# Aishura - Your AI Career Assistant")
+ with gr.Blocks(theme=gr.themes.Soft(primary_hue="sky", secondary_hue="blue", font=[gr.themes.GoogleFont("Poppins"), "Arial", "sans-serif"]), title="Aishura v3") as app:
+ gr.Markdown("# Aishura - Your Empathetic AI Career Copilot 🚀")
+ gr.Markdown("_Leveraging Google Gemini & Real-Time Data_")
+
+ # Session state to store user ID (alternative to global variable)
+ # user_id_state = gr.State(session_user_id) # Can use state if needed
+
# Welcome Screen
with gr.Group(visible=True) as welcome_group:
- gr.Markdown("## Welcome! Let's get started."); gr.Markdown("Tell me about yourself.")
+ gr.Markdown("## Welcome! Let's personalize your journey.")
+ gr.Markdown("Tell me a bit about yourself so I can help you better.")
with gr.Row():
- with gr.Column(): name_input = gr.Textbox(label="Name"); location_input = gr.Textbox(label="Location")
- with gr.Column(): emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="How are you feeling?"); goal_dropdown = gr.Dropdown(choices=GOAL_TYPES, label="What's your main goal?") # Label updated
- welcome_button = gr.Button("Start My Journey"); welcome_output = gr.Markdown()
- # Main Interface
+ 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?") # Label updated
+ 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()
+
+ # Main Interface (Hidden initially)
with gr.Group(visible=False) as main_interface:
with gr.Tabs():
- # Chat Tab
- with gr.TabItem("💬 Chat"):
+ # --- Chat Tab ---
+ with gr.TabItem("💬 Chat with Aishura"):
with gr.Row():
with gr.Column(scale=3):
- chatbot = gr.Chatbot(label="Aishura", height=550, type="messages", show_copy_button=True) # Corrected init
- msg_textbox = gr.Textbox(show_label=False, placeholder="Type message...", container=False, scale=1)
- with gr.Column(scale=1): gr.Markdown("### ✨ Recommendations"); recommendation_output = gr.Markdown("..."); refresh_recs_button = gr.Button("🔄 Refresh")
- # Analysis Tab
- with gr.TabItem("📊 Analysis"):
- with gr.Tabs():
- with gr.TabItem("📄 Resume"): gr.Markdown("### Resume Analysis"); resume_text_input = gr.Textbox(label="Paste Resume", lines=15); analyze_resume_button = gr.Button("Analyze Resume"); resume_analysis_output = gr.Markdown()
- with gr.TabItem("🎨 Portfolio"): gr.Markdown("### Portfolio Analysis"); portfolio_url_input = gr.Textbox(label="URL (Optional)"); portfolio_desc_input = gr.Textbox(label="Description", lines=5); analyze_portfolio_button = gr.Button("Analyze Portfolio"); portfolio_analysis_output = gr.Markdown()
- with gr.TabItem("💡 Skills"): gr.Markdown("### Skill Assessment"); skill_radar_chart_output = gr.Plot(label="Skills") # Corrected init
- # Tools Tab (No Job Search)
- with gr.TabItem("🛠️ Tools"):
+ # Using Gradio's ChatInterface structure for simplicity
+ chatbot_display = gr.Chatbot(
+ label="Aishura",
+ height=600,
+ show_copy_button=True,
+ bubble_full_width=False, # Modern look
+ 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") # Example AI avatar
+ )
+ msg_textbox = gr.Textbox(
+ show_label=False,
+ placeholder="Type your message here... ask for help, share progress, or just vent!",
+ container=False,
+ scale=1 # Take full width below chatbot
+ )
+ # Submit button (optional, hitting Enter also works)
+ # submit_btn = gr.Button("Send", variant="secondary", size="sm")
+
+ with gr.Column(scale=1):
+ gr.Markdown("### Recommendations")
+ recommendation_output = gr.Markdown("Loading recommendations...")
+ refresh_recs_button = gr.Button("🔄 Refresh Recs")
+ gr.Markdown("---")
+ gr.Markdown("### Quick Actions")
+ # Add quick action buttons later? e.g., "Summarize my progress"
+
+ # --- Analysis & Tools Tab ---
+ with gr.TabItem("🛠️ Analyze & Tools"):
with gr.Tabs():
- with gr.TabItem("📝 Templates"): gr.Markdown("### Docs"); doc_type_dropdown = gr.Dropdown(choices=["Resume", "Cover Letter", "LinkedIn Summary", "Networking Email"], label="Type"); doc_field_input = gr.Textbox(label="Field"); doc_exp_dropdown = gr.Dropdown(choices=["Entry", "Mid", "Senior", "Student"], label="Level"); generate_template_button = gr.Button("Generate"); template_output_md = gr.Markdown()
- with gr.TabItem("📅 Routine"): gr.Markdown("### Routine"); routine_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="Feeling?"); routine_goal_input = gr.Textbox(label="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"); routine_output_md = gr.Markdown()
- # Progress Tab
- with gr.TabItem("📈 Progress"):
- gr.Markdown("## Track Journey")
+ 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.")
+ # Use File upload component
+ resume_file_input = gr.File(label="Upload Resume (.txt, .pdf)", file_types=['.txt', '.pdf'])
+ # Display path of saved resume
+ 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...")
+
+
+ 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 using React and Node.js...")
+ analyze_portfolio_button = gr.Button("Analyze Portfolio Info", variant="primary")
+ portfolio_analysis_output = gr.Markdown("Analysis will appear here...")
+
+ with gr.TabItem("📅 Routine Builder"):
+ gr.Markdown("### Create a Personalized Routine")
+ gr.Markdown("Feeling stuck? Let's build a manageable routine based on how you feel and your goals.")
+ routine_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="How are you feeling?")
+ profile = get_user_profile(session_user_id) # Get goal from profile for default
+ 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...")
+
+
+ # --- Progress Tab ---
+ with gr.TabItem("📈 Track Your Journey"):
+ gr.Markdown("## Your Progress Dashboard")
with gr.Row():
- with gr.Column(scale=1): gr.Markdown("### Task Done"); task_input = gr.Textbox(label="Task"); complete_button = gr.Button("Complete"); task_output = gr.Markdown(); gr.Markdown("---"); gr.Markdown("### Update Emotion"); new_emotion_dropdown = gr.Dropdown(choices=EMOTIONS, label="Feeling now?"); emotion_button = gr.Button("Update"); emotion_output = gr.Markdown()
- with gr.Column(scale=2): gr.Markdown("### Visuals"); emotion_chart_output = gr.Plot(label="Emotion") # Corrected init
- with gr.Row(): progress_chart_output = gr.Plot(label="Progress") # Corrected init
- with gr.Row(): routine_gauge_output = gr.Plot(label="Routine") # Corrected init
+ 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, Completed course module")
+ 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()
+ with gr.Column(scale=2):
+ gr.Markdown("### Emotional Journey")
+ emotion_chart_output = gr.Plot(label="Emotion Trend") # Init Plot
+ gr.Markdown("### Active Routine Progress")
+ routine_gauge_output = gr.Plot(label="Routine Completion") # Init Plot
+
+ with gr.Row():
+ with gr.Column(scale=1):
+ gr.Markdown("### Progress Points")
+ progress_chart_output = gr.Plot(label="Progress Points Over Time") # Init Plot
+ with gr.Column(scale=1):
+ gr.Markdown("### Skills Assessment (from Resume)")
+ skill_radar_chart_output = gr.Plot(label="Skills Radar") # Init Plot
+
# --- Event Wiring ---
- welcome_button.click( fn=welcome, inputs=[name_input, location_input, emotion_dropdown, goal_dropdown], outputs=[chatbot, welcome_group, main_interface, emotion_chart_output, progress_chart_output, routine_gauge_output, skill_radar_chart_output] )
- msg_textbox.submit( fn=chat_submit, inputs=[msg_textbox, chatbot], outputs=[chatbot, msg_textbox, recommendation_output] )
- 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_text_input], outputs=[resume_analysis_output, skill_radar_chart_output] )
- analyze_portfolio_button.click( fn=analyze_portfolio_interface_handler, inputs=[portfolio_url_input, portfolio_desc_input], outputs=[portfolio_analysis_output] )
- generate_template_button.click( fn=generate_template_interface_handler, inputs=[doc_type_dropdown, doc_field_input, doc_exp_dropdown], outputs=[template_output_md] )
- create_routine_button.click( fn=create_routine_interface_handler, inputs=[routine_emotion_dropdown, routine_goal_input, routine_time_slider, routine_days_slider], outputs=[routine_output_md, routine_gauge_output] )
- complete_button.click( fn=complete_task_handler, inputs=[task_input], outputs=[task_output, task_input, emotion_chart_output, progress_chart_output, routine_gauge_output] )
- emotion_button.click( fn=update_emotion_handler, inputs=[new_emotion_dropdown], outputs=[emotion_output, emotion_chart_output] )
+ 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] # Added rec output
+ )
+
+ # Chat submission
+ msg_textbox.submit(
+ fn=chat_submit,
+ inputs=[msg_textbox, chatbot_display],
+ outputs=[chatbot_display, recommendation_output] # Chatbot updated 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]
+ )
+
+ # Tool Handlers
+ analyze_resume_button.click(
+ fn=analyze_resume_interface_handler,
+ inputs=[resume_file_input], # Changed to file input
+ outputs=[resume_analysis_output, skill_radar_chart_output, resume_path_display] # Added path display
+ )
+ analyze_portfolio_button.click(
+ fn=analyze_portfolio_interface_handler,
+ inputs=[portfolio_url_input, portfolio_desc_input],
+ outputs=[portfolio_analysis_output]
+ )
+ generate_template_button.click(
+ fn=generate_template_interface_handler,
+ inputs=[doc_type_dropdown, doc_field_input, doc_exp_dropdown],
+ outputs=[template_output_md]
+ )
+ create_routine_button.click(
+ fn=create_routine_interface_handler,
+ inputs=[routine_emotion_dropdown, routine_goal_input, routine_time_slider, routine_days_slider],
+ outputs=[routine_output_md, routine_gauge_output] # Updates routine text and gauge
+ )
+
+ # Progress Handlers
+ complete_button.click(
+ fn=complete_task_handler,
+ inputs=[task_input],
+ outputs=[task_output, task_input, emotion_chart_output, progress_chart_output, routine_gauge_output] # Clear input, update charts
+ )
+ emotion_button.click(
+ fn=update_emotion_handler,
+ inputs=[new_emotion_dropdown],
+ outputs=[emotion_output, emotion_chart_output] # Update status text and emotion chart
+ )
return app
# --- Main Execution ---
if __name__ == "__main__":
- if not OPENAI_API_KEY: print("\nWarning: OPENAI_API_KEY not found.\n")
- logger.info("Starting Aishura Gradio application...")
+ print("\n--- Aishura v3 Configuration Check ---")
+ if not GOOGLE_API_KEY:
+ print("⚠️ WARNING: GOOGLE_API_KEY not found in environment variables. AI features DISABLED.")
+ else:
+ print("✅ GOOGLE_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 gemini_model:
+ print("❌ ERROR: Google Gemini model failed to initialize. AI features DISABLED.")
+ else:
+ print(f"✅ Google Gemini model '{MODEL_ID}' initialized.")
+ print("-------------------------------------\n")
+
+ logger.info("Starting Aishura v3 Gradio application...")
aishura_app = create_interface()
- aishura_app.launch(share=False) # Set share=True for public link
+ # Share=True generates a public link (useful for demos)
+ # Set debug=True for more verbose Gradio logs if needed
+ aishura_app.launch(share=False, debug=False)
logger.info("Aishura Gradio application stopped.")
\ No newline at end of file