Update app.py

app.py

@@ -15,9 +15,14 @@ import logging
 from dotenv import load_dotenv
 import pytz
 import uuid
-import google.generativeai as genai
-from google.generativeai.types import HarmCategory, HarmBlockThreshold
-from google.generativeai.types import Tool, FunctionDeclaration, GenerateContentConfig
+import re
+import base64
+from io import BytesIO
+from PIL import Image
+
+# Import the updated Google GenAI SDK
+from google import genai
+from google.genai import types
 
 # Load environment variables
 load_dotenv()
@@ -28,38 +33,33 @@ logging.basicConfig(level=logging.INFO,
 logger = logging.getLogger(__name__)
 
 # Configure API keys
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "your-gemini-api-key")
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY", "your-api-key")
 SERPER_API_KEY = os.getenv("SERPER_API_KEY", "your-serper-api-key")
 
-# Configure Google Gemini API
-genai.configure(api_key=GEMINI_API_KEY)
+# Configure Google GenAI
+genai.configure(api_key=GOOGLE_API_KEY)
+
+# Init the client
+client = genai.Client()
+
+# Model configuration - using Gemini latest model
+MODEL_ID = "gemini-2.0-flash-001"
 
 # Constants for global app
 EMOTIONS = ["Unmotivated", "Anxious", "Confused", "Excited", "Overwhelmed", "Discouraged"]
 GOAL_TYPES = ["Get a job at a big company", "Find an internship", "Change careers", "Improve skills", "Network better"]
 USER_DB_PATH = "user_database.json"
+RESUME_FOLDER = "user_resumes"
+PORTFOLIO_FOLDER = "user_portfolios"
 
-# Gemini model configuration
-model = genai.GenerativeModel(
-    model_name="gemini-2.0-flash",
-    generation_config={
-        "temperature": 0.7,
-        "top_p": 0.95,
-        "top_k": 40,
-        "max_output_tokens": 2048,
-    },
-    safety_settings={
-        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
-        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
-        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
-        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
-    }
-)
+# Ensure folders exist
+os.makedirs(RESUME_FOLDER, exist_ok=True)
+os.makedirs(PORTFOLIO_FOLDER, exist_ok=True)
 
