changes made

.env

@@ -0,0 +1,3 @@
+SUPABASE_URL=https://qxvpaoeakhddzabctekw.supabase.co
+SUPABASE_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InF4dnBhb2Vha2hkZHphYmN0ZWt3Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NDEwNjU2MzEsImV4cCI6MjA1NjY0MTYzMX0.I3GsBjFRfuBKw-KxmSJ7R5iKn2cgGegqIls2Bf32UpI
+

app.py

@@ -2,175 +2,551 @@ import streamlit as st
 import requests
 import pandas as pd
 import plotly.express as px
+import time
+from chatbot import main as chatbot_main
+import matplotlib.pyplot as plt
+import plotly.figure_factory as ff
+import base64
+from sklearn.linear_model import LinearRegression, LogisticRegression
+import numpy as np
+from sklearn.preprocessing import LabelEncoder
+import plotly.graph_objects as go
+
+encoder = LabelEncoder()
+
+# ✅ Set Page Config at the Top
+st.set_page_config(page_title="HR Analytics Dashboard", layout="wide")
 
 # Backend API URL
 API_BASE_URL = "https://logeswari-cap-backend.hf.space"
 
+USERNAME = "admin"
+PASSWORD = "password123"
+
+# ✅ Store Auth State in Session
+if "authenticated" not in st.session_state:
+    st.session_state.authenticated = False
+
+
+# ========== Authentication Function ==========
+def authenticate():
+    st.title("🔒 Login to HR Analytics Dashboard")
+    st.write("Please enter your credentials to continue.")
+
+    username = st.text_input("Username", value="", key="username")
+    password = st.text_input("Password", type="password", value="", key="password")
+
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        if st.button("Login"):
+            if username == USERNAME and password == PASSWORD:
+                st.session_state.authenticated = True
+                st.success("✅ Logged in successfully!")
+                time.sleep(1)
+                st.rerun()
+            else:
+                st.error("❌ Invalid username or password")
+
+    with col2:
+        if st.button("Cancel"):
+            st.session_state.authenticated = False
+            st.experimental_rerun()
+def plot_correlation_heatmap(df):
+    st.subheader("📊 Correlation Heatmap")
+    corr = df.corr()
+    fig = ff.create_annotated_heatmap(
+        z=corr.values, 
+        x=list(corr.columns),
+        y=list(corr.index),
+        colorscale='Viridis'
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+def plot_treemap(df, path, values, title):
+    st.subheader(title)
+    fig = px.treemap(df, path=path, values=values, title=title, color=values)
+    st.plotly_chart(fig, use_container_width=True)
+
+def plot_radar_chart(categories, values, title):
+    fig = go.Figure()
+    fig.add_trace(go.Scatterpolar(r=values, theta=categories, fill='toself', name='Employee'))
+    fig.update_layout(polar=dict(radialaxis=dict(visible=True)), title=title)
+    st.plotly_chart(fig, use_container_width=True)            
+
+def get_base64_image(file_path):
+    with open(file_path, "rb") as file:
+        encoded = base64.b64encode(file.read()).decode("utf-8")
+        return f"data:image/gif;base64,{encoded}"   
+
+human_image_path = "D:\capstone\Data_new\Frontend\cap_frontend\istockphoto-1221348467-612x612.jpg"
+human_base64 = get_base64_image(human_image_path)
+
+# ✅ Add Human Image in Bottom Right (Clickable)
+# In your human image code, change this:
+st.markdown(
+    f"""
+    <div style="
+        position: fixed;
+        bottom: 20px;
+        right: 20px;
+        z-index: 9999;
+        text-align: center;
+    ">
+        <a href="?page=HR_Chatbot">
+            <img src="{human_base64}" alt="Chatbot" style="
+                width: 80px;
+                height: 80px;
+                border-radius: 50%;
+                cursor: pointer;
+                border: 3px solid #4CAF50;
+                box-shadow: 0px 4px 8px rgba(0,0,0,0.2);
+                transition: 0.3s;
+            " />
+        </a>
+        <h4 style="color: #4CAF50; font-size: 14px; margin-top: 5px;">💬 Chatbot</h4>
+    </div>
+    """,
+    unsafe_allow_html=True
+)
+
+# ✅ Logout Button
+def logout():
+    st.session_state.authenticated = False
+    st.success("✅ Logged out successfully!")
+    time.sleep(1)
+    st.rerun()
+
+
+# ✅ Show Login Page if Not Authenticated
+if not st.session_state.authenticated:
+    authenticate()
+
+else:
+    # ✅ Logout Button at Top Right
+    st.markdown(
+        """
+        <div style="position: fixed; top: 10px; right: 10px; z-index: 9999;">
+            <form action="" method="post">
+                <input type="submit" value="🚪 Logout" style="
+                    background-color: red;
+                    color: white;
+                    border: none;
+                    padding: 8px 16px;
+                    border-radius: 4px;
+                    cursor: pointer;
+                " onclick="fetch('/_logout', {method: 'POST'})">
+            </form>
+        </div>
+        """,
+        unsafe_allow_html=True
+    )
+
+    # ========== Fetch Data Function ==========
+    def fetch_data(endpoint, params=None):
+        url = f"{API_BASE_URL}{endpoint}"
+        placeholder = st.empty()
+
+        try:
+            # ✅ Show Loading GIF
+            with placeholder.container():
+                st.write("⏳ Loading data...")
+                time.sleep(2)  # Simulate loading delay
+            
+            response = requests.get(url, params=params)
+            response.raise_for_status()
+            data = response.json()
+            
+            placeholder.empty()
+            
+            return pd.DataFrame(data) if isinstance(data, list) else pd.DataFrame([data])
+        except requests.exceptions.RequestException as e:
+            placeholder.empty()
+            st.error(f"Error fetching data: {e}")
+            return None
+
+    # ========== Prediction Request Function ==========
+    def send_prediction_request(endpoint, payload):
+        placeholder = st.empty()
+
+        try:
+            with placeholder.container():
+                st.write("⏳ Processing...")
+                time.sleep(2)  # Simulate loading delay
+            
+            url = f"{API_BASE_URL}{endpoint}"
+            response = requests.post(url, json=payload)
+            placeholder.empty()
+
+            if response.status_code == 200:
+                return response.json()
+            else:
+                st.error(f"Error: {response.json().get('detail', 'Unknown error')}")
+                return None
+        except requests.exceptions.RequestException as e:
+            placeholder.empty()
+            st.error(f"Request error: {e}")
+            return None
+        
+
+        
+        
+# Convert the local GIF to base64
+def get_base64_image(file_path):
+    with open(file_path, "rb") as file:
+        encoded = base64.b64encode(file.read()).decode("utf-8")
+        return f"data:image/gif;base64,{encoded}"
+    
+    # ✅ Load Human Image as Base64
+
+
+
+# Path to local brain GIF file
+gif_base64_dashboard = get_base64_image("D:/capstone/Data_new/Frontend/cap_frontend/samplegif.gif")
+gif_base64_prediction = get_base64_image("D:/capstone/Data_new/Frontend/cap_frontend/samplegif.gif")
+def display_chart(data, chart_type, x_col, y_col, title):
+    """Display different types of charts based on user selection."""
+    if data is None or data.empty:
+        st.warning(f"No data available for {title}")
+        return
+
+    st.title(title)
+
+    if chart_type == "bar":
+        fig = px.bar(data, x=x_col, y=y_col, color=y_col, title=title, height=500)
+    elif chart_type == "scatter":
+        fig = px.scatter(data, x=x_col, y=y_col, color=y_col, title=title, size=y_col, height=500)
+    elif chart_type == "line":
+        fig = px.line(data, x=x_col, y=y_col, markers=True, title=title, height=500)
+    elif chart_type == "pie":
+        fig = px.pie(data, names=x_col, values=y_col, title=title)
+    elif chart_type == "histogram":
+        fig = px.histogram(data, x=x_col, title=title, nbins=10, height=500)
+    elif chart_type == "bubble":
+        if y_col in data.columns:
+            fig = px.scatter(data, x=x_col, y=y_col, size=y_col, color=y_col, hover_name=x_col, size_max=60, title=title)
+        else:
+            st.warning(f"{y_col} not found in data.")
+            return
+    elif chart_type == "treemap":
+        if x_col in data.columns and y_col in data.columns:
+            fig = px.treemap(data, path=[x_col], values=y_col, title=title)
+        else:
+            st.warning(f"{x_col} or {y_col} not found in data.")
+            return 
+    else:
+        st.warning("Invalid chart type")
+        return
+
+    st.plotly_chart(fig, use_container_width=True)
+
+# ========== Fetch Data Function ==========
 def fetch_data(endpoint, params=None):
-    """Fetch data from the FastAPI backend with optional query parameters."""
     url = f"{API_BASE_URL}{endpoint}"
-    
+    placeholder = st.empty()
+
     try:
+        # ✅ Show dashboard loading GIF
+        with placeholder.container():
+            st.markdown(
+                f"""
+                <div style="position: fixed; 
+                            top: 0; left: 100px;
+                            width: 100%; height: 100%;
+                            display: flex;
+                            justify-content: center;
+                            align-items: center;
+                            background-color: rgba(0, 0, 0, 0.5);
+                            z-index: 9999;">
+                    <img src="{gif_base64_dashboard}" alt="Loading..." width="120" />
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+            time.sleep(2)  # Simulate loading delay
+        
         response = requests.get(url, params=params)
         response.raise_for_status()
         data = response.json()
         
-        # Debugging: Print API response
-        print(f"Fetched from {url} | Params: {params} | Response: {data}")
-
-        # Handle single scalar values (like correlation coefficients)
-        if isinstance(data, dict) and len(data) == 1 and isinstance(list(data.values())[0], (int, float)):
-            return pd.DataFrame([data])  # Convert dictionary to DataFrame
+        # ✅ Remove GIF after fetching
+        placeholder.empty()
         
-        return pd.DataFrame(data)  # Convert list to DataFrame
+        return pd.DataFrame(data) if isinstance(data, list) else pd.DataFrame([data])
+    
     except requests.exceptions.RequestException as e:
+        placeholder.empty()
         st.error(f"Error fetching data: {e}")
         return None
 
+# ========== Prediction Request Function ==========
+def send_prediction_request(endpoint, payload):
+    placeholder = st.empty()
 
-# ✅ Set up Streamlit app layout
-st.set_page_config(page_title="HR Analytics Dashboard", layout="wide")
+    try:
+        with placeholder.container():
+            # ✅ Show prediction-specific loading GIF
+            st.markdown(
+                f"""
+                <div style="position: fixed;
+                            top: 0; left: 100px;
+                            width: 100%; height: 100%;
+                            display: flex;
+                            justify-content: center;
+                            align-items: center;
+                            background-color: rgba(0, 0, 0, 0.5);
+                            z-index: 9999;">
+                    <img src="{gif_base64_prediction}" alt="Processing..." width="120" />
+                </div>
+                """,
+                unsafe_allow_html=True
+            )
+            time.sleep(4)  # Simulate processing delay
+        
+        url = f"{API_BASE_URL}{endpoint}"
+        response = requests.post(url, json=payload)
+        
+        # ✅ Remove GIF after processing
+        placeholder.empty()
 
-# ✅ Sidebar Navigation: Two main pages
-st.sidebar.title("📊 HR Analytics Dashboard")
-page = st.sidebar.selectbox("Select Page", ["🏠 Home", "📈 Analytics Dashboard"])
+        if response.status_code == 200:
+            return response.json()
+        else:
+            st.error(f"Error: {response.json().get('detail', 'Unknown error')}")
+            return None
+
+    except requests.exceptions.RequestException as e:
+        placeholder.empty()
+        st.error(f"Request error: {e}")
+        return None
+    
+# ========== Set Up Streamlit Layout ==========
+
+
+# ========== Sidebar ==========
+import base64
+
+def get_base64_image(file_path):
+    with open(file_path, "rb") as file:
+        encoded = base64.b64encode(file.read()).decode("utf-8")
+        return f"data:image/gif;base64,{encoded}"
+
+# Load GIF as base64
+gif_base64_sidebar = get_base64_image("D:/capstone/Data_new/Frontend/cap_frontend/gif image.gif")
+
+# Embed GIF using HTML
+st.sidebar.markdown(
+    f"""
+    <div style="text-align: center;">
+        <img src="{gif_base64_sidebar}" alt="Loading..." style="width: 100%; max-width: 500px;height:220px" />
+    </div>
+    """,
+    unsafe_allow_html=True
+)
+
+
+if st.query_params.get("page") == "HR_Chatbot":
+    page = "🤖 HR Chatbot"
+else:
+    # Your existing page selection code
+    page = st.sidebar.selectbox("Select Page", [
+        "🏠 Home", 
+        "📈 Analytics Dashboard", 
+        "🧠 AI Predictions",
+        "🤖 HR Chatbot"
+    ])
 
-# ✅ HOME PAGE
+# ========== Home Page ==========
 if page == "🏠 Home":
     st.title("🏠 Welcome to the HR Analytics Dashboard")
-    st.write("Explore different HR metrics and insights.")
 
-# ✅ ANALYTICS DASHBOARD (with 9 endpoints)
+    st.markdown(
+    """
+    ### 🚀 About the Platform  
+    This platform leverages employee data to provide actionable insights on satisfaction, performance, training effectiveness, and more.  
+    Built using **FastAPI** and **Streamlit**, it enables you to explore trends, identify improvement areas, and forecast future performance.  
+
+    ### 🌟 Key Features  
+    - ✅ **Employee Satisfaction Analysis** – Track satisfaction scores and identify key drivers.  
+    - ✅ **Departmental Performance Metrics** – Compare and track performance across departments.  
+    - ✅ **Training Program Analytics** – Measure training effectiveness and ROI.  
+    - ✅ **Engagement-Performance Correlation** – Analyze how engagement impacts performance.  
+    - ✅ **Cost-Benefit Analysis** – Measure ROI of training programs and performance improvements.  
+    - ✅ **Training Effectiveness Metrics** – Assess training program success rates.  
+    - ✅ **Diversity and Inclusion Dashboard** – Monitor workforce diversity and inclusion metrics.  
+    - ✅ **Work-Life Balance Impact Study** – Explore how work-life balance influences performance.  
+    - ✅ **Career Development Tracking** – Monitor employee progression and promotion trends.  
+
+    ### 🤖 AI-Powered Insights  
+    - **Satisfaction Prediction** – Predict employee satisfaction using engagement and performance data.  
+    - **Performance Forecasting** – Forecast employee performance based on historical data.  
+    - **Employee Retention Risk** – Identify employees at risk of leaving the organization.  
+    - **Training Success Prediction** – Estimate training completion rates and success.  
+
+    ### 📊 How to Use the Dashboard  
+    1. **Select the type of analysis** from the sidebar.  
+    2. View results in both **graph and table format**.  
+    3. Filter data by **department, date, or employee type**.  
+    4. Export insights for further analysis.  
+
+    ### 🔐 Secure Data Handling  
+    All data is securely processed and protected using industry-standard encryption and authentication methods.  
+    """
+)
+
+
+# ========== Analytics Dashboard ==========
 elif page == "📈 Analytics Dashboard":
     
-    # Select an analysis option inside the Analytics page
-    analysis_option = st.sidebar.selectbox("Choose an analysis:", [
+    # ✅ Create Tabs Instead of Sidebar Dropdown
+    tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8, tab9 = st.tabs([
         "Employee Satisfaction", "Department Performance", "Training Analytics", 
         "Engagement-Performance Correlation", "Cost-Benefit Analysis", 
         "Training Effectiveness", "Diversity & Inclusion", "Work-Life Balance Impact", 
         "Career Development Tracking"
     ])
 
-    def display_chart(data, chart_type, x_col, y_col, title):
-        """Display different types of charts based on user selection."""
-        if data is None or data.empty:
-            st.warning(f"No data available for {title}")
-            return
-
-        st.title(title)
-        st.dataframe(data)  # Show table before visualization
-
-        if chart_type == "bar":
-            fig = px.bar(data, x=x_col, y=y_col, color=y_col, title=title, height=500)
-        elif chart_type == "scatter":
-            fig = px.scatter(data, x=x_col, y=y_col, color=y_col, title=title, size=y_col, height=500)
-        elif chart_type == "line":
-            fig = px.line(data, x=x_col, y=y_col, markers=True, title=title, height=500)
-        elif chart_type == "pie":
-            fig = px.pie(data, names=x_col, values=y_col, title=title)
-        elif chart_type == "histogram":
-            fig = px.histogram(data, x=x_col, title=title, nbins=10, height=500)
-        else:
-            st.warning("Invalid chart type")
-            return
-
-        st.plotly_chart(fig, use_container_width=True)
-
-
     # ✅ Employee Satisfaction Analysis
-    if analysis_option == "Employee Satisfaction":
-        department = st.sidebar.text_input("Enter Department (optional):")
+    with tab1:
+        department = st.text_input("Enter Department (optional):")
         params = {"department": department} if department else None
         data = fetch_data("/satisfaction-analysis", params)
 
         if data is not None and not data.empty:
             st.subheader(f"📊 Employee Satisfaction in {department if department else 'All Departments'}")
-            display_chart(data, "bar", "DepartmentType", "Satisfaction Score", "📊 Employee Satisfaction by Department")
-        else:
-            st.warning(f"No data available for the selected department: {department}")
 
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="satisfaction_view")
+
+            
+            if view_option == "Graph View":
+                display_chart(data, "bar", "DepartmentType", "Satisfaction Score", "📊 Employee Satisfaction by Department")
+
+            else:
+                st.dataframe(data)
 
     # ✅ Department Performance Metrics
-    if analysis_option == "Department Performance":
+    with tab2:
         data = fetch_data("/department-performance")
-        display_chart(data, "scatter", "DepartmentType", "Performance Score", "📊 Departmental Performance Metrics")
 
+        if data is not None and not data.empty:
+            st.subheader("📊 Departmental Performance Metrics")
+
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="performance_view")
+
+            
+            if view_option == "Graph View":
+                display_chart(data, "scatter", "DepartmentType", "Performance Score", "📊 Departmental Performance Metrics")
+            else:
+                st.dataframe(data)
 
     # ✅ Training Program Analytics
-    if analysis_option == "Training Analytics":
-        program_name = st.sidebar.text_input("Enter Training Program Name (optional):")
+    with tab3:
+        program_name = st.text_input("Enter Training Program Name (optional):")
         params = {"program_name": program_name} if program_name else None
         data = fetch_data("/training-analytics", params)
 
         if data is not None and not data.empty:
-            st.title("📊 Training Program Analytics")
-            st.dataframe(data)
+            st.subheader("📊 Training Program Analytics")
 
-            if "Training Program Name" in data.columns:
-                melted_data = data.melt(id_vars="Training Program Name", var_name="Outcome", value_name="Percentage")
-                display_chart(melted_data, "bar", "Training Program Name", "Percentage", "📊 Training Outcomes by Program")
-            else:
-                st.warning("Training Program Name column missing in data.")
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="training_view")
 
 
+            if view_option == "Graph View":
+                if "Training Program Name" in data.columns:
+                    melted_data = data.melt(id_vars="Training Program Name", var_name="Outcome", value_name="Percentage")
+                    display_chart(melted_data, "bubble", "Training Program Name", "Percentage", "📊 Training Outcomes by Program")
+                else:
+                    st.warning("Training Program Name column missing in data.")
+            else:
+                st.dataframe(data)
+
     # ✅ Engagement vs. Performance Correlation
-    if analysis_option == "Engagement-Performance Correlation":
+    with tab4:
         data = fetch_data("/engagement-performance")
-        
+
         if data is not None and not data.empty:
-            st.title("📊 Engagement vs. Performance Correlation")
-            correlation_value = data.iloc[0, 0]  # Extract correlation coefficient
-            st.metric(label="Correlation Coefficient", value=f"{correlation_value:.2f}")  # Display metric
+            st.subheader("📊 Engagement vs. Performance Correlation")
+
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="engagement_view")
 
 
+            correlation_value = data.iloc[0, 0]
+            if view_option == "Graph View":
+                st.metric(label="Correlation Coefficient", value=f"{correlation_value:.2f}")
+            else:
+                st.write(f"Correlation Coefficient: **{correlation_value:.2f}**")
+
     # ✅ Cost-Benefit Analysis
-    if analysis_option == "Cost-Benefit Analysis":
+    with tab5:
         data = fetch_data("/cost-benefit-analysis")
-        display_chart(data, "pie", "DepartmentType", "ROI", "📊 Cost-Benefit Analysis")
+
+        if data is not None and not data.empty:
+            st.subheader("📊 Cost-Benefit Analysis")
+
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="cost_benefit_view")
 
 
+            if view_option == "Graph View":
+                display_chart(data, "pie", "DepartmentType", "ROI", "📊 Cost-Benefit Analysis")
+            else:
+                st.dataframe(data)
+
     # ✅ Training Effectiveness Metrics
-    if analysis_option == "Training Effectiveness":
+    with tab6:
         data = fetch_data("/training-effectiveness")
-        display_chart(data, "line", "Training Program Name", "Performance Score", "📊 Training Effectiveness")
 
+        if data is not None and not data.empty:
+            st.subheader("📊 Training Effectiveness")
+
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="effectiveness_view")
+
+
+            if view_option == "Graph View":
+                display_chart(data, "line", "Training Program Name", "Performance Score", "📊 Training Effectiveness")
+            else:
+                st.dataframe(data)
 
     # ✅ Diversity and Inclusion
-    if analysis_option == "Diversity & Inclusion":
+    with tab7:
         data = fetch_data("/diversity-inclusion")
 
         if data is not None and not data.empty:
-            st.title("📊 Diversity and Inclusion Dashboard")
-            st.dataframe(data)
+            st.subheader("📊 Diversity and Inclusion Dashboard")
 
-            # Convert to long format for plotting
-            melted_data = data.melt(id_vars="DepartmentType", var_name="Gender", value_name="Percentage")
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="diversity_view")
 
-            # Bar chart for gender distribution by department
-            fig = px.bar(melted_data, x="DepartmentType", y="Percentage", color="Gender", barmode="group", 
-                         title="📊 Diversity Breakdown by Department", height=500)
-            st.plotly_chart(fig, use_container_width=True)
 
+            if view_option == "Graph View":
+                melted_data = data.melt(id_vars="DepartmentType", var_name="Gender", value_name="Percentage")
+                fig = px.bar(melted_data, x="DepartmentType", y="Percentage", color="Gender", barmode="group", 
+                             title="📊 Diversity Breakdown by Department", height=500)
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.dataframe(data)
 
     # ✅ Work-Life Balance Impact
-    if analysis_option == "Work-Life Balance Impact":
+    with tab8:
         data = fetch_data("/work-life-balance")
 
         if data is not None and not data.empty:
-            st.title("📊 Work-Life Balance vs. Performance Correlation")
-            correlation_value = data.iloc[0, 0] if isinstance(data, pd.DataFrame) else data["correlation_coefficient"]
-            st.metric(label="Correlation Coefficient", value=f"{correlation_value:.2f}")
+            st.subheader("📊 Work-Life Balance vs. Performance Correlation")
 
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="work_life_view")
 
-    # ✅ Career Development Tracking
-    if analysis_option == "Career Development Tracking":
-        st.title("📊 Career Development Tracking")
 
+            correlation_value = data.iloc[0, 0] if isinstance(data, pd.DataFrame) else data["correlation_coefficient"]
+            if view_option == "Graph View":
+                st.metric(label="Correlation Coefficient", value=f"{correlation_value:.2f}")
+            else:
+                st.write(f"Correlation Coefficient: **{correlation_value:.2f}**")
+
+    # ✅ Career Development Tracking
+    with tab9:
         all_employees = fetch_data("/career-development")
-        
+
         if all_employees is not None and not all_employees.empty:
             employee_ids = all_employees["Employee ID"].unique().tolist()
-            selected_employee = st.sidebar.selectbox("Select Employee ID:", [""] + employee_ids)
+            selected_employee = st.selectbox("Select Employee ID:", [""] + employee_ids)
         else:
             selected_employee = None
 
@@ -178,8 +554,241 @@ elif page == "📈 Analytics Dashboard":
         data = fetch_data("/career-development", params)
 
         if data is not None and not data.empty:
-            st.dataframe(data)
-            fig = px.histogram(data, x="Career Movements", title="📊 Career Development Histogram", nbins=10, height=500)
-            st.plotly_chart(fig, use_container_width=True)
-        else:
-            st.warning("No data available for the selected Employee ID.")
+            st.subheader("📊 Career Development Tracking")
+
+            view_option = st.radio("Select View:", ["Graph View", "Table View"], index=0, key="career_development_view")
+
+
+            if view_option == "Graph View":
+                fig = px.histogram(data, x="Career Movements", title="📊 Career Development Histogram", nbins=10, height=500)
+                st.plotly_chart(fig, use_container_width=True)
+            else:
+                st.dataframe(data)
+
+
+# ========== AI-Based Prediction ==========
+elif page == "🧠 AI Predictions":
+    st.title("🧠 AI-Based Employee Success Predictions")
+    prediction_type = st.sidebar.selectbox("Select Prediction Type", [
+        "Satisfaction Prediction", 
+        "Performance Forecasting", 
+        "Employee Retention Risk", 
+        "Training Success Prediction"
+    ])
+
+    # ✅ Satisfaction Prediction
+    if prediction_type == "Satisfaction Prediction":
+        st.subheader("🎯 Predict Employee Satisfaction")
+        engagement_score = st.number_input("Engagement Score", min_value=0, max_value=100, value=50)
+        work_life_balance_score = st.number_input("Work-Life Balance Score", min_value=0, max_value=100, value=50)
+        performance_score = st.number_input("Performance Score", min_value=0, max_value=100, value=50)
+        
+        if st.button("Predict Satisfaction"):
+            payload = {
+                "engagement_score": engagement_score,
+                "work_life_balance_score": work_life_balance_score,
+                "performance_score": performance_score
+            }
+            result = send_prediction_request("/predict/satisfaction", payload)
+            if result:
+                satisfaction_score = result['satisfaction_score']
+                st.success(f"✅ Predicted Satisfaction Score: {satisfaction_score:.2f}")
+                
+                # Add visualization for satisfaction score
+                fig = plt.figure(figsize=(10, 4))
+                
+                # Create gauge chart for satisfaction score
+                ax = fig.add_subplot(121)
+                gauge_colors = [(0.8, 0.0, 0.0, 0.8), (1.0, 0.9, 0.0, 0.8), (0.0, 0.8, 0.0, 0.8)]
+                gauge = plt.cm.RdYlGn(satisfaction_score/100)
+                wedges, texts = ax.pie([satisfaction_score, 100-satisfaction_score], 
+                                       wedgeprops=dict(width=0.3, edgecolor='w'),
+                                       startangle=90, colors=[gauge, (0.9, 0.9, 0.9, 0.4)])
+                ax.text(0, 0, f"{satisfaction_score:.1f}%", ha='center', va='center', fontsize=24)
+                ax.set_title("Satisfaction Score")
+                
+                # Create bar chart for factors
+                ax2 = fig.add_subplot(122)
+                factors = ['Engagement', 'Work-Life Balance', 'Performance']
+                values = [engagement_score, work_life_balance_score, performance_score]
+                colors = [plt.cm.RdYlGn(v/100) for v in values]
+                ax2.bar(factors, values, color=colors)
+                ax2.set_ylim(0, 100)
+                ax2.set_title("Contributing Factors")
+                ax2.set_ylabel("Score")
+                
+                plt.tight_layout()
+                st.pyplot(fig)
+
+    # ✅ Performance Forecasting
+    elif prediction_type == "Performance Forecasting":
+        st.subheader("📈 Predict Employee Performance")
+        satisfaction_score = st.number_input("Satisfaction Score", min_value=0, max_value=100, value=50)
+        engagement_score = st.number_input("Engagement Score", min_value=0, max_value=100, value=50)
+        training_duration = st.number_input("Training Duration (Days)", min_value=1, value=30)
+        training_cost = st.number_input("Training Cost", min_value=0.0, value=1000.0)
+        
+        if st.button("Predict Performance"):
+            payload = {
+                "satisfaction_score": satisfaction_score,
+                "engagement_score": engagement_score,
+                "training_duration": training_duration,
+                "training_cost": training_cost
+            }
+            result = send_prediction_request("/predict/performance", payload)
+            if result:
+                performance_score = result['performance_score']
+                st.success(f"✅ Predicted Performance Score: {performance_score:.2f}")
+                
+                # Add visualization for performance score
+                fig = plt.figure(figsize=(10, 4))
+                
+                # Create gauge chart for performance score
+                ax = fig.add_subplot(121)
+                gauge = plt.cm.RdYlGn(performance_score/100)
+                wedges, texts = ax.pie([performance_score, 100-performance_score], 
+                                      wedgeprops=dict(width=0.3, edgecolor='w'),
+                                      startangle=90, colors=[gauge, (0.9, 0.9, 0.9, 0.4)])
+                ax.text(0, 0, f"{performance_score:.1f}%", ha='center', va='center', fontsize=24)
+                ax.set_title("Performance Score")
+                
+                # Create spider chart for factors
+                ax2 = fig.add_subplot(122, polar=True)
+                factors = ['Satisfaction', 'Engagement', 'Training\nDuration', 'Training\nCost']
+                # Normalize values to 0-1 scale
+                norm_training_duration = min(training_duration / 60, 1)  # Assuming 60 days is max
+                norm_training_cost = min(training_cost / 5000, 1)  # Assuming $5000 is max
+                values = [satisfaction_score/100, engagement_score/100, norm_training_duration, norm_training_cost]
+                
+                angles = np.linspace(0, 2*np.pi, len(factors), endpoint=False).tolist()
+                values = values + [values[0]]  # Close the loop
+                angles = angles + [angles[0]]  # Close the loop
+                factors = factors + [factors[0]]  # Close the loop
+                
+                ax2.plot(angles, values, 'o-', linewidth=2, color='blue')
+                ax2.fill(angles, values, alpha=0.25, color='blue')
+                ax2.set_thetagrids(np.degrees(angles[:-1]), factors[:-1])
+                ax2.set_ylim(0, 1)
+                ax2.set_title("Contributing Factors")
+                
+                plt.tight_layout()
+                st.pyplot(fig)
+
+    # ✅ Retention Risk Prediction
+    elif prediction_type == "Employee Retention Risk":
+        st.subheader("🚨 Predict Employee Retention Risk")
+        satisfaction_score = st.number_input("Satisfaction Score", min_value=0, max_value=100, value=50)
+        engagement_score = st.number_input("Engagement Score", min_value=0, max_value=100, value=50)
+        performance_score = st.number_input("Performance Score", min_value=0, max_value=100, value=50)
+        
+        if st.button("Predict Retention Risk"):
+            payload = {
+                "satisfaction_score": satisfaction_score,
+                "engagement_score": engagement_score,
+                "performance_score": performance_score
+            }
+            result = send_prediction_request("/predict/retention", payload)
+            if result:
+                retention_risk = result['retention_risk']
+                st.success(f"✅ Predicted Retention Risk: {retention_risk}")
+                
+                # Convert text-based risk to numeric for visualization
+                risk_mapping = {"Low": 25, "Medium": 50, "High": 75, "Very High": 95}
+                risk_value = risk_mapping.get(retention_risk, 50)
+                
+                # Add visualization for retention risk
+                fig = plt.figure(figsize=(10, 4))
+                
+                # Create gauge chart for retention risk
+                ax = fig.add_subplot(121)
+                gauge = plt.cm.RdYlGn_r(risk_value/100)  # Reversed colormap for risk
+                wedges, texts = ax.pie([risk_value, 100-risk_value], 
+                                      wedgeprops=dict(width=0.3, edgecolor='w'),
+                                      startangle=90, colors=[gauge, (0.9, 0.9, 0.9, 0.4)])
+                ax.text(0, 0, f"{retention_risk}", ha='center', va='center', fontsize=20)
+                ax.set_title("Retention Risk")
+                
+                # Create horizontal bar chart for factors
+                ax2 = fig.add_subplot(122)
+                factors = ['Satisfaction', 'Engagement', 'Performance']
+                values = [satisfaction_score, engagement_score, performance_score]
+                colors = [plt.cm.RdYlGn(v/100) for v in values]
+                ax2.barh(factors, values, color=colors)
+                ax2.set_xlim(0, 100)
+                ax2.set_title("Employee Metrics")
+                ax2.set_xlabel("Score")
+                
+                plt.tight_layout()
+                st.pyplot(fig)
+
+    # ✅ Training Success Prediction
+    elif prediction_type == "Training Success Prediction":
+            st.subheader("🎓 Predict Training Success")
+            training_type = st.number_input("Training Type (0 = Internal, 1 = External)", min_value=0, max_value=1, value=0, key="training_type_input")
+            training_duration = st.number_input("Training Duration (Days)", min_value=1, value=30, key="training_duration_success_input")
+            training_cost = st.number_input("Training Cost", min_value=0.0, value=1000.0, key="training_cost_success_input")
+            
+            if st.button("Predict Training Success", key="predict_training_success"):
+                model = LogisticRegression()
+                X = np.array([[0, 30, 1000], [1, 45, 2000], [0, 60, 3000]])
+                y = np.array([1, 0, 1])
+                y_encoded = encoder.fit_transform(y)
+
+                model.fit(X, y_encoded)
+
+                input_data = np.array([[training_type, training_duration, training_cost]])
+                training_success = model.predict(input_data)[0]
+                success_status = encoder.inverse_transform([training_success])[0]
+                st.success(f"✅ Predicted Training Success: {success_status}")
+                
+                # Add visualization for training success prediction
+                fig = plt.figure(figsize=(10, 4))
+                
+                # Create visual indicator for success/failure
+                ax = fig.add_subplot(121)
+                success_color = 'green' if success_status == 1 else 'red'
+                success_label = 'Success' if success_status == 1 else 'Failure'
+                ax.pie([1], colors=[success_color], wedgeprops=dict(width=0.3, edgecolor='w'))
+                ax.text(0, 0, success_label, ha='center', va='center', fontsize=20, color='black')
+                ax.set_title("Predicted Outcome")
+                
+                # Create feature importance visualization
+                ax2 = fig.add_subplot(122)
+                
+                # Convert categorical training type to label
+                training_type_label = "External" if training_type == 1 else "Internal"
+                
+                # Show the input features with scaled representation
+                features = ['Training Type', 'Duration (Days)', 'Cost ($)']
+                values = [training_type, min(training_duration/60, 1)*100, min(training_cost/5000, 1)*100]
+                
+                # Create horizontal bars with custom colors
+                colors = ['#3498db', '#f39c12', '#2ecc71']
+                bars = ax2.barh(features, values, color=colors)
+                
+                # Add text annotations for the actual values
+                ax2.text(values[0] + 5, 0, training_type_label)
+                ax2.text(values[1] + 5, 1, f"{training_duration} days")
+                ax2.text(values[2] + 5, 2, f"${training_cost:.2f}")
+                
+                ax2.set_title("Training Parameters")
+                ax2.set_xlim(0, 100)
+                
+                plt.tight_layout()
+                st.pyplot(fig)
+                
+                # Add a simple recommendation based on the prediction
+                st.subheader("Recommendation")
+                if success_status == 1:
+                    st.info("✅ This training program is likely to be successful. Consider implementing it.")
+                else:
+                    st.warning("⚠️ This training may not be successful. Consider adjusting the parameters or exploring alternative training options.")
+
+
+
+
+# Update this condition to match
+elif page == "🤖 HR Chatbot":
+    chatbot_main()
+
+# ========== Footer ==========

chatbot.py

@@ -0,0 +1,180 @@
+import streamlit as st
+from langchain_community.agent_toolkits.sql.toolkit import SQLDatabaseToolkit
+from langchain_community.utilities import SQLDatabase
+from langchain.chat_models import init_chat_model
+from langchain_community.agent_toolkits import create_sql_agent
+from langchain.callbacks.base import BaseCallbackHandler
+
+# Database connection string
+url = "postgresql://postgres.qxvpaoeakhddzabctekw:8&CiDRpTFbRRBrT@aws-0-ap-south-1.pooler.supabase.com:5432/postgres"
+
+# ✅ Initialize session state variables if they don't exist
+if "db" not in st.session_state:
+    st.session_state.db = SQLDatabase.from_uri(url)
+
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []  # Stores past queries and responses
+
+if "agent_chain_output" not in st.session_state:
+    st.session_state.agent_chain_output = ""
+
+# Custom callback handler for streaming output
+class StreamHandler(BaseCallbackHandler):
+    def __init__(self, container):
+        self.container = container
+        self.text = ""
+        
+    def on_llm_start(self, serialized, prompts, **kwargs):
+        self.text += "🧠 Starting to think...\n\n"
+        self.container.markdown(self.text)
+    
+    def on_llm_new_token(self, token, **kwargs):
+        self.text += token
+        self.container.markdown(self.text)
+    
+    def on_llm_end(self, response, **kwargs):
+        self.text += "\n\n✅ Thinking complete.\n\n"
+        self.container.markdown(self.text)
+    
+    def on_tool_start(self, serialized, input_str, **kwargs):
+        self.text += f"🔧 Using tool: {serialized['name']}\n"
+        self.text += f"Tool input: {input_str}\n\n"
+        self.container.markdown(self.text)
+    
+    def on_tool_end(self, output, **kwargs):
+        self.text += f"Tool output: {output}\n\n"
+        self.container.markdown(self.text)
+    
+    def on_chain_start(self, serialized, inputs, **kwargs):
+        chain_type = serialized.get("name", "Chain")
+        self.text += f"⛓️ Starting {chain_type}...\n"
+        self.container.markdown(self.text)
+    
+    def on_chain_end(self, outputs, **kwargs):
+        self.text += f"⛓️ Chain complete.\n\n"
+        self.container.markdown(self.text)
+    
+    def on_agent_action(self, action, **kwargs):
+        self.text += f"🤖 Agent action: {action.tool}\n"
+        self.text += f"Action input: {action.tool_input}\n\n"
+        self.container.markdown(self.text)
+    
+    def on_agent_finish(self, finish, **kwargs):
+        self.text += f"🏁 Agent finished: {finish.return_values.get('output')}\n\n"
+        self.container.markdown(self.text)
+
+# Main function to run the app
+def main():
+    st.title("🤖 Database Query Assistant")
+    st.write("Ask questions about your database in natural language.")
+    
+    # Sidebar for database information and settings
+    with st.sidebar:
+        st.header("Database Information")
+        st.write(f"Connected to: PostgreSQL database")
+        
+        # Options
+        show_sql = st.checkbox("Show SQL Queries", value=True)
+        show_thinking = st.checkbox("Show Agent Thinking", value=True)
+        
+        # Database schema button
+        if st.button("Show Database Schema"):
+            with st.spinner("Fetching database schema..."):
+                schema = st.session_state.db.get_table_info()
+                st.code(schema)
+    
+    # Display Chat History
+    st.sidebar.subheader("📜 Chat History")
+    for entry in st.session_state.chat_history:
+        with st.sidebar.expander(f"Query: {entry['query']}"):
+            st.write(f"**Agent Response:** {entry['response']}")
+            if show_thinking and "thinking" in entry:
+                st.write(f"**Agent Thinking:**\n{entry['thinking']}")
+
+    if st.sidebar.button("🗑 Clear Chat History"):
+        st.session_state.chat_history = []
+        st.experimental_rerun()
+
+    # Query input section
+    query_options = ["Free-form query", "Get employee details"]
+    query_type = st.radio("Query Type:", query_options)
+    
+    if query_type == "Free-form query":
+        query = st.text_area("Enter your query:", height=100, 
+                            placeholder="Example: What are the top 3 highest paid employees?")
+    else:
+        employee_id = st.text_input("Enter Employee ID:", placeholder="Example: 1001")
+        query = f"Give details of employee ID {employee_id}" if employee_id else ""
+    
+    # Process button
+    process_button = st.button("Run Query")
+    
+    # Results section
+    st.header("Results")
+    
+    # Create containers for output
+    if show_thinking:
+        thinking_container = st.expander("Agent Thinking Process", expanded=True)
+        thinking_output = thinking_container.empty()
+    
+    result_container = st.container()
+    result_output = result_container.empty()
+    
+    # Process the query when button is clicked
+    if process_button and query:
+        # Set up the streaming handlers
+        if show_thinking:
+            stream_handler = StreamHandler(thinking_output)
+        else:
+            stream_handler = None
+        
+        # Initialize LLM
+        try:
+            api_key = "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"
+            
+            # Create a new LLM instance
+            llm = init_chat_model(
+                "llama-3.3-70b-versatile", 
+                model_provider="groq",
+                api_key=api_key,
+                streaming=True,
+                callbacks=[stream_handler] if stream_handler else None
+            )
+            
+            # Create the agent with callbacks
+            toolkit = SQLDatabaseToolkit(db=st.session_state.db, llm=llm)
+            agent_executor = create_sql_agent(
+                llm, 
+                toolkit=toolkit, 
+                verbose=show_thinking,
+                callbacks=[stream_handler] if stream_handler else None
+            )
+            
+            # Process the query and display the result
+            with st.spinner("Processing your query..."):
+                result = agent_executor.invoke(query)
+                
+                # Store chat history
+                st.session_state.chat_history.append({
+                    "query": query,
+                    "response": result["output"],
+                    "thinking": stream_handler.text if show_thinking else ""
+                })
+                
+                # Display the result
+                result_container.success("Query processed successfully!")
+                result_output.markdown("### Answer")
+                result_output.write(result["output"])
+                
+                # Show the SQL if requested
+                if show_sql and "intermediate_steps" in result:
+                    sql_container = st.expander("SQL Queries Used", expanded=True)
+                    for step in result["intermediate_steps"]:
+                        if hasattr(step[0], 'tool') and step[0].tool == "sql_db_query":
+                            sql_container.code(step[0].tool_input, language="sql")
+        
+        except Exception as e:
+            st.error(f"An error occurred: {str(e)}")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -2,3 +2,6 @@ streamlit
 requests
 pandas
 plotly
+supabase-py
+python-dotenv
+psycopg2-binary