Update app.py

app.py

@@ -6,113 +6,187 @@ import plotly.graph_objects as go
 from ydata_profiling import ProfileReport
 from streamlit_pandas_profiling import st_profile_report
 import os
-import requests
-import json
+from dotenv import load_dotenv
+from groq import Groq
+from langchain_community.vectorstores import FAISS
+from langchain_community.document_loaders import TextLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
 import re
 from scipy import stats
 from sklearn.preprocessing import StandardScaler, LabelEncoder, OneHotEncoder
-from sklearn.decomposition import PCA
-from dotenv import load_dotenv
-from flask import Flask, request, jsonify
-from openai import OpenAI
-import threading
+import tempfile
 
 # Load environment variables
 load_dotenv()
 
-# Initialize Flask app
-flask_app = Flask(__name__)
-FLASK_PORT = 5000  # Internal port for Flask, not exposed externally
+# Initialize Groq client
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+# Initialize HuggingFace embeddings for FAISS
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+# Custom CSS (aligned with previous apps)
+st.markdown("""
+    <style>
+    :root {
+        --primary-blue: #3B82F6;
+        --dark-blue: #1E40AF;
+        --light-blue: #DBEAFE;
+        --medium-grey: #6B7280;
+        --light-grey: #F3F4F6;
+        --white: #FFFFFF;
+        --border-grey: #E5E7EB;
+    }
+    .stApp {
+        background-color: var(--light-grey);
+        font-family: 'Inter', sans-serif;
+        max-width: 900px;
+        margin: 0 auto;
+    }
+    .header {
+        background-color: var(--white);
+        border-bottom: 2px solid var(--border-grey);
+        padding: 15px;
+        border-radius: 12px 12px 0 0;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.05);
+        text-align: center;
+    }
+    .header-title {
+        color: var(--dark-blue);
+        font-size: 1.5rem;
+        font-weight: 700;
+        margin: 0;
+    }
+    .header-subtitle {
+        color: var(--medium-grey);
+        font-size: 0.9rem;
+        margin-top: 5px;
+    }
+    .sidebar .sidebar-content {
+        background-color: var(--white);
+        border-radius: 12px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        padding: 15px;
+    }
+    .chat-container {
+        background-color: var(--white);
+        border-radius: 12px;
+        box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+        padding: 15px;
+        margin-top: 20px;
+    }
+    .user-message {
+        background-color: var(--primary-blue);
+        color: var(--white);
+        border-radius: 18px 18px 4px 18px;
+        padding: 12px 16px;
+        margin-left: auto;
+        max-width: 80%;
+        margin-bottom: 10px;
+    }
+    .bot-message {
+        background-color: var(--light-grey);
+        color: var(--medium-grey);
+        border-radius: 18px 18px 18px 4px;
+        padding: 12px 16px;
+        margin-right: auto;
+        max-width: 80%;
+        margin-bottom: 10px;
+    }
+    .footer {
+        text-align: center;
+        margin-top: 20px;
+        color: var(--medium-grey);
+        font-size: 0.8rem;
+    }
+    .tech-badge {
+        display: inline-block;
+        background-color: var(--light-blue);
+        color: var(--dark-blue);
+        padding: 4px 8px;
+        border-radius: 12px;
+        font-size: 0.7rem;
+        margin: 0 4px;
+    }
+    </style>
+""", unsafe_allow_html=True)
 
-# Flask RAG Endpoint
-@flask_app.route('/rag_chat', methods=['POST'])
-def rag_chat():
-    data = request.get_json()
-    user_input = data.get('user_input', '')
-    app_mode = data.get('app_mode', 'Data Upload')
-    dataset_text = data.get('dataset_text', '')
+# Helper Functions
+def enhance_section_title(title):
+    st.markdown(f"<h2 style='border-bottom: 2px solid var(--border-grey); padding-bottom: 5px; color: var(--dark-blue);'>{title}</h2>", unsafe_allow_html=True)
+
+def update_cleaned_data(df):
+    st.session_state.cleaned_data = df
+    if 'data_versions' not in st.session_state:
+        st.session_state.data_versions = [st.session_state.raw_data.copy()]
+    st.session_state.data_versions.append(df.copy())
+    st.session_state.dataset_text = convert_df_to_text(df)
+    st.success("✅ Action completed successfully!")
+    st.rerun()
 
+def convert_df_to_text(df):
+    """Convert DataFrame to text for vector store and context"""
+    text = f"Dataset Summary: {df.shape[0]} rows, {df.shape[1]} columns\n"
+    text += f"Missing Values: {df.isna().sum().sum()}\n"
+    text += "Columns:\n"
+    for col in df.columns:
+        text += f"- {col} ({df[col].dtype}): "
+        if pd.api.types.is_numeric_dtype(df[col]):
+            text += f"Mean={df[col].mean():.2f}, Min={df[col].min()}, Max={df[col].max()}"
+        else:
+            text += f"Unique={df[col].nunique()}, Top={df[col].mode()[0] if not df[col].mode().empty else 'N/A'}"
+        text += f", Missing={df[col].isna().sum()}\n"
+    return text
+
+def create_vector_store(df_text):
+    """Create a FAISS vector store from dataset text"""
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as temp_file:
+        temp_file.write(df_text)
+        temp_path = temp_file.name
+    
+    loader = TextLoader(temp_path)
+    documents = loader.load()
+    text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100)
+    texts = text_splitter.split_documents(documents)
+    vector_store = FAISS.from_documents(texts, embeddings)
+    os.unlink(temp_path)
+    return vector_store
+
+def get_chatbot_response(user_input, app_mode, vector_store=None, model="llama3-70b-8192"):
+    """Get response from Groq with vector store context"""
     system_prompt = (
         "You are an AI assistant in Data-Vision Pro, a data analysis app with RAG capabilities. "
-        "The app has three pages:\n"
+        f"The user is on the '{app_mode}' page:\n"
         "- **Data Upload**: Upload CSV/XLSX files, view stats, or generate reports.\n"
         "- **Data Cleaning**: Clean data (e.g., handle missing values, encode variables).\n"
         "- **EDA**: Visualize data (e.g., scatter plots, histograms).\n"
-        f"The user is on the '{app_mode}' page.\n"
     )