-# Function declarations for Gemini API
-search_jobs = FunctionDeclaration(
-    name="search_jobs",
-    description="Search for job opportunities based on location and career goals",
+# Function declarations for tools
+get_job_opportunities = types.FunctionDeclaration(
+    name="get_job_opportunities",
+    description="Get relevant job opportunities based on location and career goals",
     parameters={
         "type": "OBJECT",
         "properties": {
@@ -80,7 +80,7 @@ search_jobs = FunctionDeclaration(
     },
 )
 
-generate_document = FunctionDeclaration(
+generate_document = types.FunctionDeclaration(
     name="generate_document_template",
     description="Generate a document template for job applications",
     parameters={
@@ -103,7 +103,7 @@ generate_document = FunctionDeclaration(
     },
 )
 
-create_routine = FunctionDeclaration(
+create_routine = types.FunctionDeclaration(
     name="create_personalized_routine",
     description="Create a personalized career development routine",
     parameters={
@@ -130,11 +130,54 @@ create_routine = FunctionDeclaration(
     },
 )
 
-tools = [
-    Tool(function_declarations=[search_jobs]),
-    Tool(function_declarations=[generate_document]),
-    Tool(function_declarations=[create_routine])
-]
+analyze_resume = types.FunctionDeclaration(
+    name="analyze_resume",
+    description="Analyze a user's resume and provide feedback",
+    parameters={
+        "type": "OBJECT",
+        "properties": {
+            "resume_text": {
+                "type": "STRING",
+                "description": "The full text of the user's resume",
+            },
+            "career_goal": {
+                "type": "STRING",
+                "description": "The user's career goal or job interest",
+            },
+        },
+        "required": ["resume_text"],
+    },
+)
+
+analyze_portfolio = types.FunctionDeclaration(
+    name="analyze_portfolio",
+    description="Analyze a user's portfolio and provide feedback",
+    parameters={
+        "type": "OBJECT",
+        "properties": {
+            "portfolio_url": {
+                "type": "STRING",
+                "description": "URL to the user's portfolio",
+            },
+            "portfolio_description": {
+                "type": "STRING",
+                "description": "Description of the portfolio content",
+            },
+            "career_goal": {
+                "type": "STRING",
+                "description": "The user's career goal or job interest",
+            },
+        },
+        "required": ["portfolio_description"],
+    },
+)
+
+# Combine tools
+job_tool = types.Tool(function_declarations=[get_job_opportunities])
+document_tool = types.Tool(function_declarations=[generate_document])
+routine_tool = types.Tool(function_declarations=[create_routine])
+resume_tool = types.Tool(function_declarations=[analyze_resume])
+portfolio_tool = types.Tool(function_declarations=[analyze_portfolio])
 
 # User database functions
 def load_user_database():
@@ -168,6 +211,10 @@ def get_user_profile(user_id):
             "upcoming_events": [],
             "routine_history": [],
             "daily_emotions": [],
+            "resume_path": "",
+            "portfolio_path": "",
+            "recommendations": [],
+            "chat_history": [],
             "joined_date": datetime.now().strftime("%Y-%m-%d")
         }
         save_user_database(db)
@@ -231,6 +278,68 @@ def add_routine_to_user(user_id, routine):
         save_user_database(db)
     return db['users'][user_id]
 
+def save_user_resume(user_id, resume_text):
+    """Save user's resume to file and update profile"""
+    # Create filename
+    filename = f"{user_id}_resume.txt"
+    filepath = os.path.join(RESUME_FOLDER, filename)
+    
+    # Save resume text to file
+    with open(filepath, 'w') as file:
+        file.write(resume_text)
+    
+    # Update user profile
+    update_user_profile(user_id, {"resume_path": filepath})
+    
+    return filepath
+
+def save_user_portfolio(user_id, portfolio_content):
+    """Save user's portfolio info to file and update profile"""
+    # Create filename
+    filename = f"{user_id}_portfolio.json"
+    filepath = os.path.join(PORTFOLIO_FOLDER, filename)
+    
+    # Save portfolio content to file
+    with open(filepath, 'w') as file:
+        json.dump(portfolio_content, file, indent=4)
+    
+    # Update user profile
+    update_user_profile(user_id, {"portfolio_path": filepath})
+    
+    return filepath
+
+def add_recommendation_to_user(user_id, recommendation):
+    """Add a new recommendation to user's recommendations list"""
+    db = load_user_database()
+    if user_id in db['users']:
+        if 'recommendations' not in db['users'][user_id]:
+            db['users'][user_id]['recommendations'] = []
+        
+        recommendation_with_date = {
+            "recommendation": recommendation,
+            "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "status": "pending"  # pending, completed, dismissed
+        }
+        db['users'][user_id]['recommendations'].append(recommendation_with_date)
+        save_user_database(db)
+    return db['users'][user_id]
+
+def add_chat_message(user_id, role, message):
+    """Add a message to the user's chat history"""
+    db = load_user_database()
+    if user_id in db['users']:
+        if 'chat_history' not in db['users'][user_id]:
+            db['users'][user_id]['chat_history'] = []
+        
+        chat_message = {
+            "role": role,  # user or assistant
+            "message": message,
+            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+        db['users'][user_id]['chat_history'].append(chat_message)
+        save_user_database(db)
+    return db['users'][user_id]
+
 # API Helper Functions
 def search_jobs_with_serper(query, location, max_results=5):
     """Search for job opportunities using Serper API"""
@@ -288,8 +397,8 @@ def extract_company_from_title(title):
         return title.split(' - ')[1].strip()
     return "Unknown Company"
 
-def get_ai_response(user_id, user_input, context=None):
-    """Get AI response using Google Gemini API"""
+def get_ai_response(user_id, user_input, context=None, generate_recommendations=True):
+    """Get AI response using Google GenAI"""
     try:
         user_profile = get_user_profile(user_id)
         
@@ -299,42 +408,178 @@ def get_ai_response(user_id, user_input, context=None):
         1. Recognize and acknowledge the user's emotion
         2. Respond with high-empathy message
         3. Suggest specific action based on their input
-        4. Offer document support or routine
+        4. Offer document support, job opportunities, or personalized routine
+        
+        Remember to be proactive and preemptive - suggest actions before the user asks. Your goal is to provide
+        end-to-end support for the user's career journey, from emotional support to concrete action.
         
-        Remember to be proactive and preemptive - suggest actions before the user asks.
+        If the user has shared a resume or portfolio, refer to insights from those documents to provide
+        personalized guidance.
         """
         
         # Build conversation context
-        messages = []
-        if context:
-            messages.extend(context)
+        contents = []
         
         # Add user profile information as context
         profile_context = f"""
         User Profile Information:
+        - Name: {user_profile.get('name', '')}
         - Current emotion: {user_profile.get('current_emotion', '')}
         - Career goal: {user_profile.get('career_goal', '')}
         - Location: {user_profile.get('location', '')}
         """
         
-        messages.append({"role": "user", "parts": [profile_context]})
-        messages.append({"role": "user", "parts": [user_input]})
+        # Add resume context if available
+        if user_profile.get('resume_path') and os.path.exists(user_profile.get('resume_path')):
+            try:
+                with open(user_profile.get('resume_path'), 'r') as file:
+                    resume_text = file.read()
+                profile_context += f"\nUser Resume Summary: The user has shared their resume. They have experience in {resume_text[:100]}..."
+            except Exception as e:
+                logger.error(f"Error reading resume: {str(e)}")
+        
+        # Add portfolio context if available
+        if user_profile.get('portfolio_path') and os.path.exists(user_profile.get('portfolio_path')):
+            try:
+                with open(user_profile.get('portfolio_path'), 'r') as file:
+                    portfolio_data = json.load(file)
+                profile_context += f"\nUser Portfolio: The user has shared their portfolio with URL: {portfolio_data.get('url', 'Not provided')}."
+            except Exception as e:
+                logger.error(f"Error reading portfolio: {str(e)}")
+        
+        # Start with context
+        user_context = types.Content(
+            role="user",
+            parts=[types.Part.from_text(profile_context)]
+        )
+        contents.append(user_context)
         
-        response = model.generate_content(
-            messages,
-            generation_config={"temperature": 0.7},
+        # Add previous context if provided
+        if context:
+            for msg in context:
+                if msg["role"] == "user":
+                    contents.append(types.Content(
+                        role="user",
+                        parts=[types.Part.from_text(msg["message"])]
+                    ))
+                else:
+                    contents.append(types.Content(
+                        role="model",
+                        parts=[types.Part.from_text(msg["message"])]
+                    ))
+        
+        # Add current user input
+        contents.append(types.Content(
+            role="user",
+            parts=[types.Part.from_text(user_input)]
+        ))
+        
+        # Configure tools
+        tools = [job_tool, document_tool, routine_tool, resume_tool, portfolio_tool]
+        
+        # Get response
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=contents,
             system_instruction=system_instruction,
-            tools=tools
+            tools=tools,
+            generation_config=types.GenerationConfig(
+                temperature=0.7,
+                max_output_tokens=2048,
+                top_p=0.95,
+                top_k=40
+            )
         )
         
-        return response.text
+        ai_response_text = response.text
+        
+        # Log the message in chat history
+        add_chat_message(user_id, "user", user_input)
+        add_chat_message(user_id, "assistant", ai_response_text)
+        
+        # Generate recommendations if enabled
+        if generate_recommendations:
+            gen_recommendations(user_id, user_input, ai_response_text)
+        
+        return ai_response_text
     except Exception as e:
         logger.error(f"Error in get_ai_response: {str(e)}")
         return "I apologize, but I'm having trouble processing your request right now. Please try again later."
 
+def gen_recommendations(user_id, user_input, ai_response):
+    """Generate recommendations based on conversation"""
+    try:
+        user_profile = get_user_profile(user_id)
+        
+        prompt = f"""
+        Based on the following conversation between a user and Aishura (an AI career assistant),
+        generate 1-3 specific, actionable recommendations for the user's next steps in their career journey.
+        
+        User Profile:
+        - Current emotion: {user_profile.get('current_emotion', '')}
+        - Career goal: {user_profile.get('career_goal', '')}
+        - Location: {user_profile.get('location', '')}
+        
+        Recent Conversation:
+        User: {user_input}
+        
+        Aishura: {ai_response}
+        
+        Generate specific, actionable recommendations in JSON format:
+        ```json
+        [
+          {{
+            "title": "Brief recommendation title",
+            "description": "Detailed recommendation description",
+            "action_type": "job_search|skill_building|networking|resume|portfolio|interview_prep|other",
+            "priority": "high|medium|low"
+          }}
+        ]
+        ```
+        
+        Focus on immediate, practical next steps that align with the user's goals and emotional state.
+        """
+        
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=prompt
+        )
+        
+        recommendation_text = response.text
+        
+        # Extract JSON from response
+        try:
+            # Find JSON content between ```json and ``` if present
+            if "```json" in recommendation_text and "```" in recommendation_text.split("```json")[1]:
+                json_str = recommendation_text.split("```json")[1].split("```")[0].strip()
+            else:
+                # Otherwise try to find anything that looks like JSON array
+                import re
+                json_match = re.search(r'(\[.*\])', recommendation_text, re.DOTALL)
+                if json_match:
+                    json_str = json_match.group(1)
+                else:
+                    json_str = recommendation_text
+                    
+            recommendations = json.loads(json_str)
+            
+            # Add recommendations to user profile
+            for rec in recommendations:
+                add_recommendation_to_user(user_id, rec)
+                
+            return recommendations
+        except json.JSONDecodeError:
+            logger.error(f"Failed to parse JSON from AI response: {recommendation_text}")
+            return []
+    except Exception as e:
+        logger.error(f"Error in gen_recommendations: {str(e)}")
+        return []
+
 def create_personalized_routine_with_ai(user_id, emotion, goal, available_time=60, days=7):
     """Create a personalized routine using AI"""
     try:
+        user_profile = get_user_profile(user_id)
+        
         prompt = f"""
         Create a personalized {days}-day career development routine for a user who is feeling {emotion} and has a goal to {goal}.
         They have about {available_time} minutes per day to dedicate to this routine.
@@ -347,10 +592,51 @@ def create_personalized_routine_with_ai(user_id, emotion, goal, available_time=6
         3. Points value (between 10-50)
         4. A brief description of why this task is valuable
         
-        Format the routine as a JSON object.
+        Format the routine as a JSON object with this structure:
+        ```json
+        {{
+          "name": "Routine name",
+          "description": "Brief description of the routine",
+          "days": {days},
+          "daily_tasks": [
+            {{
+              "day": 1,
+              "tasks": [
+                {{
+                  "name": "Task name",
+                  "points": 20,
+                  "duration": 30,
+                  "description": "Why this task is valuable"
+                }}
+              ]
+            }}
+          ]
+        }}
+        ```
         """
         
-        response = model.generate_content(prompt)
+        # Use resume and portfolio info if available
+        if user_profile.get('resume_path') and os.path.exists(user_profile.get('resume_path')):
+            try:
+                with open(user_profile.get('resume_path'), 'r') as file:
+                    resume_text = file.read()
+                    prompt += f"\n\nTailor the routine based on the user's resume. Here's a summary: {resume_text[:500]}..."
+            except Exception as e:
+                logger.error(f"Error reading resume: {str(e)}")
+                
+        if user_profile.get('portfolio_path') and os.path.exists(user_profile.get('portfolio_path')):
+            try:
+                with open(user_profile.get('portfolio_path'), 'r') as file:
+                    portfolio_data = json.load(file)
+                    prompt += f"\n\nConsider the user's portfolio when creating the routine. Portfolio URL: {portfolio_data.get('url', 'Not provided')}"
+            except Exception as e:
+                logger.error(f"Error reading portfolio: {str(e)}")
+        
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=prompt
+        )
+        
         routine_text = response.text
         
         # Extract JSON portion from the response
@@ -458,12 +744,88 @@ def generate_document_template_with_ai(document_type, career_field="", experienc
         Format it in markdown.
         """
         
-        response = model.generate_content(prompt)
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=prompt
+        )
+        
         return response.text
     except Exception as e:
         logger.error(f"Error in generate_document_template_with_ai: {str(e)}")
         return f"Error generating {document_type} template. Please try again later."
 
+def analyze_resume_with_ai(user_id, resume_text):
+    """Analyze resume with AI and provide feedback"""
+    try:
+        user_profile = get_user_profile(user_id)
+        
+        prompt = f"""
+        Analyze the following resume for a user who has the career goal of: {user_profile.get('career_goal', 'improving their career')}
+        
+        Resume Text:
+        {resume_text}
+        
+        Provide detailed feedback on:
+        1. Overall strengths and weaknesses
+        2. Format and organization
+        3. Content effectiveness for their career goal
+        4. Specific improvement suggestions
+        5. Keywords and skills that should be highlighted
+        
+        Format your analysis with markdown headings and bullet points.
+        """
+        
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=prompt
+        )
+        
+        # Save resume
+        save_user_resume(user_id, resume_text)
+        
+        return response.text
+    except Exception as e:
+        logger.error(f"Error in analyze_resume_with_ai: {str(e)}")
+        return "I apologize, but I'm having trouble analyzing your resume right now. Please try again later."
+
+def analyze_portfolio_with_ai(user_id, portfolio_url, portfolio_description):
+    """Analyze portfolio with AI and provide feedback"""
+    try:
+        user_profile = get_user_profile(user_id)
+        
+        prompt = f"""
+        Analyze the following portfolio for a user who has the career goal of: {user_profile.get('career_goal', 'improving their career')}
+        
+        Portfolio URL: {portfolio_url}
+        Portfolio Description: {portfolio_description}
+        
+        Based on the description provided, analyze:
+        1. How well the portfolio aligns with their career goal
+        2. Strengths of the portfolio
+        3. Areas for improvement
+        4. Specific suggestions to enhance the portfolio
+        5. How to better showcase skills relevant to their goal
+        
+        Format your analysis with markdown headings and bullet points.
+        """
+        
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=prompt
+        )
+        
+        # Save portfolio info
+        portfolio_content = {
+            "url": portfolio_url,
+            "description": portfolio_description
+        }
+        save_user_portfolio(user_id, portfolio_content)
+        
+        return response.text
+    except Exception as e:
+        logger.error(f"Error in analyze_portfolio_with_ai: {str(e)}")
+        return "I apologize, but I'm having trouble analyzing your portfolio right now. Please try again later."
+
 # Chart and visualization functions
 def create_emotion_chart(user_id):
     """Create a chart of user's emotions over time"""
@@ -594,6 +956,109 @@ def create_routine_completion_gauge(user_id):
     
     return fig
 
+def create_skill_radar_chart(user_id):
+    """Create a radar chart of user's skills based on resume analysis"""
+    user_profile = get_user_profile(user_id)
+    
+    # If no resume, return empty chart
+    if not user_profile.get('resume_path') or not os.path.exists(user_profile.get('resume_path')):
+        fig = go.Figure()
+        fig.add_annotation(text="No resume data available yet", showarrow=False)
+        return fig
+    
+    # Read resume
+    try:
+        with open(user_profile.get('resume_path'), 'r') as file:
+            resume_text = file.read()
+    except Exception as e:
+        logger.error(f"Error reading resume: {str(e)}")
+        fig = go.Figure()
+        fig.add_annotation(text="Error reading resume data", showarrow=False)
+        return fig
+    
+    # Use AI to extract and score skills
+    prompt = f"""
+    Based on the following resume, identify 5-8 key skills and rate them on a scale of 1-10.
+    
+    Resume:
+    {resume_text[:2000]}...
+    
+    Return the results as a JSON object with this structure:
+    ```json
+    {{
+      "skills": [
+        {{"name": "Skill Name", "score": 7}},
+        {{"name": "Another Skill", "score": 9}}
+      ]
+    }}
+    ```
+    """
+    
+    try:
+        response = client.models.generate_content(
+            model=MODEL_ID,
+            contents=prompt
+        )
+        
+        skill_text = response.text
+        
+        # Extract JSON
+        if "```json" in skill_text and "```" in skill_text.split("```json")[1]:
+            json_str = skill_text.split("```json")[1].split("```")[0].strip()
+        else:
+            import re
+            json_match = re.search(r'(\{.*\})', skill_text, re.DOTALL)
+            if json_match:
+                json_str = json_match.group(1)
+            else:
+                json_str = skill_text
+                
+        skill_data = json.loads(json_str)
+        
+        # Create radar chart
+        if 'skills' in skill_data and skill_data['skills']:
+            skills = skill_data['skills']
+            
+            # Prepare data for radar chart
+            categories = [skill['name'] for skill in skills]
+            values = [skill['score'] for skill in skills]
+            
+            # Add the first point at the end to close the loop
+            categories.append(categories[0])
+            values.append(values[0])
+            
+            fig = go.Figure()
+            
+            fig.add_trace(go.Scatterpolar(
+                r=values,
+                theta=categories,
+                fill='toself',
+                name='Skills'
+            ))
+            
+            fig.update_layout(
+                polar=dict(
+                    radialaxis=dict(
+                        visible=True,
+                        range=[0, 10]
+                    )
+                ),
+                showlegend=False,
+                title="Skill Assessment Based on Resume"
+            )
+            
+            return fig
+        else:
+            fig = go.Figure()
+            fig.add_annotation(text="Could not extract skills from resume", showarrow=False)
+            return fig
+            
+    except Exception as e:
+        logger.error(f"Error creating skill radar chart: {str(e)}")
+        fig = go.Figure()
+        fig.add_annotation(text="Error analyzing skills", showarrow=False)
+        return fig
+
 # Gradio interface components
 def create_interface():
     """Create the Gradio interface for Aishura MVP"""
@@ -630,19 +1095,20 @@ def create_interface():
     
     # Chat function
     def chat(message, history):
-        # Record the user message for context
-        if not history:
-            history = []
+        # Get user profile
+        user_profile = get_user_profile(session_user_id)
         
-        # Add user's message to history
-        history.append({"role": "user", "parts": [message]})
+        # Convert history to the format expected by get_ai_response
+        context = []
+        for h in history:
+            context.append({"role": "user", "message": h[0]})
+            context.append({"role": "assistant", "message": h[1]})
         
         # Get AI response
-        response = get_ai_response(session_user_id, message, history)
-        
-        # Add AI's response to history
-        history.append({"role": "assistant", "parts": [response]})
+        response = get_ai_response(session_user_id, message, context)
         
+        # Return updated history and empty message
+        history.append((message, response))
         return history, ""
     
     # Function to search for jobs
@@ -683,11 +1149,28 @@ def create_interface():
                 result += f"- **{task['name']}** ({task['duration']} mins, {task['points']} points)\n"
                 result += f"  *{task['description']}*\n\n"
         
-        # Add the routine to user's profile
-        add_routine_to_user(session_user_id, routine)
-        
         return result
     
+    # Function to analyze resume
+    def analyze_resume_interface(resume_text):
+        if not resume_text:
+            return "Please enter your resume text."
+        
+        analysis = analyze_resume_with_ai(session_user_id, resume_text)
+        
+        # Update skill chart
+        skill_fig = create_skill_radar_chart(session_user_id)
+        
+        return analysis, skill_fig
+    
+    # Function to analyze portfolio
+    def analyze_portfolio_interface(portfolio_url, portfolio_description):
+        if not portfolio_description:
+            return "Please enter a description of your portfolio."
+        
+        analysis = analyze_portfolio_with_ai(session_user_id, portfolio_url, portfolio_description)
+        return analysis
+    
     # Function to mark a task as complete
     def complete_task(task_name):
         if not task_name:
@@ -728,6 +1211,29 @@ def create_interface():
             emotion_fig
         )
     
+    # Function to display recommendations
+    def display_recommendations():
+        user_profile = get_user_profile(session_user_id)
+        recommendations = user_profile.get('recommendations', [])
+        
+        if not recommendations:
+            return "No recommendations available yet. Continue chatting with Aishura to receive personalized suggestions."
+        
+        # Show the most recent 5 recommendations
+        recent_recs = recommendations[-5:]
+        
+        result = "# Your Personalized Recommendations\n\n"
+        
+        for i, rec in enumerate(recent_recs, 1):
+            recommendation = rec['recommendation']
+            result += f"## {i}. {recommendation['title']}\n\n"
+            result += f"{recommendation['description']}\n\n"
+            result += f"**Priority:** {recommendation['priority'].title()}\n"
+            result += f"**Type:** {recommendation['action_type'].replace('_', ' ').title()}\n\n"
+            result += "---\n\n"
+        
+        return result
+    
     # Create the interface
     with gr.Blocks(theme=gr.themes.Soft()) as app:
         gr.Markdown("# Aishura - Your AI Career Assistant")
@@ -750,10 +1256,49 @@ def create_interface():
             with gr.Tabs() as tabs:
                 # Chat tab
                 with gr.TabItem("Chat with Aishura"):
-                    chatbot = gr.Chatbot(height=400, avatar_images=["👤", "🤖"])
-                    msg = gr.Textbox(show_label=False, placeholder="Type your message here...", container=False)
+                    with gr.Row():
+                        with gr.Column(scale=2):
+                            chatbot = gr.Chatbot(height=500, avatar_images=["👤", "🤖"])
+                            msg = gr.Textbox(show_label=False, placeholder="Type your message here...", container=False)
+                        
+                        with gr.Column(scale=1):
+                            gr.Markdown("## Your Recommendations")
+                            recommendation_output = gr.Markdown()
+                            refresh_recs_button = gr.Button("Refresh Recommendations")
                     
                     msg.submit(chat, [msg, chatbot], [chatbot, msg])
+                    refresh_recs_button.click(display_recommendations, [], recommendation_output)
+                
+                # Profile and Career Analysis tab
+                with gr.TabItem("Profile & Analysis"):
+                    with gr.Tabs() as analysis_tabs:
+                        # Resume Analysis
+                        with gr.TabItem("Resume Analysis"):
+                            gr.Markdown("## Resume Analysis")
+                            resume_text = gr.Textbox(label="Paste your resume here", lines=10, placeholder="Copy and paste your entire resume here for analysis...")
+                            analyze_resume_button = gr.Button("Analyze Resume")
+                            resume_output = gr.Markdown()
+                            skill_chart = gr.Plot(label="Skill Assessment")
+                            
+                            analyze_resume_button.click(
+                                analyze_resume_interface, 
+                                [resume_text], 
+                                [resume_output, skill_chart]
+                            )
+                        
+                        # Portfolio Analysis
+                        with gr.TabItem("Portfolio Analysis"):
+                            gr.Markdown("## Portfolio Analysis")
+                            portfolio_url = gr.Textbox(label="Portfolio URL", placeholder="https://your-portfolio-website.com")
+                            portfolio_description = gr.Textbox(label="Describe your portfolio", lines=5, placeholder="Describe the content, structure, and purpose of your portfolio...")
+                            analyze_portfolio_button = gr.Button("Analyze Portfolio")
+                            portfolio_output = gr.Markdown()
+                            
+                            analyze_portfolio_button.click(
+                                analyze_portfolio_interface, 
+                                [portfolio_url, portfolio_description], 
+                                portfolio_output
+                            )
                 
                 # Job Search tab
                 with gr.TabItem("Find Opportunities"):
@@ -771,7 +1316,7 @@ def create_interface():
                 with gr.TabItem("Document Templates"):
                     gr.Markdown("## Generate Document Templates")
                     doc_type = gr.Dropdown(
-                        choices=["Resume", "Cover Letter", "Self-Introduction", "LinkedIn Profile", "Portfolio"], 
+                        choices=["Resume", "Cover Letter", "Self-Introduction", "LinkedIn Profile", "Portfolio", "Interview Preparation"], 
                         label="Document Type"
                     )
                     career_field = gr.Textbox(label="Career Field/Industry")
@@ -843,6 +1388,13 @@ def create_interface():
             [name_input, location_input, emotion_dropdown, goal_dropdown],
             [welcome_output, welcome_group, main_interface]
         )
+        
+        # Load initial recommendations
+        app.load(
+            display_recommendations,
+            [],
+            recommendation_output
+        )
     
     return app