Upload 6 files

house_price_prediction.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c6e2721d391e104205147cc460696129945f86a7753ae10e46d2bbaa8e8825b6
+size 6897

house_price_prediction_v2.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9a49705f5f9bae4cd6782b9bd8fa985705c95a774e62dbbdf0f87dd2e191f4fb
+size 84721402

main.py

@@ -0,0 +1,1116 @@
+from flask import Flask, render_template, request, jsonify
+import google.generativeai as genai
+import pandas as pd
+import numpy as np
+import joblib
+import os
+import json
+from datetime import datetime
+import re
+from typing import Dict, List, Any, Optional
+import logging
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.preprocessing import StandardScaler
+from sklearn.pipeline import Pipeline
+from sklearn.metrics import mean_absolute_error, r2_score
+import sklearn # Import sklearn to get version
+
+app = Flask(__name__)
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Configure Gemini API
+GEMINI_API_KEY = os.getenv('GEMINI_API_KEY', 'AIzaSyAU8NFxxscrLcPcYqp5bnnyBPTVH0v1aZY') # IMPORTANT: Replace with a secure way to manage API keys
+genai.configure(api_key=GEMINI_API_KEY)
+# Using gemini-1.5-flash for potentially larger context window and better performance
+model = genai.GenerativeModel('gemini-2.0-flash')
+
+
+class EnhancedRealEstateSalesAssistant:
+    def __init__(self):
+        self.pipeline = None  # Initialize pipeline to None
+        self.training_feature_names = [] # To store feature names from training
+        self.model_version = 'N/A'
+        self.load_model_and_data()
+        self.conversation_history = []
+        self.client_preferences = {}
+        self.last_search_results = None
+        self.context_memory = []
+
+    def _clean_gemini_text(self, text: str) -> str:
+        """Removes common Markdown formatting characters (like asterisks, hashes) from Gemini's output."""
+        if not isinstance(text, str):
+            return text # Return as is if not a string
+
+        # Remove bold/italic markers (**)
+        cleaned_text = re.sub(r'\*\*', '', text)
+        # Remove italic markers (*)
+        cleaned_text = re.sub(r'\*', '', cleaned_text)
+        # Remove header markers (#) at the start of a line, and any following whitespace
+        cleaned_text = re.sub(r'^\s*#+\s*', '', cleaned_text, flags=re.MULTILINE)
+        # Remove typical list bullet points like '- ' or '+ ' or '* ' at the start of a line
+        # (Note: '*' removal above might catch list items, this is for redundancy/clarity)
+        cleaned_text = re.sub(r'^\s*[-+]\s+', '', cleaned_text, flags=re.MULTILINE)
+        # Replace multiple newlines with a single one (or two, depending on desired paragraph spacing)
+        cleaned_text = re.sub(r'\n\s*\n', '\n\n', cleaned_text)
+        # Remove excessive leading/trailing whitespace from each line
+        cleaned_text = '\n'.join([line.strip() for line in cleaned_text.splitlines()])
+        # Final strip for the whole block
+        cleaned_text = cleaned_text.strip()
+        return cleaned_text
+
+    def load_model_and_data(self):
+        """Load the trained model and dataset with version compatibility"""
+        try:
+            # Load the dataset first
+            self.df = pd.read_csv('Pune_House_Data.csv')
+
+            # Clean and process data
+            self.df = self.clean_dataset()
+
+            # Extract unique values for filtering
+            self.locations = sorted(self.df['site_location'].unique().tolist())
+            self.area_types = sorted(self.df['area_type'].unique().tolist())
+            self.availability_types = sorted(self.df['availability'].unique().tolist())
+            self.bhk_options = sorted(self.df['bhk'].unique().tolist())
+
+            # Try to load model with version compatibility
+            model_loaded = self.load_model_with_version_check()
+
+            if not model_loaded:
+                logger.warning("Model loading failed, prediction will use fallback method.")
+                self.pipeline = None # Ensure pipeline is None if loading failed
+
+            logger.info("✅ Model and data loading process completed.")
+            logger.info(f"Dataset shape: {self.df.shape}")
+            logger.info(f"Available locations: {len(self.locations)}")
+
+        except Exception as e:
+            logger.error(f"❌ Critical error loading model/data: {e}")
+            # Create fallback data
+            self.df = self.create_fallback_data()
+            self.locations = ['Baner', 'Hadapsar', 'Kothrud', 'Viman Nagar', 'Wakad', 'Hinjewadi']
+            self.area_types = ['Built-up Area', 'Super built-up Area', 'Plot Area', 'Carpet Area']
+            self.availability_types = ['Ready To Move', 'Not Ready', 'Under Construction']
+            self.bhk_options = [1, 2, 3, 4, 5, 6]
+            self.pipeline = None # Ensure pipeline is None if data loading failed
+
+    def load_model_with_version_check(self):
+        """Load model with version compatibility check, or retrain if necessary."""
+        try:
+            # First try to load the new version-compatible model
+            try:
+                model_data = joblib.load('house_price_prediction_v2.pkl')
+                self.pipeline = model_data['pipeline']
+                self.training_feature_names = model_data.get('feature_names', [])
+                self.model_version = model_data.get('version', '2.0')
+                logger.info(f"✅ Loaded model version {self.model_version} with {len(self.training_feature_names)} features.")
+                return True
+            except FileNotFoundError:
+                logger.info("New model version (house_price_prediction_v2.pkl) not found, attempting to retrain.")
+                return self.retrain_model_with_current_version()
+            except Exception as v2_load_error:
+                logger.error(f"Failed to load new model version (v2): {v2_load_error}. Attempting retraining.")
+                return self.retrain_model_with_current_version()
+
+        except Exception as e:
+            logger.error(f"Error in model loading process: {e}. Retraining will be attempted as a last resort.")
+            return self.retrain_model_with_current_version() # Final attempt to retrain if other loading fails
+
+    def retrain_model_with_current_version(self):
+        """Retrain the model with current scikit-learn version"""
+        try:
+            logger.info(f"🔄 Retraining model with scikit-learn version {sklearn.__version__}")
+
+            # Prepare features (this method also sets self.training_feature_names)
+            X, y = self.create_training_data_with_proper_features()
+
+            if X is None or y is None:
+                logger.error("Failed to create training data, cannot retrain model.")
+                self.pipeline = None
+                return False
+
+            # Split data
+            X_train, X_test, y_train, y_test = train_test_split(
+                X, y, test_size=0.2, random_state=42
+            )
+
+            # Create pipeline
+            pipeline = Pipeline([
+                ('scaler', StandardScaler()),
+                ('model', RandomForestRegressor(
+                    n_estimators=100,
+                    random_state=42,
+                    n_jobs=-1  # Use all available cores
+                ))
+            ])
+
+            # Train model
+            logger.info("Training model...")
+            pipeline.fit(X_train, y_train)
+
+            # Test model
+            y_pred = pipeline.predict(X_test)
+            mae = mean_absolute_error(y_test, y_pred)
+            r2 = r2_score(y_test, y_pred)
+
+            logger.info(f"✅ Model trained successfully:")
+            logger.info(f"   MAE: {mae:.2f} lakhs")
+            logger.info(f"   R² Score: {r2:.3f}")
+
+            # Save the new model
+            self.pipeline = pipeline
+            # self.training_feature_names is already set by create_training_data_with_proper_features
+
+            model_data = {
+                'pipeline': self.pipeline,
+                'feature_names': self.training_feature_names,
+                'version': '2.0',
+                'sklearn_version': sklearn.__version__,
+                'training_info': {
+                    'mae': mae,
+                    'r2_score': r2,
+                    'training_samples': len(X_train),
+                    'test_samples': len(X_test),
+                    'feature_count': len(self.training_feature_names)
+                },
+                'created_at': datetime.now().isoformat()
+            }
+
+            # Save with version info
+            joblib.dump(model_data, 'house_price_prediction_v2.pkl')
+            logger.info("✅ Model saved as house_price_prediction_v2.pkl")
+
+            return True
+
+        except Exception as e:
+            logger.error(f"Error retraining model: {e}")
+            self.pipeline = None
+            return False
+
+    def create_training_data_with_proper_features(self):
+        """Create training data with proper feature engineering for consistent predictions"""
+        try:
+            # Prepare features for training
+            df_features = self.df.copy()
+
+            # Select relevant columns for training
+            feature_columns = ['site_location', 'area_type', 'availability', 'bhk', 'bath', 'balcony', 'total_sqft']
+
+            # Check if all required columns exist
+            missing_columns = [col for col in feature_columns + ['price'] if col not in df_features.columns]
+            if missing_columns:
+                logger.error(f"Missing essential columns for training: {missing_columns}")
+                return None, None
+
+            df_features = df_features[feature_columns + ['price']]
+
+            # Clean data (ensure numeric columns are correct, fillna where appropriate)
+            df_features['bhk'] = pd.to_numeric(df_features['bhk'], errors='coerce')
+            df_features['bath'] = pd.to_numeric(df_features['bath'], errors='coerce').fillna(df_features['bath'].median())
+            df_features['balcony'] = pd.to_numeric(df_features['balcony'], errors='coerce').fillna(df_features['balcony'].median())
+            df_features['total_sqft'] = pd.to_numeric(df_features['total_sqft'], errors='coerce')
+            df_features['price'] = pd.to_numeric(df_features['price'], errors='coerce')
+
+            # Remove rows with critical missing values for training
+            df_features = df_features.dropna(subset=['price', 'total_sqft', 'bhk', 'site_location'])
+
+            # Remove outliers before one-hot encoding for more robust training
+            df_features = self.remove_outliers(df_features)
+
+            # One-hot encode categorical variables
+            categorical_cols = ['site_location', 'area_type', 'availability']
+            df_encoded = pd.get_dummies(df_features, columns=categorical_cols, prefix=categorical_cols, dummy_na=False)
+
+            # Separate features and target
+            X = df_encoded.drop('price', axis=1)
+            y = df_encoded['price']
+
+            # Store feature names for later use in prediction
+            self.training_feature_names = X.columns.tolist()
+
+            logger.info(f"Training data prepared: {X.shape[0]} samples, {X.shape[1]} features")
+
+            return X, y
+
+        except Exception as e:
+            logger.error(f"Error creating training data: {e}")
+            return None, None
+
+    def remove_outliers(self, df):
+        """Remove outliers from the dataset based on price and area."""
+        try:
+            # Calculate price_per_sqft for outlier removal, then drop it if not needed as a feature
+            df['price_per_sqft'] = (df['price'] * 100000) / df['total_sqft']
+
+            # Remove price outliers (e.g., beyond 3 standard deviations from mean)
+            price_mean = df['price'].mean()
+            price_std = df['price'].std()
+            df = df[abs(df['price'] - price_mean) <= 3 * price_std]
+
+            # Remove area outliers (e.g., beyond 3 standard deviations from mean)
+            area_mean = df['total_sqft'].mean()
+            area_std = df['total_sqft'].std()
+            df = df[abs(df['total_sqft'] - area_mean) <= 3 * area_std]
+
+            # Remove properties with unrealistic price per sqft (e.g., <1000 or >20000 INR/sqft for Pune)
+            df = df[(df['price_per_sqft'] >= 1000) & (df['price_per_sqft'] <= 20000)]
+
+            # Drop temporary price_per_sqft column
+            df = df.drop(columns=['price_per_sqft'])
+
+            logger.info(f"Dataset after outlier removal: {len(df)} rows")
+            return df
+
+        except Exception as e:
+            logger.error(f"Error removing outliers: {e}")
+            return df # Return original df if error occurs
+
+    def predict_single_price(self, location, bhk, bath, balcony, sqft, area_type, availability):
+        """Predict price for a single property using ML model, with fallback to heuristic."""
+        try:
+            # Check if ML pipeline is loaded
+            if not hasattr(self, 'pipeline') or self.pipeline is None or not self.training_feature_names:
+                logger.warning("ML pipeline or training features not available. Using fallback prediction.")
+                return self.predict_single_price_fallback(location, bhk, bath, balcony, sqft, area_type, availability)
+
+            try:
+                # Create a feature dictionary initialized with 0s for all expected features
+                feature_dict = {feature: 0 for feature in self.training_feature_names}
+
+                # Set numerical features
+                numerical_mapping = {
+                    'bhk': bhk,
+                    'bath': bath,
+                    'balcony': balcony,
+                    'total_sqft': sqft
+                }
+                for feature, value in numerical_mapping.items():
+                    if feature in feature_dict:
+                        feature_dict[feature] = value
+                    else:
+                        logger.warning(f"Numerical feature '{feature}' not found in training features. Skipping.")
+
+                # Set categorical features (one-hot encoded)
+                # Location
+                location_key = f"site_location_{location}"
+                if location_key in feature_dict:
+                    feature_dict[location_key] = 1
+                else:
+                    found_loc = False
+                    for feature in self.training_feature_names:
+                        if feature.startswith('site_location_') and location.lower() in feature.lower():
+                            feature_dict[feature] = 1
+                            found_loc = True
+                            break
+                    if not found_loc:
+                        logger.warning(f"Location '{location}' not found as exact or fuzzy match in training features. This location will not contribute to the ML prediction specific to its one-hot encoding.")
+
+                # Area Type
+                area_type_key = f"area_type_{area_type}"
+                if area_type_key in feature_dict:
+                    feature_dict[area_type_key] = 1
+                else:
+                    found_area_type = False
+                    for feature in self.training_feature_names:
+                        if feature.startswith('area_type_') and area_type.lower() in feature.lower():
+                            feature_dict[feature] = 1
+                            found_area_type = True
+                            break
+                    if not found_area_type:
+                        logger.warning(f"Area type '{area_type}' not found in training features. This area type will not contribute to the ML prediction specific to its one-hot encoding.")
+
+                # Availability
+                availability_key = f"availability_{availability}"
+                if availability_key in feature_dict:
+                    feature_dict[availability_key] = 1
+                else:
+                    found_availability = False
+                    for feature in self.training_feature_names:
+                        if feature.startswith('availability_') and availability.lower() in feature.lower():
+                            feature_dict[feature] = 1
+                            found_availability = True
+                            break
+                    if not found_availability:
+                        logger.warning(f"Availability '{availability}' not found in training features. This availability will not contribute to the ML prediction specific to its one-hot encoding.")
+
+                # Create DataFrame from the feature dictionary and ensure column order
+                input_df = pd.DataFrame([feature_dict])[self.training_feature_names]
+
+                predicted_price = self.pipeline.predict(input_df)[0]
+                return round(predicted_price, 2)
+
+            except Exception as ml_prediction_error:
+                logger.warning(f"ML prediction failed for input {location, bhk, sqft}: {ml_prediction_error}. Falling back to heuristic model.")
+                return self.predict_single_price_fallback(location, bhk, bath, balcony, sqft, area_type, availability)
+
+        except Exception as general_error:
+            logger.error(f"General error in predict_single_price wrapper: {general_error}. Falling back to heuristic.")
+            return self.predict_single_price_fallback(location, bhk, bath, balcony, sqft, area_type, availability)
+
+
+    def predict_single_price_fallback(self, location, bhk, bath, balcony, sqft, area_type, availability):
+        """Enhanced fallback prediction method when ML model is unavailable or fails."""
+        try:
+            # Base price per sqft for different areas in Pune (extensive map for better fallback)
+            location_price_map = {
+                'Koregaon Park': 12000, 'Kalyani Nagar': 11000, 'Boat Club Road': 10500,
+                'Aundh': 9500, 'Baner': 8500, 'Balewadi': 8000, 'Kothrud': 8500,
+                'Viman Nagar': 7500, 'Wakad': 7000, 'Hinjewadi': 7500, 'Pune': 7000,
+                'Hadapsar': 6500, 'Kharadi': 7200, 'Yerawada': 7000, 'Lohegaon': 6000,
+                'Wagholi': 5500, 'Mundhwa': 7000, 'Undri': 6500, 'Kondhwa': 6000,
+                'Katraj': 5800, 'Dhankawadi': 6000, 'Warje': 6500, 'Karve Nagar': 7500,
+                'Bavdhan': 8000, 'Pashan': 7500, 'Sus': 7200, 'Pimpri': 6000,
+                'Chinchwad': 6200, 'Akurdi': 5800, 'Nigdi': 6500, 'Bhosari': 5500,
+                'Chakan': 4800, 'Talegaon': 4500, 'Alandi': 4200, 'Dehu': 4000,
+                'Lonavala': 5000, 'Kamshet': 4500, 'Sinhagad Road': 6800,
+                'Balaji Nagar': 5800, 'Parvati': 5500, 'Gultekdi': 5200, 'Wanowrie': 6200,
+                'Shivajinagar': 9000, 'Deccan': 8500, 'Camp': 7500, 'Koregaon': 8000,
+                'Sadashiv Peth': 8200, 'Shukrawar Peth': 7800, 'Kasba Peth': 7500,
+                'Narayan Peth': 7200, 'Rasta Peth': 7000, 'Ganj Peth': 6800,
+                'Magarpatta': 7500, 'Fursungi': 5000, 'Handewadi': 4800,
+                'Mahatma Phule Peth': 6200, 'Bhavani Peth': 6000, 'Bibwewadi': 7000
+            }
+
+            # Get base price per sqft, try fuzzy matching if exact match not found
+            base_price_per_sqft = location_price_map.get(location, 6500) # Default if no match
+            if location not in location_price_map:
+                for loc_key, price in location_price_map.items():
+                    if location.lower() in loc_key.lower() or loc_key.lower() in location.lower():
+                        base_price_per_sqft = price
+                        break
+
+            # Area type multiplier
+            area_type_multiplier = {
+                'Super built-up Area': 1.0,
+                'Built-up Area': 0.92, # Typically slightly less than super built-up for same listed price
+                'Plot Area': 0.85,    # Plot area might translate to lower built-up
+                'Carpet Area': 1.08   # Carpet area is typically more expensive per sqft
+            }.get(area_type, 1.0)
+
+            # Availability multiplier (Under Construction/Not Ready typically cheaper)
+            availability_multiplier = {
+                'Ready To Move': 1.0,
+                'Under Construction': 0.88,
+                'Not Ready': 0.82
+            }.get(availability, 0.95)
+
+            # BHK-based pricing adjustments (larger BHKs might have slightly lower price/sqft due to bulk)
+            bhk_multiplier = {
+                1: 1.15,  # Premium for 1BHK
+                2: 1.0,   # Base
+                3: 0.95,  # Slight economy
+                4: 0.92,
+                5: 0.90,
+                6: 0.88
+            }.get(bhk, 1.0)
+
+            # Bathroom and Balcony multipliers (simple linear adjustment)
+            bath_multiplier = 1.0 + (bath - 2) * 0.03 # Each extra bath adds 3% to price
+            balcony_multiplier = 1.0 + (balcony - 1) * 0.02 # Each extra balcony adds 2% to price
+
+            # Ensure multipliers don't go negative or too low
+            bath_multiplier = max(0.9, bath_multiplier)
+            balcony_multiplier = max(0.95, balcony_multiplier)
+
+            # Calculate final estimated price
+            estimated_price_raw = (sqft * base_price_per_sqft *
+                                   area_type_multiplier * availability_multiplier *
+                                   bhk_multiplier * bath_multiplier * balcony_multiplier)
+
+            estimated_price_lakhs = estimated_price_raw / 100000
+
+            return round(estimated_price_lakhs, 2)
+
+        except Exception as e:
+            logger.error(f"Error in fallback prediction: {e}")
+            return None # Indicate failure
+
+    def clean_dataset(self):
+        """Clean and process the dataset"""
+        df = self.df.copy()
+
+        # Rename 'size' to 'bhk' based on previous logic (if 'size' exists)
+        if 'size' in df.columns and 'bhk' not in df.columns:
+            df['bhk'] = df['size'].str.extract(r'(\d+)').astype(float)
+        elif 'bhk' not in df.columns:
+            df['bhk'] = np.nan # Ensure bhk column exists even if 'size' is missing
+
+        # Clean total_sqft column
+        df['total_sqft'] = pd.to_numeric(df['total_sqft'], errors='coerce')
+
+        # Clean price column
+        df['price'] = pd.to_numeric(df['price'], errors='coerce')
+
+        # Fill missing values for numerical columns (using median for robustness)
+        df['bath'] = pd.to_numeric(df['bath'], errors='coerce').fillna(df['bath'].median())
+        df['balcony'] = pd.to_numeric(df['balcony'], errors='coerce').fillna(df['balcony'].median())
+
+        # Fill missing values for categorical columns
+        df['society'] = df['society'].fillna('Not Specified')
+        df['area_type'] = df['area_type'].fillna('Super built-up Area') # Common default
+        df['availability'] = df['availability'].fillna('Ready To Move') # Common default
+        df['site_location'] = df['site_location'].fillna('Pune') # General default
+
+        # Remove rows with critical missing values after initial cleaning
+        df = df.dropna(subset=['price', 'total_sqft', 'bhk', 'site_location'])
+
+        # Ensure 'bhk' is an integer (or float if decimals are possible)
+        df['bhk'] = df['bhk'].astype(int)
+        df['bath'] = df['bath'].astype(int)
+        df['balcony'] = df['balcony'].astype(int)
+
+        logger.info(f"Dataset cleaned. Original rows: {self.df.shape[0]}, Cleaned rows: {df.shape[0]}")
+        return df
+
+    def create_fallback_data(self):
+        """Create fallback data if CSV loading fails"""
+        logger.warning("Creating fallback dataset due to CSV loading failure.")
+        fallback_data = {
+            'area_type': ['Super built-up Area', 'Built-up Area', 'Carpet Area'] * 10,
+            'availability': ['Ready To Move', 'Under Construction', 'Ready To Move'] * 10,
+            'size': ['2 BHK', '3 BHK', '4 BHK'] * 10, # Keep 'size' for cleaning process if needed
+            'society': ['Sample Society'] * 30,
+            'total_sqft': [1000, 1200, 1500] * 10,
+            'bath': [2, 3, 4] * 10,
+            'balcony': [1, 2, 3] * 10,
+            'price': [50, 75, 100] * 10,
+            'site_location': ['Baner', 'Hadapsar', 'Kothrud'] * 10,
+        }
+        df_fallback = pd.DataFrame(fallback_data)
+        # Ensure 'bhk' is generated if 'size' is used, and other derived columns
+        if 'size' in df_fallback.columns:
+            df_fallback['bhk'] = df_fallback['size'].str.extract(r'(\d+)').astype(float)
+        else:
+            df_fallback['bhk'] = [2, 3, 4] * 10 # Direct bhk if 'size' is not used
+        # Add a placeholder for price_per_sqft as it's used in analysis/outlier removal
+        df_fallback['price_per_sqft'] = (df_fallback['price'] * 100000) / df_fallback['total_sqft']
+        return df_fallback
+
+
+    def filter_properties(self, filters: Dict[str, Any]) -> pd.DataFrame:
+        """Filter properties based on user criteria"""
+        filtered_df = self.df.copy()
+
+        # Apply filters
+        if filters.get('location'):
+            # Use a more robust search for location, allowing partial or case-insensitive matches
+            search_location = filters['location'].lower()
+            filtered_df = filtered_df[filtered_df['site_location'].str.lower().str.contains(search_location, na=False)]
+
+        if filters.get('bhk') is not None: # Check for None explicitly as bhk can be 0
+            filtered_df = filtered_df[filtered_df['bhk'] == filters['bhk']]
+
+        if filters.get('min_price'):
+            filtered_df = filtered_df[filtered_df['price'] >= filters['min_price']]
+
+        if filters.get('max_price'):
+            filtered_df = filtered_df[filtered_df['price'] <= filters['max_price']]
+
+        if filters.get('min_area'):
+            filtered_df = filtered_df[filtered_df['total_sqft'] >= filters['min_area']]
+
+        if filters.get('max_area'):
+            filtered_df = filtered_df[filtered_df['total_sqft'] <= filters['max_area']]
+
+        if filters.get('area_type'):
+            search_area_type = filters['area_type'].lower()
+            filtered_df = filtered_df[filtered_df['area_type'].str.lower().str.contains(search_area_type, na=False)]
+
+        if filters.get('availability'):
+            search_availability = filters['availability'].lower()
+            filtered_df = filtered_df[filtered_df['availability'].str.lower().str.contains(search_availability, na=False)]
+
+        return filtered_df.head(20)  # Limit results for display
+
+    def get_price_range_analysis(self, filtered_df: pd.DataFrame) -> Dict[str, Any]:
+        """Analyze price range and provide insights"""
+        if filtered_df.empty:
+            return {
+                "total_properties": 0,
+                "price_range": {"min": 0.0, "max": 0.0, "avg": 0.0, "median": 0.0},
+                "area_range": {"min": 0.0, "max": 0.0, "avg": 0.0},
+                "price_per_sqft": {"min": 0.0, "max": 0.0, "avg": 0.0},
+                "location_distribution": {},
+                "area_type_distribution": {},
+                "availability_distribution": {}
+            }
+
+        analysis = {
+            "total_properties": len(filtered_df),
+            "price_range": {
+                "min": float(filtered_df['price'].min()),
+                "max": float(filtered_df['price'].max()),
+                "avg": float(filtered_df['price'].mean()),
+                "median": float(filtered_df['price'].median())
+            },
+            "area_range": {
+                "min": float(filtered_df['total_sqft'].min()),
+                "max": float(filtered_df['total_sqft'].max()),
+                "avg": float(filtered_df['total_sqft'].mean())
+            },
+            # Recalculate price_per_sqft for analysis as it might be dropped after outlier removal
+            "price_per_sqft": {
+                "min": float(((filtered_df['price'] * 100000) / filtered_df['total_sqft']).min()),
+                "max": float(((filtered_df['price'] * 100000) / filtered_df['total_sqft']).max()),
+                "avg": float(((filtered_df['price'] * 100000) / filtered_df['total_sqft']).mean())
+            },
+            "location_distribution": filtered_df['site_location'].value_counts().to_dict(),
+            "area_type_distribution": filtered_df['area_type'].value_counts().to_dict(),
+            "availability_distribution": filtered_df['availability'].value_counts().to_dict()
+        }
+
+        return analysis
+
+    def predict_prices_for_filtered_results(self, filtered_df: pd.DataFrame) -> pd.DataFrame:
+        """Predict prices for all filtered properties and add to DataFrame."""
+        if filtered_df.empty:
+            return filtered_df
+
+        predictions = []
+        for index, row in filtered_df.iterrows():
+            predicted_price = self.predict_single_price(
+                location=row['site_location'],
+                bhk=row['bhk'],
+                bath=row['bath'],
+                balcony=row['balcony'],
+                sqft=row['total_sqft'],
+                area_type=row['area_type'],
+                availability=row['availability']
+            )
+            # Use original price if prediction fails (returns None)
+            predictions.append(predicted_price if predicted_price is not None else row['price'])
+
+        filtered_df['predicted_price'] = predictions
+        filtered_df['price_difference'] = filtered_df['predicted_price'] - filtered_df['price']
+        # Avoid division by zero if original price is 0
+        filtered_df['price_difference_pct'] = (
+            filtered_df['price_difference'] / filtered_df['price'].replace(0, np.nan) * 100
+        ).fillna(0) # Fill NaN with 0 if original price was 0 or prediction failed
+
+        return filtered_df
+
+    def generate_deep_insights(self, filtered_df: pd.DataFrame, analysis: Dict[str, Any]) -> str:
+        """Generate deep insights using Gemini AI"""
+        try:
+            # Prepare context for Gemini
+            properties_sample_str = filtered_df[['site_location', 'bhk', 'total_sqft', 'price', 'predicted_price', 'price_difference_pct']].head().to_string(index=False)
+            if properties_sample_str:
+                properties_sample_str = f"Top 5 Properties Sample:\n{properties_sample_str}\n"
+            else:
+                properties_sample_str = "No specific property samples available to list."
+
+
+            context = f"""
+            You are a highly experienced real estate market expert specializing in Pune properties.
+            Your task is to analyze the provided property data and offer comprehensive, actionable insights for a potential property buyer.
+
+            Here's a summary of the current search results:
+            - Total Properties Found: {analysis['total_properties']}
+            - Price Range: ₹{analysis['price_range']['min']:.2f}L to ₹{analysis['price_range']['max']:.2f}L
+            - Average Price: ₹{analysis['price_range']['avg']:.2f}L
+            - Median Price: ₹{analysis['price_range']['median']:.2f}L
+            - Average Area: {analysis['area_range']['avg']:.0f} sq ft
+            - Average Price per sq ft: ₹{analysis['price_per_sqft']['avg']:.0f}
+
+            Location Distribution: {json.dumps(analysis['location_distribution'], indent=2)}
+            Area Type Distribution: {json.dumps(analysis['area_type_distribution'], indent=2)}
+            Availability Distribution: {json.dumps(analysis['availability_distribution'], indent=2)}
+
+            {properties_sample_str}
+
+            Please provide detailed market insights including:
+            1.  **Current Market Trends**: What are the prevailing trends in Pune's real estate market based on this data? (e.g., buyer's/seller's market, growth areas, demand patterns).
+            2.  **Price Competitiveness**: How do the prices of these properties compare to the overall Pune market? Are they underpriced, overpriced, or fair value? Highlight any anomalies based on the 'price_difference_pct' if available.
+            3.  **Best Value Propositions**: Identify what types of properties (BHK, area, location) offer the best value for money right now based on average price per sqft and price ranges.
+            4.  **Location-Specific Insights**: For the top 2-3 locations, provide specific observations on amenities, connectivity, future development potential, and why they might be good/bad for investment or living.
+            5.  **Investment Recommendations**: Based on the data, what would be your general investment advice for someone looking into Pune real estate?
+            6.  **Future Market Outlook**: Briefly discuss the short-to-medium term outlook (next 1-2 years) for the Pune real estate market.
+
+            Ensure your response is conversational, professional, and directly actionable for a property buyer.
+            """
+
+            response = model.generate_content(context)
+            return self._clean_gemini_text(response.text) # Apply cleaning here
+
+        except Exception as e:
+            logger.error(f"Error generating insights using Gemini: {e}")
+            return "I'm analyzing the market data to provide you with detailed insights. Based on the current search results, I can see various opportunities in your preferred areas. Please bear with me while I gather more information."
+
+    def get_nearby_properties_gemini(self, location: str, requirements: Dict[str, Any]) -> str:
+        """Get nearby properties and recent market data using Gemini"""
+        try:
+            # Refine requirements to be more human-readable for Gemini
+            req_str = ""
+            for k, v in requirements.items():
+                if k == 'min_price': req_str += f"Minimum Budget: {v} Lakhs. "
+                elif k == 'max_price': req_str += f"Maximum Budget: {v} Lakhs. "
+                elif k == 'min_area': req_str += f"Minimum Area: {v} sq ft. "
+                elif k == 'max_area': req_str += f"Maximum Area: {v} sq ft. "
+                elif k == 'bhk': req_str += f"BHK: {v}. "
+                elif k == 'area_type': req_str += f"Area Type: {v}. "
+                elif k == 'availability': req_str += f"Availability: {v}. "
+                elif k == 'location': req_str += f"Preferred Location: {v}. "
+            if not req_str: req_str = "No specific requirements provided beyond location."
+
+
+            context = f"""
+            You are a knowledgeable real estate advisor with up-to-date market information for Pune.
+
+            A client is interested in properties near **{location}**.
+            Their current general requirements are: {req_str.strip()}
+
+            Please provide a concise but informative overview focusing on:
+            1.  **Recent Property Launches**: Mention any significant residential projects launched in {location} or very close vicinity in the last 6-12 months.
+            2.  **Upcoming Projects**: Are there any major upcoming residential or commercial developments (e.g., IT parks, malls, new infrastructure) that could impact property values in {location} or adjacent areas?
+            3.  **Infrastructure Developments**: Discuss any planned or ongoing infrastructure improvements (roads, metro, civic amenities) that might affect property values and lifestyle in {location}.
+            4.  **Market Trends in {location}**: What are the current buying/rental trends specific to {location}? Is it a high-demand area, or is supply outpacing demand?
+            5.  **Comparative Analysis**: Briefly compare {location} with one or two similar, nearby localities in terms of property values, amenities, and lifestyle.
+            6.  **Investment Potential**: What is the general investment outlook and potential rental yield for properties in {location}?
+
+            Focus on specific details relevant to the Pune real estate market in 2024-2025.
+            """
+
+            response = model.generate_content(context)
+            return self._clean_gemini_text(response.text) # Apply cleaning here
+
+        except Exception as e:
+            logger.error(f"Error getting nearby properties from Gemini: {e}")
+            return f"I'm gathering information about recent properties and market trends near {location}. This area has shown consistent growth in property values, and I'll get you more specific details shortly."
+
+    def update_context_memory(self, user_query: str, results: Dict[str, Any]):
+        """Update context memory to maintain conversation continuity"""
+        self.context_memory.append({
+            'timestamp': datetime.now().isoformat(),
+            'user_query': user_query,
+            'results_summary': {
+                'total_properties': results.get('total_properties', 0),
+                'price_range': results.get('price_range', {}),
+                'locations': list(results.get('location_distribution', {}).keys())
+            }
+        })
+
+        # Keep only last 5 interactions
+        if len(self.context_memory) > 5:
+            self.context_memory.pop(0)
+
+    def extract_requirements(self, user_message: str) -> Dict[str, Any]:
+        """Extract property requirements from user message"""
+        requirements = {}
+        message_lower = user_message.lower()
+
+        # Extract BHK
+        bhk_match = re.search(r'(\d+)\s*bhk', message_lower)
+        if bhk_match:
+            try:
+                requirements['bhk'] = int(bhk_match.group(1))
+            except ValueError:
+                pass # Ignore if not a valid number
+
+        # Extract budget range (flexible with "lakh", "crore", "million")
+        budget_match = re.search(
+            r'(?:budget|price|cost)(?:.*?(?:of|between|from)\s*)?'
+            r'(\d+(?:\.\d+)?)\s*(?:lakhs?|crores?|million)?(?:(?:\s*to|\s*-\s*)\s*(\d+(?:\.\d+)?)\s*(?:lakhs?|crores?|million)?)?',
+            message_lower
+        )
+        if budget_match:
+            try:
+                min_amount = float(budget_match.group(1))
+                max_amount = float(budget_match.group(2)) if budget_match.group(2) else None
+
+                # Detect units for both min and max if provided
+                if 'crore' in budget_match.group(0): # Check original matched string for "crore"
+                    requirements['min_price'] = min_amount * 100
+                    if max_amount:
+                        requirements['max_price'] = max_amount * 100
+                elif 'million' in budget_match.group(0):
+                    requirements['min_price'] = min_amount * 10
+                    if max_amount:
+                        requirements['max_price'] = max_amount * 10
+                else: # Default to lakhs
+                    requirements['min_price'] = min_amount
+                    if max_amount:
+                        requirements['max_price'] = max_amount
+            except ValueError:
+                pass
+
+        # Extract location
+        found_location = False
+        for location in self.locations:
+            if location.lower() in message_lower:
+                requirements['location'] = location
+                found_location = True
+                break
+        # Broader location matching if specific location not found
+        if not found_location:
+            general_locations = ['pune', 'pcmp'] # Add more general terms if needed
+            for gen_loc in general_locations:
+                if gen_loc in message_lower:
+                    requirements['location'] = gen_loc.capitalize() # Or a default location like 'Pune'
+                    break
+
+
+        # Extract area requirements
+        area_match = re.search(r'(\d+(?:\.\d+)?)\s*(?:to|-)?\s*(\d+(?:\.\d+)?)?\s*(?:sq\s*ft|sqft|square\s*feet|sft)',
+                               message_lower)
+        if area_match:
+            try:
+                requirements['min_area'] = float(area_match.group(1))
+                if area_match.group(2):
+                    requirements['max_area'] = float(area_match.group(2))
+            except ValueError:
+                pass
+
+        # Extract area type
+        for area_type in self.area_types:
+            if area_type.lower() in message_lower:
+                requirements['area_type'] = area_type
+                break
+
+        # Extract availability
+        for availability in self.availability_types:
+            if availability.lower() in message_lower:
+                requirements['availability'] = availability
+                break
+
+        return requirements
+
+    def handle_query(self, user_message: str) -> Dict[str, Any]:
+        """Main function to handle user queries with context awareness"""
+        try:
+            # Extract requirements from current message
+            requirements = self.extract_requirements(user_message)
+
+            # Merge with previous context if building on last query
+            if self.is_follow_up_query(user_message):
+                requirements = self.merge_with_context(requirements)
+
+            # Update client preferences (store all extracted preferences)
+            self.client_preferences.update(requirements)
+
+            # Filter properties based on requirements
+            filtered_df = self.filter_properties(requirements)
+
+            # If no properties found, provide suggestions
+            if filtered_df.empty:
+                return self.handle_no_results(requirements)
+
+            # Predict prices for filtered results
+            filtered_df = self.predict_prices_for_filtered_results(filtered_df)
+
+            # Get price range analysis
+            analysis = self.get_price_range_analysis(filtered_df)
+
+            # Generate deep insights
+            insights = self.generate_deep_insights(filtered_df, analysis)
+
+            # Get nearby properties information
+            nearby_info = ""
+            if requirements.get('location'):
+                nearby_info = self.get_nearby_properties_gemini(requirements['location'], requirements)
+
+            # Prepare response
+            response_data = {
+                'filtered_properties': filtered_df.to_dict('records'),
+                'analysis': analysis,
+                'insights': insights,
+                'nearby_properties': nearby_info,
+                'requirements': requirements,
+                'context_aware': self.is_follow_up_query(user_message)
+            }
+
+            # Update context memory
+            self.update_context_memory(user_message, analysis)
+            self.last_search_results = response_data # Store the full response
+
+            return response_data
+
+        except Exception as e:
+            logger.error(f"Error handling query: {e}")
+            return {'error': f'An error occurred while processing your query: {str(e)}'}
+
+    def is_follow_up_query(self, user_message: str) -> bool:
+        """Check if this is a follow-up query building on previous results"""
+        follow_up_indicators = ['also', 'and', 'additionally', 'what about', 'show me more', 'similar', 'nearby',
+                                'around', 'close to', 'next', 'other', 'different', 'change', 'update']
+        return any(indicator in user_message.lower() for indicator in follow_up_indicators) and len(
+            self.context_memory) > 0
+
+    def merge_with_context(self, new_requirements: Dict[str, Any]) -> Dict[str, Any]:
+        """Merge new requirements with context from previous queries"""
+        # Start with the overall client preferences
+        merged = self.client_preferences.copy()
+
+        # Overwrite with any new requirements from the current message
+        merged.update(new_requirements)
+
+        # Apply default or previously established values if not specified in current query
+        # Example: If a new query doesn't specify location, use the last known location
+        if 'location' not in new_requirements and 'location' in self.client_preferences:
+            merged['location'] = self.client_preferences['location']
+
+        # You can add more sophisticated merging logic here if needed
+        # e.g., if a new budget is provided, replace the old one entirely.
+        # The current update() method already handles this for direct key conflicts.
+
+        return merged
+
+    def handle_no_results(self, requirements: Dict[str, Any]) -> Dict[str, Any]:
+        """Handle cases where no properties match the criteria"""
+        suggestions = ["Try relaxing some of your criteria."]
+
+        if requirements.get('max_price'):
+            suggestions.append(f"Consider increasing your budget above ₹{requirements['max_price']:.2f}L.")
+            # Suggest a slightly higher range
+            suggestions.append(f"Perhaps a range of ₹{requirements['max_price']:.2f}L to ₹{(requirements['max_price'] * 1.2):.2f}L?")
+
+        if requirements.get('location'):
+            # Find nearby popular locations in the dataset, excluding the one searched
+            nearby_locs = [loc for loc in self.locations if loc.lower() != requirements['location'].lower()]
+            if nearby_locs:
+                # Sort by count if possible, or just pick top 3
+                top_locations = self.df['site_location'].value_counts().index.tolist()
+                suggested_nearby = [loc for loc in top_locations if loc.lower() != requirements['location'].lower()][:3]
+                if suggested_nearby:
+                    suggestions.append(f"Consider nearby popular areas like: {', '.join(suggested_nearby)}.")
+
+        if requirements.get('bhk') is not None:
+            # Suggest +/- 1 BHK if not already at min/max reasonable bhk
+            if requirements['bhk'] > 1:
+                suggestions.append(f"Consider looking for {requirements['bhk'] - 1} BHK options.")
+            if requirements['bhk'] < 6: # Assuming 6 is a practical upper limit for most searches
+                suggestions.append(f"Consider {requirements['bhk'] + 1} BHK options.")
+
+        if requirements.get('max_area'):
+            suggestions.append(f"You might find more options if you consider properties up to ~{(requirements['max_area'] * 1.1):.0f} sq ft.")
+
+        # Default message if specific suggestions are not generated
+        if len(suggestions) == 1 and "relaxing" in suggestions[0]:
+            final_suggestion_text = "No properties found matching your exact criteria. Please try broadening your search or clarifying your preferences."
+        else:
+            final_suggestion_text = f"No properties found matching your exact criteria. Here are some suggestions: {'; '.join(suggestions)}."
+
+        return {
+            'filtered_properties': [],
+            'analysis': self.get_price_range_analysis(pd.DataFrame()), # Empty analysis
+            'insights': final_suggestion_text,
+            'nearby_properties': '',
+            'requirements': requirements,
+            'suggestions': suggestions
+        }
+
+
+# Initialize the enhanced sales assistant (MUST be after class definition)
+sales_assistant = EnhancedRealEstateSalesAssistant()
+
+
+@app.route('/')
+def index():
+    return render_template('index2.html')
+
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    """Enhanced chat endpoint with comprehensive property search"""
+    try:
+        data = request.get_json()
+        user_message = data.get('message', '').strip()
+
+        if not user_message:
+            return jsonify({'error': 'Please provide your query'}), 400
+
+        # Get comprehensive response from sales assistant
+        response_data = sales_assistant.handle_query(user_message)
+
+        # Ensure response_data always includes necessary keys even on error
+        if 'error' in response_data:
+            return jsonify({
+                'response': response_data,
+                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                'conversation_context': len(sales_assistant.context_memory)
+            }), 500 # Return 500 for internal errors
+        else:
+            return jsonify({
+                'response': response_data,
+                'timestamp': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
+                'conversation_context': len(sales_assistant.context_memory)
+            })
+
+    except Exception as e:
+        logger.error(f"Chat endpoint error: {e}")
+        return jsonify({'error': f'An unexpected error occurred in chat endpoint: {str(e)}'}), 500
+
+
+# Flask routes must be defined at the module level, not inside a class
+@app.route('/model_status')
+def model_status():
+    """Get current model status and version info"""
+    try:
+        status = {
+            'model_loaded': hasattr(sales_assistant, 'pipeline') and sales_assistant.pipeline is not None,
+            'model_version': getattr(sales_assistant, 'model_version', 'unknown'),
+            'feature_count': len(getattr(sales_assistant, 'training_feature_names', [])),
+            'prediction_method': 'ML' if hasattr(sales_assistant, 'pipeline') and sales_assistant.pipeline else 'Fallback',
+            'sklearn_version': sklearn.__version__
+        }
+        return jsonify(status)
+    except Exception as e:
+        logger.error(f"Error in model_status endpoint: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/retrain_model', methods=['POST'])
+def retrain_model():
+    """Retrain the model with current version"""
+    try:
+        logger.info("Starting model retraining via endpoint...")
+        success = sales_assistant.retrain_model_with_current_version()
+
+        if success:
+            return jsonify({
+                'message': 'Model retrained successfully',
+                'version': sales_assistant.model_version,
+                'feature_count': len(sales_assistant.training_feature_names),
+                'sample_features': sales_assistant.training_feature_names[:10] if sales_assistant.training_feature_names else []
+            })
+        else:
+            return jsonify({'error': 'Failed to retrain model. Check logs for details.'}), 500
+
+    except Exception as e:
+        logger.error(f"Retrain endpoint error: {e}")
+        return jsonify({'error': f'An unexpected error occurred during retraining: {str(e)}'}), 500
+
+
+@app.route('/filter_properties', methods=['POST'])
+def filter_properties_endpoint(): # Renamed to avoid conflict with class method
+    """Dedicated endpoint for property filtering"""
+    try:
+        filters = request.get_json()
+
+        filtered_df = sales_assistant.filter_properties(filters)
+        filtered_df = sales_assistant.predict_prices_for_filtered_results(filtered_df)
+        analysis = sales_assistant.get_price_range_analysis(filtered_df)
+
+        return jsonify({
+            'properties': filtered_df.to_dict('records'),
+            'analysis': analysis,
+            'total_count': len(filtered_df)
+        })
+
+    except Exception as e:
+        logger.error(f"Filter endpoint error: {e}")
+        return jsonify({'error': f'Filtering error: {str(e)}'}), 500
+
+
+@app.route('/get_insights', methods=['POST'])
+def get_insights():
+    """Get AI-powered insights for current search results"""
+    try:
+        data = request.get_json()
+        location_from_request = data.get('location')
+        requirements_from_request = data.get('requirements', {})
+
+        if sales_assistant.last_search_results:
+            filtered_df = pd.DataFrame(sales_assistant.last_search_results['filtered_properties'])
+            analysis = sales_assistant.last_search_results['analysis']
+            insights = sales_assistant.generate_deep_insights(filtered_df, analysis)
+
+            nearby_info = ""
+            # Use location from request if provided, otherwise from last search results
+            effective_location = location_from_request or sales_assistant.last_search_results['requirements'].get('location')
+            if effective_location:
+                nearby_info = sales_assistant.get_nearby_properties_gemini(effective_location, requirements_from_request or sales_assistant.last_search_results['requirements'])
+
+            return jsonify({
+                'insights': insights,
+                'nearby_properties': nearby_info
+            })
+        else:
+            return jsonify({'error': 'No previous search results available for insights. Please perform a search first.'}), 400
+
+    except Exception as e:
+        logger.error(f"Insights endpoint error: {e}")
+        return jsonify({'error': f'Insights error: {str(e)}'}), 500
+
+
+@app.route('/get_market_data')
+def get_market_data():
+    """Get comprehensive market data"""
+    try:
+        # Ensure df is loaded before accessing its properties
+        if not hasattr(sales_assistant, 'df') or sales_assistant.df.empty:
+            return jsonify({'error': 'Market data not available, dataset not loaded.'}), 500
+
+        market_data = {
+            'locations': sales_assistant.locations,
+            'area_types': sales_assistant.area_types,
+            'availability_types': sales_assistant.availability_types,
+            'bhk_options': sales_assistant.bhk_options,
+            'price_statistics': {
+                'min_price': float(sales_assistant.df['price'].min()),
+                'max_price': float(sales_assistant.df['price'].max()),
+                'avg_price': float(sales_assistant.df['price'].mean()),
+                'median_price': float(sales_assistant.df['price'].median())
+            },
+            'area_statistics': {
+                'min_area': float(sales_assistant.df['total_sqft'].min()),
+                'max_area': float(sales_assistant.df['total_sqft'].max()),
+                'avg_area': float(sales_assistant.df['total_sqft'].mean())
+            }
+        }
+
+        return jsonify(market_data)
+
+    except Exception as e:
+        logger.error(f"Market data endpoint error: {e}")
+        return jsonify({'error': f'Market data error: {str(e)}'}), 500
+
+
+@app.route('/client_preferences')
+def get_client_preferences():
+    """Get current client preferences and conversation history"""
+    return jsonify({
+        'preferences': sales_assistant.client_preferences,
+        'conversation_history': sales_assistant.context_memory,
+        'last_search_available': sales_assistant.last_search_results is not None
+    })
+
+
+@app.route('/reset_session', methods=['POST'])
+def reset_session():
+    """Reset entire session including preferences and context"""
+    try:
+        sales_assistant.client_preferences = {}
+        sales_assistant.context_memory = []
+        sales_assistant.last_search_results = None
+        return jsonify({'message': 'Session reset successfully'})
+    except Exception as e:
+        logger.error(f"Reset session error: {e}")
+        return jsonify({'error': f'Failed to reset session: {str(e)}'}), 500
+
+
+@app.route('/health')
+def health():
+    """Health check endpoint"""
+    try:
+        return jsonify({
+            'status': 'healthy',
+            'model_loaded': hasattr(sales_assistant, 'pipeline') and sales_assistant.pipeline is not None,
+            'model_version': sales_assistant.model_version,
+            'data_loaded': hasattr(sales_assistant, 'df') and not sales_assistant.df.empty,
+            'dataset_size': len(sales_assistant.df) if hasattr(sales_assistant, 'df') else 0,
+            'locations_available': len(sales_assistant.locations),
+            'context_memory_size': len(sales_assistant.context_memory),
+            'timestamp': datetime.now().isoformat()
+        })
+    except Exception as e:
+        logger.error(f"Health check error: {e}")
+        return jsonify({'status': 'unhealthy', 'error': str(e)}), 500
+
+
+if __name__ == '__main__':
+    # It's better to explicitly set the host for deployment environments.
+    # For development, debug=True is useful but should be False in production.
+    app.run(debug=True, host='0.0.0.0', port=5000)

templates/index.html

@@ -0,0 +1,162 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>CKD Prediction</title>
+    <style>
+    body {
+        font-family: Arial, sans-serif;
+        background-color: aquamarine;
+        padding: 20px;
+    }
+
+    .container {
+        width: 700px;
+        margin: auto;
+        background: #fff;
+        padding: 30px;
+        border-radius: 10px;
+        box-shadow: 0 0 10px rgba(0, 0, 0, 0.1);
+    }
+
+    h2 {
+        text-align: center;
+        color: #333;
+    }
+
+    .form-group {
+        margin-bottom: 15px;
+    }
+
+    label {
+        font-weight: bold;
+        display: block;
+        margin-bottom: 5px;
+    }
+
+    input, select {
+        width: 100%;
+        padding: 8px;
+        font-size: 14px;
+    }
+
+    .btn {
+        width: 100%;
+        padding: 10px;
+        background-color: #28a745;
+        border: none;
+        color: white;
+        font-size: 16px;
+        cursor: pointer;
+        border-radius: 5px;
+    }
+
+    .btn:hover {
+        background-color: #218838;
+
+
+    }
+
+    .result {
+        font-size: large;
+        font-family: 'Gill Sans', 'Gill Sans MT', Calibri, 'Trebuchet MS', sans-serif;
+        color: #333;
+        background-color: #f8f9fa;
+        margin-top: 20px;
+        font-size: 18px;
+        font-weight: bold;
+        text-align: center;
+    }
+</style>
+
+</head>
+<body>
+<div class="container">
+    <h2>CKD Prediction Form</h2>
+    <form method="post">
+        <!-- Age -->
+        <div class="form-group">
+            <label>Age</label>
+            <input type="number" name="age" min="0" max="100" placeholder="e.g., 60" required>
+        </div>
+
+        <!-- Blood Pressure -->
+        <div class="form-group">
+            <label>Blood Pressure (mmHg)</label>
+            <input type="number" name="blood_pressure" min="40" max="200" placeholder="e.g., 80" required>
+        </div>
+
+        <!-- Specific Gravity -->
+        <div class="form-group">
+            <label>Specific Gravity</label>
+            <select name="specific_gravity">
+                <option value="1.005">1.005</option>
+                <option value="1.010">1.010</option>
+                <option value="1.015">1.015</option>
+                <option value="1.020" selected>1.020</option>
+                <option value="1.025">1.025</option>
+            </select>
+        </div>
+
+        <!-- Albumin -->
+        <div class="form-group">
+            <label>Albumin (0–5)</label>
+            <input type="number" name="albumin" min="0" max="5" placeholder="e.g., 2" required>
+        </div>
+
+        <!-- Sugar -->
+        <div class="form-group">
+            <label>Sugar (0–5)</label>
+            <input type="number" name="sugar" min="0" max="5" placeholder="e.g., 1" required>
+        </div>
+
+        <!-- Binary Dropdowns -->
+        {% for field in [
+            ('red_blood_cells', 'Red Blood Cells (Normal=1 / Abnormal=0)'),
+            ('pus_cell', 'Pus Cell (Normal=1 / Abnormal=0)'),
+            ('pus_cell_clumps', 'Pus Cell Clumps (Yes=1 / No=0)'),
+            ('bacteria', 'Bacteria (Yes=1 / No=0)'),
+            ('hypertension', 'Hypertension (Yes=1 / No=0)'),
+            ('diabetes_mellitus', 'Diabetes Mellitus (Yes=1 / No=0)'),
+            ('coronary_artery_disease', 'Coronary Artery Disease (Yes=1 / No=0)'),
+            ('appetite', 'Appetite (Good=1 / Poor=0)'),
+            ('peda_edema', 'Pedal Edema (Yes=1 / No=0)'),
+            ('aanemia', 'Anaemia (Yes=1 / No=0)')
+        ] %}
+        <div class="form-group">
+            <label>{{ field[1] }}</label>
+            <select name="{{ field[0] }}">
+                <option value="1">Yes / Normal / Good</option>
+                <option value="0">No / Abnormal / Poor</option>
+            </select>
+        </div>
+        {% endfor %}
+
+        <!-- Numeric Inputs -->
+        {% for field, label, minval, maxval, placeholder in [
+            ('blood_glucose_random', 'Blood Glucose Random (mg/dL)', 50, 500, 150),
+            ('blood_urea', 'Blood Urea (mg/dL)', 5, 300, 44),
+            ('serum_creatinine', 'Serum Creatinine (mg/dL)', 0.5, 15, 1.2),
+            ('sodium', 'Sodium (mEq/L)', 120, 160, 135),
+            ('potassium', 'Potassium (mEq/L)', 2.5, 7.5, 4.6),
+            ('haemoglobin', 'Haemoglobin (g/dL)', 3, 20, 12),
+            ('packed_cell_volume', 'Packed Cell Volume (%)', 15, 55, 38),
+            ('white_blood_cell_count', 'WBC Count (cells/uL)', 3000, 25000, 8000),
+            ('red_blood_cell_count', 'RBC Count (millions/uL)', 2.5, 6.5, 4.5)
+        ] %}
+        <div class="form-group">
+            <label>{{ label }}</label>
+            <input type="number" name="{{ field }}" min="{{ minval }}" max="{{ maxval }}" step="any" placeholder="e.g., {{ placeholder }}" required>
+        </div>
+        {% endfor %}
+
+        <!-- Submit Button -->
+        <button type="submit" class="btn">Predict</button>
+    </form>
+
+    {% if result %}
+    <div class="result">{{ result }}</div>
+    {% endif %}
+</div>
+</body>
+</html>

templates/index2.html

@@ -0,0 +1,920 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Enhanced Real Estate Assistant - Pune Properties</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            min-height: 100vh;
+            color: #333;
+        }
+
+        .container {
+            max-width: 1400px;
+            margin: 0 auto;
+            padding: 20px;
+        }
+
+        .header {
+            background: rgba(255, 255, 255, 0.95);
+            padding: 20px;
+            border-radius: 15px;
+            margin-bottom: 20px;
+            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
+        }
+
+        .header h1 {
+            color: #2c3e50;
+            text-align: center;
+            margin-bottom: 10px;
+            font-size: 2.5em;
+        }
+
+        .header p {
+            text-align: center;
+            color: #7f8c8d;
+            font-size: 1.1em;
+        }
+
+        .main-content {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-bottom: 20px;
+        }
+
+        .chat-section {
+            background: rgba(255, 255, 255, 0.95);
+            padding: 20px;
+            border-radius: 15px;
+            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
+        }
+
+        .filter-section {
+            background: rgba(255, 255, 255, 0.95);
+            padding: 20px;
+            border-radius: 15px;
+            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
+        }
+
+        .section-title {
+            color: #2c3e50;
+            margin-bottom: 15px;
+            font-size: 1.5em;
+            border-bottom: 2px solid #3498db;
+            padding-bottom: 5px;
+        }
+
+        .chat-container {
+            height: 400px;
+            overflow-y: auto;
+            border: 1px solid #ddd;
+            border-radius: 10px;
+            padding: 15px;
+            margin-bottom: 15px;
+            background: #f8f9fa;
+        }
+
+        .message {
+            margin-bottom: 15px;
+            padding: 10px;
+            border-radius: 10px;
+            max-width: 80%;
+        }
+
+        .user-message {
+            background: #3498db;
+            color: white;
+            margin-left: auto;
+        }
+
+        .bot-message {
+            background: #ecf0f1;
+            color: #2c3e50;
+        }
+
+        .input-group {
+            display: flex;
+            gap: 10px;
+            margin-bottom: 15px;
+        }
+
+        .input-group input {
+            flex: 1;
+            padding: 12px;
+            border: 1px solid #ddd;
+            border-radius: 8px;
+            font-size: 16px;
+        }
+
+        .btn {
+            padding: 12px 24px;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            font-size: 16px;
+            font-weight: 600;
+            transition: all 0.3s ease;
+        }
+
+        .btn-primary {
+            background: #3498db;
+            color: white;
+        }
+
+        .btn-primary:hover {
+            background: #2980b9;
+            transform: translateY(-2px);
+        }
+
+        .btn-secondary {
+            background: #95a5a6;
+            color: white;
+        }
+
+        .btn-secondary:hover {
+            background: #7f8c8d;
+        }
+
+        .filter-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-bottom: 15px;
+        }
+
+        .filter-group {
+            display: flex;
+            flex-direction: column;
+        }
+
+        .filter-group label {
+            margin-bottom: 5px;
+            font-weight: 600;
+            color: #2c3e50;
+        }
+
+        .filter-group input, .filter-group select {
+            padding: 8px;
+            border: 1px solid #ddd;
+            border-radius: 5px;
+            font-size: 14px;
+        }
+
+        .results-section {
+            background: rgba(255, 255, 255, 0.95);
+            padding: 20px;
+            border-radius: 15px;
+            box-shadow: 0 8px 25px rgba(0, 0, 0, 0.1);
+            margin-bottom: 20px;
+        }
+
+        .tabs {
+            display: flex;
+            border-bottom: 2px solid #ddd;
+            margin-bottom: 20px;
+        }
+
+        .tab {
+            padding: 10px 20px;
+            cursor: pointer;
+            background: #f8f9fa;
+            border: none;
+            border-bottom: 2px solid transparent;
+            font-size: 16px;
+            font-weight: 600;
+            transition: all 0.3s ease;
+        }
+
+        .tab.active {
+            background: #3498db;
+            color: white;
+            border-bottom-color: #2980b9;
+        }
+
+        .tab-content {
+            display: none;
+        }
+
+        .tab-content.active {
+            display: block;
+        }
+
+        .properties-table {
+            width: 100%;
+            border-collapse: collapse;
+            margin-bottom: 20px;
+            background: white;
+            border-radius: 10px;
+            overflow: hidden;
+            box-shadow: 0 4px 15px rgba(0, 0, 0, 0.1);
+        }
+
+        .properties-table th,
+        .properties-table td {
+            padding: 12px;
+            text-align: left;
+            border-bottom: 1px solid #eee;
+        }
+
+        .properties-table th {
+            background: #34495e;
+            color: white;
+            font-weight: 600;
+        }
+
+        .properties-table tr:hover {
+            background: #f8f9fa;
+        }
+
+        .price-positive {
+            color: #27ae60;
+            font-weight: 600;
+        }
+
+        .price-negative {
+            color: #e74c3c;
+            font-weight: 600;
+        }
+
+        .analysis-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 15px;
+            margin-bottom: 20px;
+        }
+
+        .analysis-card {
+            background: #f8f9fa;
+            padding: 15px;
+            border-radius: 10px;
+            border-left: 4px solid #3498db;
+        }
+
+        .analysis-card h4 {
+            color: #2c3e50;
+            margin-bottom: 10px;
+        }
+
+        .analysis-card .value {
+            font-size: 1.5em;
+            font-weight: 600;
+            color: #3498db;
+        }
+
+        .insights-section {
+            background: #f8f9fa;
+            padding: 20px;
+            border-radius: 10px;
+            margin-bottom: 20px;
+        }
+
+        .insights-section h3 {
+            color: #2c3e50;
+            margin-bottom: 15px;
+        }
+
+        .insights-section p {
+            line-height: 1.6;
+            color: #34495e;
+            margin-bottom: 10px;
+        }
+
+        .loading {
+            text-align: center;
+            padding: 20px;
+            color: #7f8c8d;
+        }
+
+        .loading::after {
+            content: "...";
+            animation: dots 1.5s steps(5, end) infinite;
+        }
+
+        @keyframes dots {
+            0%, 20% { content: "."; }
+            40% { content: ".."; }
+            60% { content: "..."; }
+            80%, 100% { content: ""; }
+        }
+
+        .status-indicator {
+            display: inline-block;
+            padding: 4px 8px;
+            border-radius: 15px;
+            font-size: 12px;
+            font-weight: 600;
+            margin-left: 10px;
+        }
+
+        .status-connected {
+            background: #d4edda;
+            color: #155724;
+        }
+
+        .status-error {
+            background: #f8d7da;
+            color: #721c24;
+        }
+
+        .context-indicator {
+            background: #fff3cd;
+            color: #856404;
+            padding: 10px;
+            border-radius: 5px;
+            margin-bottom: 15px;
+            font-size: 14px;
+        }
+
+        @media (max-width: 768px) {
+            .main-content {
+                grid-template-columns: 1fr;
+            }
+
+            .filter-grid {
+                grid-template-columns: 1fr;
+            }
+
+            .analysis-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🏠 Pune Real Estate Assistant</h1>
+            <span id="statusIndicator" class="status-indicator status-connected">Connected</span>
+        </div>
+            <!-- Chat Section -->
+            <div class="chat-section">
+                <h2 class="section-title">💬 Smart Property Chat</h2>
+                <div id="contextIndicator" class="context-indicator" style="display: none;">
+                    Building on previous conversation...
+                </div>
+                <div id="chatContainer" class="chat-container">
+                    <div class="message bot-message">
+                        <strong>AI Assistant:</strong> Hello! I'm your intelligent real estate assistant. I can help you find properties, analyze market trends, and provide deep insights. Try asking me something like "Show me 2BHK properties in Baner under 60 lakhs" or "What's the price range for 3BHK in Kothrud?"
+                    </div>
+                </div>
+                <div class="input-group">
+                    <input type="text" id="messageInput" placeholder="Ask me about properties, prices, or market trends..." />
+                    <button class="btn btn-primary" onclick="sendMessage()">Send</button>
+                </div>
+                <div class="input-group">
+                    <button class="btn btn-secondary" onclick="resetSession()">Reset Session</button>
+                    <button class="btn btn-secondary" onclick="getInsights()">Get Insights</button>
+                </div>
+            </div>
+
+
+        <!-- Results Section -->
+        <div class="results-section">
+            <h2 class="section-title">📊 Search Results & Analysis</h2>
+
+            <div class="tabs">
+                <button class="tab active" onclick="showTab('properties')">Properties</button>
+                <button class="tab" onclick="showTab('analysis')">Market Analysis</button>
+                <button class="tab" onclick="showTab('insights')">AI Insights</button>
+                <button class="tab" onclick="showTab('nearby')">Nearby Properties</button>
+            </div>
+
+            <!-- Properties Tab -->
+            <div id="properties" class="tab-content active">
+                <div id="propertiesLoading" class="loading" style="display: none;">Loading properties</div>
+                <div id="propertiesTable"></div>
+            </div>
+
+            <!-- Analysis Tab -->
+            <div id="analysis" class="tab-content">
+                <div id="analysisLoading" class="loading" style="display: none;">Analyzing market data</div>
+                <div id="analysisContent"></div>
+            </div>
+
+            <!-- Insights Tab -->
+            <div id="insights" class="tab-content">
+                <div id="insightsLoading" class="loading" style="display: none;">Generating insights</div>
+                <div id="insightsContent"></div>
+            </div>
+
+            <!-- Nearby Properties Tab -->
+            <div id="nearby" class="tab-content">
+                <div id="nearbyLoading" class="loading" style="display: none;">Finding nearby properties</div>
+                <div id="nearbyContent"></div>
+            </div>
+        </div>
+    </div>
+    <!-- Filter Section -->
+            <div class="filter-section">
+                <h2 class="section-title">🔍 Advanced Filters</h2>
+                <div class="filter-grid">
+                    <div class="filter-group">
+                        <label>Location</label>
+                        <select id="locationFilter">
+                            <option value="">All Locations</option>
+                        </select>
+                    </div>
+                    <div class="filter-group">
+                        <label>BHK</label>
+                        <select id="bhkFilter">
+                            <option value="">Any BHK</option>
+                            <option value="1">1 BHK</option>
+                            <option value="2">2 BHK</option>
+                            <option value="3">3 BHK</option>
+                            <option value="4">4 BHK</option>
+                            <option value="5">5+ BHK</option>
+                        </select>
+                    </div>
+                    <div class="filter-group">
+                        <label>Min Price (Lakhs)</label>
+                        <input type="number" id="minPriceFilter" placeholder="e.g., 30">
+                    </div>
+                    <div class="filter-group">
+                        <label>Max Price (Lakhs)</label>
+                        <input type="number" id="maxPriceFilter" placeholder="e.g., 100">
+                    </div>
+                    <div class="filter-group">
+                        <label>Min Area (Sq Ft)</label>
+                        <input type="number" id="minAreaFilter" placeholder="e.g., 800">
+                    </div>
+                    <div class="filter-group">
+                        <label>Max Area (Sq Ft)</label>
+                        <input type="number" id="maxAreaFilter" placeholder="e.g., 2000">
+                    </div>
+                    <div class="filter-group">
+                        <label>Area Type</label>
+                        <select id="areaTypeFilter">
+                            <option value="">Any Type</option>
+                        </select>
+                    </div>
+                    <div class="filter-group">
+                        <label>Availability</label>
+                        <select id="availabilityFilter">
+                            <option value="">Any Status</option>
+                        </select>
+                    </div>
+                </div>
+                <button class="btn btn-primary" onclick="applyFilters()" style="width: 100%;">Apply Filters</button>
+            </div>
+
+    <script>
+        let currentFilters = {};
+        let conversationContext = 0;
+
+        // Initialize the application
+        document.addEventListener('DOMContentLoaded', function() {
+            loadMarketData();
+            setupEventListeners();
+        });
+
+        function setupEventListeners() {
+            document.getElementById('messageInput').addEventListener('keypress', function(e) {
+                if (e.key === 'Enter') {
+                    sendMessage();
+                }
+            });
+        }
+
+        async function loadMarketData() {
+            try {
+                const response = await fetch('/get_market_data');
+                const data = await response.json();
+
+                populateDropdowns(data);
+                updateStatusIndicator(true);
+            } catch (error) {
+                console.error('Error loading market data:', error);
+                updateStatusIndicator(false);
+            }
+        }
+
+        function populateDropdowns(data) {
+            const locationSelect = document.getElementById('locationFilter');
+            const areaTypeSelect = document.getElementById('areaTypeFilter');
+            const availabilitySelect = document.getElementById('availabilityFilter');
+
+            // Populate locations
+            data.locations.forEach(location => {
+                const option = document.createElement('option');
+                option.value = location;
+                option.textContent = location;
+                locationSelect.appendChild(option);
+            });
+
+            // Populate area types
+            data.area_types.forEach(type => {
+                const option = document.createElement('option');
+                option.value = type;
+                option.textContent = type;
+                areaTypeSelect.appendChild(option);
+            });
+
+            // Populate availability
+            data.availability_types.forEach(availability => {
+                const option = document.createElement('option');
+                option.value = availability;
+                option.textContent = availability;
+                availabilitySelect.appendChild(option);
+            });
+        }
+
+        function updateStatusIndicator(connected) {
+            const indicator = document.getElementById('statusIndicator');
+            if (connected) {
+                indicator.className = 'status-indicator status-connected';
+                indicator.textContent = 'Connected';
+            } else {
+                indicator.className = 'status-indicator status-error';
+                indicator.textContent = 'Error';
+            }
+        }
+
+        function showContextIndicator(show) {
+            const indicator = document.getElementById('contextIndicator');
+            indicator.style.display = show ? 'block' : 'none';
+        }
+
+        async function sendMessage() {
+            const messageInput = document.getElementById('messageInput');
+            const message = messageInput.value.trim();
+
+            if (!message) return;
+
+            addMessageToChat(message, 'user');
+            messageInput.value = '';
+
+            try {
+                const response = await fetch('/chat', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({ message })
+                });
+
+                const data = await response.json();
+
+                if (data.error) {
+                    addMessageToChat(`Error: ${data.error}`, 'bot');
+                } else {
+                    handleChatResponse(data);
+                }
+
+                conversationContext = data.conversation_context || 0;
+                showContextIndicator(conversationContext > 0);
+
+            } catch (error) {
+                addMessageToChat(`Error: ${error.message}`, 'bot');
+                updateStatusIndicator(false);
+            }
+        }
+
+        function handleChatResponse(data) {
+            const response = data.response;
+
+            if (response.error) {
+                addMessageToChat(`Error: ${response.error}`, 'bot');
+                return;
+            }
+
+            // Add insights to chat
+            if (response.insights) {
+                addMessageToChat(response.insights, 'bot');
+            }
+
+            // Update results
+            if (response.filtered_properties) {
+                displayProperties(response.filtered_properties);
+            }
+
+            if (response.analysis) {
+                displayAnalysis(response.analysis);
+            }
+
+            if (response.nearby_properties) {
+                displayNearbyProperties(response.nearby_properties);
+            }
+
+            // Show summary message
+            const summary = generateSummaryMessage(response);
+            addMessageToChat(summary, 'bot');
+        }
+
+        function generateSummaryMessage(response) {
+            const total = response.analysis?.total_properties || 0;
+            const priceRange = response.analysis?.price_range;
+
+            if (total === 0) {
+                return "No properties found matching your criteria. Try adjusting your search parameters.";
+            }
+
+            let summary = `Found ${total} properties`;
+            if (priceRange) {
+                summary += ` with prices ranging from ₹${priceRange.min.toFixed(2)}L to ₹${priceRange.max.toFixed(2)}L (avg: ₹${priceRange.avg.toFixed(2)}L)`;
+            }
+
+            return summary + ". Check the results tabs below for detailed analysis.";
+        }
+
+        function addMessageToChat(message, sender) {
+            const chatContainer = document.getElementById('chatContainer');
+            const messageDiv = document.createElement('div');
+            messageDiv.className = `message ${sender}-message`;
+
+            const senderLabel = sender === 'user' ? 'You' : 'AI Assistant';
+            messageDiv.innerHTML = `<strong>${senderLabel}:</strong> ${message}`;
+
+            chatContainer.appendChild(messageDiv);
+            chatContainer.scrollTop = chatContainer.scrollHeight;
+        }
+
+        async function applyFilters() {
+            const filters = {
+                location: document.getElementById('locationFilter').value,
+                bhk: document.getElementById('bhkFilter').value ? parseInt(document.getElementById('bhkFilter').value) : null,
+                min_price: document.getElementById('minPriceFilter').value ? parseFloat(document.getElementById('minPriceFilter').value) : null,
+                max_price: document.getElementById('maxPriceFilter').value ? parseFloat(document.getElementById('maxPriceFilter').value) : null,
+                min_area: document.getElementById('minAreaFilter').value ? parseFloat(document.getElementById('minAreaFilter').value) : null,
+                max_area: document.getElementById('maxAreaFilter').value ? parseFloat(document.getElementById('maxAreaFilter').value) : null,
+                area_type: document.getElementById('areaTypeFilter').value,
+                availability: document.getElementById('availabilityFilter').value
+            };
+
+            // Remove null values
+            Object.keys(filters).forEach(key => {
+                if (filters[key] === null || filters[key] === '') {
+                    delete filters[key];
+                }
+            });
+
+            currentFilters = filters;
+
+            try {
+                showLoading('properties');
+                showLoading('analysis');
+
+                const response = await fetch('/filter_properties', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify(filters)
+                });
+
+                const data = await response.json();
+
+                if (data.error) {
+                    hideLoading('properties');
+                    hideLoading('analysis');
+                    alert(`Error: ${data.error}`);
+                } else {
+                    displayProperties(data.properties);
+                    displayAnalysis(data.analysis);
+                    hideLoading('properties');
+                    hideLoading('analysis');
+                }
+
+            } catch (error) {
+                hideLoading('properties');
+                hideLoading('analysis');
+                alert(`Error: ${error.message}`);
+            }
+        }
+
+        function displayProperties(properties) {
+            const container = document.getElementById('propertiesTable');
+
+            if (!properties || properties.length === 0) {
+                container.innerHTML = '<p>No properties found matching your criteria.</p>';
+                return;
+            }
+
+            let html = `
+                <table class="properties-table">
+                    <thead>
+                        <tr>
+                            <th>Location</th>
+                            <th>BHK</th>
+                            <th>Area (Sq Ft)</th>
+                            <th>Price (₹L)</th>
+                            <th>Predicted (₹L)</th>
+                            <th>Price/Sq Ft</th>
+                            <th>Society</th>
+                            <th>Availability</th>
+                        </tr>
+                    </thead>
+                    <tbody>
+            `;
+
+            properties.forEach(property => {
+                const priceDiff = property.price_difference || 0;
+                const priceClass = priceDiff > 0 ? 'price-positive' : priceDiff < 0 ? 'price-negative' : '';
+
+                html += `
+                    <tr>
+                        <td>${property.site_location}</td>
+                        <td>${property.bhk}</td>
+                        <td>${property.total_sqft}</td>
+                        <td>₹${property.price.toFixed(2)}</td>
+                        <td class="${priceClass}">���${(property.predicted_price || property.price).toFixed(2)}</td>
+                        <td>₹${Math.round(property.price_per_sqft)}</td>
+                        <td>${property.society || 'N/A'}</td>
+                        <td>${property.availability}</td>
+                    </tr>
+                `;
+            });
+
+            html += '</tbody></table>';
+            container.innerHTML = html;
+        }
+
+        function displayAnalysis(analysis) {
+            const container = document.getElementById('analysisContent');
+
+            if (!analysis || analysis.total_properties === 0) {
+                container.innerHTML = '<p>No analysis available.</p>';
+                return;
+            }
+
+            const html = `
+                <div class="analysis-grid">
+                    <div class="analysis-card">
+                        <h4>Total Properties</h4>
+                        <div class="value">${analysis.total_properties}</div>
+                    </div>
+                    <div class="analysis-card">
+                        <h4>Price Range</h4>
+                        <div class="value">₹${analysis.price_range.min.toFixed(2)}L - ₹${analysis.price_range.max.toFixed(2)}L</div>
+                    </div>
+                    <div class="analysis-card">
+                        <h4>Average Price</h4>
+                        <div class="value">₹${analysis.price_range.avg.toFixed(2)}L</div>
+                    </div>
+                    <div class="analysis-card">
+                        <h4>Median Price</h4>
+                        <div class="value">₹${analysis.price_range.median.toFixed(2)}L</div>
+                    </div>
+                    <div class="analysis-card">
+                        <h4>Avg Area</h4>
+                        <div class="value">${Math.round(analysis.area_range.avg)} Sq Ft</div>
+                    </div>
+                    <div class="analysis-card">
+                        <h4>Avg Price/Sq Ft</h4>
+                        <div class="value">₹${Math.round(analysis.price_per_sqft.avg)}</div>
+                    </div>
+                </div>
+
+                <div class="insights-section">
+                    <h3>Location Distribution</h3>
+                    ${Object.entries(analysis.location_distribution).map(([location, count]) =>
+                        `<p><strong>${location}:</strong> ${count} properties</p>`
+                    ).join('')}
+                </div>
+
+                <div class="insights-section">
+                    <h3>Area Type Distribution</h3>
+                    ${Object.entries(analysis.area_type_distribution).map(([type, count]) =>
+                        `<p><strong>${type}:</strong> ${count} properties</p>`
+                    ).join('')}
+                </div>
+            `;
+
+            container.innerHTML = html;
+        }
+
+        function displayNearbyProperties(content) {
+            const container = document.getElementById('nearbyContent');
+            container.innerHTML = `
+                <div class="insights-section">
+                    <h3>Nearby Properties & Market Trends</h3>
+                    <div style="white-space: pre-wrap;">${content}</div>
+                </div>
+            `;
+        }
+
+        async function getInsights() {
+            try {
+                showLoading('insights');
+
+                const response = await fetch('/get_insights', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        location: currentFilters.location,
+                        requirements: currentFilters
+                    })
+                });
+
+                const data = await response.json();
+
+                if (data.error) {
+                    alert(`Error: ${data.error}`);
+                } else {
+                    displayInsights(data.insights);
+                    if (data.nearby_properties) {
+                        displayNearbyProperties(data.nearby_properties);
+                    }
+                }
+
+                hideLoading('insights');
+                showTab('insights');
+
+            } catch (error) {
+                hideLoading('insights');
+                alert(`Error: ${error.message}`);
+            }
+        }
+
+        function displayInsights(insights) {
+            const container = document.getElementById('insightsContent');
+            container.innerHTML = `
+                <div class="insights-section">
+                    <h3>AI-Powered Market Insights</h3>
+                    <div style="white-space: pre-wrap; line-height: 1.6;">${insights}</div>
+                </div>
+            `;
+        }
+
+        async function resetSession() {
+            try {
+                await fetch('/reset_session', { method: 'POST' });
+
+                // Clear chat
+                document.getElementById('chatContainer').innerHTML = `
+                    <div class="message bot-message">
+                        <strong>AI Assistant:</strong> Session reset! I'm ready to help you find properties again.
+                    </div>
+                `;
+
+                // Clear filters
+                document.getElementById('locationFilter').value = '';
+                document.getElementById('bhkFilter').value = '';
+                document.getElementById('minPriceFilter').value = '';
+                document.getElementById('maxPriceFilter').value = '';
+                document.getElementById('minAreaFilter').value = '';
+                document.getElementById('maxAreaFilter').value = '';
+                document.getElementById('areaTypeFilter').value = '';
+                document.getElementById('availabilityFilter').value = '';
+
+                // Clear results
+                document.getElementById('propertiesTable').innerHTML = '';
+                document.getElementById('analysisContent').innerHTML = '';
+                document.getElementById('insightsContent').innerHTML = '';
+                document.getElementById('nearbyContent').innerHTML = '';
+
+                currentFilters = {};
+                conversationContext = 0;
+                showContextIndicator(false);
+
+            } catch (error) {
+                alert(`Error: ${error.message}`);
+            }
+        }
+
+        function showTab(tabName) {
+            // Hide all tab contents
+            document.querySelectorAll('.tab-content').forEach(content => {
+                content.classList.remove('active');
+            });
+
+            // Remove active class from all tabs
+            document.querySelectorAll('.tab').forEach(tab => {
+                tab.classList.remove('active');
+            });
+
+            // Show selected tab content
+            document.getElementById(tabName).classList.add('active');
+
+            // Add active class to selected tab
+            event.target.classList.add('active');
+        }
+
+        function showLoading(tabName) {
+            const loadingElement = document.getElementById(tabName + 'Loading');
+            if (loadingElement) {
+                loadingElement.style.display = 'block';
+            }
+        }
+
+        function hideLoading(tabName) {
+            const loadingElement = document.getElementById(tabName + 'Loading');
+            if (loadingElement) {
+                loadingElement.style.display = 'none';
+            }
+        }
+
+    </script>
+</body>
+</html>