-
-    if dataset_text:
-        system_prompt += (
-            "Using the following dataset context, augment your response:\n"
-            f"{dataset_text}\n"
-            "Answer based on this data where relevant, otherwise provide general assistance."
-        )
+    
+    context = ""
+    if vector_store:
+        docs = vector_store.similarity_search(user_input, k=3)
+        if docs:
+            context = "\n\nDataset Context:\n" + "\n".join([f"- {doc.page_content}" for doc in docs])
+            system_prompt += f"Use this dataset context to augment your response:\n{context}"
     else:
         system_prompt += "No dataset is loaded. Assist based on app functionality."
-
+    
     try:
         response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
+            model=model,
             messages=[
                 {"role": "system", "content": system_prompt},
                 {"role": "user", "content": user_input}
             ],
-            max_tokens=100,
-            temperature=0.7
+            temperature=0.7,
+            max_tokens=1024
         )
-        return jsonify({"response": response.choices[0].message.content})
+        return response.choices[0].message.content
     except Exception as e:
-        return jsonify({"error": str(e)}), 500
-
-# Run Flask in a background thread
-def run_flask():
-    flask_app.run(host='0.0.0.0', port=FLASK_PORT, debug=False, use_reloader=False)
-
-flask_thread = threading.Thread(target=run_flask, daemon=True)
-flask_thread.start()
-
-# Helper Functions
-def enhance_section_title(title):
-    st.markdown(f"<h2 style='border-bottom: 2px solid #ccc; padding-bottom: 5px;'>{title}</h2>", unsafe_allow_html=True)
+        return f"Error: {str(e)}"
 
-def update_cleaned_data(df):
-    st.session_state.cleaned_data = df
-    if 'data_versions' not in st.session_state:
-        st.session_state.data_versions = [st.session_state.raw_data.copy()]
-    st.session_state.data_versions.append(df.copy())
-    st.session_state.dataset_text = convert_csv_to_json_and_text(df)
-    st.success("✅ Action completed successfully!")
-    st.rerun()
-
-def convert_csv_to_json_and_text(df):
-    json_data = df.to_json(orient="records")
-    data_dict = json.loads(json_data)
-    text_summary = f"Dataset Summary: {df.shape[0]} rows, {df.shape[1]} columns\n"
-    text_summary += f"Missing Values: {df.isna().sum().sum()}\n"
-    text_summary += "Columns:\n"
-    for col in df.columns:
-        text_summary += f"- {col} ({df[col].dtype}): "
-        if pd.api.types.is_numeric_dtype(df[col]):
-            text_summary += f"Mean={df[col].mean():.2f}, Min={df[col].min()}, Max={df[col].max()}"
-        else:
-            text_summary += f"Unique={df[col].nunique()}, Top={df[col].mode()[0] if not df[col].mode().empty else 'N/A'}"
-        text_summary += f", Missing={df[col].isna().sum()}\n"
-    return text_summary
-
-def get_chatbot_response(user_input, app_mode, dataset_text=""):
-    payload = {
-        "user_input": user_input,
-        "app_mode": app_mode,
-        "dataset_text": dataset_text
-    }
-    try:
-        response = requests.post(f"http://localhost:{FLASK_PORT}/rag_chat", json=payload, timeout=5)
-        response.raise_for_status()
-        return response.json().get("response", "Error: No response from server")
-    except requests.exceptions.RequestException as e:
-        return f"Error: Could not connect to RAG server. {str(e)}"
-
-# Command Functions for LLM
+# Command Functions
 def drop_columns(columns):
     if 'cleaned_data' in st.session_state:
         df = st.session_state.cleaned_data.copy()
@@ -126,7 +200,6 @@ def drop_columns(columns):
             return "No valid columns found to drop."
     return "No dataset loaded."
 
-# LLM-Driven EDA Commands
 def generate_scatter_plot(params):
     df = st.session_state.cleaned_data
     match = re.search(r"([\w\s]+)\s+vs\s+([\w\s]+)", params)
@@ -149,7 +222,6 @@ def generate_histogram(params):
         return f"Generated histogram of {x_axis}"
     return "Invalid column for histogram."
 
-# Inference from Plotted Data
 def analyze_plot():
     if "last_plot" not in st.session_state:
         return "No plot available to analyze."
@@ -170,7 +242,6 @@ def analyze_plot():
         return f"The histogram of {x_col} is {skew_desc} (skewness = {skewness:.2f})."
     return "Inference not available for this plot type."
 
-# Parse Chatbot Commands
 def parse_command(command):
     command = command.lower().strip()
     if "drop columns" in command or "drop column" in command:
@@ -184,358 +255,317 @@ def parse_command(command):
         return generate_histogram, params
     elif "analyze plot" in command:
         return lambda x: analyze_plot(), None
-    return None, "Command not recognized. Try 'drop columns X, Y', 'scatter plot of X vs Y', or 'analyze plot'."
+    return None, command
 
 # Dataset Preview Function
 def display_dataset_preview():
     if 'cleaned_data' in st.session_state:
         st.subheader("Current Dataset Preview")
         st.dataframe(st.session_state.cleaned_data.head(10), use_container_width=True)
