Upload 21 files

.gitattributes

@@ -33,3 +33,10 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+models/llm/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+models/saved_models/feature_matcher/zero_shot_model filter=lfs diff=lfs merge=lfs -text
+models/llm/conversations.json filter=lfs diff=lfs merge=lfs -text
+models/saved_models/feature_matcher/base_model/model.safetensors filter=lfs diff=lfs merge=lfs -text
+models/saved_models/model_state_dict.pth filter=lfs diff=lfs merge=lfs -text
+models/saved_models/property_index.faiss filter=lfs diff=lfs merge=lfs -text
+models/saved_models/search_system.pkl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,11 @@
+# Ignore Python cache files
+models/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+env/
+venv/
+.env
+*.log 

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.9
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    libsndfile1 \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p models/saved_models models/llm temp
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1
+ENV PORT=7860
+
+# Expose the port
+EXPOSE 7860
+
+# Run the application
+CMD ["python", "app.py"] 

app.py

@@ -0,0 +1,605 @@
+import os
+import logging
+from flask import Flask, request, jsonify, render_template
+from flask_cors import CORS
+from flask_limiter import Limiter
+from flask_limiter.util import get_remote_address
+import threading
+from functools import wraps
+import sys
+import time
+from geopy.distance import geodesic
+import torch
+
+# Add the modules directory to Python path
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+# Import modules
+from modules.config import *
+from modules.models import *
+from modules.security import *
+from modules.audio import *
+from modules.location_processor import LocationProcessor, set_location
+from modules.response import *
+from modules.input_tracker import *
+from modules.chatbot_processor import ChatbotProcessor
+
+# Import specific functions
+from modules.security import with_user_plan
+from modules.audio import process_audio_file
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(os.path.join(BASE_DIR, 'app.log')),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger(__name__)
+
+# Initialize Flask app with correct template folder path
+app = Flask(__name__, 
+    template_folder=os.path.join(BASE_DIR, 'templates'),
+    static_folder=os.path.join(BASE_DIR, 'static')
+)
+conversation_context = {}
+
+# Configure CORS
+CORS(app, resources={
+    r"/*": {
+        "origins": ["*"],  # Allow all origins for Hugging Face Spaces
+        "methods": ["GET", "POST", "OPTIONS"],
+        "allow_headers": ["Content-Type", "X-Session-ID"]
+    }
+})
+
+# Initialize rate limiter
+limiter = Limiter(
+    app=app,
+    key_func=get_remote_address,
+    default_limits=[f"{MAX_REQUESTS_PER_WINDOW} per minute", "1000 per hour"]
+)
+
+# Initialize components in the correct order
+print("Loading sentence transformer...")
+model_embedding = load_sentence_transformer()
+
+print("Fetching and caching properties...")
+properties = fetch_and_cache_properties()
+if not properties:
+    logger.error("Failed to fetch properties. Please check API connection.")
+    sys.exit(1)
+
+print("Loading FAISS index...")
+index = load_faiss_index()
+
+print("Loading PCA model...")
+pca = load_pca_model()
+
+print("Initializing retriever...")
+retriever = CustomRagRetriever(index, model_embedding, pca)
+
+print("Loading tokenizer and LLM model...")
+tokenizer, model_llm = load_tokenizer_and_model()
+
+print("Initializing security components...")
+security_manager = SecurityManager()
+query_validator = QueryValidator(model_embedding)
+
+print("Initializing input tracker...")
+input_tracker = UserInputTracker()
+
+# Initialize processors
+chatbot_processor = ChatbotProcessor()
+
+def security_check(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        try:
+            ip_address = request.remote_addr
+
+            if not security_manager.check_rate_limit(ip_address):
+                return jsonify({"error": "Rate limit exceeded"}), 429
+
+            if request.method == 'POST':
+                if not request.is_json:
+                    return jsonify({"error": "Content-Type must be application/json"}), 415
+
+            return f(*args, **kwargs)
+        except Exception as e:
+            logging.error(f"Security check failed: {str(e)}")
+            return jsonify({"error": "Security check failed"}), 400
+    return decorated_function
+
+@app.before_request
+def handle_preflight():
+    if request.method == 'OPTIONS':
+        response = app.make_default_options_response()
+        response.headers.add('Access-Control-Allow-Headers', 'Content-Type, X-Session-ID')
+        response.headers.add('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
+        return response
+
+@app.route('/')
+def index():
+    print("Rendering index page")
+    return render_template('index.html')
+
+@app.route('/search', methods=['POST'])
+@security_check
+@limiter.limit("30 per minute")
+@with_user_plan
+def search():
+    try:
+        data = request.json
+        query = data.get('query')
+
+        if not query:
+            return jsonify({"error": "Query parameter is missing"}), 400
+
+        cleaned_query = query_validator.clean_input(query)
+        if not query_validator.validate_query_length(cleaned_query):
+            return jsonify({"error": "Query too long"}), 400
+
+        session_id = data.get('session_id')
+        continue_conversation = data.get('continue', False)
+
+        if session_id not in conversation_context or not continue_conversation:
+            search_results = retriever.retrieve(cleaned_query)
+            formatted_results = []
+
+            for result in search_results:
+                property_info = result['property']
+
+                # Get property images from the property info
+                property_images = property_info.get('propertyImages', [])
+                if isinstance(property_images, str):
+                    if ',' in property_images:
+                        property_images = [img.strip() for img in property_images.split(',')]
+                    else:
+                        property_images = [property_images]
+                elif property_images is None:
+                    property_images = []
+
+                property_info = convert_numeric_fields_to_int(property_info)
+
+                formatted_result = {
+                    "PropertyName": property_info.get('PropertyName', 'N/A'),
+                    "Address": property_info.get('Address', 'N/A'),
+                    "ZipCode": property_info.get('ZipCode', 0),
+                    "LeasableSquareFeet": property_info.get('LeasableSquareFeet', 0),
+                    "YearBuilt": property_info.get('YearBuilt', 0),
+                    "NumberOfRooms": property_info.get('NumberOfRooms', 0),
+                    "ParkingSpaces": property_info.get('ParkingSpaces', 0),
+                    "PropertyManager": property_info.get('PropertyManager', 'N/A'),
+                    "MarketValue": float(property_info.get('MarketValue', 0)),
+                    "TaxAssessmentNumber": property_info.get('TaxAssessmentNumber', 'N/A'),
+                    "Latitude": float(property_info.get('Latitude', 0)),
+                    "Longitude": float(property_info.get('Longitude', 0)),
+                    "CreateDate": property_info.get('CreateDate', 'N/A'),
+                    "LastModifiedDate": property_info.get('LastModifiedDate', 'N/A'),
+                    "City": property_info.get('City', 'N/A'),
+                    "State": property_info.get('State', 'N/A'),
+                    "Country": property_info.get('Country', 'N/A'),
+                    "PropertyType": property_info.get('PropertyType', 'N/A'),
+                    "PropertyStatus": property_info.get('PropertyStatus', 'N/A'),
+                    "Description": property_info.get('Description', 'N/A'),
+                    "ViewNumber": property_info.get('ViewNumber', 0),
+                    "Contact": property_info.get('Contact', 0),
+                    "TotalSquareFeet": property_info.get('TotalSquareFeet', 0),
+                    "IsDeleted": bool(property_info.get('IsDeleted', False)),
+                    "Beds": property_info.get('Beds', 0),
+                    "Baths": property_info.get('Baths', 0),
+                    "AgentName": property_info.get('AgentName', 'N/A'),
+                    "AgentPhoneNumber": property_info.get('AgentPhoneNumber', 'N/A'),
+                    "AgentEmail": property_info.get('AgentEmail', 'N/A'),
+                    "KeyFeatures": property_info.get('KeyFeatures', 'N/A'),
+                    "NearbyAmenities": property_info.get('NearbyAmenities', 'N/A'),
+                    "propertyImages": property_images,
+                    "Distance": result['distance']
+                }
+                formatted_results.append(formatted_result)
+
+            conversation_context[session_id] = formatted_results
+        else:
+            formatted_results = conversation_context[session_id]
+
+        print(f"Returning {len(formatted_results)} search results")
+        if formatted_results:
+            print(f"Sample property images array: {formatted_results[0]['propertyImages']}")
+
+        return jsonify(formatted_results)
+
+    except Exception as e:
+        logging.error(f"Error in search endpoint: {str(e)}")
+        return jsonify({"error": "An error occurred processing your request"}), 500
+
+@app.route('/transcribe', methods=['POST'])
+@security_check
+def transcribe():
+    try:
+        if 'audio' not in request.files:
+            return jsonify({"error": "No audio file provided"}), 400
+
+        audio_file = request.files['audio']
+        
+        # Validate file size (max 10MB)
+        if audio_file.content_length and audio_file.content_length > 10 * 1024 * 1024:
+            return jsonify({"error": "Audio file too large. Maximum size is 10MB"}), 400
+
+        # Validate file type
+        allowed_extensions = {'wav', 'mp3', 'ogg', 'webm'}
+        if '.' not in audio_file.filename or \
+           audio_file.filename.rsplit('.', 1)[1].lower() not in allowed_extensions:
+            return jsonify({"error": "Invalid audio file format. Supported formats: WAV, MP3, OGG, WEBM"}), 400
+
+        result = process_audio_file(audio_file)
+        
+        if isinstance(result, tuple) and len(result) == 2:
+            response, status_code = result
+            return jsonify(response), status_code
+        
+        return jsonify(result)
+
+    except Exception as e:
+        logger.error(f"Error in transcribe endpoint: {str(e)}")
+        return jsonify({"error": "An error occurred processing your audio file"}), 500
+
+@app.route('/generate', methods=['POST'])
+@security_check
+@limiter.limit("30 per minute")
+@with_user_plan
+def generate():
+    data = request.json
+    query = data.get('query')
+    session_id = data.get('session_id')
+    continue_conversation = data.get('continue', False)
+    current_plan = get_current_plan()
+
+    if not query:
+        return jsonify({"error": "Query parameter is missing"}), 400
+    if session_id in conversation_context and continue_conversation:
+        previous_results = conversation_context[session_id]
+        combined_query = f"Based on previous results:{previous_results}New Query: {query}"
+        response, duration = generate_response(combined_query, tokenizer, model_llm)
+    else:
+        response, duration = generate_response(query, tokenizer, model_llm)
+        conversation_context[session_id] = response
+    print(f"Generated response: {response}")
+    print(f"Time taken to generate response: {duration:.2f} seconds\n")
+    return jsonify({"response": response, "duration": duration})
+
+@app.route('/set-location', methods=['POST'])
+@security_check
+def handle_set_location():
+    """Handle location setting and nearby property search"""
+    try:
+        # Get request data
+        data = request.get_json()
+        print(f"Received data: {data}")
+        
+        # Extract values
+        latitude = float(data.get('latitude', 0))
+        longitude = float(data.get('longitude', 0))
+        session_id = data.get('session_id', '')
+        
+        print(f"Extracted values - latitude: {latitude}, longitude: {longitude}, session_id: {session_id}")
+        
+        # Validate coordinates
+        if latitude == 0 or longitude == 0:
+            return jsonify({
+                "status": "error",
+                "message": "Invalid coordinates"
+            }), 400
+            
+        # Initialize location processor
+        location_processor = LocationProcessor()
+        
+        # Set location and find nearby properties
+        result = location_processor.set_location(latitude, longitude, session_id)
+        
+        return jsonify(result)
+        
+    except Exception as e:
+        logger.error(f"Error in set_location: {str(e)}")
+        return jsonify({
+            "status": "error",
+            "message": "Error processing location"
+        }), 500
+
+@app.route('/check-input-limit', methods=['GET'])
+@security_check
+def check_input_limit():
+    try:
+        session_id = request.args.get('session_id')
+        if not session_id:
+            return jsonify({"error": "session_id is required"}), 400
+
+        current_plan = get_current_plan()
+        remaining_inputs = input_tracker.get_remaining_inputs(session_id, current_plan)
+        usage_stats = input_tracker.get_usage_stats(session_id)
+
+        return jsonify({
+            "plan": current_plan.value,
+            "remaining_inputs": remaining_inputs,
+            "total_limit": PLAN_INPUT_LIMITS[current_plan],
+            "usage_stats": usage_stats
+        })
+
+    except Exception as e:
+        logging.error(f"Error checking input limit: {str(e)}")
+        return jsonify({"error": "Error checking input limit"}), 500
+
+@app.route('/recommend', methods=['POST'])
+@security_check
+@limiter.limit("30 per minute")
+@with_user_plan
+def recommend():
+    try:
+        data = request.json
+        query = data.get('query')
+        session_id = data.get('session_id')
+        continue_conversation = data.get('continue', False)
+        current_plan = get_current_plan()
+
+        if not query:
+            return jsonify({"error": "Query parameter is missing"}), 400
+
+        # Clean and validate input
+        cleaned_query = query_validator.clean_input(query)
+        if not query_validator.validate_query_length(cleaned_query):
+            return jsonify({"error": "Query too long"}), 400
+
+        # Check if query is related to real estate
+        if not query_validator.is_real_estate_query(cleaned_query):
+            return jsonify({
+                "response": "I'm a real estate chatbot. I can help you with property-related queries like finding apartments, PG accommodations, hostels, or commercial properties. Please ask me about properties!",
+                "is_real_estate": False
+            })
+
+        # Special handling for "hi" query
+        if cleaned_query.lower() == 'hi':
+            return jsonify({
+                "response": "Do you want to know the properties located near you? (yes/no):",
+                "is_location_query": True
+            })
+
+        # Special handling for "yes" after "hi"
+        if cleaned_query.lower() == 'yes':
+            # Get location from the request
+            latitude = data.get('latitude')
+            longitude = data.get('longitude')
+            
+            if not latitude or not longitude:
+                return jsonify({
+                    "error": "Location not available. Please allow location access or set your location first.",
+                    "needs_location": True
+                }), 400
+
+            # Initialize location processor
+            location_processor = LocationProcessor()
+            
+            # Get nearby properties
+            result = location_processor.set_location(latitude, longitude, session_id)
+            
+            if result["status"] == "success":
+                # Format the response for frontend
+                properties = result["properties"]
+                response_text = "Here are the properties near your location:\n\n"
+                
+                for i, prop in enumerate(properties, 1):
+                    response_text += (
+                        f"{i}. {prop.get('PropertyName', 'Unnamed Property')}\n"
+                        f"   Address: {prop.get('Address', 'No address available')}\n"
+                        f"   Distance: {prop.get('Distance', 0)} km\n"
+                        f"   Type: {prop.get('PropertyType', 'Not specified')}\n"
+                        f"   Price: ${prop.get('MarketValue', 0):,.2f}\n\n"
+                    )
+                
+                return jsonify({
+                    # "response": response_text,
+                    "properties": properties,
+                    "location": result["location"],
+                    "is_location_based": True,
+                    "status": "success"
+                })
+            else:
+                return jsonify({
+                    "error": "No properties found near your location",
+                    "status": "error"
+                }), 404
+
+        # Handle regular queries with RAG-based recommendation
+        if session_id in conversation_context and continue_conversation:
+            previous_results = conversation_context[session_id]
+            combined_query = f"Based on previous results:{previous_results}New Query: {cleaned_query}"
+            raw_results = retriever.retrieve(combined_query, top_k=5)
+        else:
+            raw_results = retriever.retrieve(cleaned_query, top_k=5)
+
+        # Filter results based on user plan
+        filtered_results = []
+        for result in raw_results:
+            property_dict = result['property'].to_dict() if hasattr(result['property'], 'to_dict') else result['property']
+            property_dict = convert_numeric_fields_to_int(property_dict)
+            filtered_property = filter_property_by_plan(property_dict, current_plan)
+            
+            if 'propertyImages' in filtered_property:
+                del filtered_property['propertyImages']
+            if 'property_image' in filtered_property:
+                del filtered_property['property_image']
+            if 'image_url' in filtered_property:
+                del filtered_property['image_url']
+
+            filtered_results.append({
+                'property': filtered_property,
+                'propertyImages': result.get('image_url', []) if current_plan == UserPlan.PRO else [],
+                'distance': result.get('distance')
+            })
+
+        # Generate response
+        response_text, has_restricted_request = format_llm_prompt(
+            query=combined_query if continue_conversation else cleaned_query,
+            filtered_results=filtered_results,
+            user_plan=current_plan,
+            original_query=cleaned_query
+        )
+
+        response, duration = generate_response(
+            response_text,
+            tokenizer=tokenizer,
+            model_llm=model_llm,
+            max_new_tokens=512,
+            temperature=0.7,
+            top_k=30,
+            top_p=0.8,
+            repetition_penalty=1.05
+        )
+
+        # Store the response in conversation context
+        conversation_context[session_id] = response
+
+        return jsonify({
+            "response": response,
+            "duration": duration,
+            "plan_level": current_plan.value,
+            "filtered_results": filtered_results,
+            "input_limit_info": {
+                "remaining_inputs": input_tracker.get_remaining_inputs(session_id, current_plan),
+                "total_limit": PLAN_INPUT_LIMITS[current_plan],
+                "usage_stats": input_tracker.get_usage_stats(session_id)
+            }
+        })
+
+    except Exception as e:
+        logging.error(f"Error in recommend endpoint: {str(e)}")
+        return jsonify({"error": "An error occurred processing your request"}), 500
+
+@app.route('/api/properties/search', methods=['POST'])
+def search_properties():
+    try:
+        data = request.get_json()
+        query = data.get('query', '')
+        user_location = data.get('user_location')  # (latitude, longitude)
+        
+        # Get properties from database or external source
+        properties = get_properties()  # Implement this function to get properties
+        
+        # Process query and get filtered properties
+        results = chatbot_processor.process_query(
+            query, properties, user_location
+        )
+        
+        return jsonify({
+            'status': 'success',
+            'results': results
+        })
+        
+    except Exception as e:
+        logging.error(f"Error searching properties: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
+@app.route('/api/properties/similar', methods=['POST'])
+def find_similar_properties():
+    try:
+        data = request.get_json()
+        reference_property = data.get('property')
+        top_k = data.get('top_k', 5)
+        
+        # Get properties from database or external source
+        properties = get_properties()  # Implement this function to get properties
+        
+        # Find similar properties
+        results = chatbot_processor.get_similar_properties(
+            reference_property, properties, top_k
+        )
+        
+        return jsonify({
+            'status': 'success',
+            'results': results
+        })
+        
+    except Exception as e:
+        logging.error(f"Error finding similar properties: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
+@app.route('/api/properties/landmarks', methods=['POST'])
+def get_property_landmarks():
+    try:
+        data = request.get_json()
+        property_data = data.get('property')
+        radius_miles = data.get('radius_miles', 5.0)
+        
+        # Get nearby landmarks
+        landmarks = chatbot_processor.get_nearby_landmarks(
+            property_data, radius_miles
+        )
+        
+        return jsonify({
+            'status': 'success',
+            'landmarks': landmarks
+        })
+        
+    except Exception as e:
+        logging.error(f"Error getting property landmarks: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
+@app.route('/api/properties/location', methods=['POST'])
+def get_property_location():
+    try:
+        data = request.get_json()
+        property_data = data.get('property')
+        
+        # Get location details
+        location_details = chatbot_processor.get_location_details(property_data)
+        
+        return jsonify({
+            'status': 'success',
+            'location': location_details
+        })
+        
+    except Exception as e:
+        logging.error(f"Error getting property location: {str(e)}")
+        return jsonify({
+            'status': 'error',
+            'message': str(e)
+        }), 500
+
+@app.errorhandler(429)
+def ratelimit_handler(e):
+    return jsonify({"error": "Rate limit exceeded"}), 429
+
+@app.errorhandler(400)
+def bad_request_handler(e):
+    return jsonify({"error": "Bad request"}), 400
+
+@app.errorhandler(500)
+def internal_error_handler(e):
+    return jsonify({"error": "Internal server error"}), 500
+
+# Add helper functions
+def convert_numeric_fields_to_int(property_dict):
+    """Convert numeric fields to integers in property dictionary"""
+    numeric_fields = ['Bedrooms', 'Bathrooms', 'SquareFeet', 'YearBuilt', 'Price']
+    for field in numeric_fields:
+        if field in property_dict and property_dict[field] is not None:
+            try:
+                property_dict[field] = int(float(property_dict[field]))
+            except (ValueError, TypeError):
+                property_dict[field] = None
+    return property_dict
+
+if __name__ == '__main__':
+    # Get port from environment variable or default to 7860 for Hugging Face Spaces
+    port = int(os.environ.get('PORT', 7860))
+    app.run(host='0.0.0.0', port=port) 

modules/__init__.py

@@ -0,0 +1 @@
+# This file makes the modules directory a Python package 

modules/audio.py

@@ -0,0 +1,165 @@
+import os
+import webrtcvad
+import collections
+import speech_recognition as sr
+from pydub import AudioSegment
+from happytransformer import HappyTextToText, TTSettings
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class VADAudio:
+    def __init__(self, aggressiveness=3):
+        self.vad = webrtcvad.Vad(aggressiveness)
+        self.sample_rate = 16000
+        self.frame_duration_ms = 30
+
+    def frame_generator(self, audio, frame_duration_ms, sample_rate):
+        n = int(sample_rate * (frame_duration_ms / 1000.0))
+        offset = 0
+        while offset + n < len(audio):
+            yield audio[offset:offset + n]
+            offset += n
+
+    def vad_collector(self, audio, sample_rate, frame_duration_ms, padding_duration_ms=300, aggressiveness=3):
+        vad = webrtcvad.Vad(aggressiveness)
+        num_padding_frames = int(padding_duration_ms / frame_duration_ms)
+        ring_buffer = collections.deque(maxlen=num_padding_frames)
+        triggered = False
+
+        for frame in self.frame_generator(audio, frame_duration_ms, sample_rate):
+            is_speech = vad.is_speech(frame, sample_rate)
+            if not triggered:
+                ring_buffer.append((frame, is_speech))
+                num_voiced = len([f for f, speech in ring_buffer if speech])
+                if num_voiced > 0.9 * ring_buffer.maxlen:
+                    triggered = True
+                    for f, s in ring_buffer:
+                        yield f
+                    ring_buffer.clear()
+            else:
+                yield frame
+                ring_buffer.append((frame, is_speech))
+                num_unvoiced = len([f for f, speech in ring_buffer if not speech])
+                if num_unvoiced > 0.9 * ring_buffer.maxlen:
+                    triggered = False
+                    yield b''.join([f for f in ring_buffer])
+                    ring_buffer.clear()
+
+def transcribe_with_vad(audio_file):
+    try:
+        vad_audio = VADAudio()
+        audio = AudioSegment.from_file(audio_file)
+        audio = audio.set_frame_rate(vad_audio.sample_rate).set_channels(1)
+        raw_audio = audio.raw_data
+
+        frames = vad_audio.vad_collector(raw_audio, vad_audio.sample_rate, vad_audio.frame_duration_ms)
+        for frame in frames:
+            if len(frame) > 0:
+                recognizer = sr.Recognizer()
+                recognizer.energy_threshold = 300
+                recognizer.dynamic_energy_threshold = True
+                recognizer.pause_threshold = 0.8
+                
+                audio_data = sr.AudioData(frame, vad_audio.sample_rate, audio.sample_width)
+                try:
+                    text = recognizer.recognize_google(audio_data, language="en-US")
+                    if text.strip():
+                        print(f"Transcription: {text}")
+                        return text
+                except sr.UnknownValueError:
+                    logger.warning("Google Speech Recognition could not understand the audio")
+                except sr.RequestError as e:
+                    logger.error(f"Could not request results from Google Speech Recognition service; {e}")
+        return ""
+    except Exception as e:
+        logger.error(f"Error in transcribe_with_vad: {str(e)}")
+        return ""
+
+def process_audio_file(audio_file):
+    if 'audio' not in audio_file:
+        return {"error": "No audio file provided"}, 400
+
+    # Ensure the file has an allowed extension
+    allowed_extensions = {'wav', 'mp3', 'ogg', 'webm'}
+    if '.' not in audio_file.filename or \
+       audio_file.filename.rsplit('.', 1)[1].lower() not in allowed_extensions:
+        return {"error": "Invalid audio file format"}, 400
+
+    temp_path = None
+    wav_path = None
+    try:
+        # Save the uploaded file temporarily
+        temp_dir = os.path.join(os.getcwd(), 'temp')
+        os.makedirs(temp_dir, exist_ok=True)
+        temp_path = os.path.join(temp_dir, 'temp_audio.' + audio_file.filename.rsplit('.', 1)[1].lower())
+
+        audio_file.save(temp_path)
+
+        # Convert audio to proper format if needed
+        audio = AudioSegment.from_file(temp_path)
+        audio = audio.set_channels(1)  # Convert to mono
+        audio = audio.set_frame_rate(16000)  # Set sample rate to 16kHz
+        audio = audio.normalize()  # Normalize audio levels
+
+        # Save as WAV for speech recognition
+        wav_path = os.path.join(temp_dir, 'temp_audio.wav')
+        audio.export(wav_path, format="wav", parameters=["-ar", "16000", "-ac", "1"])
+
+        # Try VAD-based transcription first
+        text = transcribe_with_vad(wav_path)
+        
+        # If VAD fails, try direct recognition
+        if not text:
+            recognizer = sr.Recognizer()
+            recognizer.energy_threshold = 300
+            recognizer.dynamic_energy_threshold = True
+            recognizer.pause_threshold = 0.8
+
+            with sr.AudioFile(wav_path) as source:
+                recognizer.adjust_for_ambient_noise(source, duration=0.5)
+                audio_data = recognizer.record(source)
+                text = recognizer.recognize_google(audio_data, language="en-US")
+
+        if not text.strip():
+            return {"error": "No speech detected. Please try speaking again."}, 400
+
+        # Grammar correction
+        try:
+            happy_tt = HappyTextToText("T5", "vennify/t5-base-grammar-correction")
+            settings = TTSettings(do_sample=True, top_k=50, temperature=0.7)
+            corrected_text = happy_tt.generate_text(f"grammar: {text}", args=settings)
+            corrected_text = corrected_text.text
+        except Exception as e:
+            logger.error(f"Grammar correction failed: {str(e)}")
+            corrected_text = text  # Fall back to original text
+
+        print(f"Original Transcription: {text}")
+        print(f"Corrected Transcription: {corrected_text}")
+
+        return {
+            "transcription": corrected_text,
+            "original": text
+        }
+
+    except sr.UnknownValueError:
+        return {"error": "Could not understand audio. Please speak more clearly."}, 400
+    except sr.RequestError as e:
+        return {"error": f"Speech recognition service error: {str(e)}"}, 500
+    except Exception as e:
+        logger.error(f"Error processing audio: {str(e)}")
+        return {"error": f"Audio processing error: {str(e)}"}, 500
+    finally:
+        # Ensure temp files are cleaned up even if an error occurs
+        if temp_path and os.path.exists(temp_path):
+            try:
+                os.remove(temp_path)
+            except Exception as e:
+                logger.error(f"Error removing temp file: {str(e)}")
+        if wav_path and os.path.exists(wav_path):
+            try:
+                os.remove(wav_path)
+            except Exception as e:
+                logger.error(f"Error removing wav file: {str(e)}") 

modules/chatbot_processor.py

@@ -0,0 +1,247 @@
+from typing import Dict, List, Optional, Union, Tuple
+import logging
+from .nlp_processor import NLPProcessor
+from .location_processor import LocationProcessor
+from .property_processor import PropertyProcessor
+from .models import fetch_and_cache_properties, CustomRagRetriever
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ChatbotProcessor:
+    def __init__(self):
+        self.nlp_processor = NLPProcessor()
+        self.location_processor = LocationProcessor()
+        self.property_processor = PropertyProcessor()
+        logger.info("Initialized ChatbotProcessor")
+        
+    def process_query(self, 
+                     query: str, 
+                     user_location: Optional[Tuple[float, float]] = None,
+                     retriever: Optional[CustomRagRetriever] = None) -> List[Dict]:
+        """Process user query and return filtered properties"""
+        try:
+            logger.info(f"Processing query: {query}")
+            
+            # Extract numerical values and criteria from query
+            criteria = self.nlp_processor.process_query(query)
+            logger.info(f"Extracted criteria: {criteria}")
+            
+            # Get properties from cache
+            properties = fetch_and_cache_properties()
+            if not properties:
+                logger.error("No properties available in cache")
+                return []
+            
+            # Process properties
+            processed_properties = [
+                self.property_processor.process_property_data(p)
+                for p in properties
+            ]
+            logger.info(f"Processed {len(processed_properties)} properties")
+            
+            # Apply filters based on extracted criteria
+            filtered_properties = processed_properties
+            
+            # Filter by BHK if specified
+            if criteria.get('bhk'):
+                filtered_properties = self.property_processor.filter_by_bhk(
+                    filtered_properties, criteria['bhk']
+                )
+                logger.info(f"Filtered by BHK: {criteria['bhk']}, remaining: {len(filtered_properties)}")
+                
+            # Filter by bathrooms if specified
+            if criteria.get('bathrooms'):
+                filtered_properties = self.property_processor.filter_by_bathrooms(
+                    filtered_properties, criteria['bathrooms']
+                )
+                logger.info(f"Filtered by bathrooms: {criteria['bathrooms']}, remaining: {len(filtered_properties)}")
+                
+            # Filter by square footage if specified
+            if criteria.get('square_footage'):
+                min_sqft, max_sqft = criteria['square_footage']
+                filtered_properties = self.property_processor.filter_by_square_footage(
+                    filtered_properties, min_sqft, max_sqft
+                )
+                logger.info(f"Filtered by square footage: {min_sqft}-{max_sqft}, remaining: {len(filtered_properties)}")
+                
+            # Filter by market value if specified
+            if criteria.get('market_value'):
+                min_value, max_value = criteria['market_value']
+                filtered_properties = self.property_processor.filter_by_market_value(
+                    filtered_properties, min_value, max_value
+                )
+                logger.info(f"Filtered by market value: {min_value}-{max_value}, remaining: {len(filtered_properties)}")
+                
+            # Filter by year built if specified
+            if criteria.get('year_built'):
+                min_year, max_year = criteria['year_built']
+                filtered_properties = self.property_processor.filter_by_year_built(
+                    filtered_properties, min_year, max_year
+                )
+                logger.info(f"Filtered by year built: {min_year}-{max_year}, remaining: {len(filtered_properties)}")
+                
+            # Filter by status if specified
+            if criteria.get('status'):
+                filtered_properties = self.property_processor.filter_by_status(
+                    filtered_properties, criteria['status']
+                )
+                logger.info(f"Filtered by status: {criteria['status']}, remaining: {len(filtered_properties)}")
+                
+            # Handle location-based filtering
+            if user_location:
+                # Calculate distances from user location
+                filtered_properties = self.location_processor.calculate_distances(
+                    user_location, filtered_properties
+                )
+                logger.info(f"Calculated distances for {len(filtered_properties)} properties")
+                
+                # Filter by distance if specified
+                if criteria.get('max_distance'):
+                    filtered_properties = self.location_processor.filter_by_location_criteria(
+                        filtered_properties,
+                        {'max_distance': criteria['max_distance']}
+                    )
+                    logger.info(f"Filtered by max distance: {criteria['max_distance']}, remaining: {len(filtered_properties)}")
+                    
+            # Handle landmark-based filtering
+            if criteria.get('landmarks'):
+                landmark_criteria = {
+                    'nearby_landmarks': criteria['landmarks']
+                }
+                filtered_properties = self.location_processor.filter_by_location_criteria(
+                    filtered_properties, landmark_criteria
+                )
+                logger.info(f"Filtered by landmarks: {criteria['landmarks']}, remaining: {len(filtered_properties)}")
+                
+            # Use RAG retriever if available
+            if retriever:
+                logger.info("Using RAG retriever for semantic search")
+                rag_results = retriever.retrieve(query, top_k=5)
+                if rag_results:
+                    # Merge RAG results with filtered properties
+                    rag_properties = [r['property'] for r in rag_results]
+                    filtered_properties = [p for p in filtered_properties if p in rag_properties]
+                    logger.info(f"After RAG filtering, remaining: {len(filtered_properties)}")
+                
+            # Format property details for display
+            formatted_properties = []
+            for property_data in filtered_properties:
+                formatted_property = {
+                    'details': self.property_processor.format_property_details(property_data),
+                    'data': property_data
+                }
+                formatted_properties.append(formatted_property)
+                
+            logger.info(f"Returning {len(formatted_properties)} formatted properties")
+            return formatted_properties
+            
+        except Exception as e:
+            logger.error(f"Error processing query: {str(e)}")
+            return []
+            
+    def get_similar_properties(self,
+                             reference_property: Dict,
+                             properties: List[Dict],
+                             top_k: int = 5) -> List[Dict]:
+        """Find properties similar to reference property"""
+        try:
+            logger.info(f"Finding similar properties to: {reference_property.get('PropertyName', 'Unknown')}")
+            
+            # Process properties
+            processed_properties = [
+                self.property_processor.process_property_data(p)
+                for p in properties
+            ]
+            
+            # Find similar properties
+            similar_properties = self.property_processor.find_similar_properties(
+                reference_property, processed_properties, top_k
+            )
+            
+            # Format results
+            formatted_results = []
+            for property_data, similarity in similar_properties:
+                formatted_property = {
+                    'details': self.property_processor.format_property_details(property_data),
+                    'data': property_data,
+                    'similarity': similarity
+                }
+                formatted_results.append(formatted_property)
+                
+            logger.info(f"Found {len(formatted_results)} similar properties")
+            return formatted_results
+            
+        except Exception as e:
+            logger.error(f"Error finding similar properties: {str(e)}")
+            return []
+            
+    def get_nearby_landmarks(self,
+                           property_data: Dict,
+                           radius_miles: float = 5.0) -> List[Dict]:
+        """Get landmarks near a property"""
+        try:
+            logger.info(f"Finding landmarks near property: {property_data.get('PropertyName', 'Unknown')}")
+            
+            # Get property coordinates
+            latitude = float(property_data.get('Latitude', 0))
+            longitude = float(property_data.get('Longitude', 0))
+            
+            if latitude and longitude:
+                landmarks = self.location_processor.find_nearby_landmarks(
+                    latitude, longitude, radius_miles
+                )
+                logger.info(f"Found {len(landmarks)} nearby landmarks")
+                return landmarks
+            return []
+            
+        except Exception as e:
+            logger.error(f"Error finding nearby landmarks: {str(e)}")
+            return []
+            
+    def get_location_details(self, property_data: Dict) -> Dict:
+        """Get detailed location information for a property"""
+        try:
+            logger.info(f"Getting location details for property: {property_data.get('PropertyName', 'Unknown')}")
+            
+            # Get property coordinates
+            latitude = float(property_data.get('Latitude', 0))
+            longitude = float(property_data.get('Longitude', 0))
+            
+            if latitude and longitude:
+                details = self.location_processor.get_location_details(
+                    latitude, longitude
+                )
+                logger.info(f"Location details: {details}")
+                return details
+            return {}
+            
+        except Exception as e:
+            logger.error(f"Error getting location details: {str(e)}")
+            return {}
+
+    def find_similar_properties(self, query, top_k=5):
+        """Find similar properties using the retriever"""
+        try:
+            # Get properties from retriever
+            results = self.retriever.retrieve(query, top_k=top_k)
+            
+            # Ensure we have exactly 5 properties
+            while len(results) < 5:
+                # Add remaining properties with high distance scores
+                remaining_idx = len(results)
+                properties = fetch_and_cache_properties()
+                if remaining_idx < len(properties):
+                    property_data = properties[remaining_idx]
+                    formatted_property = format_property_details(property_data)
+                    if formatted_property:
+                        results.append({
+                            "property": formatted_property,
+                            "distance": 1.0  # High distance score for additional properties
+                        })
+            
+            return results[:5]  # Return exactly 5 properties
+        except Exception as e:
+            logger.error(f"Error finding similar properties: {str(e)}")
+            return [] 

modules/config.py

@@ -0,0 +1,87 @@
+import os
+from dotenv import load_dotenv
+from enum import Enum
+
+# Load environment variables
+load_dotenv()
+
+# User Plan Enum
+class UserPlan(Enum):
+    BASIC = "basic"
+    PLUS = "plus"
+    PRO = "pro"
+
+# API Keys and Credentials
+API_KEY = os.getenv("GOOGLE_API_KEY")
+CSE_ID = os.getenv("GOOGLE_CSE_ID")
+CLOUDINARY_CLOUD_NAME = os.getenv("CLOUDINARY_CLOUD_NAME")
+CLOUDINARY_API_KEY = os.getenv("CLOUDINARY_API_KEY")
+CLOUDINARY_API_SECRET = os.getenv("CLOUDINARY_API_SECRET")
+NGROK_AUTH_TOKEN = os.getenv("NGROK_AUTH_TOKEN")
+SECRET_KEY = os.getenv('SECRET_KEY', 'your-secret-key-here')
+
+# Base directory for the project
+BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+
+# Model Paths - Updated for local deployment
+MODEL_DIR = os.getenv("MODEL_DIR", os.path.join(BASE_DIR, "models", "saved_models"))
+LLM_MODEL_DIR = os.getenv("LLM_MODEL_DIR", os.path.join(BASE_DIR, "models", "llm"))
+FEATURE_MATCHER_DIR = os.path.join(MODEL_DIR, "feature_matcher")
+BASE_MODEL_DIR = os.path.join(FEATURE_MATCHER_DIR, "base_model")
+SEMANTIC_MODEL_DIR = os.path.join(FEATURE_MATCHER_DIR, "semantic_model")
+
+# Create necessary directories
+os.makedirs(MODEL_DIR, exist_ok=True)
+os.makedirs(LLM_MODEL_DIR, exist_ok=True)
+os.makedirs(FEATURE_MATCHER_DIR, exist_ok=True)
+os.makedirs(BASE_MODEL_DIR, exist_ok=True)
+os.makedirs(SEMANTIC_MODEL_DIR, exist_ok=True)
+os.makedirs(os.path.join(BASE_DIR, "temp"), exist_ok=True)
+
+# Rate Limiting
+RATE_LIMIT_WINDOW = int(os.getenv("RATE_LIMIT_WINDOW", 60))
+MAX_REQUESTS_PER_WINDOW = int(os.getenv("MAX_REQUESTS_PER_WINDOW", 30))
+MAX_QUERY_LENGTH = int(os.getenv("MAX_QUERY_LENGTH", 1000))
+
+# Cache Settings
+CACHE_TTL = int(os.getenv("CACHE_TTL", 3600))
+
+# Domain Classifier
+DOMAIN_CLASSIFIER_MODEL = os.getenv("DOMAIN_CLASSIFIER_MODEL", "distilbert-base-uncased")
+
+# Plan input limits
+PLAN_INPUT_LIMITS = {
+    UserPlan.BASIC: int(os.getenv("BASIC_PLAN_LIMIT", 5)),
+    UserPlan.PLUS: int(os.getenv("PLUS_PLAN_LIMIT", 10)),
+    UserPlan.PRO: int(os.getenv("PRO_PLAN_LIMIT", 20))
+}
+
+# Plan-specific fields
+PLAN_FIELDS = {
+    UserPlan.BASIC: {
+        "PropertyName", "Address", "City", "State", "ZipCode",
+        "LeasableSquareFeet", "NumberOfRooms", "Beds", "Baths",
+        "PropertyStatus", "Description"
+    },
+    UserPlan.PLUS: {
+        # Basic fields plus additional ones
+        "PropertyName", "Address", "City", "State", "ZipCode",
+        "LeasableSquareFeet", "NumberOfRooms", "Beds", "Baths",
+        "PropertyStatus", "Description", "YearBuilt", "MarketValue",
+        "PropertyType", "ParkingSpaces", "PropertyManager",
+        "TaxAssessmentNumber", "Latitude", "Longitude", "CreateDate",
+        "LastModifiedDate", "ViewNumber", "Contact", "TotalSquareFeet"
+    },
+    UserPlan.PRO: {
+        # All fields
+        "PropertyName", "Address", "City", "State", "ZipCode",
+        "LeasableSquareFeet", "NumberOfRooms", "Beds", "Baths",
+        "PropertyStatus", "Description", "YearBuilt", "MarketValue",
+        "PropertyType", "ParkingSpaces", "PropertyManager",
+        "TaxAssessmentNumber", "Latitude", "Longitude", "CreateDate",
+        "LastModifiedDate", "ViewNumber", "Contact", "TotalSquareFeet",
+        "AgentName", "AgentPhoneNumber", "AgentEmail", "KeyFeatures",
+        "NearbyAmenities", "property_image",
+        "Distance", "IsDeleted"
+    }
+} 

modules/input_tracker.py

@@ -0,0 +1,133 @@
+import time
+from collections import defaultdict
+import logging
+import json
+import os
+from datetime import datetime
+from modules.config import PLAN_INPUT_LIMITS, UserPlan
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class UserInputTracker:
+    def __init__(self):
+        self.input_counts = defaultdict(lambda: {'count': 0, 'last_reset': time.time()})
+        self.session_data_file = 'session_data.json'
+        self.load_session_data()
+
+    def load_session_data(self):
+        """Load session data from file if it exists"""
+        try:
+            if os.path.exists(self.session_data_file):
+                with open(self.session_data_file, 'r') as f:
+                    data = json.load(f)
+                    for session_id, session_info in data.items():
+                        self.input_counts[session_id] = session_info
+                print(f"Loaded {len(data)} sessions from file")
+        except Exception as e:
+            logger.error(f"Error loading session data: {str(e)}")
+
+    def save_session_data(self):
+        """Save session data to file"""
+        try:
+            with open(self.session_data_file, 'w') as f:
+                json.dump(dict(self.input_counts), f)
+            print("Session data saved successfully")
+        except Exception as e:
+            logger.error(f"Error saving session data: {str(e)}")
+
+    def can_accept_input(self, session_id, plan):
+        """Check if the user can make another query based on their plan"""
+        self._check_reset(session_id)
+        max_inputs = self._get_max_inputs(plan)
+        current_count = self.input_counts[session_id]['count']
+        
+        print(f"Session {session_id} - Plan: {plan}, Current count: {current_count}, Max inputs: {max_inputs}")
+        return current_count < max_inputs
+
+    def add_input(self, session_id, plan):
+        """Add an input to the user's count"""
+        self._check_reset(session_id)
+        if self.can_accept_input(session_id, plan):
+            self.input_counts[session_id]['count'] += 1
+            self.save_session_data()
+            print(f"Added input for session {session_id}. New count: {self.input_counts[session_id]['count']}")
+            return True
+        return False
+
+    def get_remaining_inputs(self, session_id, plan):
+        """Get the number of remaining inputs for the user"""
+        self._check_reset(session_id)
+        max_inputs = self._get_max_inputs(plan)
+        current_count = self.input_counts[session_id]['count']
+        remaining = max(0, max_inputs - current_count)
+        print(f"Session {session_id} - Remaining inputs: {remaining}")
+        return remaining
+
+    def get_usage_stats(self, session_id):
+        """Get usage statistics for a session"""
+        try:
+            user_data = self.input_counts[session_id]
+            current_time = time.time()
+            remaining_time = 24 - ((current_time - user_data['last_reset']) / 3600)
+            
+            return {
+                'total_used': user_data['count'],
+                'last_reset': datetime.fromtimestamp(user_data['last_reset']).isoformat(),
+                'remaining_time': remaining_time
+            }
+        except Exception as e:
+            logger.error(f"Error in get_usage_stats: {str(e)}")
+            return {
+                'total_used': 0,
+                'last_reset': datetime.fromtimestamp(time.time()).isoformat(),
+                'remaining_time': 24
+            }
+
+    def _check_reset(self, session_id):
+        """Check if the 24-hour period has passed and reset if necessary"""
+        current_time = time.time()
+        last_reset = self.input_counts[session_id]['last_reset']
+        
+        if current_time - last_reset >= 24 * 3600:  # 24 hours in seconds
+            self.input_counts[session_id] = {'count': 0, 'last_reset': current_time}
+            self.save_session_data()
+            print(f"Reset count for session {session_id}")
+
+    def _get_max_inputs(self, plan):
+        """Get the maximum number of inputs allowed for a plan"""
+        try:
+            # If plan is a UserPlan enum, get its value
+            if isinstance(plan, UserPlan):
+                plan = plan.value
+            
+            # Convert plan to lowercase string for comparison
+            plan = str(plan).lower()
+            
+            plan_limits = {
+                'basic': 5,
+                'plus': 20,
+                'pro': 50
+            }
+            return plan_limits.get(plan, 5)  # Default to basic plan if unknown
+        except Exception as e:
+            logger.error(f"Error getting max inputs for plan {plan}: {str(e)}")
+            return 5  # Default to basic plan on error
+
+    def get_usage_stats(self, session_id):
+        """Get usage statistics for a session"""
+        try:
+            user_data = self.input_counts[session_id]
+            return {
+                'total_used': user_data['count'],
+                'last_reset': user_data['last_reset'],
+                'recent_queries': [i['query'] for i in user_data['inputs'][-5:]]  # Last 5 queries
+            }
+        except Exception as e:
+            logging.error(f"Error in get_usage_stats: {str(e)}")
+            return {
+                'total_used': 0,
+                'last_reset': time.time(),
+                'recent_queries': []
+            } 

modules/location.py

@@ -0,0 +1,76 @@
+import geocoder
+from geopy.distance import geodesic
+from geopy.geocoders import Nominatim
+import logging
+
+def get_nearby_properties(latitude, longitude, df, top_k=5):
+    """Get properties near a given location"""
+    try:
+        my_location = (latitude, longitude)
+
+        # Filter out rows with invalid coordinates
+        valid_properties = df[
+            df['Latitude'].notna() &
+            df['Longitude'].notna() &
+            df['Latitude'].apply(lambda x: isinstance(x, (int, float)) or (isinstance(x, str) and x.replace('.', '').isdigit())) &
+            df['Longitude'].apply(lambda x: isinstance(x, (int, float)) or (isinstance(x, str) and x.replace('.', '').isdigit()))
+        ].copy()
+
+        # Convert coordinates to float
+        valid_properties['Latitude'] = valid_properties['Latitude'].astype(float)
+        valid_properties['Longitude'] = valid_properties['Longitude'].astype(float)
+
+        # Calculate distances
+        valid_properties['Distance'] = valid_properties.apply(
+            lambda row: geodesic(my_location, (row['Latitude'], row['Longitude'])).miles,
+            axis=1
+        )
+
+        # Get nearest properties
+        nearest_properties = valid_properties.nsmallest(top_k, 'Distance')
+        return nearest_properties
+
+    except Exception as e:
+        logging.error(f"Error getting nearby properties: {str(e)}")
+        return None
+
+def get_location_details(latitude, longitude):
+    """Get location details from coordinates"""
+    try:
+        geolocator = Nominatim(user_agent="hive_prop")
+        location = geolocator.reverse(f"{latitude}, {longitude}", language='en')
+
+        if location and location.raw.get('address'):
+            address = location.raw['address']
+            city = address.get('city') or address.get('town') or address.get('suburb') or address.get('county')
+            state = address.get('state')
+            country = address.get('country')
+
+            return {
+                'city': city,
+                'state': state,
+                'country': country
+            }
+        else:
+            return None
+
+    except Exception as e:
+        logging.error(f"Error getting location details: {str(e)}")
+        return None
+
+def set_location(latitude, longitude, session_id, conversation_context):
+    """Set location for a session"""
+    try:
+        location_details = get_location_details(latitude, longitude)
+        if location_details:
+            conversation_context[session_id] = {
+                'location': (latitude, longitude),
+                'city': location_details['city'],
+                'state': location_details['state'],
+                'country': location_details['country']
+            }
+            return True, location_details
+        return False, None
+    except Exception as e:
+        logging.error(f"Error setting location: {str(e)}")
+        return False, None 

modules/location_processor.py

@@ -0,0 +1,346 @@
+import numpy as np
+from geopy.distance import geodesic
+from geopy.geocoders import Nominatim
+from typing import Dict, List, Tuple, Optional
+import logging
+from sentence_transformers import SentenceTransformer
+import torch
+import math
+from modules.models import get_cached_properties
+
+class LocationProcessor:
+    def __init__(self):
+        self.geolocator = Nominatim(user_agent="real_estate_app")
+        self.sentence_transformer = SentenceTransformer('all-MiniLM-L6-v2')
+        
+    def get_location_details(self, latitude: float, longitude: float) -> Dict:
+        """Get detailed location information from coordinates"""
+        try:
+            location = self.geolocator.reverse(f"{latitude}, {longitude}", language='en')
+            if location and location.raw.get('address'):
+                address = location.raw['address']
+                return {
+                    'city': address.get('city') or address.get('town') or address.get('suburb'),
+                    'state': address.get('state'),
+                    'country': address.get('country'),
+                    'postcode': address.get('postcode'),
+                    'road': address.get('road'),
+                    'neighbourhood': address.get('neighbourhood'),
+                    'suburb': address.get('suburb')
+                }
+        except Exception as e:
+            logging.error(f"Error getting location details: {str(e)}")
+        return {}
+
+    def calculate_distance(self, lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+        """Calculate distance between two points using Haversine formula"""
+        try:
+            # Convert latitude and longitude from degrees to radians
+            lat1, lon1, lat2, lon2 = map(math.radians, [lat1, lon1, lat2, lon2])
+            
+            # Haversine formula
+            dlat = lat2 - lat1
+            dlon = lon2 - lon1
+            a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2
+            c = 2 * math.asin(math.sqrt(a))
+            r = 6371  # Radius of earth in kilometers
+            
+            return c * r
+        except Exception as e:
+            logging.error(f"Error calculating distance: {str(e)}")
+            return float('inf')
+
+    def find_nearby_properties(self, latitude: float, longitude: float, radius_km: float = 10.0) -> List[Dict]:
+        """Find properties within specified radius of given coordinates"""
+        print(f"\n=== Finding nearby properties ===")
+        print(f"Searching within {radius_km}km of coordinates: {latitude}, {longitude}")
+        
+        try:
+            properties = get_cached_properties()
+            if not properties:
+                print("No properties available in cache")
+                return []
+                
+            nearby_properties = []
+            for prop in properties:
+                try:
+                    # Get property location - handle both location object and direct lat/lon fields
+                    prop_lat = None
+                    prop_lon = None
+                    
+                    # Try to get location from location object
+                    location = prop.get('location', {})
+                    if location and isinstance(location, dict):
+                        prop_lat = location.get('latitude')
+                        prop_lon = location.get('longitude')
+                    
+                    # If not found in location object, try direct fields
+                    if prop_lat is None or prop_lon is None:
+                        prop_lat = prop.get('Latitude')
+                        prop_lon = prop.get('Longitude')
+                    
+                    # Skip if coordinates are missing or invalid
+                    if not prop_lat or not prop_lon:
+                        continue
+                        
+                    try:
+                        prop_lat = float(prop_lat)
+                        prop_lon = float(prop_lon)
+                    except (ValueError, TypeError):
+                        continue
+                    
+                    # Skip if coordinates are zero or invalid
+                    if prop_lat == 0 or prop_lon == 0:
+                        continue
+                    
+                    # Calculate distance
+                    distance = self.calculate_distance(latitude, longitude, prop_lat, prop_lon)
+                    
+                    # Add distance to property data
+                    prop['Distance'] = round(distance, 2)
+                    
+                    # Check if property is within radius
+                    if distance <= radius_km:
+                        print(f"Found nearby property: {prop.get('propertyName', 'Unnamed Property')} at {distance}km")
+                        nearby_properties.append(prop)
+                        
+                except Exception as e:
+                    print(f"Error processing property: {str(e)}")
+                    continue
+                    
+            # Sort by distance
+            nearby_properties.sort(key=lambda x: x.get('Distance', float('inf')))
+            print(f"Found {len(nearby_properties)} properties within {radius_km}km")
+            return nearby_properties
+            
+        except Exception as e:
+            print(f"Error finding nearby properties: {str(e)}")
+            return []
+
+    def set_location(self, latitude: float, longitude: float, session_id: str) -> Dict:
+        """Set user location and find nearby properties"""
+        print(f"\n=== Setting location ===")
+        print(f"Latitude: {latitude}")
+        print(f"Longitude: {longitude}")
+        print(f"Session ID: {session_id}")
+        
+        try:
+            # Get location details
+            location_details = self.get_location_details(latitude, longitude)
+            print(f"Location details: {location_details}")
+            
+            # Find nearby properties
+            nearby_properties = self.find_nearby_properties(latitude, longitude)
+            
+            # Format the response
+            response = {
+                "status": "success",
+                "message": f"Found {len(nearby_properties)} properties nearby",
+                "location": location_details,
+                "properties": nearby_properties
+            }
+            
+            # Add more detailed information if properties were found
+            if nearby_properties:
+                response["nearest_property"] = {
+                    "name": nearby_properties[0].get('propertyName', 'Unnamed Property'),
+                    "distance": nearby_properties[0].get('Distance', 0),
+                    "address": nearby_properties[0].get('Address', 'No address available')
+                }
+            
+            return response
+            
+        except Exception as e:
+            print(f"Error in set_location: {str(e)}")
+            return {
+                "status": "error",
+                "message": "Error processing location",
+                "properties": []
+            }
+
+    def calculate_distances(self, 
+                          reference_point: Tuple[float, float], 
+                          properties: List[Dict]) -> List[Dict]:
+        """Calculate distances between reference point and properties"""
+        distances = []
+        for property_data in properties:
+            try:
+                prop_lat = float(property_data.get('Latitude', 0))
+                prop_lon = float(property_data.get('Longitude', 0))
+                
+                if prop_lat and prop_lon:
+                    distance = geodesic(reference_point, (prop_lat, prop_lon)).miles
+                    property_data['Distance'] = round(distance, 2)
+                    distances.append(property_data)
+            except (ValueError, TypeError) as e:
+                logging.error(f"Error calculating distance: {str(e)}")
+                continue
+                
+        return sorted(distances, key=lambda x: x.get('Distance', float('inf')))
+
+    def find_nearby_landmarks(self, 
+                            latitude: float, 
+                            longitude: float, 
+                            radius_miles: float = 5.0) -> List[Dict]:
+        """Find landmarks near a given location"""
+        try:
+            # Use Nominatim to search for nearby places
+            query = f"amenity near {latitude}, {longitude}"
+            places = self.geolocator.geocode(query, exactly_one=False, limit=10)
+            
+            landmarks = []
+            if places:
+                for place in places:
+                    try:
+                        place_lat = float(place.raw.get('lat', 0))
+                        place_lon = float(place.raw.get('lon', 0))
+                        
+                        if place_lat and place_lon:
+                            distance = geodesic((latitude, longitude), 
+                                             (place_lat, place_lon)).miles
+                            
+                            if distance <= radius_miles:
+                                landmarks.append({
+                                    'name': place.raw.get('display_name', 'Unknown'),
+                                    'type': place.raw.get('type', 'Unknown'),
+                                    'distance': round(distance, 2)
+                                })
+                    except (ValueError, TypeError):
+                        continue
+                        
+            return sorted(landmarks, key=lambda x: x['distance'])
+            
+        except Exception as e:
+            logging.error(f"Error finding nearby landmarks: {str(e)}")
+            return []
+
+    def filter_by_location_criteria(self,
+                                  properties: List[Dict],
+                                  criteria: Dict) -> List[Dict]:
+        """Filter properties based on location criteria"""
+        filtered_properties = []
+        
+        for property_data in properties:
+            try:
+                # Check if property meets all criteria
+                meets_criteria = True
+                
+                # Check distance if specified
+                if 'max_distance' in criteria:
+                    if property_data.get('Distance', float('inf')) > criteria['max_distance']:
+                        meets_criteria = False
+                
+                # Check landmarks if specified
+                if 'nearby_landmarks' in criteria:
+                    property_landmarks = self.find_nearby_landmarks(
+                        float(property_data.get('Latitude', 0)),
+                        float(property_data.get('Longitude', 0))
+                    )
+                    landmark_names = [l['name'].lower() for l in property_landmarks]
+                    if not any(landmark.lower() in landmark_names 
+                             for landmark in criteria['nearby_landmarks']):
+                        meets_criteria = False
+                
+                if meets_criteria:
+                    filtered_properties.append(property_data)
+                    
+            except Exception as e:
+                logging.error(f"Error filtering property: {str(e)}")
+                continue
+                
+        return filtered_properties
+
+    def get_location_embedding(self, location_text: str) -> np.ndarray:
+        """Get embedding for location text"""
+        return self.sentence_transformer.encode(location_text)
+
+    def find_similar_locations(self,
+                             reference_location: str,
+                             candidate_locations: List[str],
+                             top_k: int = 5) -> List[Tuple[str, float]]:
+        """Find locations similar to reference location"""
+        ref_embedding = self.get_location_embedding(reference_location)
+        candidate_embeddings = self.sentence_transformer.encode(candidate_locations)
+        
+        similarities = []
+        for location, embedding in zip(candidate_locations, candidate_embeddings):
+            similarity = np.dot(ref_embedding, embedding) / (
+                np.linalg.norm(ref_embedding) * np.linalg.norm(embedding)
+            )
+            similarities.append((location, float(similarity)))
+            
+        return sorted(similarities, key=lambda x: x[1], reverse=True)[:top_k]
+
+def find_nearby_properties(latitude: float, longitude: float, radius_km: float = 5.0) -> List[Dict]:
+    """Find properties within specified radius of given coordinates"""
+    print(f"\n=== Finding nearby properties ===")
+    print(f"Searching within {radius_km}km of coordinates: {latitude}, {longitude}")
+    
+    try:
+        properties = get_cached_properties()
+        if not properties:
+            print("No properties available in cache")
+            return []
+            
+        nearby_properties = []
+        for prop in properties:
+            try:
+                # Get property location
+                location = prop.get('location', {})
+                if not location:
+                    continue
+                    
+                prop_lat = float(location.get('latitude', 0))
+                prop_lon = float(location.get('longitude', 0))
+                
+                if prop_lat == 0 or prop_lon == 0:
+                    continue
+                
+                # Calculate distance
+                distance = calculate_distance(latitude, longitude, prop_lat, prop_lon)
+                
+                # Add distance to property data
+                prop['Distance'] = round(distance, 2)
+                
+                # Check if property is within radius
+                if distance <= radius_km:
+                    print(f"Found nearby property: {prop.get('propertyName')} at {distance}km")
+                    nearby_properties.append(prop)
+                    
+            except Exception as e:
+                print(f"Error processing property: {str(e)}")
+                continue
+                
+        # Sort by distance
+        nearby_properties.sort(key=lambda x: x.get('Distance', float('inf')))
+        print(f"Found {len(nearby_properties)} properties within {radius_km}km")
+        return nearby_properties
+        
+    except Exception as e:
+        print(f"Error finding nearby properties: {str(e)}")
+        return []
+
+def set_location(latitude: float, longitude: float, session_id: str) -> Dict:
+    """Set user location and find nearby properties"""
+    print(f"\n=== Setting location ===")
+    print(f"Latitude: {latitude}")
+    print(f"Longitude: {longitude}")
+    print(f"Session ID: {session_id}")
+    
+    try:
+        # Find nearby properties
+        nearby_properties = find_nearby_properties(latitude, longitude)
+        
+        return {
+            "status": "success",
+            "message": f"Found {len(nearby_properties)} properties nearby",
+            "properties": nearby_properties
+        }
+        
+    except Exception as e:
+        print(f"Error in set_location: {str(e)}")
+        return {
+            "status": "error",
+            "message": "Error processing location",
+            "properties": []
+        } 

modules/models.py

@@ -0,0 +1,703 @@
+import torch
+import faiss
+import pandas as pd
+import requests
+import json
+import urllib3
+from sentence_transformers import SentenceTransformer, util
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from modules.config import (
+    MODEL_DIR, 
+    LLM_MODEL_DIR, 
+    FEATURE_MATCHER_DIR,
+    BASE_MODEL_DIR,
+    SEMANTIC_MODEL_DIR
+)
+from modules.parallel import ModelParallelizer, parallel_map, batch_process, get_device
+import os
+import pickle
+import numpy as np
+import logging
+from sklearn.decomposition import PCA
+from pathlib import Path
+from typing import Dict, Any, Tuple, List
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Disable SSL warnings for development
+urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+
+# Check device
+device = get_device()
+print(f"Using device: {device}")
+
+# Global variables
+model_embedding = None
+model_parallelizer = None
+properties_cache = None
+property_embeddings = None
+
+# API Configuration
+API_BASE_URL = os.getenv("API_BASE_URL", "https://99e3-171-78-177-251.ngrok-free.app/api/Property")
+API_ENDPOINT = f"{API_BASE_URL}/allPropertieswithfulldetails"
+
+class SearchSystem:
+    def __init__(self, model_path: str = None, index_path: str = None, pca_path: str = None):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model_path = Path(model_path) if model_path else Path("models/saved_models/search")
+        self.index_path = Path(index_path) if index_path else self.model_path / "faiss_index.bin"
+        self.pca_path = Path(pca_path) if pca_path else self.model_path / "pca_model.pkl"
+        
+        self.model = None
+        self.index = None
+        self.pca = None
+        self.dimension = 384  # Default dimension for all-MiniLM-L6-v2
+        
+    def load_models(self):
+        """Load all models and index"""
+        try:
+            # Load base model
+            self.model = SentenceTransformer('all-MiniLM-L6-v2').to(self.device)
+            
+            # Load FAISS index
+            if self.index_path.exists():
+                self.index = faiss.read_index(str(self.index_path))
+            else:
+                logger.warning(f"FAISS index not found at {self.index_path}")
+                
+            # Load PCA model
+            if self.pca_path.exists():
+                with open(self.pca_path, 'rb') as f:
+                    self.pca = pickle.load(f)
+            else:
+                logger.warning(f"PCA model not found at {self.pca_path}")
+                
+            logger.info("Successfully loaded all models")
+            
+        except Exception as e:
+            logger.error(f"Error loading models: {str(e)}")
+            raise
+            
+    def train_pca(self, embeddings: np.ndarray, n_components: int = 128):
+        """Train PCA model on embeddings"""
+        try:
+            self.pca = PCA(n_components=n_components)
+            self.pca.fit(embeddings)
+            
+            # Save PCA model
+            self.model_path.mkdir(parents=True, exist_ok=True)
+            with open(self.pca_path, 'wb') as f:
+                pickle.dump(self.pca, f)
+                
+            logger.info(f"Successfully trained and saved PCA model with {n_components} components")
+            
+        except Exception as e:
+            logger.error(f"Error training PCA: {str(e)}")
+            raise
+            
+    def transform_embeddings(self, embeddings: np.ndarray) -> np.ndarray:
+        """Transform embeddings using PCA if available"""
+        if self.pca is not None:
+            return self.pca.transform(embeddings)
+        return embeddings
+        
+    def create_embeddings(self, texts: List[str]) -> np.ndarray:
+        """Create embeddings for texts"""
+        embeddings = self.model.encode(texts, convert_to_numpy=True)
+        return self.transform_embeddings(embeddings)
+        
+    def search(self, query: str, k: int = 5) -> Tuple[np.ndarray, np.ndarray]:
+        """Search for similar texts"""
+        if self.index is None:
+            raise ValueError("FAISS index not loaded")
+            
+        # Create query embedding
+        query_embedding = self.create_embeddings([query])[0]
+        
+        # Search
+        distances, indices = self.index.search(query_embedding.reshape(1, -1), k)
+        return distances[0], indices[0]
+        
+    def save_index(self, embeddings: np.ndarray):
+        """Create and save FAISS index"""
+        try:
+            # Create index
+            dimension = embeddings.shape[1]
+            self.index = faiss.IndexFlatL2(dimension)
+            self.index.add(embeddings.astype('float32'))
+            
+            # Save index
+            self.model_path.mkdir(parents=True, exist_ok=True)
+            faiss.write_index(self.index, str(self.index_path))
+            
+            logger.info(f"Successfully created and saved FAISS index with dimension {dimension}")
+            
+        except Exception as e:
+            logger.error(f"Error creating FAISS index: {str(e)}")
+            raise
+
+def fetch_and_cache_properties():
+    """Fetch properties from API and cache them"""
+    global properties_cache
+    try:
+        print("Fetching properties from API...")
+        
+        # Configure session with retry mechanism
+        session = requests.Session()
+        session.verify = False
+        
+        # Add headers for better API communication
+        headers = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'ngrok-skip-browser-warning': 'true'
+        }
+        
+        # Make the API request with increased page size
+        response = session.get(
+            API_ENDPOINT,
+            params={"pageNumber": 1, "pageSize": 500},  # Increased page size to ensure we get enough properties
+            headers=headers
+        )
+        
+        # Check for successful response
+        response.raise_for_status()
+        
+        # Parse and validate response
+        data = response.json()
+        if not isinstance(data, dict) or 'data' not in data:
+            raise ValueError("Invalid API response format")
+            
+        properties_cache = data["data"]
+        if not properties_cache:
+            raise ValueError("No properties found in API response")
+            
+        print(f"Successfully cached {len(properties_cache)} properties")
+        print("\nSample Raw API Response (First Property):")
+        print(json.dumps(properties_cache[0], indent=2))
+        return properties_cache
+        
+    except Exception as e:
+        logger.error(f"Error fetching properties: {str(e)}")
+        return []
+
+def get_cached_properties():
+    """Get cached properties or fetch if not available"""
+    global properties_cache
+    if properties_cache is None:
+        properties_cache = fetch_and_cache_properties()
+    return properties_cache or []
+
+def create_property_embeddings(properties, model):
+    """Create embeddings for properties and store in FAISS index"""
+    global property_embeddings
+    try:
+        print("\n=== Creating property embeddings ===")
+        
+        # Prepare property texts for embedding
+        property_texts = []
+        for prop in properties:
+            # Create a rich text representation of the property
+            text = f"""
+            Property Name: {prop.get('propertyName', 'N/A')}
+            Type: {prop.get('typeName', 'N/A')}
+            Description: {prop.get('description', 'N/A')}
+            Address: {prop.get('address', 'N/A')}
+
+            Location Information:
+            Full Address: {prop.get('location', {}).get('address', 'N/A')}
+            Latitude: {prop.get('location', {}).get('latitude', 'N/A')}
+            Longitude: {prop.get('location', {}).get('longitude', 'N/A')}
+
+            Property Details:
+            Total Square Feet: {prop.get('totalSquareFeet', 'N/A')}
+            Number of Rooms: {prop.get('numberOfRooms', 'N/A')}
+            Market Value: {prop.get('marketValue', 'N/A')}
+
+            Features: {', '.join(prop.get('features', []))}
+
+            PG Property Details:
+            {format_pg_details(prop.get('pgPropertyDetails', {}))}
+
+            Commercial Property Details:
+            {format_commercial_details(prop.get('commercialPropertyDetails', {}))}
+            """
+            property_texts.append(text)
+        
+        print(f"Created text representations for {len(property_texts)} properties")
+        
+        # Create embeddings in batches
+        embeddings = []
+        batch_size = 32
+        for i in range(0, len(property_texts), batch_size):
+            batch = property_texts[i:i + batch_size]
+            print(f"Processing batch {i//batch_size + 1}/{(len(property_texts) + batch_size - 1)//batch_size}")
+            batch_embeddings = model.encode(batch, convert_to_numpy=True)
+            embeddings.extend(batch_embeddings)
+            
+        property_embeddings = np.array(embeddings).astype('float32')
+        print(f"Created embeddings for {len(property_embeddings)} properties")
+        
+        # Create and save FAISS index
+        dimension = property_embeddings.shape[1]
+        print(f"Creating FAISS index with dimension {dimension}")
+        index = faiss.IndexFlatL2(dimension)
+        index.add(property_embeddings)
+        
+        # Save the index
+        index_path = os.path.join(MODEL_DIR, "property_index.faiss")
+        faiss.write_index(index, index_path)
+        print(f"Saved FAISS index to {index_path}")
+        
+        return index
+        
+    except Exception as e:
+        print(f"Error creating property embeddings: {str(e)}")
+        raise
+
+def format_pg_details(pg_details):
+    """Format PG property details into text"""
+    if not pg_details:
+        return "N/A"
+    
+    return f"""
+    Deposit: {pg_details.get('depositAmount', 'N/A')}
+    Food Included: {pg_details.get('foodIncluded', 'N/A')}
+    Food Type: {pg_details.get('foodAvailability', 'N/A')}
+    WiFi: {pg_details.get('wifiAvailable', 'N/A')}
+    AC: {pg_details.get('isACAvailable', 'N/A')}
+    Parking: {pg_details.get('isParkingAvailable', 'N/A')}
+    Power Backup: {pg_details.get('powerBackup', 'N/A')}
+    Available For: {pg_details.get('availableFor', 'N/A')}
+    Total Beds: {pg_details.get('totalBeds', 'N/A')}
+    """
+
+def format_commercial_details(commercial_details):
+    """Format commercial property details into text"""
+    if not commercial_details:
+        return "N/A"
+    
+    return f"""
+    Washrooms: {commercial_details.get('washrooms', 'N/A')}
+    Floor Details: {commercial_details.get('floorDetails', 'N/A')}
+    Parking: {commercial_details.get('hasParking', 'N/A')}
+    Parking Capacity: {commercial_details.get('parkingCapacity', 'N/A')}
+    Facing: {commercial_details.get('facing', 'N/A')}
+    Lift: {commercial_details.get('hasLift', 'N/A')}
+    Furnished: {commercial_details.get('isFurnished', 'N/A')}
+    """
+
+def load_sentence_transformer():
+    global model_embedding, model_parallelizer
+    print("\n=== Loading SentenceTransformer model ===")
+    try:
+        # Load base model first
+        base_model_path = os.path.join(BASE_MODEL_DIR, "model.safetensors")
+        print(f"Loading base model from: {base_model_path}")
+        
+        # Load semantic model
+        semantic_model_path = os.path.join(SEMANTIC_MODEL_DIR, "model.safetensors")
+        print(f"Loading semantic model from: {semantic_model_path}")
+        
+        # Initialize with default model first
+        model_embedding = SentenceTransformer("jinaai/jina-embeddings-v3", trust_remote_code=True).to(device)
+        print("Loaded default model successfully")
+        
+        # Try to load base model if exists
+        if os.path.exists(base_model_path):
+            print("Loading base model state dict...")
+            try:
+                state_dict = torch.load(base_model_path, map_location=device)
+                model_embedding.load_state_dict(state_dict)
+                print("Base model loaded successfully")
+            except Exception as e:
+                print(f"Error loading base model: {str(e)}")
+        else:
+            print(f"Base model not found at {base_model_path}")
+            
+        # Try to load semantic model if exists
+        if os.path.exists(semantic_model_path):
+            print("Loading semantic model state dict...")
+            try:
+                semantic_state_dict = torch.load(semantic_model_path, map_location=device)
+                model_embedding.load_state_dict(semantic_state_dict, strict=False)
+                print("Semantic model loaded successfully")
+            except Exception as e:
+                print(f"Error loading semantic model: {str(e)}")
+        else:
+            print(f"Semantic model not found at {semantic_model_path}")
+        
+        # Initialize parallelizer
+        model_parallelizer = ModelParallelizer(model_embedding)
+        print("Model parallelizer initialized")
+        return model_embedding
+    except Exception as e:
+        print(f"Error loading model: {str(e)}")
+        raise
+
+def load_faiss_index():
+    print("\n=== Loading FAISS index ===")
+    try:
+        index_path = os.path.join(MODEL_DIR, "property_index.faiss")
+        print(f"Looking for FAISS index at: {index_path}")
+        
+        if os.path.exists(index_path):
+            index = faiss.read_index(index_path)
+            print("FAISS index loaded successfully")
+            return index
+        else:
+            print("FAISS index not found, creating new index...")
+            # Fetch properties and create new index
+            properties = get_cached_properties()
+            if not properties:
+                raise ValueError("No properties available to create index")
+            model = load_sentence_transformer()
+            return create_property_embeddings(properties, model)
+    except Exception as e:
+        print(f"Error loading FAISS index: {str(e)}")
+        raise
+
+def load_pca_model():
+    print("Loading PCA model...")
+    try:
+        pca_path = os.path.join(MODEL_DIR, "pca_model.pkl")
+        if os.path.exists(pca_path):
+            with open(pca_path, 'rb') as f:
+                pca = pickle.load(f)
+            print("PCA model loaded successfully.")
+            return pca
+        return None
+    except Exception as e:
+        logger.error(f"Error loading PCA model: {str(e)}")
+        return None
+
+def load_search_system(model_path: str = None, index_path: str = None, pca_path: str = None) -> SearchSystem:
+    """Load the entire search system"""
+    system = SearchSystem(model_path, index_path, pca_path)
+    system.load_models()
+    return system
+
+def format_property_details(property_data):
+    """Format property details with all available information"""
+    try:
+        # Extract location details safely
+        location = property_data.get('location', {})
+        address_parts = location.get('address', '').split(',') if location.get('address') else []
+        
+        # Ensure we have enough parts for address parsing
+        while len(address_parts) < 4:
+            address_parts.append('N/A')
+            
+        formatted_property = {
+            # Basic Information
+            "PropertyName": property_data.get('propertyName', 'Unknown'),
+            "Address": property_data.get('address', 'N/A'),
+            "ZipCode": address_parts[-1].strip() if address_parts else 'N/A',
+            "LeasableSquareFeet": float(property_data.get('totalSquareFeet', 0)),
+            "YearBuilt": property_data.get('yearBuilt', None),
+            "NumberOfRooms": int(property_data.get('numberOfRooms', 0)),
+            "ParkingSpaces": int(property_data.get('commercialPropertyDetails', {}).get('parkingCapacity', 0)) if property_data.get('commercialPropertyDetails') else 0,
+            "PropertyManager": property_data.get('agents', [{}])[0].get('name', 'N/A') if property_data.get('agents') else 'N/A',
+            "MarketValue": float(property_data.get('marketValue', 0)),
+            "TaxAssessmentNumber": None,  # Not available in API
+            "Latitude": float(location.get('latitude', 0)) if location.get('latitude') is not None else 0.0,
+            "Longitude": float(location.get('longitude', 0)) if location.get('longitude') is not None else 0.0,
+            "CreateDate": property_data.get('date', 'N/A'),
+            "LastModifiedDate": property_data.get('date', 'N/A'),
+            "City": address_parts[1].strip() if len(address_parts) > 1 else 'N/A',
+            "State": address_parts[2].strip() if len(address_parts) > 2 else 'N/A',
+            "Country": address_parts[3].strip() if len(address_parts) > 3 else 'N/A',
+            "PropertyType": property_data.get('typeName', 'N/A'),
+            "PropertyStatus": property_data.get('parentCategoryName', 'N/A'),
+            "Description": property_data.get('description', 'N/A'),
+            "ViewNumber": 0,  # Not available in API
+            "Contact": property_data.get('agents', [{}])[0].get('phoneNumber', 'N/A') if property_data.get('agents') else 'N/A',
+            "TotalSquareFeet": float(property_data.get('totalSquareFeet', 0)),
+            "IsDeleted": False,  # Not available in API
+            "Beds": int(property_data.get('beds', 0)),  # Updated to use beds instead of numberOfRooms
+            "Baths": int(property_data.get('baths', 0)),  # Updated to use baths directly
+            "AgentName": property_data.get('agents', [{}])[0].get('name', 'N/A') if property_data.get('agents') else 'N/A',
+            "AgentPhoneNumber": property_data.get('agents', [{}])[0].get('phoneNumber', 'N/A') if property_data.get('agents') else 'N/A',
+            "AgentEmail": property_data.get('agents', [{}])[0].get('email', 'N/A') if property_data.get('agents') else 'N/A',
+            "KeyFeatures": ', '.join(property_data.get('features', [])) if property_data.get('features') else 'N/A',
+            "NearbyAmenities": property_data.get('description', 'N/A'),
+            "propertyImages": property_data.get('propertyImages', []),
+            
+            # PG Property Details
+            "PGDetails": {
+                "DepositAmount": property_data.get('pgPropertyDetails', {}).get('depositAmount', 'N/A'),
+                "FoodIncluded": property_data.get('pgPropertyDetails', {}).get('foodIncluded', 'N/A'),
+                "FoodType": property_data.get('pgPropertyDetails', {}).get('foodAvailability', 'N/A'),
+                "WifiAvailable": property_data.get('pgPropertyDetails', {}).get('wifiAvailable', 'N/A'),
+                "ACAvailable": property_data.get('pgPropertyDetails', {}).get('isACAvailable', 'N/A'),
+                "ParkingAvailable": property_data.get('pgPropertyDetails', {}).get('isParkingAvailable', 'N/A'),
+                "PowerBackup": property_data.get('pgPropertyDetails', {}).get('powerBackup', 'N/A'),
+                "AvailableFor": property_data.get('pgPropertyDetails', {}).get('availableFor', 'N/A'),
+                "TotalBeds": property_data.get('pgPropertyDetails', {}).get('totalBeds', 'N/A'),
+                "OperatingSince": property_data.get('pgPropertyDetails', {}).get('operatingSince', 'N/A'),
+                "NoticePeriod": property_data.get('pgPropertyDetails', {}).get('noticePeriod', 'N/A'),
+                "PreferredTenants": property_data.get('pgPropertyDetails', {}).get('preferredTenants', 'N/A')
+            } if property_data.get('pgPropertyDetails') else None,
+            
+            # Commercial Property Details
+            "CommercialDetails": {
+                "Washrooms": property_data.get('commercialPropertyDetails', {}).get('washrooms', 'N/A'),
+                "FloorDetails": property_data.get('commercialPropertyDetails', {}).get('floorDetails', 'N/A'),
+                "HasParking": property_data.get('commercialPropertyDetails', {}).get('hasParking', 'N/A'),
+                "ParkingCapacity": property_data.get('commercialPropertyDetails', {}).get('parkingCapacity', 'N/A'),
+                "Facing": property_data.get('commercialPropertyDetails', {}).get('facing', 'N/A'),
+                "HasLift": property_data.get('commercialPropertyDetails', {}).get('hasLift', 'N/A'),
+                "IsFurnished": property_data.get('commercialPropertyDetails', {}).get('isFurnished', 'N/A'),
+                "Overlooking": property_data.get('commercialPropertyDetails', {}).get('overlooking', 'N/A'),
+                "MonthlyRent": property_data.get('commercialPropertyDetails', {}).get('monthlyRent', 'N/A'),
+                "LeaseTerms": property_data.get('commercialPropertyDetails', {}).get('leaseTerms', 'N/A')
+            } if property_data.get('commercialPropertyDetails') else None
+        }
+        return formatted_property
+    except Exception as e:
+        logger.error(f"Error formatting property details: {str(e)}")
+        return None
+
+class CustomRagRetriever:
+    def __init__(self, faiss_index, model, pca=None):
+        self.index = faiss_index
+        self.model = model
+        self.pca = pca
+        self.dimension = faiss_index.d
+        self.model_parallelizer = ModelParallelizer(model)
+        print(f"Initialized CustomRagRetriever with dimension {self.dimension}")
+
+    def retrieve(self, query, top_k=10, distance_threshold=1.0):  # Added distance_threshold parameter
+        print(f"\n=== RETRIEVAL DEBUG ===")
+        print(f"Query: {query}")
+        try:
+            # Get query embedding
+            query_embedding = self.model_parallelizer.parallel_encode([query])[0]
+            query_embedding = query_embedding.astype(np.float32)
+            
+            # Reshape query embedding to 2D array (1, embedding_dim)
+            query_embedding = query_embedding.reshape(1, -1)
+
+            # Apply PCA if it exists
+            if self.pca is not None:
+                query_embedding = self.pca.transform(query_embedding)
+
+            # Get cached properties first to ensure we have data
+            properties = get_cached_properties()
+            if not properties:
+                logger.error("No properties available in cache")
+                return []
+
+            print(f"\nTotal properties in cache: {len(properties)}")
+
+            # Adjust top_k if it's larger than available properties
+            top_k = min(top_k, len(properties))
+
+            try:
+                # Search for top_k results in the FAISS index
+                distances, indices = self.index.search(query_embedding, top_k)
+                print(f"\nFAISS Search Results:")
+                print(f"Indices: {indices[0]}")
+                print(f"Distances: {distances[0]}")
+            except Exception as e:
+                logger.error(f"Error in FAISS search: {str(e)}")
+                print(f"\nFalling back to text search due to FAISS error: {str(e)}")
+                return self._fallback_search(query, properties, top_k)
+
+            # Process retrieved properties with enhanced scoring
+            retrieved_properties = []
+            seen_properties = set()
+            print("\nProcessing retrieved properties:")
+            
+            for idx, dist in zip(indices[0], distances[0]):
+                if idx >= len(properties):
+                    continue
+                    
+                property_data = properties[idx]
+                if not property_data:
+                    continue
+                
+                property_id = property_data.get('id', str(property_data))
+                if property_id in seen_properties:
+                    continue
+                seen_properties.add(property_id)
+
+                if dist > distance_threshold:
+                    continue
+
+                # Format property data with all details
+                formatted_property = format_property_details(property_data)
+                if not formatted_property:
+                    continue
+
+                # Calculate semantic similarity
+                property_text = f"""
+                Property: {formatted_property['PropertyName']}
+                Type: {formatted_property['PropertyType']}
+                Description: {formatted_property['Description']}
+                Features: {formatted_property['KeyFeatures']}
+                """
+                
+                semantic_score = util.pytorch_cos_sim(
+                    self.model_parallelizer.parallel_encode([query])[0],
+                    self.model_parallelizer.parallel_encode([property_text])[0]
+                ).item()
+
+                # Combine scores (60% distance, 40% semantic)
+                combined_score = (1 - dist) * 0.6 + semantic_score * 0.4
+                
+                print(f"\nProperty {idx}:")
+                print(f"Name: {formatted_property['PropertyName']}")
+                print(f"Type: {formatted_property['PropertyType']}")
+                print(f"Distance: {dist}")
+                print(f"Semantic Score: {semantic_score}")
+                print(f"Combined Score: {combined_score}")
+                
+                retrieved_properties.append({
+                    "property": formatted_property,
+                    "distance": float(dist),
+                    "semantic_score": semantic_score,
+                    "combined_score": combined_score,
+                    "match_quality": "perfect" if combined_score > 0.7 else "partial",
+                    "confidence": combined_score
+                })
+
+            # Sort by combined score
+            retrieved_properties.sort(key=lambda x: x['combined_score'], reverse=True)
+
+            # If we don't have enough results, add more properties
+            if len(retrieved_properties) < top_k:
+                print(f"\nAdding {top_k - len(retrieved_properties)} more properties to reach {top_k}")
+                remaining_properties = self._get_remaining_properties(
+                    properties, retrieved_properties, top_k
+                )
+                retrieved_properties.extend(remaining_properties)
+
+            print(f"\nFinal number of properties retrieved: {len(retrieved_properties)}")
+            print("=== END RETRIEVAL DEBUG ===\n")
+            
+            return retrieved_properties[:top_k]  # Return exactly top_k properties
+
+        except Exception as e:
+            logger.error(f"Error in retrieve: {str(e)}")
+            print(f"\nError in retrieve: {str(e)}")
+            # Return empty list instead of raising to prevent 500 errors
+            return []
+
+    def _fallback_search(self, query, properties, top_k):
+        """Fallback search method using simple text matching with enhanced scoring"""
+        print("\n=== FALLBACK SEARCH DEBUG ===")
+        print(f"Query: {query}")
+        print(f"Total properties to search: {len(properties)}")
+        try:
+            query_terms = query.lower().split()
+            print(f"Query terms: {query_terms}")
+            scored_properties = []
+            
+            for prop in properties:
+                score = 0
+                # Check property name
+                if prop.get('propertyName'):
+                    name_terms = prop['propertyName'].lower().split()
+                    name_matches = sum(1 for term in query_terms if any(term in name_term for name_term in name_terms))
+                    score += name_matches * 2  # Give more weight to name matches
+                    if name_matches > 0:
+                        print(f"\nProperty: {prop['propertyName']}")
+                        print(f"Name matches: {name_matches}")
+                
+                # Check property type
+                if prop.get('typeName'):
+                    type_terms = prop['typeName'].lower().split()
+                    type_matches = sum(1 for term in query_terms if any(term in type_term for type_term in type_terms))
+                    score += type_matches * 1.5  # Give good weight to type matches
+                    if type_matches > 0:
+                        print(f"Type matches: {type_matches}")
+                
+                # Check description
+                if prop.get('description'):
+                    desc_terms = prop['description'].lower().split()
+                    desc_matches = sum(1 for term in query_terms if any(term in desc_term for desc_term in desc_terms))
+                    score += desc_matches
+                    if desc_matches > 0:
+                        print(f"Description matches: {desc_matches}")
+                
+                # Check features
+                if prop.get('features'):
+                    feature_matches = sum(1 for term in query_terms if any(term in feature.lower() for feature in prop['features']))
+                    score += feature_matches * 1.2  # Give good weight to feature matches
+                    if feature_matches > 0:
+                        print(f"Feature matches: {feature_matches}")
+                
+                if score > 0:
+                    formatted_property = format_property_details(prop)
+                    if formatted_property:
+                        print(f"Total score: {score}")
+                        # Convert score to a normalized confidence value
+                        confidence = min(score / (len(query_terms) * 2), 1.0)
+                        scored_properties.append({
+                            "property": formatted_property,
+                            "distance": 1.0 / (score + 1),  # Convert score to distance
+                            "semantic_score": confidence,
+                            "combined_score": confidence,
+                            "match_quality": "perfect" if confidence > 0.7 else "partial",
+                            "confidence": confidence
+                        })
+            
+            # Sort by score (distance) and return top_k
+            scored_properties.sort(key=lambda x: x['combined_score'], reverse=True)
+            print(f"\nFound {len(scored_properties)} matching properties")
+            print("=== END FALLBACK SEARCH DEBUG ===\n")
+            return scored_properties[:top_k]
+            
+        except Exception as e:
+            logger.error(f"Error in fallback search: {str(e)}")
+            print(f"\nError in fallback search: {str(e)}")
+            return []
+
+    def _get_remaining_properties(self, properties, retrieved_properties, top_k):
+        """Get additional properties to fill up to top_k with basic scoring"""
+        try:
+            remaining = []
+            retrieved_ids = {p['property']['PropertyName'] for p in retrieved_properties}
+            
+            for prop in properties:
+                if len(remaining) >= top_k - len(retrieved_properties):
+                    break
+                    
+                if prop.get('propertyName') not in retrieved_ids:
+                    formatted_property = format_property_details(prop)
+                    if formatted_property:
+                        remaining.append({
+                            "property": formatted_property,
+                            "distance": 1.0,  # High distance score for additional properties
+                            "semantic_score": 0.0,
+                            "combined_score": 0.0,
+                            "match_quality": "partial",
+                            "confidence": 0.0
+                        })
+                        retrieved_ids.add(prop['propertyName'])
+            
+            return remaining
+            
+        except Exception as e:
+            logger.error(f"Error getting remaining properties: {str(e)}")
+            return []
+
+def load_tokenizer_and_model():
+    print("Loading tokenizer and LLM model...")
+    try:
+        # Load tokenizer
+        tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL_DIR)
+        
+        # Load model and move to device
+        model_llm = AutoModelForCausalLM.from_pretrained(LLM_MODEL_DIR)
+        model_llm = model_llm.to(device)
+        model_llm.eval()  # Set to evaluation mode
+        
+        print("Tokenizer and LLM model loaded successfully.")
+        return tokenizer, model_llm
+    except Exception as e:
+        logger.error(f"Error loading tokenizer/model: {str(e)}")
+        raise 

modules/nlp_processor.py

@@ -0,0 +1,158 @@
+import re
+import spacy
+import numpy as np
+from transformers import pipeline
+from sentence_transformers import SentenceTransformer
+import torch
+from typing import Dict, List, Tuple, Union
+import logging
+
+class NLPProcessor:
+    def __init__(self):
+        # Load lightweight models
+        self.nlp = spacy.load("en_core_web_sm")
+        self.ner_pipeline = pipeline("ner", model="dbmdz/bert-large-cased-finetuned-conll03-english")
+        self.zero_shot = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")
+        self.sentence_transformer = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        # Initialize numerical extraction patterns
+        self.number_patterns = {
+            'price': r'\$?\d+(?:,\d{3})*(?:\.\d{2})?',
+            'sqft': r'\d+(?:,\d{3})*\s*(?:sq\s*ft|square\s*feet)',
+            'year': r'(?:19|20)\d{2}',
+            'beds': r'\d+\s*(?:bed|beds|bedroom|bedrooms)',
+            'baths': r'\d+\s*(?:bath|baths|bathroom|bathrooms)'
+        }
+        
+        # Property status categories
+        self.status_categories = [
+            "available", "sold", "pending", "under contract", 
+            "off market", "coming soon", "active", "inactive"
+        ]
+        
+        # Currency conversion rates (example)
+        self.currency_rates = {
+            'lakh': 100000,
+            'crore': 10000000,
+            'million': 1000000,
+            'billion': 1000000000
+        }
+
+    def convert_currency(self, value: str) -> float:
+        """Convert various currency formats to a standard number"""
+        try:
+            # Remove currency symbols and commas
+            value = re.sub(r'[^\d.]', '', value)
+            
+            # Check for word-based numbers
+            value_lower = value.lower()
+            for word, multiplier in self.currency_rates.items():
+                if word in value_lower:
+                    # Extract the number and multiply by the rate
+                    num = float(re.sub(r'[^\d.]', '', value))
+                    return num * multiplier
+            
+            # If no special words found, return the number as is
+            return float(value)
+        except (ValueError, TypeError):
+            return 0.0
+
+    def extract_numerical_values(self, text: str) -> Dict[str, Union[float, int]]:
+        """Extract numerical values from text using regex and NLP"""
+        values = {}
+        
+        # Extract numbers using patterns
+        for key, pattern in self.number_patterns.items():
+            matches = re.finditer(pattern, text.lower())
+            for match in matches:
+                value = match.group()
+                # Clean and convert value
+                if key == 'price':
+                    values[key] = self.convert_currency(value)
+                elif key in ['sqft', 'beds', 'baths']:
+                    values[key] = int(re.sub(r'[^\d]', '', value))
+                elif key == 'year':
+                    values[key] = int(value)
+        
+        return values
+
+    def classify_property_status(self, text: str) -> str:
+        """Classify property status using zero-shot classification"""
+        result = self.zero_shot(
+            text,
+            candidate_labels=self.status_categories,
+            multi_label=False
+        )
+        return result['labels'][0]
+
+    def extract_landmarks(self, text: str) -> List[str]:
+        """Extract landmarks and points of interest using NER"""
+        doc = self.nlp(text)
+        landmarks = []
+        
+        # Extract named entities
+        for ent in doc.ents:
+            if ent.label_ in ['FAC', 'ORG', 'LOC']:
+                landmarks.append(ent.text)
+        
+        return landmarks
+
+    def semantic_similarity(self, query: str, candidates: List[str]) -> List[Tuple[str, float]]:
+        """Calculate semantic similarity between query and candidates"""
+        query_embedding = self.sentence_transformer.encode(query)
+        candidate_embeddings = self.sentence_transformer.encode(candidates)
+        
+        similarities = []
+        for candidate, embedding in zip(candidates, candidate_embeddings):
+            similarity = np.dot(query_embedding, embedding) / (
+                np.linalg.norm(query_embedding) * np.linalg.norm(embedding)
+            )
+            similarities.append((candidate, float(similarity)))
+        
+        return sorted(similarities, key=lambda x: x[1], reverse=True)
+
+    def process_query(self, query: str) -> Dict:
+        """Process a natural language query and extract structured information"""
+        # Extract numerical values
+        numerical_values = self.extract_numerical_values(query)
+        
+        # Extract landmarks
+        landmarks = self.extract_landmarks(query)
+        
+        # Classify property status if mentioned
+        status = None
+        if any(status_word in query.lower() for status_word in self.status_categories):
+            status = self.classify_property_status(query)
+        
+        return {
+            'numerical_values': numerical_values,
+            'landmarks': landmarks,
+            'status': status,
+            'original_query': query
+        }
+
+    def format_property_details(self, property_data: Dict) -> str:
+        """Format property details in a natural language format"""
+        details = []
+        
+        # Basic information
+        if 'PropertyName' in property_data:
+            details.append(f"Property: {property_data['PropertyName']}")
+        if 'Address' in property_data:
+            details.append(f"Location: {property_data['Address']}")
+        
+        # Numerical details
+        if 'Beds' in property_data:
+            details.append(f"{property_data['Beds']} bedrooms")
+        if 'Baths' in property_data:
+            details.append(f"{property_data['Baths']} bathrooms")
+        if 'LeasableSquareFeet' in property_data:
+            details.append(f"{property_data['LeasableSquareFeet']} square feet")
+        
+        # Status and price
+        if 'PropertyStatus' in property_data:
+            details.append(f"Status: {property_data['PropertyStatus']}")
+        if 'MarketValue' in property_data:
+            details.append(f"Price: ${property_data['MarketValue']:,.2f}")
+        
+        return "\n".join(details) 

modules/parallel.py

@@ -0,0 +1,126 @@
+import multiprocessing
+import threading
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+import torch
+import logging
+from functools import partial
+import queue
+import time
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global thread pool for I/O bound tasks
+thread_pool = ThreadPoolExecutor(max_workers=multiprocessing.cpu_count() * 2)
+
+# Global process pool for CPU bound tasks
+process_pool = ProcessPoolExecutor(max_workers=multiprocessing.cpu_count())
+
+# Queue for managing async tasks
+task_queue = queue.Queue()
+
+def get_device():
+    """Get the appropriate device for computation"""
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+def parallel_map(func, items, use_processes=False):
+    """Execute a function in parallel on a list of items"""
+    executor = process_pool if use_processes else thread_pool
+    return list(executor.map(func, items))
+
+def batch_process(items, batch_size=32, func=None):
+    """Process items in batches"""
+    results = []
+    for i in range(0, len(items), batch_size):
+        batch = items[i:i + batch_size]
+        if func:
+            batch_results = parallel_map(func, batch)
+        else:
+            batch_results = batch
+        results.extend(batch_results)
+    return results
+
+class AsyncTaskManager:
+    def __init__(self, max_workers=None):
+        self.max_workers = max_workers or multiprocessing.cpu_count()
+        self.thread_pool = ThreadPoolExecutor(max_workers=self.max_workers)
+        self.tasks = {}
+        self.results = {}
+        self.lock = threading.Lock()
+
+    def submit_task(self, task_id, func, *args, **kwargs):
+        """Submit a task to be executed asynchronously"""
+        future = self.thread_pool.submit(func, *args, **kwargs)
+        with self.lock:
+            self.tasks[task_id] = future
+        return task_id
+
+    def get_result(self, task_id, timeout=None):
+        """Get the result of a task"""
+        if task_id not in self.tasks:
+            return None
+        
+        if task_id in self.results:
+            return self.results[task_id]
+        
+        try:
+            result = self.tasks[task_id].result(timeout=timeout)
+            with self.lock:
+                self.results[task_id] = result
+            return result
+        except Exception as e:
+            logger.error(f"Error getting result for task {task_id}: {str(e)}")
+            return None
+
+    def cancel_task(self, task_id):
+        """Cancel a running task"""
+        if task_id in self.tasks:
+            self.tasks[task_id].cancel()
+            with self.lock:
+                del self.tasks[task_id]
+
+    def cleanup(self):
+        """Clean up completed tasks"""
+        with self.lock:
+            completed_tasks = [task_id for task_id, future in self.tasks.items() 
+                             if future.done()]
+            for task_id in completed_tasks:
+                if task_id not in self.results:
+                    try:
+                        self.results[task_id] = self.tasks[task_id].result()
+                    except Exception:
+                        pass
+                del self.tasks[task_id]
+
+class ModelParallelizer:
+    def __init__(self, model, batch_size=32):
+        self.model = model
+        self.batch_size = batch_size
+        self.device = get_device()
+        self.model = self.model.to(self.device)
+        self.model.eval()
+
+    def parallel_predict(self, inputs):
+        """Run predictions in parallel using batching"""
+        results = []
+        with torch.no_grad():
+            for i in range(0, len(inputs), self.batch_size):
+                batch = inputs[i:i + self.batch_size]
+                batch = torch.stack(batch).to(self.device)
+                batch_results = self.model(batch)
+                results.extend(batch_results.cpu().numpy())
+        return results
+
+    def parallel_encode(self, texts):
+        """Encode texts in parallel using batching"""
+        return batch_process(texts, self.batch_size, self.model.encode)
+
+# Global task manager instance
+task_manager = AsyncTaskManager()
+
+def cleanup_resources():
+    """Clean up all parallel processing resources"""
+    thread_pool.shutdown(wait=True)
+    process_pool.shutdown(wait=True)
+    task_manager.cleanup() 

modules/property_processor.py

@@ -0,0 +1,220 @@
+from typing import Dict, List, Optional, Union, Tuple
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import logging
+from sentence_transformers import SentenceTransformer
+
+class PropertyProcessor:
+    def __init__(self):
+        self.sentence_transformer = SentenceTransformer('all-MiniLM-L6-v2')
+        
+    def format_property_details(self, property_data: Dict) -> str:
+        """Format property details into a natural language string"""
+        print(f"\n=== Formatting property details for: {property_data.get('propertyName', 'Unknown')} ===")
+        details = []
+        
+        # Basic information
+        if property_data.get('Address'):
+            details.append(f"Located at {property_data['Address']}")
+            
+        # Handle PG properties specifically
+        if property_data.get('typeName', '').lower() == 'pg':
+            print("Processing PG property")
+            pg_details = property_data.get('pgPropertyDetails', {})
+            if pg_details:
+                details.append("PG Accommodation")
+                if pg_details.get('totalBeds'):
+                    details.append(f"Total Beds: {pg_details['totalBeds']}")
+                if pg_details.get('availableFor'):
+                    details.append(f"Available for: {pg_details['availableFor']}")
+                if pg_details.get('foodIncluded'):
+                    details.append(f"Food: {pg_details['foodIncluded']}")
+                if pg_details.get('wifiAvailable'):
+                    details.append(f"WiFi: {'Available' if pg_details['wifiAvailable'] else 'Not Available'}")
+        else:
+            # Regular property details
+            if property_data.get('BHK'):
+                details.append(f"{property_data['BHK']} BHK")
+            
+            if property_data.get('Bathrooms'):
+                details.append(f"with {property_data['Bathrooms']} bathrooms")
+            
+            if property_data.get('Square_Footage'):
+                details.append(f"covering {property_data['Square_Footage']} sq ft")
+            
+            if property_data.get('Year_Built'):
+                details.append(f"built in {property_data['Year_Built']}")
+            
+            if property_data.get('Market_Value'):
+                details.append(f"priced at ${property_data['Market_Value']:,.2f}")
+        
+        # Enhanced status display
+        if property_data.get('Status'):
+            status = property_data['Status'].lower()
+            status_display = {
+                'available': 'Available for purchase/rent',
+                'sold': 'Sold',
+                'pending': 'Sale/Rental pending',
+                'under contract': 'Under contract',
+                'off market': 'Currently off market',
+                'coming soon': 'Coming soon to market',
+                'active': 'Active listing',
+                'inactive': 'Inactive listing'
+            }.get(status, f"Status: {property_data['Status']}")
+            details.append(status_display)
+            
+        if property_data.get('Distance'):
+            details.append(f"Distance: {property_data['Distance']} miles")
+            
+        # Add landmark information if available
+        if property_data.get('Nearby_Landmarks'):
+            landmarks = property_data['Nearby_Landmarks']
+            if isinstance(landmarks, list):
+                details.append(f"Nearby landmarks: {', '.join(landmarks)}")
+            elif isinstance(landmarks, str):
+                details.append(f"Nearby landmarks: {landmarks}")
+        
+        formatted_details = " | ".join(details)
+        print(f"Formatted details: {formatted_details}")
+        return formatted_details
+
+    def filter_by_numerical_range(self,
+                                properties: List[Dict],
+                                field: str,
+                                min_value: Optional[float] = None,
+                                max_value: Optional[float] = None) -> List[Dict]:
+        """Filter properties based on numerical range"""
+        filtered_properties = []
+        
+        for property_data in properties:
+            try:
+                value = float(property_data.get(field, 0))
+                
+                if min_value is not None and value < min_value:
+                    continue
+                    
+                if max_value is not None and value > max_value:
+                    continue
+                    
+                filtered_properties.append(property_data)
+                
+            except (ValueError, TypeError) as e:
+                logging.error(f"Error filtering {field}: {str(e)}")
+                continue
+                
+        return filtered_properties
+
+    def filter_by_status(self,
+                        properties: List[Dict],
+                        status: str) -> List[Dict]:
+        """Filter properties by status"""
+        return [p for p in properties 
+                if p.get('Status', '').lower() == status.lower()]
+
+    def filter_by_bhk(self,
+                     properties: List[Dict],
+                     bhk: Union[int, str]) -> List[Dict]:
+        """Filter properties by BHK count"""
+        try:
+            bhk_value = int(bhk) if isinstance(bhk, str) else bhk
+            return [p for p in properties 
+                   if int(p.get('BHK', 0)) == bhk_value]
+        except (ValueError, TypeError):
+            return []
+
+    def filter_by_bathrooms(self,
+                          properties: List[Dict],
+                          bathroom_count: Union[int, str]) -> List[Dict]:
+        """Filter properties by bathroom count"""
+        try:
+            bath_value = int(bathroom_count) if isinstance(bathroom_count, str) else bathroom_count
+            return [p for p in properties 
+                   if int(p.get('Bathrooms', 0)) == bath_value]
+        except (ValueError, TypeError):
+            return []
+
+    def filter_by_year_built(self,
+                           properties: List[Dict],
+                           min_year: Optional[int] = None,
+                           max_year: Optional[int] = None) -> List[Dict]:
+        """Filter properties by year built"""
+        return self.filter_by_numerical_range(
+            properties, 'Year_Built', min_year, max_year
+        )
+
+    def filter_by_square_footage(self,
+                               properties: List[Dict],
+                               min_sqft: Optional[float] = None,
+                               max_sqft: Optional[float] = None) -> List[Dict]:
+        """Filter properties by square footage"""
+        return self.filter_by_numerical_range(
+            properties, 'Square_Footage', min_sqft, max_sqft
+        )
+
+    def filter_by_market_value(self,
+                             properties: List[Dict],
+                             min_value: Optional[float] = None,
+                             max_value: Optional[float] = None) -> List[Dict]:
+        """Filter properties by market value"""
+        return self.filter_by_numerical_range(
+            properties, 'Market_Value', min_value, max_value
+        )
+
+    def get_property_embedding(self, property_data: Dict) -> np.ndarray:
+        """Get embedding for property description"""
+        description = self.format_property_details(property_data)
+        return self.sentence_transformer.encode(description)
+
+    def find_similar_properties(self,
+                              reference_property: Dict,
+                              candidate_properties: List[Dict],
+                              top_k: int = 5) -> List[Tuple[Dict, float]]:
+        """Find properties similar to reference property"""
+        ref_embedding = self.get_property_embedding(reference_property)
+        
+        similarities = []
+        for property_data in candidate_properties:
+            try:
+                prop_embedding = self.get_property_embedding(property_data)
+                similarity = np.dot(ref_embedding, prop_embedding) / (
+                    np.linalg.norm(ref_embedding) * np.linalg.norm(prop_embedding)
+                )
+                similarities.append((property_data, float(similarity)))
+            except Exception as e:
+                logging.error(f"Error calculating similarity: {str(e)}")
+                continue
+                
+        return sorted(similarities, key=lambda x: x[1], reverse=True)[:top_k]
+
+    def format_zip_code(self, zip_code: Union[str, float, int]) -> str:
+        """Format zip code as string"""
+        try:
+            return str(int(float(zip_code)))
+        except (ValueError, TypeError):
+            return str(zip_code)
+
+    def process_property_data(self, property_data: Dict) -> Dict:
+        """Process and clean property data"""
+        processed_data = property_data.copy()
+        
+        # Format zip code
+        if 'Zip_Code' in processed_data:
+            processed_data['Zip_Code'] = self.format_zip_code(
+                processed_data['Zip_Code']
+            )
+            
+        # Convert numerical fields
+        numerical_fields = [
+            'Square_Footage', 'Market_Value', 'Year_Built',
+            'BHK', 'Bathrooms', 'Latitude', 'Longitude'
+        ]
+        
+        for field in numerical_fields:
+            if field in processed_data:
+                try:
+                    processed_data[field] = float(processed_data[field])
+                except (ValueError, TypeError):
+                    processed_data[field] = 0.0
+                    
+        return processed_data 

modules/rag/feature_matcher.py

@@ -0,0 +1,243 @@
+import torch
+import numpy as np
+from sentence_transformers import SentenceTransformer, util
+from transformers import pipeline
+import pickle
+from pathlib import Path
+from typing import Dict, List, Any, Tuple
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class DynamicFeatureMatcher:
+    def __init__(self, load_saved=False):
+        self.model_path = Path("models/saved_models/feature_matcher")
+        self.model_path.mkdir(parents=True, exist_ok=True)
+        
+        if load_saved:
+            self._load_models()
+        else:
+            self._initialize_models()
+            
+    def _load_models(self):
+        """Load all saved models and patterns"""
+        # Load base model
+        self.models = {
+            'base': SentenceTransformer(str(self.model_path / "base_model")).to(device),
+            'semantic': SentenceTransformer(str(self.model_path / "semantic_model")).to(device)
+        }
+        
+        # Load zero-shot model
+        with open(self.model_path / "zero_shot_model", 'rb') as f:
+            self.models['zero_shot'] = pickle.load(f)
+        
+        # Load feature patterns
+        with open(self.model_path / "feature_patterns.pkl", 'rb') as f:
+            self.feature_patterns = pickle.load(f)
+    
+        # Initialize embedding cache
+        self.embedding_cache = {}
+
+    def _initialize_models(self):
+        """Initialize new models"""
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.models = {
+            'base': SentenceTransformer('all-MiniLM-L6-v2').to(device),
+            'zero_shot': pipeline("zero-shot-classification", 
+                                model="facebook/bart-large-mnli",
+                                device=0 if torch.cuda.is_available() else -1),
+            'semantic': SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2').to(device)
+        }
+        
+        # Initialize feature patterns
+        self.feature_patterns = self._initialize_feature_patterns()
+        
+        # Initialize embedding cache
+        self.embedding_cache = {}
+
+    def _initialize_feature_patterns(self) -> Dict[str, Dict[str, Any]]:
+        """Initialize feature patterns for different property types"""
+        return {
+            'wifi': {
+                'semantic_patterns': [
+                    "wifi available",
+                    "internet access",
+                    "wireless internet",
+                    "high-speed internet"
+                ],
+                'context_patterns': [
+                    "wifi",
+                    "internet",
+                    "wireless",
+                    "wi-fi"
+                ],
+                'pg': 'wifiAvailable',
+                'commercial': 'wifiAvailable'
+            },
+            'ac': {
+                'semantic_patterns': [
+                    "air conditioning",
+                    "central air",
+                    "climate control",
+                    "cooling system"
+                ],
+                'context_patterns': [
+                    "ac",
+                    "air conditioning",
+                    "central air",
+                    "cooling"
+                ],
+                'pg': 'isACAvailable',
+                'commercial': 'isACAvailable'
+            },
+            'parking': {
+                'semantic_patterns': [
+                    "parking available",
+                    "car parking",
+                    "garage",
+                    "parking space"
+                ],
+                'context_patterns': [
+                    "parking",
+                    "garage",
+                    "car space",
+                    "vehicle parking"
+                ],
+                'pg': 'isParkingAvailable',
+                'commercial': 'hasParking'
+            },
+            'power_backup': {
+                'semantic_patterns': [
+                    "power backup",
+                    "generator",
+                    "backup power",
+                    "uninterrupted power"
+                ],
+                'context_patterns': [
+                    "power backup",
+                    "generator",
+                    "ups",
+                    "inverter"
+                ],
+                'pg': 'powerBackup',
+                'commercial': 'powerBackup'
+            }
+        }
+
+    def _get_embedding(self, text: str) -> torch.Tensor:
+        """Get embedding for text with caching"""
+        if text in self.embedding_cache:
+            return self.embedding_cache[text]
+            
+        embedding = self.models['base'].encode(text, convert_to_tensor=True)
+        self.embedding_cache[text] = embedding
+        return embedding
+
+    def _analyze_negation(self, query: str) -> Tuple[bool, float]:
+        """Analyze if query contains negation"""
+        negation_patterns = [
+            "no", "not", "without", "lack of", "missing",
+            "doesn't have", "don't have", "doesn't need",
+            "don't need", "isn't", "aren't"
+        ]
+        
+        query_lower = query.lower()
+        has_negation = any(pattern in query_lower for pattern in negation_patterns)
+        
+        # Calculate confidence based on negation word position
+        confidence = 0.0
+        if has_negation:
+            words = query_lower.split()
+            for i, word in enumerate(words):
+                if word in negation_patterns:
+                    # Higher confidence if negation is closer to feature words
+                    confidence = max(confidence, 1.0 - (i / len(words)))
+        
+        return has_negation, confidence
+
+    def _analyze_feature_presence(self, query: str, feature: str, patterns: Dict[str, Any]) -> Tuple[bool, float]:
+        """Analyze if a feature is mentioned in the query using multiple methods"""
+        query_lower = query.lower()
+        
+        # 1. Zero-shot classification
+        zero_shot_result = self.models['zero_shot'](
+            query,
+            [f"This property has {feature}", f"This property does not have {feature}"]
+        )
+        
+        # 2. Semantic similarity
+        query_embedding = self._get_embedding(query)
+        pattern_embeddings = [self._get_embedding(p) for p in patterns['semantic_patterns']]
+        similarities = [util.pytorch_cos_sim(query_embedding, p).item() for p in pattern_embeddings]
+        max_similarity = max(similarities) if similarities else 0
+        
+        # 3. Context pattern matching
+        context_match = any(pattern in query_lower for pattern in patterns['context_patterns'])
+        
+        # Combine results with weights
+        presence_score = (
+            0.4 * zero_shot_result['scores'][0] +
+            0.4 * max_similarity +
+            0.2 * (1.0 if context_match else 0.0)
+        )
+        
+        return presence_score > 0.5, presence_score
+
+    def analyze_query(self, query: str) -> Dict[str, bool]:
+        """Analyze query to understand feature requirements"""
+        # Analyze negation
+        has_negation, negation_confidence = self._analyze_negation(query)
+        
+        # Analyze each feature
+        feature_requirements = {}
+        for feature, patterns in self.feature_patterns.items():
+            is_present, confidence = self._analyze_feature_presence(query, feature, patterns)
+            if is_present:
+                feature_requirements[feature] = not has_negation
+        
+        return feature_requirements
+
+    def check_property_features(self, property_data: Dict[str, Any], feature_requirements: Dict[str, bool]) -> bool:
+        """Check if property meets the feature requirements"""
+        property_type = property_data.get('typeName', '').lower()
+        
+        for feature, required in feature_requirements.items():
+            patterns = self.feature_patterns[feature]
+            
+            if 'pg' in property_type or 'hostel' in property_type:
+                pg_details = property_data.get('pgPropertyDetails', {})
+                if pg_details and patterns['pg']:
+                    if pg_details.get(patterns['pg'], False) != required:
+                        return False
+            elif any(t in property_type for t in ['office', 'shop', 'commercial']):
+                commercial_details = property_data.get('commercialPropertyDetails', {})
+                if commercial_details and patterns['commercial']:
+                    if commercial_details.get(patterns['commercial'], False) != required:
+                        return False
+        
+        return True
+
+    def save_models(self):
+        """Save all models and patterns"""
+        try:
+            # Save base model
+            self.models['base'].save(str(self.model_path / "base_model"))
+            
+            # Save semantic model
+            self.models['semantic'].save(str(self.model_path / "semantic_model"))
+            
+            # Save zero-shot model
+            with open(self.model_path / "zero_shot_model", 'wb') as f:
+                pickle.dump(self.models['zero_shot'], f)
+            
+            # Save feature patterns
+            with open(self.model_path / "feature_patterns.pkl", 'wb') as f:
+                pickle.dump(self.feature_patterns, f)
+                
+            logger.info("Successfully saved all models and patterns")
+            
+        except Exception as e:
+            logger.error(f"Error saving models: {str(e)}")
+            raise 

modules/response.py

@@ -0,0 +1,249 @@
+import time
+import logging
+from modules.config import UserPlan, PLAN_FIELDS
+from modules.parallel import ModelParallelizer, parallel_map, batch_process
+import re
+import torch
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor
+from typing import Dict
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Global thread pool for text generation
+text_generation_pool = ThreadPoolExecutor(max_workers=4)
+
+def generate_response(query, tokenizer, model_llm, max_new_tokens=256, temperature=0.7, top_k=30, top_p=0.8, repetition_penalty=1.05):
+    print("\n" + "="*50)
+    print("GENERATE RESPONSE DEBUG")
+    print(f"Input Query: {query}")
+    print("="*50 + "\n")
+
+    print("Generation Parameters:")
+    print(f"- Max New Tokens: {max_new_tokens}")
+    print(f"- Temperature: {temperature}")
+    print(f"- Top-K Sampling: {top_k}")
+    print(f"- Top-P Sampling: {top_p}")
+    print(f"- Repetition Penalty: {repetition_penalty}")
+    print(f"- Sampling Enabled: True (do_sample=True)\n")
+
+    # Format the input text without the assistant prefix
+    input_text = f"""User: {query}
+    Assistant: I am a concise real estate chatbot. I'll provide a clear, direct answer about:
+"""
+    print(f"Formatted Input Text: {input_text}\n")
+    inputs = tokenizer(input_text, return_tensors="pt").to("cuda" if torch.cuda.is_available() else "cpu")
+
+    start_time = time.time()
+
+    try:
+        print("Generating response...")
+        
+        # Use parallel processing for generation
+        def generate_batch(batch_inputs):
+            with torch.no_grad():
+                outputs = model_llm.generate(
+                    batch_inputs.input_ids,
+                    max_new_tokens=max_new_tokens,
+                    temperature=temperature,
+                    top_k=top_k,
+                    top_p=top_p,
+                    repetition_penalty=repetition_penalty,
+                    do_sample=True,
+                    eos_token_id=tokenizer.eos_token_id,
+                    pad_token_id=tokenizer.pad_token_id
+                )
+                return tokenizer.decode(outputs[0], skip_special_tokens=True)
+
+        # Submit generation task to thread pool
+        future = text_generation_pool.submit(generate_batch, inputs)
+        response = future.result()
+        
+        # Clean up the response
+        response = response.replace(input_text, "").strip()
+        
+        # Remove any remaining prefixes or instructions
+        cleanup_patterns = [
+            "USER QUERY:",
+            "PROPERTIES:",
+            "CHATBOT INSTRUCTIONS:",
+            "Assistant:",
+            "I am a concise real estate chatbot.",
+            "I'll provide a clear, direct answer about:"
+        ]
+        
+        for pattern in cleanup_patterns:
+            if pattern in response:
+                response = response.split(pattern)[-1].strip()
+        
+        # Remove any empty lines and normalize spacing
+        response = "\n".join(line.strip() for line in response.split("\n") if line.strip())
+
+        end_time = time.time()
+        duration = end_time - start_time
+
+        print("\nGeneration Results:")
+        print(f"Raw Response: {response}")
+        print(f"Duration: {duration:.2f} seconds\n")
+        print("="*50 + "\n")
+
+        return response, duration
+
+    except Exception as e:
+        logger.error(f"\nERROR in generate_response: {str(e)}")
+        logging.error(f"Error generating response: {e}")
+        return "An error occurred while generating the response.", None
+
+def format_field_name(field_name):
+    """Convert camelCase or PascalCase field names to space-separated words"""
+    formatted = re.sub(r'([A-Z])', r' \1', field_name).strip()
+    formatted = ' '.join(word.capitalize() for word in formatted.split())
+    return formatted
+
+def format_llm_prompt(query, filtered_results, user_plan, original_query):
+    """Format the prompt for LLM with all property details"""
+    try:
+        response_text = (
+            f"USER QUERY: {original_query}\n\n"
+            f"PROPERTIES:\n"
+        )
+
+        # Parallel processing of property formatting
+        def format_property(property_data):
+            property_info = property_data['property']
+            formatted_text = ""
+
+            # Include all property information
+            for key, value in property_info.items():
+                if key not in ["propertyImages", "property_image", "image_url"]:
+                    formatted_key = format_field_name(key)
+                    if key in ["ZipCode", "LeasableSquareFeet", "YearBuilt", "NumberOfRooms",
+                              "ParkingSpaces", "ViewNumber", "Contact", "TotalSquareFeet",
+                              "Beds", "Baths"] and isinstance(value, (int, float)):
+                        value = int(value)
+                    formatted_text += f"{formatted_key}: {value}\n"
+
+            return formatted_text
+
+        # Process properties in parallel
+        property_texts = parallel_map(format_property, filtered_results)
+        for i, text in enumerate(property_texts, 1):
+            response_text += f"\n{i}. {text}"
+
+        response_text += (
+            "\nCHATBOT INSTRUCTIONS:\n"
+            "1. You are a REAL ESTATE CHATBOT. Be direct and conversational.\n"
+            "2. Keep responses CONCISE.\n"
+            "3. Focus ONLY on answering the user's specific question.\n"
+            "4. Use simple formatting: property names in **bold**, separate properties with bullet points.\n"
+            "5. Avoid phrases like 'I found' or 'Based on the information' - just give the facts.\n"
+            "6. Speak in a friendly, helpful tone as if texting a client.\n"
+            "7. Start with a friendly greeting or opening line like 'Here's what I found for you!' or 'Great question!'\n"
+            "8. End with a friendly follow-up question like 'Would you like more details?' or 'Is there a specific property you're interested in?'\n"
+        )
+
+        return response_text, False
+
+    except Exception as e:
+        logging.error(f"Error in format_llm_prompt: {str(e)}")
+        return f"USER QUERY: {original_query}\n\nPROPERTIES:\n\nI apologize, but I encountered an error processing your request. Please try again.", False
+
+def convert_numeric_fields_to_int(property_dict):
+    """Convert numeric fields from float to int for better display"""
+    int_fields = [
+        "ZipCode", "LeasableSquareFeet", "YearBuilt", "NumberOfRooms",
+        "ParkingSpaces", "ViewNumber", "Contact", "TotalSquareFeet",
+        "Beds", "Baths"
+    ]
+
+    # Parallel processing of numeric field conversion
+    def convert_field(field):
+        if field in property_dict and isinstance(property_dict[field], (int, float)):
+            try:
+                return field, int(property_dict[field])
+            except (ValueError, TypeError):
+                return field, property_dict[field]
+        return field, property_dict.get(field)
+
+    converted_fields = parallel_map(convert_field, int_fields)
+    for field, value in converted_fields:
+        property_dict[field] = value
+
+    return property_dict
+
+def filter_property_by_plan(property_dict, plan):
+    """Return all property data without filtering"""
+    try:
+        # Return all property data
+        filtered_property = {
+            **property_dict,
+            'propertyImages': property_dict.get('property_image', []),
+        }
+
+        return filtered_property
+
+    except Exception as e:
+        logging.error(f"Error in filter_property_by_plan: {str(e)}")
+        raise
+
+def format_response(self, response: Dict) -> Dict:
+    """Format the response for frontend display"""
+    print("\n=== Formatting response for frontend ===")
+    try:
+        # Extract only the response text, removing any prompt or debug information
+        response_text = response.get("response", "")
+        
+        # Clean up the response text by removing unwanted prefixes
+        cleanup_patterns = [
+            "USER QUERY:",
+            "PROPERTIES:",
+            "CHATBOT INSTRUCTIONS:",
+            "Assistant:",
+            "I am a concise real estate chatbot.",
+            "I'll provide a clear, direct answer about:"
+        ]
+        
+        # Remove each pattern if it exists
+        for pattern in cleanup_patterns:
+            if pattern in response_text:
+                response_text = response_text.split(pattern)[-1].strip()
+        
+        # Remove any remaining debug information
+        if "DEBUG" in response_text:
+            response_text = response_text.split("DEBUG")[0].strip()
+        
+        # Remove any empty lines and normalize spacing
+        response_text = "\n".join(line.strip() for line in response_text.split("\n") if line.strip())
+        
+        # Format the response
+        formatted = {
+            "response": response_text,
+            "properties": response.get("properties", []),
+            "status": "success"
+        }
+        print(f"Formatted response: {formatted}")
+        return formatted
+    except Exception as e:
+        print(f"Error formatting response: {str(e)}")
+        return {
+            "response": "I apologize, but I encountered an error processing your request.",
+            "properties": [],
+            "status": "error"
+        }
+
+def send_response(self, response: Dict) -> Dict:
+    """Send response to frontend"""
+    print("\n=== Sending response to frontend ===")
+    try:
+        formatted_response = self.format_response(response)
+        print(f"Sending response: {formatted_response}")
+        return formatted_response
+    except Exception as e:
+        print(f"Error sending response: {str(e)}")
+        return {
+            "response": "I apologize, but I encountered an error processing your request.",
+            "properties": [],
+            "status": "error"
+        } 

modules/security.py

@@ -0,0 +1,192 @@
+import time
+import logging
+from collections import defaultdict
+from better_profanity import profanity
+from modules.config import (
+    RATE_LIMIT_WINDOW, 
+    MAX_REQUESTS_PER_WINDOW, 
+    CACHE_TTL,
+    MAX_QUERY_LENGTH,
+    UserPlan,
+    PLAN_FIELDS
+)
+import torch
+import numpy as np
+from sentence_transformers import util
+import re
+import bleach
+import threading
+from functools import wraps
+from transformers import pipeline
+
+# Thread local storage for user plan
+_thread_local = threading.local()
+
+def get_current_plan():
+    """Get the current user plan from thread local storage"""
+    return getattr(_thread_local, 'current_plan', UserPlan.PLUS)
+
+def set_current_plan(plan):
+    """Set the current user plan in thread local storage"""
+    _thread_local.current_plan = plan
+
+def with_user_plan(f):
+    """Decorator to handle user plan from request"""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        try:
+            from flask import request
+            plan = UserPlan.BASIC  # Default to BASIC plan
+            
+            if request.is_json:
+                plan_str = request.json.get('user_plan', 'basic').lower()
+                try:
+                    plan = UserPlan(plan_str)
+                except ValueError:
+                    logging.warning(f"Invalid plan value: {plan_str}, defaulting to BASIC")
+                    plan = UserPlan.BASIC
+            
+            set_current_plan(plan)
+            return f(*args, **kwargs)
+        except Exception as e:
+            logging.error(f"Error in with_user_plan decorator: {str(e)}")
+            set_current_plan(UserPlan.BASIC)  # Ensure BASIC plan is set even on error
+            return f(*args, **kwargs)
+    return decorated_function
+
+class SecurityManager:
+    def __init__(self):
+        self.request_counts = defaultdict(lambda: {'count': 0, 'window_start': 0})
+
+    def check_rate_limit(self, ip_address):
+        current_time = time.time()
+        if current_time - self.request_counts[ip_address]['window_start'] >= RATE_LIMIT_WINDOW:
+            self.request_counts[ip_address] = {'count': 0, 'window_start': current_time}
+
+        self.request_counts[ip_address]['count'] += 1
+        return self.request_counts[ip_address]['count'] <= MAX_REQUESTS_PER_WINDOW
+
+class QueryValidator:
+    def __init__(self, model_embedding):
+        self.model_embedding = model_embedding
+        self.domain_classifier = pipeline(
+            "zero-shot-classification",
+            model="facebook/bart-large-mnli",
+            device=0 if torch.cuda.is_available() else -1
+        )
+        
+        # Real estate related categories
+        self.real_estate_categories = [
+            "property search",
+            "rental property",
+            "property for sale",
+            "PG accommodation",
+            "hostel accommodation",
+            "commercial property",
+            "property details",
+            "property location",
+            "property price",
+            "property features"
+        ]
+        
+        # Initialize with examples
+        self.initialize_with_examples()
+
+    def initialize_with_examples(self):
+        """Initialize with example queries for better classification"""
+        self.real_estate_examples = [
+            "Show me 2BHK apartments in Hyderabad",
+            "Find PG accommodation near Hitech City",
+            "What are the properties for sale in Madhapur?",
+            "Looking for a 3BHK villa in Gachibowli",
+            "Need a girls hostel in Kondapur",
+            "Show me commercial properties for rent",
+            "Find properties near my location",
+            "What's the price of 2BHK in Gachibowli?",
+            "Show me properties with swimming pool",
+            "Find PG with food facility",
+            "Looking for boys hostel in Madhapur",
+            "Show me properties near metro station",
+            "Find properties with 24/7 security",
+            "Need a furnished apartment",
+            "Show me properties with parking"
+        ]
+        
+        self.non_real_estate_examples = [
+            "What's the weather like today?",
+            "Tell me a joke",
+            "What's the time?",
+            "How to make pasta?",
+            "What's the capital of France?",
+            "Show me the latest news",
+            "Play some music",
+            "What's the meaning of life?",
+            "How to fix my computer?",
+            "Tell me about history"
+        ]
+
+    def is_real_estate_query(self, query):
+        """Check if the query is related to real estate using zero-shot classification"""
+        try:
+            # Handle simple responses that are part of a conversation
+            simple_responses = ["yes", "no", "ok", "sure", "fine", "alright"]
+            if query.lower().strip() in simple_responses:
+                # If it's a simple response, check if we're in a real estate context
+                # This could be enhanced by checking conversation history
+                return True
+
+            # First check for common real estate keywords
+            real_estate_keywords = [
+                "property", "house", "apartment", "flat", "villa", "pg", "hostel",
+                "rent", "sale", "buy", "accommodation", "room", "beds", "baths",
+                "bhk", "square feet", "location", "price", "amenities", "facilities"
+            ]
+            
+            query_lower = query.lower()
+            if any(keyword in query_lower for keyword in real_estate_keywords):
+                return True
+
+            # Use zero-shot classification for more complex cases
+            result = self.domain_classifier(
+                query,
+                candidate_labels=["real estate query", "non real estate query"],
+                hypothesis_template="This is a {}."
+            )
+            
+            # Get the confidence score for real estate
+            real_estate_score = result['scores'][0] if result['labels'][0] == "real estate query" else result['scores'][1]
+            
+            # Also check against our example categories
+            category_result = self.domain_classifier(
+                query,
+                candidate_labels=self.real_estate_categories,
+                hypothesis_template="This query is about {}."
+            )
+            
+            # If any category has high confidence, consider it a real estate query
+            max_category_score = max(category_result['scores'])
+            
+            # Consider it a real estate query if either the general classification
+            # or any specific category has high confidence
+            return real_estate_score > 0.6 or max_category_score > 0.7
+
+        except Exception as e:
+            logging.error(f"Error in is_real_estate_query: {str(e)}")
+            # Default to True if there's an error to be safe
+            return True
+
+    def clean_input(self, query):
+        """Clean and validate the input query"""
+        # Remove any special characters and extra spaces
+        cleaned = re.sub(r'[^\w\s]', ' ', query)
+        cleaned = ' '.join(cleaned.split())
+        return cleaned
+
+    def validate_query_length(self, query):
+        """Validate query length"""
+        return len(query) <= MAX_QUERY_LENGTH
+
+    def check_profanity(self, query):
+        """Check for profanity in the query"""
+        # Add profanity checking logic here if needed
+        return True 

requirements.txt

@@ -0,0 +1,43 @@
+# Core Dependencies
+Flask==3.0.0
+python-dotenv==1.0.0
+Werkzeug==3.0.1
+gunicorn==21.2.0
+flask-cors==4.0.0
+flask-limiter==3.5.0
+
+# AI and Machine Learning
+torch==2.2.1
+transformers==4.38.2
+sentence-transformers==2.5.1
+faiss-cpu==1.7.4
+numpy==1.26.4
+pandas==2.2.1
+scikit-learn==1.3.1
+
+# Audio Processing
+webrtcvad==2.0.10
+SpeechRecognition==3.10.0
+pydub==0.25.1
+happytransformer==2.4.1
+
+# Location and Geocoding
+geopy==2.4.1
+geocoder==1.38.1
+
+# Security and Rate Limiting
+better-profanity==0.7.0
+bleach==6.0.0
+
+# Utilities
+python-dateutil==2.8.2
+requests==2.31.0
+tqdm==4.66.1
+
+# NLP and Text Processing
+spacy==3.7.4
+en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.7.1/en_core_web_sm-3.7.1-py3-none-any.whl
+
+# Additional Dependencies
+python-Levenshtein==0.23.0
+fuzzywuzzy==0.18.0 

templates/index.html

@@ -0,0 +1,1824 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>HIVE PROP</title>
+    <link href="https://fonts.googleapis.com/css2?family=Poppins:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.0.0/css/all.min.css" rel="stylesheet">
+    <style>
+    /* Root Variables */
+    :root {
+        --primary-color: #31511E;
+        --secondary-color: #F6FCDF;
+        --accent-color: #859F3D;
+        --text-primary: rgb(26, 26, 25);
+        --text-secondary: rgb(49, 81, 30);
+        --border-radius: 20px;
+        --box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+        --transition: all 0.3s ease;
+        --chat-bg: #F6FCDF;
+        --bubble-user: #ffffff;
+        --bubble-bot: #31511E;
+    }
+
+    /* Property Search Styles */
+    body {
+        font-family: 'Poppins', sans-serif;
+        background-color: #F6FCDF;
+        margin: 0;
+        padding: 20px;
+        color: var(--text-primary);
+    }
+
+    h1 {
+        text-align: center;
+        color: var(--primary-color);
+        margin-bottom: 40px;
+        font-size: 3rem;
+        font-weight: 700;
+        text-transform: uppercase;
+        letter-spacing: 2px;
+        position: relative;
+        animation: fadeIn 1s ease-in-out;
+    }
+
+    h1::after {
+        content: '';
+        position: absolute;
+        bottom: -10px;
+        left: 50%;
+        transform: translateX(-50%);
+        width: 100px;
+        height: 4px;
+        background: var(--primary-color);
+        border-radius: 2px;
+    }
+
+    @keyframes fadeIn {
+        from {
+            opacity: 0;
+            transform: translateY(-20px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+
+    /* Property Search Components */
+    .search-container {
+        display: flex;
+        justify-content: center;
+        gap: 20px;
+        margin-bottom: 40px;
+    }
+
+    #queryForm {
+        display: flex;
+        gap: 20px;
+        align-items: center;
+    }
+
+    #userQuery {
+        width: 400px;
+        padding: 15px 25px;
+        border: 2px solid #E1E8ED;
+        border-radius: var(--border-radius);
+        font-size: 1.1rem;
+        transition: var(--transition);
+        background: white;
+        box-shadow: var(--box-shadow);
+    }
+
+    /* Property Card Styles */
+    .property {
+        display: flex;
+        flex-direction: row;
+        background: white;
+        border-radius: 30px;
+        box-shadow: var(--box-shadow);
+        margin-bottom: 30px;
+        overflow: hidden;
+        width: 90%;
+        margin-left: auto;
+        margin-right: auto;
+        transition: var(--transition);
+        gap: 20px;
+        padding: 20px;
+        animation: slideUp 0.5s ease-out;
+        position: relative;
+    }
+
+    @keyframes slideUp {
+        from {
+            opacity: 0;
+            transform: translateY(20px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+
+    .image-container {
+        flex: 2;
+        position: relative;
+        overflow: hidden;
+        border-radius: 20px;
+        box-shadow: var(--box-shadow);
+    }
+
+    .carousel {
+        width: 100%;
+        height: 100%;
+    }
+
+    .carousel-images {
+        display: flex;
+        transition: transform 0.5s ease-in-out;
+        height: 100%;
+    }
+
+    .carousel-image {
+        width: 100%;
+        height: 100%;
+        object-fit: cover;
+        flex-shrink: 0;
+        border-radius: 20px;
+    }
+
+    .property-details {
+        flex: 3;
+        display: flex;
+        flex-direction: column;
+    }
+
+    /* Accordion Styles */
+    .accordion-section {
+        border-bottom: 1px solid #E1E8ED;
+    }
+
+    .accordion-header {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 15px 0;
+        cursor: pointer;
+        border-bottom: 1px solid #E1E8ED;
+        transition: var(--transition);
+    }
+
+    .accordion-header:hover {
+        background-color: var(--secondary-color);
+        border-radius: 10px;
+    }
+
+    .accordion-content {
+        display: none;
+        padding: 15px 0;
+        color: var(--text-secondary);
+        line-height: 1.6;
+    }
+
+    /* Add active class for accordion */
+    .accordion-header.active + .accordion-content {
+        display: block; /* Show content when active */
+    }
+
+    /* Loading Spinner */
+    .loading-spinner {
+        border: 4px solid rgba(74, 144, 226, 0.1);
+        border-left-color: var(--primary-color);
+        border-radius: 50%;
+        width: 40px;
+        height: 40px;
+        animation: spin 1s linear infinite;
+        margin: 40px auto;
+    }
+
+    .loading-message {
+        width: 40px;
+        height: 40px;
+        margin: auto auto;
+    }
+
+    @keyframes spin {
+        0% { transform: rotate(0deg); }
+        100% { transform: rotate(360deg); }
+    }
+
+    .error-message {
+        color: #DC3545;
+        text-align: center;
+        font-weight: 500;
+        margin-top: 20px;
+    }
+
+    @media (max-width: 1024px) {
+        .property {
+            flex-direction: column;
+            width: 95%;
+        }
+
+        .image-container {
+            width: 100%;
+            height: 300px;
+        }
+
+        #userQuery {
+            width: 300px;
+        }
+    }
+
+    @media (max-width: 768px) {
+        .search-container {
+            flex-direction: column;
+            align-items: center;
+        }
+
+        #queryForm {
+            flex-direction: column;
+            width: 100%;
+            max-width: 400px;
+        }
+
+        #userQuery {
+            width: 100%;
+        }
+
+        button {
+            width: 100%;
+        }
+    }
+
+    #userQuery:focus {
+        outline: none;
+        border-color: var(--primary-color);
+        box-shadow: 0 0 0 3px rgba(74, 144, 226, 0.2);
+    }
+
+    #userQuery::placeholder {
+        color: #A4A4A4;
+        font-weight: 300;
+    }
+
+    .property:hover {
+        transform: translateY(-5px);
+        box-shadow: 0 8px 15px rgba(0, 0, 0, 0.1);
+    }
+
+    .carousel-nav {
+        position: absolute;
+        bottom: 20px;
+        left: 50%;
+        transform: translateX(-50%);
+        display: flex;
+        gap: 10px;
+    }
+
+    .carousel-dot {
+        width: 10px;
+        height: 10px;
+        border-radius: 50%;
+        background: rgba(255, 255, 255, 0.5);
+        cursor: pointer;
+        transition: var(--transition);
+    }
+
+    .carousel-dot.active {
+        background: white;
+    }
+
+    .property-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+    }
+
+    .property-header h2 {
+        font-size: 1.8rem;
+        font-weight: 700;
+        color: var(--text-primary);
+        margin: 0 0 10px 0;
+    }
+
+    .property-type {
+        display: inline-block;
+        padding: 8px 16px;
+        background-color: var(--accent-color);
+        color: white;
+        border-radius: 20px;
+        font-size: 0.9rem;
+        font-weight: 500;
+    }
+
+    .property-info {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(100px, 1fr));
+        gap: 20px;
+        padding: 20px 0;
+        border-top: 1px solid #E1E8ED;
+        border-bottom: 1px solid #E1E8ED;
+        max-height: 300px; /* Set a max height for scrolling */
+        overflow-y: auto; /* Enable vertical scrolling */
+        scrollbar-width: thin; /* For Firefox */
+        scrollbar-color: var(--primary-color) var(--secondary-color); /* For Firefox */
+    }
+
+    .property-info::-webkit-scrollbar {
+        width: 8px; /* Width of the scrollbar */
+    }
+
+    .property-info::-webkit-scrollbar-track {
+        background: var(--secondary-color); /* Color of the scrollbar track */
+        border-radius: 10px;
+    }
+
+    .property-info::-webkit-scrollbar-thumb {
+        background: var(--primary-color); /* Color of the scrollbar thumb */
+        border-radius: 10px;
+    }
+
+    .property-info::-webkit-scrollbar-thumb:hover {
+        background: var(--accent-color); /* Color of the scrollbar thumb on hover */
+    }
+
+    .description {
+        margin: 10px 0;
+        line-height: 1.6;
+        color: var(--text-secondary);
+    }
+
+    .key-features {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        margin: 10px 0;
+        align-items: center;
+    }
+
+    .feature-pill {
+        background-color: var(--secondary-color);
+        padding: 2px 10px;
+        border-radius: 10px;
+        font-size: 0.9rem;
+        color: var(--text-primary);
+        font-weight: 500;
+        transition: var(--transition);
+        border: 2px solid var(--primary-color); /* Added border */
+    }
+
+    .feature-pill:hover {
+        background-color: var(--primary-color);
+        color: white;
+        transform: translateY(-2px);
+    }
+
+    .amenities-card {
+        background-color: var(--secondary-color);
+        border-radius: var(--border-radius);
+        padding: 20px;
+        margin: 10px 0;
+    }
+
+    .amenities-pills {
+        display: flex;
+        flex-wrap: wrap;
+        gap: 10px;
+        margin-top: 10px;
+    }
+
+    .amenity-pill {
+        background-color: var(--secondary-color);
+        padding: 2px 10px;
+        border-radius: 10px;
+        font-size: 0.9rem;
+        color: var(--text-primary);
+        font-weight: 500;
+        transition: var(--transition);
+        border: 2px solid var(--primary-color); /* Added border */
+    }
+
+    .amenity-pill:hover {
+        background-color: var(--primary-color);
+        color: white;
+        transform: translateY(-2px);
+    }
+
+    .construction-status {
+        display: flex;
+        justify-content: space-between;
+        padding-top: 20px;
+        color: var(--text-secondary);
+    }
+
+    .accordion {
+        background-color: var(--secondary-color);
+        border-radius: var(--border-radius);
+        box-shadow: var(--box-shadow);
+        margin-bottom: 20px;
+        overflow: hidden;
+    }
+
+    .accordion-header:hover {
+    }
+
+    .accordion-header .arrow {
+        transition: transform 0.3s ease;
+    }
+
+    .accordion-header.active .arrow {
+        transform: rotate(90deg);
+    }
+
+    .accordion-header strong {
+        font-size: 1.1rem;
+        color: var(--text-primary);
+        display: flex;
+        align-items: center;
+        gap: 10px;
+    }
+
+    .accordion-arrow {
+        transition: transform 0.3s ease;
+        font-size: 0.9rem;
+        color: var(--primary-color);
+    }
+
+    .accordion-arrow.active {
+        transform: rotate(180deg);
+    }
+
+    .accordion-section:last-child {
+        border-bottom: none;
+    }
+
+    .accordion-header.active + .accordion-content {
+        display: block; /* Show content when active */
+    }
+
+    .favorite-button {
+        position: absolute;
+        top: 10px;
+        right: 10px;
+        background: none;
+        border: none;
+        color: white;
+        cursor: pointer;
+        padding: 10px;
+        border-radius: 50px;
+        display: flex;
+        background-color: var(--primary-color);
+    }
+
+    .favorite-button.active {
+        color: var(--primary-color);
+        background-color: var(--accent-color);
+        border: 2px solid var(--primary-color);
+    }
+
+    /* Chat Assistant Styles */
+    .chatbot-container {
+        position: fixed;
+        bottom: 2rem;
+        left: 0;
+        right: 0;
+        display: flex;
+        justify-content: space-between;
+        padding: 0 2rem;
+        z-index: 1000;
+    }
+
+    .chatbot-icon {
+        width: 3.5rem;
+        height: 3.5rem;
+        background: var(--primary-color);
+        border-radius: 50%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        cursor: pointer;
+        box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+        transition: transform 0.3s ease, box-shadow 0.3s ease;
+    }
+
+    .chatbot-icon:hover {
+        transform: scale(1.1);
+        box-shadow: 0 6px 16px rgba(0, 0, 0, 0.2);
+    }
+
+    .chatbot-icon i {
+        color: white;
+        font-size: 1.5rem;
+    }
+
+    .chat-container {
+        position: fixed;
+        bottom: 6rem;
+        width: 450px;
+        height: 35rem;
+        background: var(--chat-bg);
+        border-radius: 1rem;
+        box-shadow: 0 4px 20px rgba(0, 0, 0, 0.1);
+        display: none;
+        flex-direction: column;
+        overflow: hidden;
+        z-index: 999;
+        animation: slideUp 0.3s ease-out;
+        border: 1px solid var(--primary-color); /* Added border */
+    }
+
+    .chat-header {
+        background: var(--primary-color);
+        color: white;
+        padding: 1rem;
+        display: flex;
+        align-items: center;
+        gap: 0.5rem;
+        position: relative;
+        border-top-left-radius: 1rem;
+        border-top-right-radius: 1rem;
+    }
+
+    .chat-header img {
+        width: 2rem;
+        height: 2rem;
+        border-radius: 50%;
+    }
+
+    .chat-header .close-button {
+        position: absolute;
+        right: 1rem;
+        background: none;
+        border: none;
+        font-size: 1.5rem;
+        color: white;
+        cursor: pointer;
+    }
+
+    /* Custom Scrollbar for Chatbot */
+    .chat-body::-webkit-scrollbar {
+        width: 12px; /* Width of the scrollbar */
+    }
+
+    .chat-body::-webkit-scrollbar-track {
+        background: var(--secondary-color); /* Color of the scrollbar track */
+        border-radius: 20px; /* Rounded corners for the track */
+        border: 2px solid var(--primary-color); /* Border around the track */
+    }
+
+    .chat-body::-webkit-scrollbar-thumb {
+        background: var(--primary-color); /* Color of the scrollbar thumb */
+        border-radius: 50%; /* Rounded corners for the thumb */
+        border: 2px solid var(--secondary-color); /* Border around the thumb */
+    }
+
+    .chat-body::-webkit-scrollbar-thumb:hover {
+        background: var(--accent-color); /* Color of the scrollbar thumb on hover */
+    }
+
+    /* For Firefox */
+    .chat-body {
+        scrollbar-width: thin; /* Width of the scrollbar */
+        scrollbar-color: var(--primary-color) var(--secondary-color); /* Color of the scrollbar thumb and track */
+        flex: 1;
+        padding: 1rem;
+        overflow-y: auto;
+        background: var(--background-color); /* Color of the scrollbar thumb and track */
+    }
+
+    .message {
+        display: flex;
+        flex-direction: column;
+        margin-bottom: 1rem;
+    }
+
+    .message-content {
+        max-width: 80%;
+        padding: 0.75rem 1rem;
+        border-radius: 1rem;
+        position: relative;
+        animation: messageAppear 0.3s ease-out;
+    }
+
+    @keyframes messageAppear {
+        from {
+            opacity: 0;
+            transform: translateY(10px);
+        }
+        to {
+            opacity: 1;
+            transform: translateY(0);
+        }
+    }
+
+    .user-message {
+        align-items: flex-end;
+    }
+
+    .bot-message {
+        align-items: flex-start;
+    }
+
+    .user-message .message-content {
+        background: var(--bubble-user);
+        color: var(--text-color);
+        border-bottom-right-radius: 0.25rem;
+    }
+
+    .bot-message .message-content {
+        background: var(--bubble-bot);
+        color: white;
+        border-bottom-left-radius: 0.25rem;
+    }
+
+    .typing-indicator {
+        display: none;
+        padding: 0.75rem 1rem;
+        background: var(--bubble-bot);
+        color: white;
+        border-radius: 1rem;
+        border-bottom-left-radius: 0.25rem;
+        margin-bottom: 1rem;
+        width: fit-content;
+    }
+
+    .typing-dot {
+        display: inline-block;
+        width: 0.5rem;
+        height: 0.5rem;
+        margin: 0 0.1rem;
+        background: white;
+        border-radius: 50%;
+        animation: typing 1.4s infinite ease-in-out;
+    }
+
+    .typing-dot:nth-child(1) { animation-delay: 200ms; }
+    .typing-dot:nth-child(2) { animation-delay: 300ms; }
+    .typing-dot:nth-child(3) { animation-delay: 400ms; }
+
+    @keyframes typing {
+        0%, 60%, 100% { transform: translateY(0); }
+        30% { transform: translateY(-6px); }
+    }
+
+    .chat-footer {
+        padding: 1rem;
+        background: var(--chat-bg);
+        border-top: 1px solid rgba(0, 0, 0, 0.1);
+    }
+
+    .input-group {
+        display: flex;
+        gap: 0.5rem;
+        align-items: center;
+    }
+
+    .chat-input {
+        flex: 1;
+        padding: 0.75rem 1rem;
+        border: 1px solid rgba(0, 0, 0, 0.1);
+        border-radius: 1.5rem;
+        outline: none;
+        font-size: 0.95rem;
+        transition: border-color 0.3s ease;
+    }
+
+    .chat-input:focus {
+        border-color: var(--primary-color);
+    }
+
+    .send-chatbutton {
+        background: var(--bubble-bot);
+        color: white;
+        border: 2px solid var(--primary-color); /* Added border */
+        width: 2.5rem;
+        height: 2.5rem;
+        border-radius: 50%;
+        cursor: pointer;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        transition: background-color 0.3s ease;
+        border-radius: 20px;
+    }
+
+    .send-chatbutton:hover {
+        background: var(--accent-color);
+    }
+
+    .timestamp {
+        font-size: 0.75rem;
+        color: #64748b;
+        margin-top: 0.25rem;
+    }
+
+    .property-card {
+        background: #f8fafc;
+        border-radius: 0.5rem;
+        padding: 1rem;
+        margin: 0.5rem 0;
+        border-left: 4px solid var(--primary-color);
+        box-shadow: var(--box-shadow);
+    }
+
+    .property-name {
+        font-weight: bold;
+        color: var(--primary-color);
+        margin-bottom: 0.5rem;
+    }
+
+    button {
+        padding: 15px 30px;
+        background-color: var(--primary-color);
+        color: white;
+        border: none;
+        border-radius: var(--border-radius);
+        font-size: 1.1rem;
+        font-weight: 600;
+        cursor: pointer;
+        transition: var(--transition);
+        font-family: 'Poppins', sans-serif;
+        box-shadow: var(--box-shadow);
+    }
+
+    button:hover {
+        background-color: #859F3D;
+        transform: translateY(-2px);
+        box-shadow: var(--box-shadow);
+    }
+
+    .quick-keywords::-webkit-scrollbar {
+        display: none;
+    }
+
+    .quick-keyword {
+        flex: 0 0 auto; /* Prevent buttons from shrinking */
+        padding: 10px 15px;
+        border-radius: 50px;
+        border: none;
+        color: white;
+        cursor: pointer;
+        white-space: nowrap;
+    }
+
+    .plan-selector-container {
+        display: flex;
+        justify-content: center;
+        margin-bottom: 20px;
+    }
+
+    .plan-selector {
+        padding: 10px 20px;
+        border: 2px solid var(--primary-color);
+        border-radius: var(--border-radius);
+        background-color: white;
+        color: var(--text-primary);
+        font-family: 'Poppins', sans-serif;
+        font-size: 1rem;
+        cursor: pointer;
+        transition: var(--transition);
+        width: 200px;
+        text-align: center;
+    }
+
+    .plan-selector:hover {
+        border-color: var(--accent-color);
+    }
+
+    .plan-selector:focus {
+        outline: none;
+        border-color: var(--primary-color);
+        box-shadow: 0 0 0 3px rgba(74, 144, 226, 0.2);
+    }
+</style>
+</head>
+<body>
+    <h1>HIVE PROP</h1>
+
+    <!-- Property Search Section -->
+    <div class="search-container">
+        <form id="queryForm">
+            <input type="text" id="userQuery" placeholder="Search for your dream property..." required>
+            <button type="button" id="microphoneButton">
+                <i class="fas fa-microphone"></i>
+            </button>
+            <button type="submit">Search Properties</button>
+        </form>
+    </div>
+    <div class="plan-selector-container">
+        <select id="planSelector" class="plan-selector">
+            <option value="basic" selected>Basic Plan</option>
+            <option value="plus">Plus Plan</option>
+            <option value="pro">Pro Plan</option>
+        </select>
+    </div>
+    <div id="results"></div>
+    <div id="errorMessage" class="error-message"></div>
+    <div id="loadingMessage" style="display: none;">
+        <div class="loading-spinner"></div>
+        <!--<div class="loading-message">Loading...</div>-->
+    </div>
+    <div id="listeningMessage" style="display: none;">
+        <div class="loading-spinner"></div>
+        <div class="loading-message">Listening...</div>
+    </div>
+
+    <!-- Chat Assistant and Recommendations Container -->
+    <div class="chatbot-container">
+        <!-- Chat Assistant Icon -->
+        <div class="chatbot-icon" id="chatbot-icon" style="background-color: #31511E;">
+            <i class="fas fa-comment"></i>
+        </div>
+
+        <!-- Recommendations Icon -->
+        <div class="chatbot-icon" id="recommend-icon" style="background-color: #859F3D;">
+            <i class="fas fa-search"></i>
+        </div>
+    </div>
+
+    <!-- Chat Assistant Container -->
+    <div class="chat-container" id="chat-container" style="left: 2rem;">
+        <div class="chat-header">
+            <img src="/api/placeholder/32/32" alt="Bot Avatar">
+            <span>Hive Prop Chat Bot</span>
+            <button class="close-button">
+                <i class="fas fa-times"></i>
+            </button>
+        </div>
+
+        <div class="chat-body" id="chat-body">
+            <div class="message bot-message">
+                <div class="message-content">
+                    Hello! I'm your real estate recommendation assistant. How can I help you today? Please reply with 'hi' to access your location.
+                </div>
+                <div class="timestamp">Now</div>
+            </div>
+            <div class="typing-indicator" id="typing-indicator">
+                <div class="typing-dot"></div>
+                <div class="typing-dot"></div>
+                <div class="typing-dot"></div>
+            </div>
+        </div>
+
+        <div class="chat-footer">
+            <div class="input-group">
+                <input type="text" class="chat-input" id="user-input" placeholder="Type your message..." required>
+                <button class="send-chatbutton" id="send-button">
+                    <i class="fas fa-paper-plane"></i>
+                </button>
+                <button type="button" style="padding: 10px 15px;border-radius: 100px;" id="chatMicrophoneButton">
+                    <i class="fas fa-microphone"></i>
+                </button>
+            </div>
+            <div class="quick-keywords">
+                <button class="quick-keyword" data-message="Show me nearby properties">Nearby Properties</button>
+                <button class="quick-keyword" data-message="Find luxury homes">Luxury Homes</button>
+                <button class="quick-keyword" data-message="Affordable apartments">Affordable Apartments</button>
+                <button class="quick-keyword" data-message="Properties with pools">Properties with Pools</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Recommendations Container -->
+    <div class="chat-container" id="recommend-container" style="right: 2rem;">
+        <div class="chat-header">
+            <img src="/content/sample_data/hive_prop.jpg" alt="Bot Avatar">
+            <span>Hive Prop Chatbot</span>
+            <button class="close-button">
+                <i class="fas fa-times"></i>
+            </button>
+        </div>
+
+        <div class="chat-body" id="recommend-body">
+            <div class="message bot-message">
+                <div class="message-content">
+                    Hello! I'm your real estate recommendation assistant. How can I help you today? Please reply with 'hi' to access your location.
+                </div>
+                <div class="timestamp">Now</div>
+            </div>
+            <div class="typing-indicator" id="recommend-typing-indicator">
+                <div class="typing-dot"></div>
+                <div class="typing-dot"></div>
+                <div class="typing-dot"></div>
+            </div>
+        </div>
+
+        <div class="chat-footer">
+            <div class="input-group">
+                <input type="text" class="chat-input" id="recommend-input" placeholder="Type your message..." required>
+                <button class="send-chatbutton" id="recommend-send-button">
+                    <i class="fas fa-paper-plane"></i>
+                </button>
+                <button type="button" style="padding: 10px 15px;border-radius: 100px;" id="recommendMicrophoneButton">
+                    <i class="fas fa-microphone"></i>
+                </button>
+            </div>
+            <div class="quick-keywords" style="
+            border-radius:50px;
+            display: flex;
+            flex-direction: row;
+            overflow-x: auto;
+            white-space: nowrap;
+            gap: 10px;
+            padding: 10px;
+            scrollbar-width: none; /* Hide scrollbar for Firefox */
+            -ms-overflow-style: none; /* Hide scrollbar for IE/Edge */
+            position: relative;
+            background: white;
+            box-shadow: inset 20px 0 20px -10px rgba(0, 0, 0, 0.5), inset -20px 0 20px -10px rgba(0, 0, 0, 0.5);
+        ">
+                <button class="quick-keyword" data-message="Show me nearby properties">Nearby Properties</button>
+                <button class="quick-keyword" data-message="Find luxury homes">Luxury Homes</button>
+                <button class="quick-keyword" data-message="Affordable apartments">Affordable Apartments</button>
+                <button class="quick-keyword" data-message="Properties with pools">Properties with Pools</button>
+                <button class="quick-keyword" data-message="Pet-friendly rentals">Pet-friendly Rentals</button>
+                <button class="quick-keyword" data-message="Beachfront properties">Beachfront Properties</button>
+            </div>
+        </div>
+    </div>
+
+<script>
+    // Property Search Scripts
+    $(document).ready(function() {
+        $('#queryForm').on('submit', function(event) {
+            event.preventDefault();
+            const query = $('#userQuery').val();
+            $('#results').empty();
+            $('#errorMessage').empty();
+            $('#loadingMessage').show();
+
+            $.ajax({
+                url: '/search',
+                type: 'POST',
+                contentType: 'application/json',
+                data: JSON.stringify({ 
+                    query: query,
+                    user_plan: plan 
+                }),
+                success: function(data) {
+                    $('#loadingMessage').hide();
+                    if (data.error) {
+                        $('#errorMessage').text('Error: ' + data.error);
+                    } else {
+                        displayProperties(data, plan);
+                    }
+                },
+                error: function() {
+                    $('#loadingMessage').hide();
+                    $('#errorMessage').text('Error: Unable to fetch data. Please try again later.');
+                }
+            });
+        });
+
+        $('#queryForm').on('submit', function() {
+            $('html, body').animate({
+                scrollTop: $('#results').offset().top - 20
+            }, 1000);
+        });
+
+        $('#userQuery').on('focus', function() {
+            $(this).parent().addClass('focused');
+        }).on('blur', function() {
+            $(this).parent().removeClass('focused');
+        });
+
+        $(window).on('resize', function() {
+            if ($(window).width() <= 768) {
+                $('.property').addClass('mobile-view');
+            } else {
+                $('.property').removeClass('mobile-view');
+            }
+        });
+
+        $('[data-tooltip]').each(function() {
+            $(this).tooltip({
+                placement: 'top',
+                title: $(this).data('tooltip')
+            });
+        });
+
+        if ('IntersectionObserver' in window) {
+            const imageObserver = new IntersectionObserver((entries, observer) => {
+                entries.forEach(entry => {
+                    if (entry.isIntersecting) {
+                        const img = entry.target;
+                        img.src = img.dataset.src;
+                        img.removeAttribute('data-src');
+                        observer.unobserve(img);
+                    }
+                });
+            });
+
+            document.querySelectorAll('img[data-src]').forEach(img => {
+                imageObserver.observe(img);
+            });
+        }
+
+        const microphoneButton = document.getElementById("microphoneButton");
+        const recognizer = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
+        recognizer.lang = 'en-US';
+        recognizer.continuous = true;
+        recognizer.interimResults = true;
+
+        let silenceTimer = null;
+        const SILENCE_DURATION = 3000;
+
+        microphoneButton.addEventListener("click", () => {
+            microphoneButton.classList.add('listening');
+            $('#listeningMessage').show();
+            recognizer.start();
+            console.log("Listening...");
+        });
+
+        recognizer.onresult = function(event) {
+            clearTimeout(silenceTimer);
+            
+            let finalTranscript = '';
+            for (let i = event.resultIndex; i < event.results.length; i++) {
+                if (event.results[i].isFinal) {
+                    finalTranscript += event.results[i][0].transcript;
+                }
+            }
+
+            if (finalTranscript) {
+                $('#userQuery').val(finalTranscript);
+                console.log("Transcript: ", finalTranscript);
+            }
+
+            silenceTimer = setTimeout(() => {
+                recognizer.stop();
+                console.log("Stopped listening due to silence");
+            }, SILENCE_DURATION);
+        };
+
+        recognizer.onend = function() {
+            console.log("Speech recognition service disconnected");
+            $('#listeningMessage').hide();
+            microphoneButton.classList.remove('listening');
+            clearTimeout(silenceTimer);
+            
+            if ($('#userQuery').val().trim()) {
+                $('#queryForm').submit();
+            }
+        };
+
+        recognizer.onerror = function(event) {
+            console.error("Speech recognition error", event.error);
+            $('#listeningMessage').hide();
+            microphoneButton.classList.remove('listening');
+            clearTimeout(silenceTimer);
+        };
+
+        document.getElementById("chatbot-icon").addEventListener("click", function() {
+            const chatContainer = document.getElementById("chat-container");
+            chatContainer.style.display = chatContainer.style.display === "none" || chatContainer.style.display === "" ? "flex" : "none";
+        });
+
+        const chatBody = document.getElementById("chat-body");
+        const userInput = document.getElementById("user-input");
+        const sendButton = document.getElementById("send-button");
+        const typingIndicator = document.getElementById("typing-indicator");
+
+        function addMessage(content, isUser = false) {
+            const messageDiv = document.createElement("div");
+            messageDiv.className = `message ${isUser ? "user-message" : "bot-message"}`;
+
+            const messageContent = document.createElement("div");
+            messageContent.className = "message-content";
+            messageContent.innerHTML = formatMessageContent(content);
+
+            const timestamp = document.createElement("div");
+            timestamp.className = "timestamp";
+            timestamp.textContent = new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+
+            messageDiv.appendChild(messageContent);
+            messageDiv.appendChild(timestamp);
+
+            chatBody.insertBefore(messageDiv, typingIndicator);
+            chatBody.scrollTop = chatBody.scrollHeight;
+        }
+
+        function handleUserInput() {
+            const message = userInput.value.trim().toLowerCase();
+            if (!message) return;
+
+            addMessage(message, true);
+            userInput.value = "";
+            typingIndicator.style.display = "block";
+
+            if (message === 'hi') {
+                if (navigator.geolocation) {
+                    navigator.geolocation.getCurrentPosition(function(position) {
+                        const latitude = position.coords.latitude;
+                        const longitude = position.coords.longitude;
+                        console.log("User Location:", latitude, longitude);
+
+                        // First set the location
+                        const locationData = {
+                            latitude: latitude,
+                            longitude: longitude,
+                            session_id: 'chat-session',
+                            user_plan: plan
+                        };
+
+                        fetch("/set-location", {
+                            method: "POST",
+                            headers: {
+                                "Content-Type": "application/json",
+                            },
+                            body: JSON.stringify(locationData)
+                        })
+                        .then(response => response.json())
+                        .then(data => {
+                            console.log("Location set:", data);
+                            if (data.error) {
+                                addMessage("Error setting location: " + data.error);
+                            } else {
+                                const city = data.city || 'Unknown city';
+                                const state = data.state || 'Unknown state';
+                                const country = data.country || 'Unknown country';
+                                addMessage(`Location set successfully in ${city}, ${state}, ${country}. Would you like to see nearby properties? Please reply with 'yes' or 'no'.`);
+                            }
+                            typingIndicator.style.display = "none";
+                        })
+                        .catch(error => {
+                            console.error("Error setting location:", error);
+                            addMessage("Unable to access your location. Please try again.");
+                            typingIndicator.style.display = "none";
+                        });
+                    }, function(error) {
+                        console.error("Error getting user location:", error);
+                        addMessage("Unable to access your location. Please try again.");
+                        typingIndicator.style.display = "none";
+                    });
+                } else {
+                    console.error("Geolocation is not supported by this browser.");
+                    addMessage("Geolocation is not supported by your browser.");
+                    typingIndicator.style.display = "none";
+                }
+            } else {
+                // Handle other messages with plan
+                const fetchOptions = {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ 
+                        query: message, 
+                        session_id: 'chat-session',
+                        user_plan: plan 
+                    })
+                };
+
+                const endpoint = message === 'yes' ? '/recommend' : '/generate';
+                
+                fetch(endpoint, fetchOptions)
+                .then(response => response.json())
+                .then(data => {
+                    if (message === 'yes' && data.properties) {
+                        let propertiesMessage = "Here are the 5 nearest properties to your location:\n";
+                        data.properties.forEach(property => {
+                            propertiesMessage += `**${property.PropertyName}** at ${property.Address}, ${property.City}\n`;
+                            propertiesMessage += `  Type: ${property.PropertyType}\n`;
+                            propertiesMessage += `  (Distance: ${property.Distance} miles)\n\n`;
+                        });
+                        addMessage(propertiesMessage);
+                    } else {
+                        addMessage(data.response);
+                    }
+                    typingIndicator.style.display = "none";
+                })
+                .catch(error => {
+                    console.error("Error:", error);
+                    addMessage("I apologize, but I encountered an error. Please try again.");
+                    typingIndicator.style.display = "none";
+                });
+            }
+        }
+
+        sendButton.addEventListener("click", handleUserInput);
+        userInput.addEventListener("keypress", function(event) {
+            if (event.key === "Enter") {
+                handleUserInput();
+            }
+        });
+
+        const chatMicrophoneButton = document.getElementById("chatMicrophoneButton");
+        const chatRecognizer = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
+        chatRecognizer.lang = 'en-US';
+        chatRecognizer.continuous = true;
+        chatRecognizer.interimResults = true;
+
+        let chatSilenceTimer = null;
+
+        chatMicrophoneButton.addEventListener("click", () => {
+            chatMicrophoneButton.classList.add('listening');
+            $('#listeningMessage').show();
+            chatRecognizer.start();
+            console.log("Chat listening...");
+        });
+
+        chatRecognizer.onresult = function(event) {
+            clearTimeout(chatSilenceTimer);
+            
+            let finalTranscript = '';
+            for (let i = event.resultIndex; i < event.results.length; i++) {
+                if (event.results[i].isFinal) {
+                    finalTranscript += event.results[i][0].transcript;
+                }
+            }
+
+            if (finalTranscript) {
+                userInput.value = finalTranscript;
+                console.log("Chat Transcript: ", finalTranscript);
+            }
+
+            chatSilenceTimer = setTimeout(() => {
+                chatRecognizer.stop();
+                console.log("Stopped chat listening due to silence");
+            }, SILENCE_DURATION);
+        };
+
+        chatRecognizer.onend = function() {
+            console.log("Chat speech recognition service disconnected");
+            $('#listeningMessage').hide();
+            chatMicrophoneButton.classList.remove('listening');
+            clearTimeout(chatSilenceTimer);
+            
+            if (userInput.value.trim()) {
+                handleUserInput();
+            }
+        };
+
+        chatRecognizer.onerror = function(event) {
+            console.error("Chat speech recognition error", event.error);
+            $('#listeningMessage').hide();
+            chatMicrophoneButton.classList.remove('listening');
+            clearTimeout(chatSilenceTimer);
+        };
+
+        document.getElementById("recommend-icon").addEventListener("click", function() {
+            const recommendContainer = document.getElementById("recommend-container");
+            recommendContainer.style.display = recommendContainer.style.display === "none" || recommendContainer.style.display === "" ? "flex" : "none";
+        });
+
+        const recommendBody = document.getElementById("recommend-body");
+        const recommendInput = document.getElementById("recommend-input");
+        const recommendSendButton = document.getElementById("recommend-send-button");
+        const recommendTypingIndicator = document.getElementById("recommend-typing-indicator");
+
+        function addRecommendMessage(content, isUser = false) {
+            const messageDiv = document.createElement("div");
+            messageDiv.className = `message ${isUser ? "user-message" : "bot-message"}`;
+
+            const messageContent = document.createElement("div");
+            messageContent.className = "message-content";
+            messageContent.innerHTML = formatMessageContent(content);
+
+            const timestamp = document.createElement("div");
+            timestamp.className = "timestamp";
+            timestamp.textContent = new Date().toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+
+            messageDiv.appendChild(messageContent);
+            messageDiv.appendChild(timestamp);
+
+            recommendBody.insertBefore(messageDiv, recommendTypingIndicator);
+            recommendBody.scrollTop = recommendBody.scrollHeight;
+        }
+
+        function handleRecommendInput() {
+            const message = recommendInput.value.trim().toLowerCase();
+            if (!message) return;
+
+            addRecommendMessage(message, true);
+            recommendInput.value = "";
+            recommendTypingIndicator.style.display = "block";
+
+            if (message === 'hi') {
+                if (navigator.geolocation) {
+                    navigator.geolocation.getCurrentPosition(function(position) {
+                        const latitude = position.coords.latitude;
+                        const longitude = position.coords.longitude;
+                        console.log("User Location:", latitude, longitude);
+
+                        // First set the location
+                        const locationData = {
+                            latitude: latitude,
+                            longitude: longitude,
+                            session_id: 'recommend-session',
+                            user_plan: plan
+                        };
+
+                        fetch("/set-location", {
+                            method: "POST",
+                            headers: {
+                                "Content-Type": "application/json",
+                            },
+                            body: JSON.stringify(locationData)
+                        })
+                        .then(response => response.json())
+                        .then(data => {
+                            console.log("Location set:", data);
+                            if (data.error) {
+                                addRecommendMessage("Error setting location: " + data.error);
+                            } else {
+                                const city = data.city || 'Unknown city';
+                                const state = data.state || 'Unknown state';
+                                const country = data.country || 'Unknown country';
+                                addRecommendMessage(`Location set successfully in ${city}, ${state}, ${country}. Would you like to see nearby properties? Please reply with 'yes' or 'no'.`);
+                            }
+                            recommendTypingIndicator.style.display = "none";
+                        })
+                        .catch(error => {
+                            console.error("Error setting location:", error);
+                            addRecommendMessage("Unable to access your location. Please try again.");
+                            recommendTypingIndicator.style.display = "none";
+                        });
+                    }, function(error) {
+                        console.error("Error getting user location:", error);
+                        addRecommendMessage("Unable to access your location. Please try again.");
+                        recommendTypingIndicator.style.display = "none";
+                    });
+                } else {
+                    console.error("Geolocation is not supported by this browser.");
+                    addRecommendMessage("Geolocation is not supported by your browser.");
+                    recommendTypingIndicator.style.display = "none";
+                }
+            } else {
+                // Handle other messages with plan
+                const fetchOptions = {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ 
+                        query: message, 
+                        session_id: 'recommend-session',
+                        user_plan: plan 
+                    })
+                };
+
+                fetch("/recommend", fetchOptions)
+                .then(response => response.json())
+                .then(data => {
+                    if (message === 'yes' && data.properties) {
+                        let propertiesMessage = "Here are the 5 nearest properties to your location:\n";
+                        data.properties.forEach(property => {
+                            propertiesMessage += `**${property.PropertyName}** at ${property.Address}, ${property.City}\n`;
+                            propertiesMessage += `  Type: ${property.PropertyType}\n`;
+                            propertiesMessage += `  (Distance: ${property.Distance} miles)\n\n`;
+                        });
+                        addRecommendMessage(propertiesMessage);
+                    } else {
+                        addRecommendMessage(data.response);
+                    }
+                    recommendTypingIndicator.style.display = "none";
+                })
+                .catch(error => {
+                    console.error("Error:", error);
+                    addRecommendMessage("I apologize, but I encountered an error. Please try again.");
+                    recommendTypingIndicator.style.display = "none";
+                });
+            }
+        }
+
+        recommendSendButton.addEventListener("click", handleRecommendInput);
+        recommendInput.addEventListener("keypress", function(event) {
+            if (event.key === "Enter") {
+                handleRecommendInput();
+            }
+        });
+
+        const recommendMicrophoneButton = document.getElementById("recommendMicrophoneButton");
+        const recommendRecognizer = new (window.SpeechRecognition || window.webkitSpeechRecognition)();
+        recommendRecognizer.lang = 'en-US';
+        recommendRecognizer.continuous = true;
+        recommendRecognizer.interimResults = true;
+
+        let recommendSilenceTimer = null;
+
+        recommendMicrophoneButton.addEventListener("click", () => {
+            recommendMicrophoneButton.classList.add('listening');
+            $('#listeningMessage').show();
+            recommendRecognizer.start();
+            console.log("Recommend listening...");
+        });
+
+        recommendRecognizer.onresult = function(event) {
+            clearTimeout(recommendSilenceTimer);
+            
+            let finalTranscript = '';
+            for (let i = event.resultIndex; i < event.results.length; i++) {
+                if (event.results[i].isFinal) {
+                    finalTranscript += event.results[i][0].transcript;
+                }
+            }
+
+            if (finalTranscript) {
+                recommendInput.value = finalTranscript;
+                console.log("Recommend Transcript: ", finalTranscript);
+            }
+
+            recommendSilenceTimer = setTimeout(() => {
+                recommendRecognizer.stop();
+                console.log("Stopped recommend listening due to silence");
+            }, SILENCE_DURATION);
+        };
+
+        recommendRecognizer.onend = function() {
+            console.log("Recommend speech recognition service disconnected");
+            $('#listeningMessage').hide();
+            recommendMicrophoneButton.classList.remove('listening');
+            clearTimeout(recommendSilenceTimer);
+            
+            if (recommendInput.value.trim()) {
+                handleRecommendInput();
+            }
+        };
+
+        recommendRecognizer.onerror = function(event) {
+            console.error("Recommend speech recognition error", event.error);
+            $('#listeningMessage').hide();
+            recommendMicrophoneButton.classList.remove('listening');
+            clearTimeout(recommendSilenceTimer);
+        };
+
+        function formatMessageContent(content) {
+            content = content.replace(/\n/g, '<br>');
+            content = content.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>');
+            return content;
+        }
+
+        document.querySelectorAll('.quick-keyword').forEach(button => {
+            button.addEventListener('click', function() {
+                const message = this.getAttribute('data-message');
+                if (this.closest('#chat-container')) {
+                    userInput.value = message;
+                    handleUserInput();
+                } else if (this.closest('#recommend-container')) {
+                    recommendInput.value = message;
+                    handleRecommendInput();
+                }
+            });
+        });
+
+        let plan = 'basic'; // Default plan
+
+        // Generate a unique session ID
+        function generateSessionId() {
+            return 'session_' + Math.random().toString(36).substr(2, 9) + '_' + Date.now();
+        }
+
+        // Initialize session IDs
+        const chatSessionId = generateSessionId();
+        const recommendSessionId = generateSessionId();
+
+        // Initialize with stored plan or default to 'basic'
+        const storedPlan = localStorage.getItem('selectedPlan') || 'basic';
+        $('#planSelector').val(storedPlan);
+        plan = storedPlan;
+        updatePlanInRequests(storedPlan);
+
+        // Add plan selector change handler
+        $('#planSelector').on('change', function() {
+            const selectedPlan = $(this).val();
+            console.log('Plan changed to:', selectedPlan);
+            
+            // Store the selected plan in localStorage
+            localStorage.setItem('selectedPlan', selectedPlan);
+            
+            // Update the global plan variable
+            plan = selectedPlan;
+            
+            // Update all subsequent requests to include the new plan
+            updatePlanInRequests(selectedPlan);
+        });
+
+        // Function to update plan in all requests
+        function updatePlanInRequests(plan) {
+            // Update search request
+            $('#queryForm').off('submit').on('submit', function(event) {
+                event.preventDefault();
+                const query = $('#userQuery').val();
+                $('#results').empty();
+                $('#errorMessage').empty();
+                $('#loadingMessage').show();
+
+                $.ajax({
+                    url: '/search',
+                    type: 'POST',
+                    contentType: 'application/json',
+                    data: JSON.stringify({ 
+                        query: query,
+                        user_plan: plan 
+                    }),
+                    success: function(data) {
+                        $('#loadingMessage').hide();
+                        if (data.error) {
+                            $('#errorMessage').text('Error: ' + data.error);
+                        } else {
+                            displayProperties(data, plan);
+                        }
+                    },
+                    error: function() {
+                        $('#loadingMessage').hide();
+                        $('#errorMessage').text('Error: Unable to fetch data. Please try again later.');
+                    }
+                });
+            });
+
+            // Update chat requests
+            handleUserInput = function() {
+                const message = userInput.value.trim().toLowerCase();
+                if (!message) return;
+
+                addMessage(message, true);
+                userInput.value = "";
+                typingIndicator.style.display = "block";
+
+                const fetchOptions = {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ 
+                        query: message, 
+                        session_id: chatSessionId,
+                        user_plan: plan 
+                    })
+                };
+
+                const endpoint = message === 'yes' ? '/recommend' : '/generate';
+                
+                fetch(endpoint, fetchOptions)
+                .then(response => response.json())
+                .then(data => {
+                    if (message === 'yes' && data.properties) {
+                        let propertiesMessage = "Here are the 5 nearest properties to your location:\n";
+                        data.properties.forEach(property => {
+                            propertiesMessage += `**${property.PropertyName}** at ${property.Address}, ${property.City}\n`;
+                            propertiesMessage += `  Type: ${property.PropertyType}\n`;
+                            propertiesMessage += `  (Distance: ${property.Distance} miles)\n\n`;
+                        });
+                        addMessage(propertiesMessage);
+                    } else {
+                        addMessage(data.response);
+                    }
+                    typingIndicator.style.display = "none";
+                })
+                .catch(error => {
+                    console.error("Error:", error);
+                    addMessage("I apologize, but I encountered an error. Please try again.");
+                    typingIndicator.style.display = "none";
+                });
+            };
+
+            // Update recommend requests
+            handleRecommendInput = function() {
+                const message = recommendInput.value.trim().toLowerCase();
+                if (!message) return;
+
+                addRecommendMessage(message, true);
+                recommendInput.value = "";
+                recommendTypingIndicator.style.display = "block";
+
+                const fetchOptions = {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                    body: JSON.stringify({ 
+                        query: message, 
+                        session_id: recommendSessionId,
+                        user_plan: plan 
+                    })
+                };
+
+                fetch("/recommend", fetchOptions)
+                .then(response => response.json())
+                .then(data => {
+                    if (message === 'yes' && data.properties) {
+                        let propertiesMessage = "Here are the 5 nearest properties to your location:\n";
+                        data.properties.forEach(property => {
+                            propertiesMessage += `**${property.PropertyName}** at ${property.Address}, ${property.City}\n`;
+                            propertiesMessage += `  Type: ${property.PropertyType}\n`;
+                            propertiesMessage += `  (Distance: ${property.Distance} miles)\n\n`;
+                        });
+                        addRecommendMessage(propertiesMessage);
+                    } else {
+                        addRecommendMessage(data.response);
+                    }
+                    recommendTypingIndicator.style.display = "none";
+                })
+                .catch(error => {
+                    console.error("Error:", error);
+                    addRecommendMessage("I apologize, but I encountered an error. Please try again.");
+                    recommendTypingIndicator.style.display = "none";
+                });
+            };
+        }
+    });
+
+    function displayProperties(properties, plan) {
+        properties.forEach(function(property) {
+            // Create image carousel HTML based on propertyImages array
+            const carouselHTML = property.propertyImages && property.propertyImages.length > 0 ? `
+                <div class="carousel">
+                    <div class="carousel-images">
+                        ${property.propertyImages.map(imgUrl => `
+                            <img src="${imgUrl}" alt="${property.PropertyName}" class="carousel-image">
+                        `).join('')}
+                    </div>
+                    ${property.propertyImages.length > 1 ? `
+                        <div class="carousel-nav">
+                            ${property.propertyImages.map((_, index) => `
+                                <div class="carousel-dot ${index === 0 ? 'active' : ''}" data-index="${index}"></div>
+                            `).join('')}
+                        </div>
+                    ` : ''}
+                </div>
+            ` : '<div class="no-image">No images available</div>';
+
+            const propertyElement = $(`
+                <div class="property">
+                    <div class="image-container">
+                        ${carouselHTML}
+                        <button class="favorite-button">
+                            <i class="fas fa-heart"></i>
+                        </button>
+                    </div>
+                    <div class="property-details">
+                        <div class="property-header">
+                            <h2>${property["PropertyName"]}</h2>
+                            <span class="property-type">${property["PropertyType"]}</span>
+                        </div>
+                        <div style="display: flex; justify-content: space-between; flex-direction:column; gap:10px">
+                            <span>
+                                <strong>Location</strong>
+                                ${property["Address"]}, ${property["City"]}, ${property["State"]}, ${property["Country"]}
+                            </span>
+                            <span>
+                                <strong>Zip Code</strong>
+                                ${property["ZipCode"]}
+                            </span>
+                        </div>
+                        <div class="property-info">
+                            <div class="scrollable-info" style="display: flex; justify-content: space-between">
+                                <span><strong>Market Value</strong><br>${property["MarketValue"]}</span>
+                                <span><strong>Total Square Feet</strong><br>${property["TotalSquareFeet"]}</span>
+                                <span><strong>Beds</strong><br>${property["Beds"]}</span>
+                                <span><strong>Baths</strong><br>${property["Baths"]}</span>
+                                <span><strong>Year Built</strong><br>${property["YearBuilt"]}</span>
+                                <span><strong>Status</strong><br>${property["PropertyStatus"]}</span>
+                            </div>
+                        </div>
+                        <div class="accordion-section">
+                            <div class="accordion-header">
+                                <strong>Description</strong>
+                                <i class="fas fa-chevron-down accordion-arrow"></i>
+                            </div>
+                            <div class="accordion-content">
+                                <p>${property["Description"]}</p>
+                            </div>
+                        </div>
+                        <div class="accordion-section">
+                            <div class="accordion-header">
+                                <strong>Key Features</strong>
+                                <i class="fas fa-chevron-down accordion-arrow"></i>
+                            </div>
+                            <div class="accordion-content">
+                                <div class="key-features">
+                                    ${property["KeyFeatures"].split(', ').map(feature => `
+                                        <span class="feature-pill">${feature}</span>
+                                    `).join('')}
+                                </div>
+                            </div>
+                        </div>
+                        <div class="accordion-section">
+                            <div class="accordion-header">
+                                <strong>Nearby Amenities</strong>
+                                <i class="fas fa-chevron-down accordion-arrow"></i>
+                            </div>
+                            <div class="accordion-content">
+                                <div class="amenities-pills">
+                                    ${property["NearbyAmenities"].split(', ').map(amenity => `
+                                        <span class="amenity-pill">${amenity}</span>
+                                    `).join('')}
+                                </div>
+                            </div>
+                        </div>
+                        <div class="construction-status">
+                            <p><strong>Property Status:</strong> ${property["PropertyStatus"]}</p>
+                            <p><strong>Year Built:</strong> ${property["YearBuilt"]}</p>
+                        </div>
+                        <div class="accordion-section">
+                            <div class="accordion-header">
+                                <strong>Agent Details</strong>
+                                <i class="fas fa-chevron-down accordion-arrow"></i>
+                            </div>
+                            <div class="accordion-content">
+                                <div style="display: flex; justify-content: space-between">
+                                    <span><strong>Agent Name</strong><br>${property["AgentName"]}</span>
+                                    <span><strong>Agent Phone</strong><br>${property["AgentPhoneNumber"]}</span>
+                                    <span><strong>Agent Email</strong><br>${property["AgentEmail"]}</span>
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            `);
+            $('#results').append(propertyElement);
+
+            // Add carousel functionality if multiple images
+            if (property.propertyImages && property.propertyImages.length > 1) {
+                const carousel = propertyElement.find('.carousel');
+                const images = carousel.find('.carousel-images');
+                const dots = carousel.find('.carousel-dot');
+                let currentIndex = 0;
+
+                // Update carousel display
+                function updateCarousel(index) {
+                    images.css('transform', `translateX(-${index * 100}%)`);
+                    dots.removeClass('active').eq(index).addClass('active');
+                    currentIndex = index;
+                }
+
+                // Click handlers for dots
+                dots.on('click', function() {
+                    const index = $(this).data('index');
+                    updateCarousel(index);
+                });
+
+                // Optional: Add swipe functionality
+                let touchStartX = 0;
+                let touchEndX = 0;
+
+                carousel.on('touchstart', function(e) {
+                    touchStartX = e.touches[0].clientX;
+                });
+
+                carousel.on('touchend', function(e) {
+                    touchEndX = e.changedTouches[0].clientX;
+                    const diff = touchStartX - touchEndX;
+
+                    if (Math.abs(diff) > 50) { // Minimum swipe distance
+                        if (diff > 0 && currentIndex < property.propertyImages.length - 1) {
+                            // Swipe left
+                            updateCarousel(currentIndex + 1);
+                        } else if (diff < 0 && currentIndex > 0) {
+                            // Swipe right
+                            updateCarousel(currentIndex - 1);
+                        }
+                    }
+                });
+
+                // Optional: Auto-advance carousel
+                let autoAdvance = setInterval(() => {
+                    const nextIndex = (currentIndex + 1) % property.propertyImages.length;
+                    updateCarousel(nextIndex);
+                }, 5000); // Change image every 5 seconds
+
+                // Pause auto-advance on hover
+                carousel.hover(
+                    () => clearInterval(autoAdvance),
+                    () => {
+                        autoAdvance = setInterval(() => {
+                            const nextIndex = (currentIndex + 1) % property.propertyImages.length;
+                            updateCarousel(nextIndex);
+                        }, 5000);
+                    }
+                );
+            }
+
+            propertyElement.find('.accordion-header').each(function() {
+                $(this).on('click', function() {
+                    const $header = $(this);
+                    const $content = $header.next('.accordion-content');
+                    const $arrow = $header.find('.accordion-arrow');
+
+                    $content.slideToggle(300);
+                    $arrow.toggleClass('active');
+
+                    const $otherHeaders = $header.closest('.property-details')
+                        .find('.accordion-header').not($header);
+
+                    $otherHeaders.each(function() {
+                        $(this).next('.accordion-content').slideUp(300);
+                        $(this).find('.accordion-arrow').removeClass('active');
+                    });
+                });
+            });
+
+            propertyElement.find('.favorite-button').on('click', function() {
+                $(this).toggleClass('active');
+            });
+        });
+    }
+</script>
+
+</body>
+</html>
+