-        st.write("---")
-
-# Sidebar Navigation with API Key Input
-with st.sidebar:
-    st.title("🔮 Data-Vision Pro")
-    st.markdown("Your AI-powered data analysis suite with RAG.")
-    st.markdown("---")
-    app_mode = st.selectbox(
-        "Navigation",
-        ["Data Upload", "Data Cleaning", "EDA"],
-        format_func=lambda x: f"📌 {x}"
-    )
+        st.markdown("---")
+
+# Main App
+def main():
+    # Header
+    st.markdown("""
+        <div class="header">
+            <h1 class="header-title">Data-Vision Pro</h1>
+            <div class="header-subtitle">Advanced Data Analysis with Groq Inference</div>
+        </div>
+    """, unsafe_allow_html=True)
+    
+    # Sidebar Navigation
+    with st.sidebar:
+        st.markdown("### 🔮 Data-Vision Pro")
+        st.markdown("Your AI-powered data analysis suite with RAG.")
+        st.markdown("---")
+        app_mode = st.selectbox(
+            "Navigation",
+            ["Data Upload", "Data Cleaning", "EDA"],
+            format_func=lambda x: f"📌 {x}"
+        )
+        model = st.selectbox(
+            "Select Groq Model",
+            ["llama3-70b-8192", "llama3-8b-8192", "mixtral-8x7b-32768", "gemma-7b-it"],
+            index=0
+        )
+        if app_mode == "Data Upload":
+            st.info("⬆️ Upload your CSV or XLSX dataset to begin.")
+        elif app_mode == "Data Cleaning":
+            st.info("🧹 Clean and preprocess your data.")
+        elif app_mode == "EDA":
+            st.info("🔍 Explore your data visually.")
+        
+        if 'cleaned_data' in st.session_state:
+            csv = st.session_state.cleaned_data.to_csv(index=False)
+            st.download_button(
+                label="Download Cleaned Data",
+                data=csv,
+                file_name='cleaned_data.csv',
+                mime='text/csv',
+            )
+        st.markdown("---")
+        st.markdown("Built with <span class='tech-badge'>Streamlit</span> + <span class='tech-badge'>Groq</span>", unsafe_allow_html=True)
+    
+    # Initialize Session State
+    if 'vector_store' not in st.session_state:
+        st.session_state.vector_store = None
+    if 'chat_history' not in st.session_state:
+        st.session_state.chat_history = []
+    
+    # Display Dataset Preview
+    display_dataset_preview()
+    
+    # App Pages
     if app_mode == "Data Upload":
-        st.info("⬆️ Upload your CSV or XLSX dataset to begin.")
+        st.header("📤 Data Upload & Profiling")
+        uploaded_file = st.file_uploader("Choose a file", type=["csv", "xlsx"], key="file_uploader")
+        if uploaded_file:
+            st.session_state.pop('raw_data', None)
+            st.session_state.pop('cleaned_data', None)
+            st.session_state.pop('data_versions', None)
+            try:
+                if uploaded_file.name.endswith('.csv'):
+                    df = pd.read_csv(uploaded_file)
+                else:
+                    df = pd.read_excel(uploaded_file)
+                if df.empty:
+                    st.error("Uploaded file is empty.")
+                    st.stop()
+                st.session_state.raw_data = df
+                st.session_state.cleaned_data = df.copy()
+                st.session_state.dataset_text = convert_df_to_text(df)
+                st.session_state.vector_store = create_vector_store(st.session_state.dataset_text)
+                if 'data_versions' not in st.session_state:
+                    st.session_state.data_versions = [df.copy()]
+                col1, col2, col3 = st.columns(3)
+                with col1: st.metric("Rows", df.shape[0])
+                with col2: st.metric("Columns", df.shape[1])
+                with col3: st.metric("Missing Values", df.isna().sum().sum())
+                if st.checkbox("Show Data Preview"):
+                    st.dataframe(df.head(10), use_container_width=True)
+                if st.button("Generate Full Profile Report"):
+                    with st.spinner("Generating report..."):
+                        pr = ProfileReport(df, explorative=True)
+                        st_profile_report(pr)
+                st.success("✅ Data loaded successfully!")
+            except Exception as e:
+                st.error(f"An error occurred: {str(e)}")
+
     elif app_mode == "Data Cleaning":
-        st.info("🧹 Clean and preprocess your data using various tools.")
-    elif app_mode == "EDA":
-        st.info("🔍 Explore your data visually and statistically.")
-    
-    # API Key Input Field
-    api_key_input = st.text_input(
-        "Enter your API key (optional)",
-        type="password",
-        help="Enter your API key to override the default. Leave blank to use the app's default key."
-    )
+        st.header("🧹 Smart Data Cleaning")
+        if 'raw_data' not in st.session_state:
+            st.warning("Please upload data first in the Data Upload section.")
+            st.stop()
+        if 'cleaned_data' not in st.session_state:
+            st.session_state.cleaned_data = st.session_state.raw_data.copy()
+        df = st.session_state.cleaned_data.copy()
 
-    st.markdown("---")
-    st.markdown("**Note**: Requires dependencies in `requirements.txt`.")
-    if 'cleaned_data' in st.session_state:
-        csv = st.session_state.cleaned_data.to_csv(index=False)
-        st.download_button(
-            label="Download Cleaned Data as CSV",
-            data=csv,
-            file_name='cleaned_data.csv',
-            mime='text/csv',
-        )
-    st.markdown("Created by Calvin Allen-Crawford")
-    st.markdown("v1.0 | © 2025")
-
-# Determine which API key to use
-if api_key_input:
-    api_key = api_key_input  # Use the user-provided API key from the sidebar
-else:
-    api_key = st.secrets.get("OPENAI_API_KEY", os.getenv("OPENAI_API_KEY"))  # Fall back to secret or environment variable
-
-if not api_key:
-    st.error("API key is required. Please provide it in the sidebar or ensure it’s set in the app’s secrets.")
-    st.stop()
-
-# Initialize OpenAI client with the selected API key
-client = OpenAI(api_key=api_key)
-
-# Display dataset preview at the top of each page
-display_dataset_preview()
-
-# Main App Pages
-if app_mode == "Data Upload":
-    st.title("📤 Data Upload & Profiling")
-    st.header("Upload Your Dataset")
-    st.write("Supported formats: CSV, XLSX")
-    if 'raw_data' not in st.session_state:
-        st.info("It looks like no dataset has been uploaded yet. Would you like to upload a CSV or XLSX file?")
-    uploaded_file = st.file_uploader("Choose a file", type=["csv", "xlsx"], key="file_uploader")
-    if uploaded_file:
-        st.session_state.pop('raw_data', None)
-        st.session_state.pop('cleaned_data', None)
-        st.session_state.pop('data_versions', None)
-        try:
-            if uploaded_file.name.endswith('.csv'):
-                df = pd.read_csv(uploaded_file)
-            else:
-                df = pd.read_excel(uploaded_file)
-            if df.empty:
-                st.error("Uploaded file is empty.")
-                st.stop()
-            st.session_state.raw_data = df
-            st.session_state.cleaned_data = df.copy()
-            st.session_state.dataset_text = convert_csv_to_json_and_text(df)
-            if 'data_versions' not in st.session_state:
-                st.session_state.data_versions = [df.copy()]
+        enhance_section_title("📊 Data Health Dashboard")
+        with st.expander("Explore Data Health Metrics", expanded=True):
             col1, col2, col3 = st.columns(3)
-            with col1: st.metric("Rows", df.shape[0])
-            with col2: st.metric("Columns", df.shape[1])
+            with col1: st.metric("Columns", len(df.columns))
+            with col2: st.metric("Rows", len(df))
             with col3: st.metric("Missing Values", df.isna().sum().sum())
-            if st.checkbox("Show Data Preview"):
-                st.dataframe(df.head(10), use_container_width=True)
-            if st.button("Generate Full Profile Report"):
+            if st.button("Generate Detailed Health Report"):
                 with st.spinner("Generating report..."):
-                    pr = ProfileReport(df, explorative=True)
-                    st_profile_report(pr)
-            st.success("✅ Data loaded successfully!")
-        except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
-
-elif app_mode == "Data Cleaning":
-    st.title("🧹 Smart Data Cleaning")
-    st.header("Preprocess and Transform Your Data")
-    if 'raw_data' not in st.session_state:
-        st.warning("Please upload data first in the Data Upload section.")
-        st.stop()
-    if 'cleaned_data' not in st.session_state:
-        st.session_state.cleaned_data = st.session_state.raw_data.copy()
-    df = st.session_state.cleaned_data.copy()
-
-    enhance_section_title("📊 Data Health Dashboard")
-    with st.expander("Explore Data Health Metrics", expanded=True):
-        col1, col2, col3 = st.columns(3)
-        with col1: st.metric("Columns", len(df.columns))
-        with col2: st.metric("Rows", len(df))
-        with col3: st.metric("Missing Values", df.isna().sum().sum())
-        if st.button("Generate Detailed Health Report"):
-            with st.spinner("Generating report..."):
-                profile = ProfileReport(df, minimal=True)
-                st_profile_report(profile)
-        if 'data_versions' in st.session_state and len(st.session_state.data_versions) > 1:
-            if st.button("Undo Last Action"):
-                st.session_state.data_versions.pop()
-                st.session_state.cleaned_data = st.session_state.data_versions[-1].copy()
-                st.session_state.dataset_text = convert_csv_to_json_and_text(st.session_state.cleaned_data)
-                st.rerun()
-
-    with st.expander("🛠️ Data Cleaning Operations", expanded=True):
-        enhance_section_title("🔍 Missing Values Treatment")
-        missing_cols = df.columns[df.isna().any()].tolist()
-        if missing_cols:
-            cols = st.multiselect("Select columns with missing values", missing_cols)
-            method = st.selectbox("Choose imputation method", [
-                "Drop Missing Values", "Fill with Mean/Median", "Fill with Custom Value", "Forward Fill", "Backward Fill"
-            ])
-            if method == "Fill with Custom Value":
-                custom_val = st.text_input("Enter custom value:")
-            if st.button("Apply Missing Value Treatment"):
+                    profile = ProfileReport(df, minimal=True)
+                    st_profile_report(profile)
+            if 'data_versions' in st.session_state and len(st.session_state.data_versions) > 1:
+                if st.button("Undo Last Action"):
+                    st.session_state.data_versions.pop()
+                    st.session_state.cleaned_data = st.session_state.data_versions[-1].copy()
+                    st.session_state.dataset_text = convert_df_to_text(st.session_state.cleaned_data)
+                    st.session_state.vector_store = create_vector_store(st.session_state.dataset_text)
+                    st.rerun()
+
+        with st.expander("🛠️ Data Cleaning Operations", expanded=True):
+            enhance_section_title("🔍 Missing Values Treatment")
+            missing_cols = df.columns[df.isna().any()].tolist()
+            if missing_cols:
+                cols = st.multiselect("Select columns with missing values", missing_cols)
+                method = st.selectbox("Choose imputation method", [
+                    "Drop Missing Values", "Fill with Mean/Median", "Fill with Custom Value", "Forward Fill", "Backward Fill"
+                ])
+                if method == "Fill with Custom Value":
+                    custom_val = st.text_input("Enter custom value:")
+                if st.button("Apply Missing Value Treatment"):
+                    new_df = df.copy()
+                    if method == "Drop Missing Values":
+                        new_df = new_df.dropna(subset=cols)
+                    elif method == "Fill with Mean/Median":
+                        for col in cols:
+                            if pd.api.types.is_numeric_dtype(new_df[col]):
+                                new_df[col] = new_df[col].fillna(new_df[col].median())
+                            else:
+                                new_df[col] = new_df[col].fillna(new_df[col].mode()[0])
+                    elif method == "Fill with Custom Value" and custom_val:
+                        new_df[cols] = new_df[cols].fillna(custom_val)
+                    elif method == "Forward Fill":
+                        new_df[cols] = new_df[cols].ffill()
+                    elif method == "Backward Fill":
+                        new_df[cols] = new_df[cols].bfill()
+                    update_cleaned_data(new_df)
+            else:
+                st.success("✨ No missing values detected!")
+
+            enhance_section_title("🔄 Data Type Conversion")
+            col_to_convert = st.selectbox("Select column to convert", df.columns)
+            new_type = st.selectbox("Select new data type", ["String", "Integer", "Float", "Boolean", "Datetime"])
+            if new_type == "Datetime":
+                date_format = st.text_input("Enter date format (e.g., %Y-%m-%d):", "%Y-%m-%d")
+            if st.button("Convert Data Type"):
                 new_df = df.copy()
-                if method == "Drop Missing Values":
-                    new_df = new_df.dropna(subset=cols)
-                elif method == "Fill with Mean/Median":
-                    for col in cols:
-                        if pd.api.types.is_numeric_dtype(new_df[col]):
-                            new_df[col] = new_df[col].fillna(new_df[col].median())
-                        else:
-                            new_df[col] = new_df[col].fillna(new_df[col].mode()[0])
-                elif method == "Fill with Custom Value" and custom_val:
-                    new_df[cols] = new_df[cols].fillna(custom_val)
-                elif method == "Forward Fill":
-                    new_df[cols] = new_df[cols].ffill()
-                elif method == "Backward Fill":
-                    new_df[cols] = new_df[cols].bfill()
+                if new_type == "String":
+                    new_df[col_to_convert] = new_df[col_to_convert].astype(str)
+                elif new_type == "Integer":
+                    new_df[col_to_convert] = pd.to_numeric(new_df[col_to_convert], errors='coerce').astype('Int64')
+                elif new_type == "Float":
+                    new_df[col_to_convert] = pd.to_numeric(new_df[col_to_convert], errors='coerce')
+                elif new_type == "Boolean":
+                    new_df[col_to_convert] = new_df[col_to_convert].astype(bool)
+                elif new_type == "Datetime":
+                    new_df[col_to_convert] = pd.to_datetime(new_df[col_to_convert], format=date_format, errors='coerce')
                 update_cleaned_data(new_df)
-        else:
-            st.success("✨ No missing values detected!")
-
-        enhance_section_title("🔄 Data Type Conversion")
-        col_to_convert = st.selectbox("Select column to convert", df.columns)
-        new_type = st.selectbox("Select new data type", ["String", "Integer", "Float", "Boolean", "Datetime"])
-        if new_type == "Datetime":
-            date_format = st.text_input("Enter date format (e.g., %Y-%m-%d):", "%Y-%m-%d")
-        if st.button("Convert Data Type"):
-            new_df = df.copy()
-            if new_type == "String":
-                new_df[col_to_convert] = new_df[col_to_convert].astype(str)
-            elif new_type == "Integer":
-                new_df[col_to_convert] = pd.to_numeric(new_df[col_to_convert], errors='coerce').astype('Int64')
-            elif new_type == "Float":
-                new_df[col_to_convert] = pd.to_numeric(new_df[col_to_convert], errors='coerce')
-            elif new_type == "Boolean":
-                new_df[col_to_convert] = new_df[col_to_convert].astype(bool)
-            elif new_type == "Datetime":
-                new_df[col_to_convert] = pd.to_datetime(new_df[col_to_convert], format=date_format, errors='coerce')
-            update_cleaned_data(new_df)
-
-        enhance_section_title("🗑️ Drop Columns")
-        columns_to_drop = st.multiselect("Select columns to remove", df.columns)
-        if columns_to_drop and st.button("Confirm Column Removal"):
-            new_df = df.copy()
-            new_df = new_df.drop(columns=columns_to_drop)
-            update_cleaned_data(new_df)
-
-        enhance_section_title("🔢 Encoding Options")
-        encoding_method = st.radio("Choose encoding method", ("Label Encoding", "One-Hot Encoding"))
-        data_to_encode = st.multiselect("Select columns to encode", df.select_dtypes(include='object').columns)
-        if data_to_encode and st.button("Apply Encoding"):
-            new_df = df.copy()
-            if encoding_method == "Label Encoding":
-                for col in data_to_encode:
-                    le = LabelEncoder()
-                    new_df[col] = le.fit_transform(new_df[col].astype(str))
-            elif encoding_method == "One-Hot Encoding":
-                new_df = pd.get_dummies(new_df, columns=data_to_encode, drop_first=True, dtype=int)
-            update_cleaned_data(new_df)
-
-        enhance_section_title("📏 StandardScaler")
-        scale_cols = st.multiselect("Select numerical columns to scale", df.select_dtypes(include=np.number).columns)
-        if scale_cols and st.button("Apply StandardScaler"):
-            new_df = df.copy()
-            scaler = StandardScaler()
-            new_df[scale_cols] = scaler.fit_transform(new_df[scale_cols])
-            update_cleaned_data(new_df)
-
-        enhance_section_title("🕵️ Pattern-Based Cleaning")
-        selected_col = st.selectbox("Select text column for pattern cleaning", df.select_dtypes(include='object').columns)
-        pattern = st.text_input("Enter regex pattern:")
-        replacement = st.text_input("Enter replacement value:")
-        if st.button("Apply Pattern Replacement"):
-            new_df = df.copy()
-            new_df[selected_col] = new_df[selected_col].str.replace(pattern, replacement, regex=True)
-            update_cleaned_data(new_df)
-
-elif app_mode == "EDA":
-    st.title("🔍 Interactive Data Explorer")
-    if 'cleaned_data' not in st.session_state:
-        st.warning("Please upload and clean data first.")
-        st.stop()
-    df = st.session_state.cleaned_data.copy()
-
-    enhance_section_title("Dataset Overview")
-    with st.container():
-        col1, col2, col3, col4 = st.columns(4)
-        col1.metric("Total Rows", df.shape[0])
-        col2.metric("Total Columns", df.shape[1])
-        missing_percentage = df.isna().sum().sum() / df.size * 100
-        col3.metric("Missing Values", f"{df.isna().sum().sum()} ({missing_percentage:.1f}%)")
-        col4.metric("Duplicates", df.duplicated().sum())
-
-    tab1, tab2, tab3 = st.tabs(["Quick Preview", "Column Types", "Missing Matrix"])
-    with tab1:
-        st.write("First few rows of the dataset:")
-        st.dataframe(df.head(), use_container_width=True)
-    with tab2:
-        st.write("Column Data Types:")
-        type_counts = df.dtypes.value_counts().reset_index()
-        type_counts.columns = ['Type', 'Count']
-        st.dataframe(type_counts, use_container_width=True)
-    with tab3:
-        st.write("Missing Values Matrix:")
-        fig_missing = px.imshow(df.isna(), color_continuous_scale=['#e0e0e0', '#66c2a5'])
-        fig_missing.update_layout(coloraxis_colorscale=[[0, 'lightgrey'], [1, '#FF4B4B']])
-        st.plotly_chart(fig_missing, use_container_width=True)
-
-    enhance_section_title("Interactive Visualization Builder")
-    with st.container():
-        col1, col2 = st.columns([1, 3])
-        with col1:
-            plot_type = st.selectbox("Choose visualization type", [
-                "Scatter Plot", "Histogram", "Box Plot", "Violin Plot", "Line Chart", "Bar Chart",
-                "Correlation Matrix", "Heatmap", "3D Scatter", "Parallel Categories", "Segmented Bar Chart",
-                "Swarm Plot", "Ridge Plot", "Bubble Plot", "Density Plot", "Count Plot", "Lollipop Chart"
-            ])
-            x_axis = st.selectbox("X-axis", df.columns) if plot_type != "Correlation Matrix" else None
-            y_axis = st.selectbox("Y-axis", df.columns) if plot_type in ["Scatter Plot", "Box Plot", "Violin Plot", "Line Chart", "Heatmap", "Swarm Plot", "Ridge Plot", "Bubble Plot", "Density Plot", "Lollipop Chart"] else None
-            z_axis = st.selectbox("Z-axis", df.columns) if plot_type == "3D Scatter" else None
-            color_by = st.selectbox("Color encoding", ["None"] + df.columns.tolist(), format_func=lambda x: "No color" if x == "None" else x) if plot_type != "Correlation Matrix" else None
-            if plot_type == "Parallel Categories":
-                dimensions = st.multiselect("Dimensions", df.columns.tolist(), default=df.columns[:3].tolist())
-            elif plot_type == "Segmented Bar Chart":
-                segment_col = st.selectbox("Segment Column (Categorical)", df.select_dtypes(exclude=np.number).columns)
-            elif plot_type == "Bubble Plot":
-                size_col = st.selectbox("Size Column", df.columns)
-
-        with col2:
-            try:
-                fig = None
-                if plot_type == "Scatter Plot" and x_axis and y_axis:
-                    fig = px.scatter(df, x=x_axis, y=y_axis, color=color_by if color_by != "None" else None, trendline="lowess", title=f'Scatter Plot of {x_axis} vs {y_axis}')
-                elif plot_type == "Histogram" and x_axis:
-                    fig = px.histogram(df, x=x_axis, color=color_by if color_by != "None" else None, nbins=30, marginal="box", title=f'Histogram of {x_axis}')
-                elif plot_type == "Box Plot" and x_axis and y_axis:
-                    fig = px.box(df, x=x_axis, y=y_axis, color=color_by if color_by != "None" else None, title=f'Box Plot of {x_axis} vs {y_axis}')
-                elif plot_type == "Violin Plot" and x_axis and y_axis:
-                    fig = px.violin(df, x=x_axis, y=y_axis, color=color_by if color_by != "None" else None, box=True, title=f'Violin Plot of {x_axis} vs {y_axis}')
-                elif plot_type == "Line Chart" and x_axis and y_axis:
-                    fig = px.line(df, x=x_axis, y=y_axis, color=color_by if color_by != "None" else None, title=f'Line Chart of {x_axis} vs {y_axis}')
-                elif plot_type == "Bar Chart" and x_axis:
-                    fig = px.bar(df, x=x_axis, color=color_by if color_by != "None" else None, title=f'Bar Chart of {x_axis}')
-                elif plot_type == "Correlation Matrix":
-                    numeric_df = df.select_dtypes(include=np.number)
-                    if len(numeric_df.columns) > 1:
-                        corr = numeric_df.corr()
-                        fig = px.imshow(corr, text_auto=True, color_continuous_scale='RdBu_r', zmin=-1, zmax=1, title='Correlation Matrix')
-                elif plot_type == "Heatmap" and x_axis and y_axis:
-                    fig = px.density_heatmap(df, x=x_axis, y=y_axis, facet_col=color_by if color_by != "None" else None, title=f'Heatmap of {x_axis} vs {y_axis}')
-                elif plot_type == "3D Scatter" and x_axis and y_axis and z_axis:
-                    fig = px.scatter_3d(df, x=x_axis, y=y_axis, z=z_axis, color=color_by if color_by != "None" else None, title=f'3D Scatter Plot of {x_axis} vs {y_axis} vs {z_axis}')
-                elif plot_type == "Parallel Categories" and dimensions:
-                    fig = px.parallel_categories(df, dimensions=dimensions, color=color_by if color_by != "None" else None, title='Parallel Categories Plot')
-                elif plot_type == "Segmented Bar Chart" and x_axis and segment_col:
-                    segment_counts = df.groupby([x_axis, segment_col]).size().reset_index(name='counts')
-                    fig = px.bar(segment_counts, x=x_axis, y='counts', color=segment_col, title=f'Segmented Bar Chart of {x_axis} by {segment_col}')
-                    fig.update_layout(yaxis_title="Count")
-                elif plot_type == "Swarm Plot" and x_axis and y_axis:
-                    fig = px.strip(df, x=x_axis, y=y_axis, color=color_by if color_by != "None" else None, title=f'Swarm Plot of {x_axis} vs {y_axis}')
-                elif plot_type == "Ridge Plot" and x_axis and y_axis:
-                    fig = px.histogram(df, x=x_axis, color=y_axis, marginal="rug", title=f'Ridge Plot of {x_axis} by {y_axis}')
-                elif plot_type == "Bubble Plot" and x_axis and y_axis and size_col:
-                    fig = px.scatter(df, x=x_axis, y=y_axis, size=size_col, color=color_by if color_by != "None" else None, title=f'Bubble Plot of {x_axis} vs {y_axis}')
-                elif plot_type == "Density Plot" and x_axis and y_axis:
-                    fig = px.density_heatmap(df, x=x_axis, y=y_axis, color_continuous_scale="Viridis", title=f'Density Plot of {x_axis} vs {y_axis}')
-                elif plot_type == "Count Plot" and x_axis:
-                    fig = px.bar(df, x=x_axis, color=color_by if color_by != "None" else None, title=f'Count Plot of {x_axis}')
-                    fig.update_layout(yaxis_title="Count")
-                elif plot_type == "Lollipop Chart" and x_axis and y_axis:
-                    fig = go.Figure()
-                    fig.add_trace(go.Scatter(x=df[x_axis], y=df[y_axis], mode='markers', marker=dict(size=10)))
-                    for i in range(len(df)):
-                        fig.add_trace(go.Scatter(x=[df[x_axis].iloc[i], df[x_axis].iloc[i]], y=[0, df[y_axis].iloc[i]], mode='lines', line=dict(color='gray')))
-                    fig.update_layout(showlegend=False, title=f'Lollipop Chart of {x_axis} vs {y_axis}')
-
-                if fig:
-                    fig.update_layout(template="plotly_white")
-                    st.plotly_chart(fig, use_container_width=True)
-                    st.session_state.last_plot = {
-                        "type": plot_type,
-                        "x": x_axis,
-                        "y": y_axis,
-                        "z": z_axis,
-                        "color": color_by if color_by != "None" else None,
-                        "data": df[[x_axis, y_axis] + ([z_axis] if z_axis else [])].to_json() if x_axis and y_axis else df[[x_axis]].to_json()
-                    }
-                else:
-                    st.error("Please provide required inputs for the selected plot type.")
-            except Exception as e:
-                st.error(f"Couldn't create visualization: {str(e)}")
-
-# Chatbot Section
-st.markdown("---")
-st.subheader("💬 AI Chatbot Assistant (RAG Enabled)")
-st.info("Ask me about the app or your data! Try: 'drop columns X, Y', 'scatter plot of X vs Y', or 'analyze plot'")
-if "chat_history" not in st.session_state:
-    st.session_state.chat_history = []
-
-for message in st.session_state.chat_history:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
-
-user_input = st.chat_input("Ask me anything about the app or your data...")
-if user_input:
-    st.session_state.chat_history.append({"role": "user", "content": user_input})
-    with st.chat_message("user"):
-        st.markdown(user_input)
-    with st.spinner("Processing..."):
-        dataset_text = st.session_state.get("dataset_text", "")
-        func, param = parse_command(user_input)
-        if func:
-            response = func(param) if param else func(None)
-        else:
-            response = get_chatbot_response(user_input, app_mode, dataset_text)
-        st.session_state.chat_history.append({"role": "assistant", "content": response})
-    with st.chat_message("assistant"):
-        st.markdown(response)
+
+            enhance_section_title("🗑️ Drop Columns")
+            columns_to_drop = st.multiselect("Select columns to remove", df.columns)
+            if columns_to_drop and st.button("Confirm Column Removal"):
+                new_df = df.copy()
+                new_df = new_df.drop(columns=columns_to_drop)
+                update_cleaned_data(new_df)
+
+            enhance_section_title("🔢 Encoding Options")
+            encoding_method = st.radio("Choose encoding method", ("Label Encoding", "One-Hot Encoding"))
+            data_to_encode = st.multiselect("Select columns to encode", df.select_dtypes(include='object').columns)
+            if data_to_encode and st.button("Apply Encoding"):
+                new_df = df.copy()
+                if encoding_method == "Label Encoding":
+                    for col in data_to_encode:
+                        le = LabelEncoder()
+                        new_df[col] = le.fit_transform(new_df[col].astype(str))
+                elif encoding_method == "One-Hot Encoding":
+                    new_df = pd.get_dummies(new_df, columns=data_to_encode, drop_first=True, dtype=int)
+                update_cleaned_data(new_df)
+
+            enhance_section_title("📏 StandardScaler")
+            scale_cols = st.multiselect("Select numerical columns to scale", df.select_dtypes(include=np.number).columns)
+            if scale_cols and st.button("Apply StandardScaler"):
+                new_df = df.copy()
+                scaler = StandardScaler()
+                new_df[scale_cols] = scaler.fit_transform(new_df[scale_cols])
+                update_cleaned_data(new_df)
+
+    elif app_mode == "EDA":
+        st.header("🔍 Interactive Data Explorer")
+        if 'cleaned_data' not in st.session_state:
+            st.warning("Please upload and clean data first.")
+            st.stop()
+        df = st.session_state.cleaned_data.copy()
+
+        enhance_section_title("Dataset Overview")
+        with st.container():
+            col1, col2, col3, col4 = st.columns(4)
+            col1.metric("Total Rows", df.shape[0])
+            col2.metric("Total Columns", df.shape[1])
+            missing_percentage = df.isna().sum().sum() / df.size * 100
+            col3.metric("Missing Values", f"{df.isna().sum().sum()} ({missing_percentage:.1f}%)")
+            col4.metric("Duplicates", df.duplicated().sum())
+
+        tab1, tab2, tab3 = st.tabs(["Quick Preview", "Column Types", "Missing Matrix"])
+        with tab1:
+            st.write("First few rows of the dataset:")
+            st.dataframe(df.head(), use_container_width=True)
+        with tab2:
+            st.write("Column Data Types:")
+            type_counts = df.dtypes.value_counts().reset_index()
+            type_counts.columns = ['Type', 'Count']
+            st.dataframe(type_counts, use_container_width=True)
+        with tab3:
+            st.write("Missing Values Matrix:")
+            fig_missing = px.imshow(df.isna(), color_continuous_scale=['#e0e0e0', '#66c2a5'])
+            fig_missing.update_layout(coloraxis_colorscale=[[0, 'lightgrey'], [1, '#FF4B4B']])
+            st.plotly_chart(fig_missing, use_container_width=True)
+
+        enhance_section_title("Interactive Visualization Builder")
+        with st.container():
+            col1, col2 = st.columns([1, 3])
+            with col1:
+                plot_type = st.selectbox("Choose visualization type", [
+                    "Scatter Plot", "Histogram", "Box Plot", "Line Chart", "Bar Chart", "Correlation Matrix"
+                ])
+                x_axis = st.selectbox("X-axis", df.columns) if plot_type != "Correlation Matrix" else None
+                y_axis = st.selectbox("Y-axis", df.columns) if plot_type in ["Scatter Plot", "Box Plot", "Line Chart"] else None
+                color_by = st.selectbox("Color encoding", ["None"] + df.columns.tolist(), format_func=lambda x: "No color" if x == "None" else x) if plot_type != "Correlation Matrix" else None
+
+            with col2:
+                try:
+                    fig = None
+                    if plot_type == "Scatter Plot" and x_axis and y_axis:
+                        fig = px.scatter(df, x=x_axis, y=y_axis, color=color_by if color_by != "None" else None, title=f'Scatter Plot of {x_axis} vs {y_axis}')
+                    elif plot_type == "Histogram" and x_axis:
+                        fig = px.histogram(df, x=x_axis, color=color_by if color_by != "None" else None, nbins=30, title=f'Histogram of {x_axis}')
+                    elif plot_type == "Box Plot" and x_axis and y_axis:
+                        fig = px.box(df, x=x_axis, y=y_axis, color=color_by if color_by != "None" else None, title=f'Box Plot of {x_axis} vs {y_axis}')
+                    elif plot_type == "Line Chart" and x_axis and y_axis:
+                        fig = px.line(df, x=x_axis, y=y_axis, color=color_by if color_by != "None" else None, title=f'Line Chart of {x_axis} vs {y_axis}')
+                    elif plot_type == "Bar Chart" and x_axis:
+                        fig = px.bar(df, x=x_axis, color=color_by if color_by != "None" else None, title=f'Bar Chart of {x_axis}')
+                    elif plot_type == "Correlation Matrix":
+                        numeric_df = df.select_dtypes(include=np.number)
+                        if len(numeric_df.columns) > 1:
+                            corr = numeric_df.corr()
+                            fig = px.imshow(corr, text_auto=True, color_continuous_scale='RdBu_r', zmin=-1, zmax=1, title='Correlation Matrix')
+
+                    if fig:
+                        fig.update_layout(template="plotly_white")
+                        st.plotly_chart(fig, use_container_width=True)
+                        st.session_state.last_plot = {
+                            "type": plot_type,
+                            "x": x_axis,
+                            "y": y_axis,
+                            "data": df[[x_axis, y_axis]].to_json() if y_axis else df[[x_axis]].to_json()
+                        }
+                    else:
+                        st.error("Please provide required inputs for the selected plot type.")
+                except Exception as e:
+                    st.error(f"Couldn't create visualization: {str(e)}")
+
+    # Chatbot Section
+    st.markdown("---")
+    st.markdown('<div class="chat-container">', unsafe_allow_html=True)
+    st.subheader("💬 AI Chatbot Assistant (RAG Enabled)")
+    st.info("Ask about your data or app features! Try: 'drop columns X, Y', 'scatter plot of X vs Y', 'analyze plot'")
+    
+    for message in st.session_state.chat_history:
+        with st.chat_message(message["role"]):
+            st.markdown(f'<div class="{message["role"]}-message">{message["content"]}</div>', unsafe_allow_html=True)
+    
+    user_input = st.chat_input("Ask me anything...")
+    if user_input:
+        st.session_state.chat_history.append({"role": "user", "content": user_input})
+        with st.chat_message("user"):
+            st.markdown(f'<div class="user-message">{user_input}</div>', unsafe_allow_html=True)
+        with st.spinner("Processing..."):
+            func, param = parse_command(user_input)
+            if func:
+                response = func(param) if param else func(None)
+            else:
+                response = get_chatbot_response(user_input, app_mode, st.session_state.vector_store, model)
+            st.session_state.chat_history.append({"role": "assistant", "content": response})
+        with st.chat_message("assistant"):
+            st.markdown(f'<div class="bot-message">{response}</div>', unsafe_allow_html=True)
+    
+    st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Footer
+    st.markdown("""
+        <div class="footer">
+            <div>Built with <span class="tech-badge">Streamlit</span> + <span class="tech-badge">Groq</span> + <span class="tech-badge">LangChain</span> + <span class="tech-badge">FAISS</span></div>
+            <div style="margin-top: 8px;">Fast inference for data insights</div>
+        </div>
+    """, unsafe_allow_html=True)
+
+if __name__ == "__main__":
+    st.set_page_config(page_title="Data-Vision Pro", layout="wide")
+    main()