Upload folder using huggingface_hub

.idea/AI_chatbot.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.10 (AI_chatbot)" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+  <component name="TestRunnerService">
+    <option name="PROJECT_TEST_RUNNER" value="py.test" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/AI_chatbot.iml" filepath="$PROJECT_DIR$/.idea/AI_chatbot.iml" />
+    </modules>
+  </component>
+</project>

.idea/workspace.xml

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="aed0b69f-8b78-421a-90c0-9e8f8d7fd214" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="ProjectColorInfo"><![CDATA[{
+  "customColor": "",
+  "associatedIndex": 5
+}]]></component>
+  <component name="ProjectId" id="3D4uuD9kg3KtHzbudGUI6I5KUS4" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "ModuleVcsDetector.initialDetectionPerformed": "true",
+    "RunOnceActivity.ShowReadmeOnStart": "true"
+  }
+}]]></component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-python-sdk-ca5e2b39c7df-6e1f45a539f7-com.jetbrains.pycharm.pro.sharedIndexes.bundled-PY-253.29346.308" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="aed0b69f-8b78-421a-90c0-9e8f8d7fd214" name="Changes" comment="" />
+      <created>1777553886147</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1777553886147</updated>
+    </task>
+    <servers />
+  </component>
+</project>

admin.py

@@ -0,0 +1,68 @@
+from django.contrib import admin
+from .models import MasterQuestion, PropertyQA, AgencyAutoChatSetting, PropertyAutoChatState, GlobalQA, PropertyCustomQA
+
+@admin.register(GlobalQA)
+class GlobalQAAdmin(admin.ModelAdmin):
+    list_display = ['question', 'answer_preview', 'language', 'priority', 'is_active']
+    list_filter = ['language', 'is_active', 'priority']
+    search_fields = ['question', 'answer']
+    list_editable = ['priority', 'is_active']
+    
+    def answer_preview(self, obj):
+        return obj.answer[:50]
+    answer_preview.short_description = 'Answer'
+    
+    fieldsets = (
+        ('Question & Answer', {
+            'fields': ('question', 'answer', 'language')
+        }),
+        ('Settings', {
+            'fields': ('priority', 'is_active'),
+            'description': 'Higher priority = checked first for matching'
+        }),
+    )
+
+@admin.register(MasterQuestion)
+class MasterQuestionAdmin(admin.ModelAdmin):
+    list_display = ['question', 'order', 'is_active']
+    list_editable = ['order', 'is_active']
+    search_fields = ['question']
+
+@admin.register(PropertyQA)
+class PropertyQAAdmin(admin.ModelAdmin):
+    list_display = ['property', 'question_preview', 'answer_preview']
+    list_filter = ['agency']
+    search_fields = ['answer']
+    
+    def question_preview(self, obj):
+        return obj.question_text[:50]
+    question_preview.short_description = 'Question'
+    
+    def answer_preview(self, obj):
+        return obj.answer[:50]
+    answer_preview.short_description = 'Answer'
+
+@admin.register(AgencyAutoChatSetting)
+class AgencyAutoChatSettingAdmin(admin.ModelAdmin):
+    list_display = ['agency', 'is_enabled', 'delay_seconds', 'confidence_threshold']
+    list_filter = ['is_enabled']
+    list_editable = ['delay_seconds', 'confidence_threshold']
+
+@admin.register(PropertyAutoChatState)
+class PropertyAutoChatStateAdmin(admin.ModelAdmin):
+    list_display = ['property', 'is_auto_chat_enabled', 'total_auto_replies', 'last_auto_reply_at']
+    list_filter = ['is_auto_chat_enabled']
+    readonly_fields = ['total_auto_replies', 'last_auto_reply_at']
+
+@admin.register(PropertyCustomQA)
+class PropertyCustomQAAdmin(admin.ModelAdmin):
+    list_display = ['property', 'agency', 'order', 'question_preview', 'is_active']
+    list_filter = ['agency', 'is_active', 'property']
+    search_fields = ['question', 'answer']
+    list_editable = ['is_active']
+    
+    def question_preview(self, obj):
+        return obj.question[:60]
+    question_preview.short_description = 'Question'
+    
+    readonly_fields = ['question_embedding']

apps.py

@@ -0,0 +1,77 @@
+import sys
+import atexit
+import os
+from django.apps import AppConfig, apps
+from django.db import connection
+from django.core.exceptions import AppRegistryNotReady
+
+class AiChatbotConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'ai_chatbot'
+    
+    def ready(self):
+        # Prevent double execution in runserver
+        if 'runserver' in sys.argv and '--noreload' not in sys.argv:
+            if os.environ.get('RUN_MAIN') != 'true':
+                return
+        
+        # ✅ FIX: Check if tables exist before syncing
+        try:
+            from django.db.utils import OperationalError, ProgrammingError
+            
+            # Check if master_question table exists
+            with connection.cursor() as cursor:
+                cursor.execute("""
+                    SELECT EXISTS (
+                        SELECT FROM information_schema.tables 
+                        WHERE table_name = 'ai_chatbot_masterquestion'
+                    );
+                """)
+                table_exists = cursor.fetchone()[0]
+            
+            if not table_exists:
+                print("⚠️ Database tables not ready yet. Skipping auto-sync.")
+                return
+                
+        except (OperationalError, ProgrammingError) as e:
+            print(f"⚠️ Database not ready: {e}. Skipping auto-sync.")
+            return
+        
+        from .services import EmbeddingService
+        from .models import GlobalQA, MasterQuestion
+        from .greeting_question import SYSTEM_GREETINGS
+        
+        try:
+            service = EmbeddingService()
+            print("✓ AI Model loaded for Auto-Sync")
+            
+            # # 1. Sync Master Questions
+            # for q_data in SYSTEM_QUESTIONS:
+            #     MasterQuestion.objects.get_or_create(
+            #         question=q_data['question'],
+            #         defaults={'order': q_data['order']}
+            #     )
+            
+            # 2. Sync Global Greetings
+            for g_data in SYSTEM_GREETINGS:
+                if not GlobalQA.objects.filter(question=g_data['question']).exists():
+                    print(f"→ Generating vector for greeting: {g_data['question']}")
+                    vector = service.generate_embedding(g_data['question'])
+                    GlobalQA.objects.create(
+                        question=g_data['question'],
+                        answer=g_data['answer'],
+                        question_embedding=vector,
+                        language=g_data['language'],
+                        priority=g_data['priority']
+                    )
+            print("✅ System AI Knowledge Sync Complete")
+            
+            # Register thread cleanup on exit
+            atexit.register(EmbeddingService.cleanup_thread)
+            
+        except Exception as e:
+            print(f"✗ Auto-Sync failed: {e}")
+    
+    def get_property_info(property_id):
+        PropertyModel = apps.get_model('Property', 'Property')
+        return PropertyModel.objects.get(id=property_id)

consumers.py

@@ -0,0 +1,510 @@
+# ai_chatbot/consumers.py
+import json
+import logging
+import asyncio
+from datetime import datetime
+from typing import Dict, Optional
+
+from asgiref.sync import sync_to_async
+from channels.generic.websocket import AsyncWebsocketConsumer
+from django.db.models import Q
+from django.utils import timezone
+
+from Chat.models import ChatMessage
+from ai_chatbot.services import AutoChatService
+from ai_chatbot.models import AgencyAutoChatSetting, PropertyAutoChatState
+
+logger = logging.getLogger(__name__)
+
+
+class AIAutoChatConsumer(AsyncWebsocketConsumer):
+    """
+    Enhanced WebSocket consumer with proper per-property timer management
+    Fixes: Race conditions, memory leaks, hardcoded delays
+    """
+    
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.auto_reply_service = AutoChatService()
+        # Per-property timers
+        self.auto_reply_tasks: Dict[str, asyncio.Task] = {}
+        self.last_client_message_at: Dict[str, datetime] = {}
+        self.last_agency_reply_at: Dict[str, datetime] = {}  # ✅ FIXED: Added
+        self.current_chat_property = None
+    
+    async def connect(self):
+        """Handle WebSocket connection with authentication"""
+        user = self.scope.get('user', None)
+        if user and user.is_authenticated:
+            self.user = user
+            self.user_channel_name = f'ws_channel_layer_{self.user.id}'
+            
+            await self.channel_layer.group_add(
+                self.user_channel_name, 
+                self.channel_name
+            )
+            await self.accept()
+            
+            await self.send(text_data=json.dumps({
+                'type': 'CONNECTION_SUCCESS',
+                'message': {
+                    'status': True, 
+                    'message': 'Connected to AI Chat!',
+                    'status_code': 200
+                }
+            }))
+            logger.info(f"✅ User {self.user.id} connected to AI Chat WebSocket")
+        else:
+            await self.accept()
+            await self.send(text_data=json.dumps({
+                'type': 'CONNECTION_SUCCESS',
+                'message': {
+                    'status': False,
+                    'message': 'Authentication required',
+                    'status_code': 401
+                }
+            }))
+            logger.warning("❌ Unauthenticated WebSocket connection attempt")
+    
+    async def disconnect(self, close_code):
+        """Clean up all timers on disconnect"""
+        # Cancel all pending AI timers for this connection
+        for property_id, task in self.auto_reply_tasks.items():
+            if task and not task.done():
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    pass
+                logger.info(f"🛑 Cancelled AI timer for property {property_id}")
+        
+        # Remove from channel group
+        if hasattr(self, 'user_channel_name'):
+            await self.channel_layer.group_discard(
+                self.user_channel_name, 
+                self.channel_name
+            )
+        
+        logger.info(f"👋 User {getattr(self, 'user', 'Unknown')} disconnected")
+    
+    async def receive(self, text_data):
+        """Handle incoming WebSocket messages"""
+        try:
+            data = json.loads(text_data)
+            msg_type = data.get('type')
+            
+            if msg_type == 'NEW_CHAT_MESSAGE':
+                await self.process_message_with_ai(data)
+            elif msg_type == 'MARK_AS_READ_CHAT':
+                await self.mark_as_read_chat(data.get('chat_id'))
+            else:
+                logger.warning(f"Unknown message type: {msg_type}")
+                
+        except json.JSONDecodeError:
+            logger.error("Invalid JSON received")
+        except Exception as e:
+            logger.error(f"Error in receive: {e}", exc_info=True)
+            await self.send(text_data=json.dumps({
+                'type': 'ERROR',
+                'message': {'status': False, 'message': 'Server error', 'status_code': 500}
+            }))
+    
+    async def process_message_with_ai(self, message_data):
+        """
+        Process message with per-property timers and idempotency
+        """
+        chat_text = message_data.get('message', '')
+        property_id = str(message_data.get('property_id'))
+        other_user_id = message_data.get('user_id')
+        
+        if not property_id:
+            logger.error("No property_id in message")
+            return
+        
+        # Store current property for this message
+        self.current_chat_property = property_id
+        
+        # Create chat and message (sync operations in thread pool)
+        chat = await self.get_or_create_chat(other_user_id, property_id)
+        if not chat:
+            logger.error(f"Failed to create/get chat for property {property_id}")
+            return
+            
+        msg = await self.create_chat_message(chat, chat_text, property_id)
+        serialized = await self.serialize_message(msg)
+        
+        # Identify agency (property owner)
+        agency_user = await self.get_agency_from_property(property_id)
+        is_current_user_agency = (str(self.user.id) == str(agency_user.id)) if agency_user else False
+        
+        # Cancel ONLY this property's timer
+        if property_id in self.auto_reply_tasks:
+            old_task = self.auto_reply_tasks[property_id]
+            if old_task and not old_task.done():
+                old_task.cancel()
+                logger.info(f"🔄 Cancelled existing AI timer for property {property_id}")
+        
+        if not is_current_user_agency:
+            # CLIENT sent message → Start AI timer
+            self.last_client_message_at[property_id] = timezone.now()
+            
+            # Start new timer for this property only
+            task = asyncio.create_task(
+                self.handle_ai_delay(
+                    str(chat.id), 
+                    property_id, 
+                    chat_text, 
+                    str(agency_user.id) if agency_user else None,
+                    msg.id if msg else None
+                )
+            )
+            self.auto_reply_tasks[property_id] = task
+            logger.info(f"⏰ Started AI timer for property {property_id} (client message)")
+        else:
+            # AGENCY replied → Cancel AI for this property
+            if property_id in self.auto_reply_tasks:
+                old_task = self.auto_reply_tasks[property_id]
+                if old_task and not old_task.done():
+                    old_task.cancel()
+                del self.auto_reply_tasks[property_id]
+                logger.info(f"✅ Agency replied, cancelled AI timer for property {property_id}")
+            
+            # Update last agency reply time
+            self.last_agency_reply_at[property_id] = timezone.now()
+            await self.update_last_agency_reply(property_id)
+        
+        # Broadcast the message to both participants
+        await self.broadcast_message(chat, other_user_id, serialized, property_id, is_ai=False)
+    
+    async def handle_ai_delay(self, chat_id: str, property_id: str, client_message: str, 
+                              agency_id: Optional[str], client_message_id: Optional[int] = None):
+        """
+        Use configured delay from agency settings with idempotency
+        """
+        try:
+            # Get agency's configured delay
+            delay_seconds = 30  # Default fallback
+            
+            if agency_id:
+                try:
+                    agency_settings = await sync_to_async(
+                        AgencyAutoChatSetting.objects.get
+                    )(agency_id=agency_id)
+                    delay_seconds = agency_settings.delay_seconds
+                    logger.info(f"⏱️ Using delay {delay_seconds}s for agency {agency_id}")
+                except AgencyAutoChatSetting.DoesNotExist:
+                    logger.warning(f"No settings found for agency {agency_id}, using default 30s")
+            
+            # Wait for configured delay
+            await asyncio.sleep(delay_seconds)
+            
+            # Idempotency check - did agency already reply?
+            has_agency_replied = await self.check_agency_replied_after_message(
+                chat_id, client_message_id
+            )
+            
+            if has_agency_replied:
+                logger.info(f"🛡️ Agency replied during delay, skipping AI for property {property_id}")
+                return
+            
+            # Check if AI already replied to this message
+            already_replied = await self.check_ai_already_replied(chat_id, client_message_id)
+            
+            if already_replied:
+                logger.info(f"🛡️ AI already replied, skipping duplicate for property {property_id}")
+                return
+            
+            # Check if auto-chat is still enabled
+            is_auto_enabled = await self.is_auto_chat_enabled(property_id)
+            if not is_auto_enabled:
+                logger.info(f"🛡️ Auto-chat disabled for property {property_id}, skipping AI")
+                return
+            
+            # Generate AI response
+            reply = await sync_to_async(self.auto_reply_service.generate_auto_reply)(
+                client_message, property_id, chat_id
+            )
+            
+            if reply and reply.get('answer'):
+                # Save AI message as agency
+                if agency_id:
+                    ai_msg = await self.create_ai_message(
+                        chat_id, reply['answer'], agency_id, property_id
+                    )
+                    
+                    # Serialize and broadcast
+                    serialized_ai = await self.serialize_message(ai_msg)
+                    await self.broadcast_message(
+                        ai_msg.chat, None, serialized_ai, property_id, is_ai=True
+                    )
+                    
+                    # Update auto-chat stats if property match
+                    if reply.get('type') == 'property':
+                        await self.update_auto_chat_stats(property_id)
+                    
+                    logger.info(f"🤖 AI auto-reply sent for property {property_id} | Type: {reply.get('type')} | Confidence: {reply.get('confidence', 0):.2f}")
+                else:
+                    logger.error(f"Cannot send AI reply: No agency_id for property {property_id}")
+            else:
+                logger.info(f"⚠️ No AI reply generated for property {property_id}")
+                
+        except asyncio.CancelledError:
+            logger.info(f"🛑 AI timer cancelled for property {property_id} (agency replied)")
+            raise
+        except Exception as e:
+            logger.error(f"❌ AI delay task error for property {property_id}: {e}", exc_info=True)
+    
+    # ========== Helper Methods ==========
+    
+    @sync_to_async
+    def get_agency_from_property(self, property_id: str):
+        """Get agency (property owner)"""
+        try:
+            from Property.models import Property
+            prop = Property.objects.select_related('user').get(id=property_id)
+            return prop.user
+        except Exception as e:
+            logger.error(f"Error getting agency: {e}")
+            return None
+    
+    @sync_to_async
+    def get_or_create_chat(self, user_id: str, property_id: str):
+        """Get or create chat between users"""
+        from Authentication.models import User
+        from Chat.models import Chat
+        from Property.models import Property
+        
+        try:
+            other_user = User.objects.get(id=user_id)
+            prop = Property.objects.filter(id=property_id).first()
+            
+            # Find existing chat
+            chat = Chat.objects.filter(
+                Q(created_by=self.user, participants=other_user, prop=prop) |
+                Q(created_by=other_user, participants=self.user, prop=prop)
+            ).first()
+            
+            if not chat:
+                chat = Chat.objects.create(created_by=self.user, prop=prop)
+                chat.participants.add(self.user, other_user)
+                
+                # Create system message
+                ChatMessage.objects.create(
+                    chat=chat,
+                    user=self.user,
+                    msg_type='Notification',
+                    text=f'{self.user.user_full_name} started a new chat.',
+                    prop=prop
+                )
+            
+            return chat
+        except User.DoesNotExist:
+            logger.error(f"User {user_id} not found")
+            return None
+        except Exception as e:
+            logger.error(f"Error getting/creating chat: {e}")
+            return None
+    
+    @sync_to_async
+    def create_chat_message(self, chat, text: str, property_id: str):
+        """Create a new chat message"""
+        from Chat.models import ChatMessage
+        from Property.models import Property
+        
+        prop = Property.objects.filter(id=property_id).first()
+        msg = ChatMessage.objects.create(
+            chat=chat,
+            user=self.user,
+            text=text,
+            prop=prop
+        )
+        msg.read_by.add(self.user)
+        
+        chat.last_message = msg
+        chat.save(update_fields=['last_message'])
+        
+        return msg
+    
+    @sync_to_async
+    def create_ai_message(self, chat_id: str, text: str, agency_id: str, property_id: str):
+        """Create AI message as agency"""
+        from Authentication.models import User
+        from Chat.models import Chat, ChatMessage
+        from Property.models import Property
+        
+        chat = Chat.objects.get(id=chat_id)
+        agency = User.objects.get(id=agency_id)
+        prop = Property.objects.filter(id=property_id).first()
+        
+        msg = ChatMessage.objects.create(
+            chat=chat,
+            user=agency,
+            text=text,
+            prop=prop,
+            msg_type='AI'  # Mark as AI-generated
+        )
+        
+        chat.last_message = msg
+        chat.save(update_fields=['last_message'])
+        
+        return msg
+    
+    @sync_to_async
+    def serialize_message(self, msg):
+        """Serialize message for WebSocket response"""
+        from Chat import serializers
+        return serializers.SocketChatMessageSerializer(msg).data
+    
+    @sync_to_async
+    def mark_as_read_chat(self, chat_id: str):
+        """Mark all messages in chat as read"""
+        from Chat.models import ChatMessage
+        
+        try:
+            msgs = ChatMessage.objects.filter(chat__id=chat_id).exclude(read_by=self.user)
+            count = 0
+            for msg in msgs:
+                msg.read_by.add(self.user)
+                count += 1
+            logger.info(f"📖 User {self.user.id} marked {count} messages as read in chat {chat_id}")
+            return True
+        except Exception as e:
+            logger.error(f"Error marking chat read: {e}")
+            return False
+    
+    @sync_to_async
+    def update_last_agency_reply(self, property_id: str):
+        """Update last agency reply timestamp"""
+        try:
+            state, created = PropertyAutoChatState.objects.get_or_create(
+                property_id=property_id
+            )
+            state.last_agency_reply_at = timezone.now()
+            state.save(update_fields=['last_agency_reply_at'])
+        except Exception as e:
+            logger.error(f"Error updating agency reply time: {e}")
+    
+    @sync_to_async
+    def update_auto_chat_stats(self, property_id: str):
+        """Update auto-chat statistics"""
+        try:
+            state = PropertyAutoChatState.objects.get(property_id=property_id)
+            state.total_auto_replies += 1
+            state.last_auto_reply_at = timezone.now()
+            state.save(update_fields=['total_auto_replies', 'last_auto_reply_at'])
+        except PropertyAutoChatState.DoesNotExist:
+            PropertyAutoChatState.objects.create(
+                property_id=property_id,
+                total_auto_replies=1,
+                last_auto_reply_at=timezone.now()
+            )
+        except Exception as e:
+            logger.error(f"Error updating stats: {e}")
+    
+    @sync_to_async
+    def is_auto_chat_enabled(self, property_id: str) -> bool:
+        """Check if auto-chat is enabled for property"""
+        try:
+            state = PropertyAutoChatState.objects.select_related('property__user').get(
+                property_id=property_id
+            )
+            if not state.is_auto_chat_enabled:
+                return False
+            
+            # Also check agency setting
+            if state.property and state.property.user:
+                try:
+                    agency_setting = AgencyAutoChatSetting.objects.get(
+                        agency=state.property.user
+                    )
+                    return agency_setting.is_enabled
+                except AgencyAutoChatSetting.DoesNotExist:
+                    return False
+            return False
+        except PropertyAutoChatState.DoesNotExist:
+            return False
+        except Exception as e:
+            logger.error(f"Error checking auto-chat enabled: {e}")
+            return False
+    
+    @sync_to_async
+    def check_agency_replied_after_message(self, chat_id: str, client_message_id: int) -> bool:
+        """Check if agency replied after client's message"""
+        from Chat.models import ChatMessage
+        
+        if not client_message_id:
+            return False
+        
+        try:
+            client_msg = ChatMessage.objects.get(id=client_message_id)
+            # Check if any agency message came after this client message
+            agency_reply = ChatMessage.objects.filter(
+                chat_id=chat_id,
+                created_at__gt=client_msg.created_at
+            ).exclude(user_id=client_msg.user_id).exists()
+            
+            return agency_reply
+        except ChatMessage.DoesNotExist:
+            return False
+        except Exception as e:
+            logger.error(f"Error checking agency reply: {e}")
+            return False
+    
+    @sync_to_async
+    def check_ai_already_replied(self, chat_id: str, client_message_id: int) -> bool:
+        """Check if AI already replied to this message"""
+        from Chat.models import ChatMessage
+        
+        if not client_message_id:
+            return False
+        
+        try:
+            client_msg = ChatMessage.objects.get(id=client_message_id)
+            # Check for AI message after client message
+            ai_reply = ChatMessage.objects.filter(
+                chat_id=chat_id,
+                created_at__gt=client_msg.created_at,
+                msg_type='AI'
+            ).exists()
+            
+            return ai_reply
+        except ChatMessage.DoesNotExist:
+            return False
+        except Exception as e:
+            logger.error(f"Error checking AI reply: {e}")
+            return False
+    
+    async def broadcast_message(self, chat, other_user_id, serialized, property_id, is_ai=False):
+        """Send message to both participants"""
+        participants = await sync_to_async(list)(chat.participants.all())
+        
+        for participant in participants:
+            is_me = (str(participant.id) == str(self.user.id))
+            
+            data = {
+                'type': 'NEW_CHAT_MESSAGE',
+                'chat_id': str(chat.id),
+                'prop_id': property_id,
+                'chat_message': {
+                    **serialized,
+                    'is_me': is_me,
+                    'is_ai': is_ai
+                }
+            }
+            
+            if is_me:
+                # Send to sender
+                await self.send(text_data=json.dumps(data))
+            else:
+                # Send to other participant
+                await self.channel_layer.group_send(
+                    f'ws_channel_layer_{participant.id}',
+                    {'type': 'chat_message', 'message': data}
+                )
+    
+    async def chat_message(self, event):
+        """Handle messages sent to user's channel"""
+        try:
+            await self.send(text_data=json.dumps(event['message']))
+        except Exception as e:
+            logger.error(f"Error sending chat message: {e}")

greeting_question.py

@@ -0,0 +1,44 @@
+# ai_chatbot/questions_data.py
+
+SYSTEM_QUESTIONS = [
+    {"question": "What is the load shedding situation in this area?", "order": 1},
+    {"question": "Is Sui gas available and functional?", "order": 2},
+    {"question": "Is water available 24/7 or are there specific timings?", "order": 3},
+    {"question": "Is there a dedicated parking space (Inside/Outside)?", "order": 4},
+    {"question": "Are there any hidden maintenance or security charges?", "order": 5},
+    {"question": "Is the security deposit refundable?", "order": 6},
+    {"question": "Is the internet (Fiber/DSL) pre-installed or available?", "order": 7},
+]
+
+SYSTEM_GREETINGS = [
+    # --- ENGLISH GREETINGS ---
+    {"question": "Hello", "answer": "Hello! How can I help you with this property?", "language": "en", "priority": 10},
+    {"question": "Hi", "answer": "Hi there! Feel free to ask me any questions about this listing.", "language": "en", "priority": 10},
+    {"question": "Hey", "answer": "Hey! How can I assist you today?", "language": "en", "priority": 10},
+    {"question": "Good morning", "answer": "Good morning! How may I help you with this property?", "language": "en", "priority": 9},
+    {"question": "Good afternoon", "answer": "Good afternoon! What would you like to know about this property?", "language": "en", "priority": 9},
+    {"question": "Good evening", "answer": "Good evening! How can I assist you?", "language": "en", "priority": 9},
+    {"question": "How are you?", "answer": "I'm doing great, thank you! How can I help you with your property search?", "language": "en", "priority": 8},
+    
+    # --- ROMAN URDU GREETINGS ---
+    {"question": "Assalam-o-Alaikum", "answer": "Wa Alaikum Assalam! Main ap ki kya madad kar sakta hoon?", "language": "ur", "priority": 10},
+    {"question": "Aoa", "answer": "Wa Alaikum Assalam! Kaisay madad kar sakta hoon?", "language": "ur", "priority": 10},
+    {"question": "Salam", "answer": "Wa Alaikum Assalam! Kya haal hain? Property ke baray mein kuch poochna hai?", "language": "ur", "priority": 10},
+    {"question": "Adaab", "answer": "Adaab! Kya main is property ki details share karoon?", "language": "ur", "priority": 9},
+    {"question": "Kya haal hai", "answer": "Allah ka shukar hai! Ap batayain, property ke baray mein kya janna chahte hain?", "language": "ur", "priority": 8},
+    {"question": "Kaisay ho", "answer": "Main bilkul theek! Ap property ke baray mein koi sawal pooch sakte hain.", "language": "ur", "priority": 8},
+    {"question": "Theek ho?", "answer": "Jee haan, shukriya! Main apki madad ke liye hazir hoon.", "language": "ur", "priority": 7},
+
+    # --- GRATITUDE & CLOSING (BILINGUAL) ---
+    {"question": "Thank you", "answer": "You're very welcome! Let me know if you need anything else.", "language": "en", "priority": 10},
+    {"question": "Thanks", "answer": "My pleasure! Feel free to ask more questions.", "language": "en", "priority": 10},
+    {"question": "Shukriya", "answer": "Apka khair maqdam hai! Koi aur baat jo ap poochna chahain?", "language": "ur", "priority": 10},
+    {"question": "Bohot shukriya", "answer": "Khushi hui apki madad karke! Allah hafiz.", "language": "ur", "priority": 10},
+    {"question": "JazakAllah", "answer": "Wa iyyakum! Main yahan apki mazeed madad ke liye hoon.", "language": "ur", "priority": 10},
+    {"question": "Bye", "answer": "Goodbye! Have a great day ahead.", "language": "en", "priority": 8},
+    {"question": "Allah hafiz", "answer": "Allah hafiz! Phir kabhi madad chahiye ho toh zaroor batayain.", "language": "ur", "priority": 8},
+
+    # --- COMMON MIXED PHRASES ---
+    {"question": "Hi, kya haal hai", "answer": "Hello! Main theek hoon. Property ke baray mein batayain, kya janna chahte hain?", "language": "both", "priority": 9},
+    {"question": "Salam, is it available?", "answer": "Wa Alaikum Assalam! Let me check the details for you. Our agent will confirm shortly.", "language": "both", "priority": 9},
+]

management/commands/setup_global_qa.py

@@ -0,0 +1,65 @@
+from django.core.management.base import BaseCommand
+from ai_chatbot.models import GlobalQA
+from ai_chatbot.services import EmbeddingService
+
+class Command(BaseCommand):
+    help = 'Setup global greeting Q&A for all properties'
+    
+    def handle(self, *args, **options):
+        service = EmbeddingService()
+        
+        global_qa = [
+            # English Greetings
+            ("Hello", "Hello! How can I help you with this property?", "en", 10),
+            ("Hi", "Hi there! Feel free to ask me any questions about this property.", "en", 10),
+            ("Hey", "Hey! How can I assist you today?", "en", 10),
+            ("Good morning", "Good morning! How may I help you with this property?", "en", 9),
+            ("Good afternoon", "Good afternoon! What would you like to know about this property?", "en", 9),
+            ("Good evening", "Good evening! How can I assist you?", "en", 9),
+            ("How are you?", "I'm doing great! How can I help you with this property?", "en", 8),
+            ("Thanks", "You're welcome! Let me know if you have any other questions.", "en", 10),
+            ("Thank you", "My pleasure! Feel free to ask anything else.", "en", 10),
+            ("Thank you so much", "You're very welcome! Happy to help.", "en", 10),
+            ("Ok thanks", "Anytime! Let me know if you need more information.", "en", 9),
+            ("Bye", "Goodbye! Feel free to come back if you have more questions.", "en", 8),
+            ("Goodbye", "Take care! Have a great day.", "en", 8),
+            
+            # Roman Urdu Greetings
+            ("Assalam-o-Alaikum", "Wa Alaikum Assalam! Main ap ki kya madad kar sakta hoon?", "ur", 10),
+            ("AoA", "Wa Alaikum Assalam! Kya sawal hai?", "ur", 10),
+            ("Salam", "Wa Alaikum Assalam! Kaisay madad kar sakta hoon?", "ur", 10),
+            ("Adaab", "Adaab! Kya poochna chahte ho property ke bare mein?", "ur", 9),
+            ("Kya haal hai", "Allah ka shukar hai! Ap property ke bare mein kya poochna chahte ho?", "ur", 8),
+            ("Theek ho", "Haan bilkul! Koi sawal poochain.", "ur", 8),
+            ("Shukriya", "Apka khair maqdam hai! Koi aur sawal?", "ur", 10),
+            ("Bohot shukriya", "Khushi hui madad karke! Aur poochain.", "ur", 10),
+            ("Allah hafiz", "Allah hafiz! Phir kabhi ayen.", "ur", 8),
+            
+            # Mixed/Common
+            ("Hello, kya haal hai", "Wa Alaikum Assalam! Mein theek hoon. Ap property ke bare mein kya janna chahte ho?", "both", 9),
+            ("Hi, property available?", "Hello! Let me check the availability for you. Our agent will confirm shortly.", "both", 7),
+            ("Salam, price kya hai", "Wa Alaikum Assalam! Please allow our agent to share detailed pricing information.", "both", 7),
+        ]
+        
+        count = 0
+        for question, answer, language, priority in global_qa:
+            embedding = service.generate_embedding(question)
+            obj, created = GlobalQA.objects.get_or_create(
+                question=question,
+                defaults={
+                    'answer': answer,
+                    'question_embedding': embedding,
+                    'language': language,
+                    'priority': priority,
+                    'is_active': True
+                }
+            )
+            if created:
+                count += 1
+                self.stdout.write(self.style.SUCCESS(f'✓ Added: {question[:40]}...'))
+            else:
+                # Update embedding if question exists
+                obj.question_embedding = embedding
+                obj.save()
+        
+        self.stdout.write(self.style.SUCCESS(f'\n✅ Successfully added/updated {count} global Q&A pairs!'))

management/commands/setup_master_questions.py

@@ -0,0 +1,42 @@
+from django.core.management.base import BaseCommand
+from ai_chatbot.models import MasterQuestion
+
+class Command(BaseCommand):
+    help = 'Setup predefined master questions for property listings'
+    
+    def handle(self, *args, **options):
+        questions = [
+            "What is the load shedding situation in this area?",
+            "Is there backup (UPS / Generator / Solar)?",
+            "Is Sui gas available?",
+            "Is water available 24/7?",
+            "Is the street paved or kacha?",
+            "Does water accumulate during rain?",
+            "Is parking inside or outside?",
+            "Is it safe for overnight parking?",
+            "How far is the nearest mosque?",
+            "Are schools, markets, and hospitals nearby?",
+            "Are there security guards?",
+            "Is CCTV installed?",
+            "Is the area considered safe at night?",
+            "Which internet services are available?",
+            "Any extra charges not mentioned? (maintenance, security, garbage)",
+            "Who pays utility bills?",
+            "Is the portion completely separate?",
+            "Is entrance shared with owner?",
+            "What is the monthly rent of the property?",
+            "What is the security deposit?",
+            "Is the rent negotiable?",
+        ]
+        
+        count = 0
+        for order, question in enumerate(questions, start=1):
+            obj, created = MasterQuestion.objects.get_or_create(
+                question=question,
+                defaults={'order': order, 'is_active': True}
+            )
+            if created:
+                count += 1
+                self.stdout.write(self.style.SUCCESS(f'✓ Added: {question[:50]}...'))
+        
+        self.stdout.write(self.style.SUCCESS(f'\n✅ Successfully added {count} master questions!'))

migrations/0001_initial.py

@@ -0,0 +1,160 @@
+# Generated by Django 4.2.6 on 2026-04-29 07:00
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import pgvector.django.vector
+import uuid
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        ('Property', '0063_alter_property_amenties'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='AgencyAutoChatSetting',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_enabled', models.BooleanField(default=False)),
+                ('delay_seconds', models.IntegerField(default=30, help_text='Seconds to wait before AI replies')),
+                ('confidence_threshold', models.FloatField(default=0.6, help_text='Minimum similarity score (0-1)')),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='GlobalQA',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('question', models.TextField(unique=True)),
+                ('answer', models.TextField()),
+                ('question_embedding', pgvector.django.vector.VectorField(dimensions=384)),
+                ('language', models.CharField(choices=[('en', 'English'), ('ur', 'Roman Urdu'), ('both', 'Both')], default='both', max_length=20)),
+                ('is_active', models.BooleanField(default=True)),
+                ('priority', models.IntegerField(default=0)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+            ],
+            options={
+                'ordering': ['-priority', 'question'],
+            },
+        ),
+        migrations.CreateModel(
+            name='MasterQuestion',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('question', models.TextField(unique=True)),
+                ('is_active', models.BooleanField(default=True)),
+                ('order', models.IntegerField(default=0)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+            ],
+            options={
+                'ordering': ['order'],
+            },
+        ),
+        migrations.CreateModel(
+            name='PropertyQA',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('answer', models.TextField()),
+                ('question_embedding', pgvector.django.vector.VectorField(dimensions=384)),
+                ('is_active', models.BooleanField(default=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('agency', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='property_qa_answers', to=settings.AUTH_USER_MODEL)),
+                ('master_question', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='ai_chatbot.masterquestion')),
+                ('property', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='ai_qa', to='Property.property')),
+            ],
+        ),
+        migrations.CreateModel(
+            name='PropertyCustomQA',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('question', models.TextField()),
+                ('answer', models.TextField()),
+                ('question_embedding', pgvector.django.vector.VectorField(dimensions=384)),
+                ('order', models.IntegerField(default=0)),
+                ('is_active', models.BooleanField(default=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+                ('agency', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='property_custom_qa', to=settings.AUTH_USER_MODEL)),
+                ('property', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='custom_qa', to='Property.property')),
+            ],
+            options={
+                'ordering': ['order'],
+            },
+        ),
+        migrations.CreateModel(
+            name='PropertyAutoChatState',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('is_auto_chat_enabled', models.BooleanField(default=False)),
+                ('last_auto_reply_at', models.DateTimeField(blank=True, null=True)),
+                ('total_auto_replies', models.IntegerField(default=0)),
+                ('last_agency_reply_at', models.DateTimeField(blank=True, null=True)),
+                ('property', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='auto_chat_state', to='Property.property')),
+            ],
+        ),
+        migrations.AddIndex(
+            model_name='masterquestion',
+            index=models.Index(fields=['is_active', 'order'], name='ai_chatbot__is_acti_4e4a3d_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='globalqa',
+            index=models.Index(fields=['is_active', '-priority'], name='ai_chatbot__is_acti_fa63b9_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='globalqa',
+            index=models.Index(fields=['language', 'is_active'], name='ai_chatbot__languag_9d512a_idx'),
+        ),
+        migrations.AddField(
+            model_name='agencyautochatsetting',
+            name='agency',
+            field=models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, related_name='auto_chat_setting', to=settings.AUTH_USER_MODEL),
+        ),
+        migrations.AddIndex(
+            model_name='propertyqa',
+            index=models.Index(fields=['property', 'is_active'], name='ai_chatbot__propert_d93b25_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='propertyqa',
+            index=models.Index(fields=['agency', 'is_active'], name='ai_chatbot__agency__41090d_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='propertyqa',
+            index=models.Index(fields=['master_question', 'is_active'], name='ai_chatbot__master__144853_idx'),
+        ),
+        migrations.AlterUniqueTogether(
+            name='propertyqa',
+            unique_together={('property', 'master_question')},
+        ),
+        migrations.AddIndex(
+            model_name='propertycustomqa',
+            index=models.Index(fields=['property', 'is_active'], name='ai_chatbot__propert_e9a86b_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='propertycustomqa',
+            index=models.Index(fields=['agency', 'is_active'], name='ai_chatbot__agency__fdf146_idx'),
+        ),
+        migrations.AddConstraint(
+            model_name='propertycustomqa',
+            constraint=models.UniqueConstraint(fields=('property', 'order'), name='unique_order_per_property'),
+        ),
+        migrations.AddIndex(
+            model_name='propertyautochatstate',
+            index=models.Index(fields=['is_auto_chat_enabled'], name='ai_chatbot__is_auto_1f624d_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='propertyautochatstate',
+            index=models.Index(fields=['property', 'is_auto_chat_enabled'], name='ai_chatbot__propert_697127_idx'),
+        ),
+        migrations.AddIndex(
+            model_name='agencyautochatsetting',
+            index=models.Index(fields=['is_enabled'], name='ai_chatbot__is_enab_7f8ec6_idx'),
+        ),
+    ]

migrations/__init__.py

@@ -0,0 +1 @@
+# ai_chatbot migrations

models.py

@@ -0,0 +1,190 @@
+import uuid
+import builtins
+from django.db import models
+from pgvector.django import VectorField
+from django.conf import settings
+
+
+class GlobalQA(models.Model):
+    """Global Q&A for greetings - works across ALL properties and agencies"""
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    question = models.TextField(unique=True)
+    answer = models.TextField()
+    question_embedding = VectorField(dimensions=384)
+    language = models.CharField(max_length=20, choices=[
+        ('en', 'English'),
+        ('ur', 'Roman Urdu'),
+        ('both', 'Both')
+    ], default='both')
+    is_active = models.BooleanField(default=True)
+    priority = models.IntegerField(default=0)
+    created_at = models.DateTimeField(auto_now_add=True)
+    
+    class Meta:
+        ordering = ['-priority', 'question']
+        indexes = [
+            models.Index(fields=['is_active', '-priority']),
+            models.Index(fields=['language', 'is_active']),
+        ]
+    
+    def __str__(self):
+        return f"{self.question[:50]}"
+
+
+class MasterQuestion(models.Model):
+    """Pre-defined questions created by admin that agencies must answer"""
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    question = models.TextField(unique=True)
+    is_active = models.BooleanField(default=True)
+    order = models.IntegerField(default=0)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ['order']
+        indexes = [
+            models.Index(fields=['is_active', 'order']),
+        ]
+    
+    def __str__(self):
+        return self.question[:100]
+
+
+class PropertyQA(models.Model):
+    """Agency's answers to master questions for a specific property"""
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    
+    agency = models.ForeignKey(
+        settings.AUTH_USER_MODEL, 
+        on_delete=models.CASCADE, 
+        related_name='property_qa_answers'
+    )
+    property = models.ForeignKey(
+        'Property.Property', 
+        on_delete=models.CASCADE, 
+        related_name='ai_qa'
+    )
+    master_question = models.ForeignKey(
+        MasterQuestion, 
+        on_delete=models.CASCADE, 
+        null=True, 
+        blank=True
+    )
+    answer = models.TextField()
+    
+    # Embedding for similarity search
+    question_embedding = VectorField(dimensions=384)
+    
+    is_active = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)  # FIX #5: Track updates
+    
+    class Meta:
+        unique_together = ['property', 'master_question']
+        # FIX #2: Database indexes for performance
+        indexes = [
+            models.Index(fields=['property', 'is_active']),
+            models.Index(fields=['agency', 'is_active']),
+            models.Index(fields=['master_question', 'is_active']),
+            # Vector index will be added via migration
+        ]
+    
+    @builtins.property
+    def question_text(self):
+        return self.master_question.question if self.master_question else None
+    
+    def __str__(self):
+        return f"{self.property.title}: {self.question_text[:50] if self.question_text else 'No question'}"
+
+
+class AgencyAutoChatSetting(models.Model):
+    """Auto-chat settings per agency"""
+    agency = models.OneToOneField(
+        settings.AUTH_USER_MODEL, 
+        on_delete=models.CASCADE, 
+        related_name='auto_chat_setting'
+    )
+    is_enabled = models.BooleanField(default=False)
+    delay_seconds = models.IntegerField(default=30, help_text="Seconds to wait before AI replies")
+    confidence_threshold = models.FloatField(default=0.6, help_text="Minimum similarity score (0-1)")
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    
+    class Meta:
+        indexes = [
+            models.Index(fields=['is_enabled']),
+        ]
+    
+    def __str__(self):
+        return f"{self.agency.email}: {'ON' if self.is_enabled else 'OFF'}"
+
+
+class PropertyAutoChatState(models.Model):
+    """Track auto-chat state per property"""
+    property = models.OneToOneField(
+        'Property.Property', 
+        on_delete=models.CASCADE, 
+        related_name='auto_chat_state'
+    )
+    is_auto_chat_enabled = models.BooleanField(default=False)
+    last_auto_reply_at = models.DateTimeField(null=True, blank=True)
+    total_auto_replies = models.IntegerField(default=0)
+    last_agency_reply_at = models.DateTimeField(null=True, blank=True)  
+    
+    class Meta:
+        indexes = [
+            models.Index(fields=['is_auto_chat_enabled']),
+            models.Index(fields=['property', 'is_auto_chat_enabled']),
+        ]
+    
+    def __str__(self):
+        return f"{self.property.title}: Auto Chat {'ON' if self.is_auto_chat_enabled else 'OFF'}"
+
+
+class PropertyCustomQA(models.Model):
+    """
+    Custom Q&A for a specific property (max 5 per property)
+    Agency writes these when enabling auto-chat
+    """
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    
+    # Relationships
+    agency = models.ForeignKey(
+        settings.AUTH_USER_MODEL,
+        on_delete=models.CASCADE,
+        related_name='property_custom_qa'
+    )
+    property = models.ForeignKey(
+        'Property.Property',
+        on_delete=models.CASCADE,
+        related_name='custom_qa'
+    )
+    
+    # The actual Q&A
+    question = models.TextField()
+    answer = models.TextField()
+    
+    # For AI similarity search
+    question_embedding = VectorField(dimensions=384)
+    
+    # Metadata
+    order = models.IntegerField(default=0)  # 1-5 for display order
+    is_active = models.BooleanField(default=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    
+    class Meta:
+        ordering = ['order']
+        # Ensure max 5 per property
+        constraints = [
+            models.UniqueConstraint(
+                fields=['property', 'order'],
+                name='unique_order_per_property'
+            )
+        ]
+        indexes = [
+            models.Index(fields=['property', 'is_active']),
+            models.Index(fields=['agency', 'is_active']),
+        ]
+    
+    def __str__(self):
+        return f"{self.property.title}: Q{self.order} - {self.question[:50]}"

models/fine_tuned_bilingual_model_v2/1_Pooling/config.json

@@ -0,0 +1,5 @@
+{
+    "embedding_dimension": 384,
+    "pooling_mode": "mean",
+    "include_prompt": true
+}

models/fine_tuned_bilingual_model_v2/README.md

@@ -0,0 +1,341 @@
+---
+tags:
+- sentence-transformers
+- sentence-similarity
+- feature-extraction
+- generated_from_trainer
+- dataset_size:45
+- loss:MultipleNegativesRankingLoss
+base_model: embedingHF/bilingual-roman-urdu-embedder
+widget:
+- source_sentence: map location
+  sentences:
+  - is garage available
+  - how much is it
+  - bedrooms kitnay hain
+- source_sentence: car stand hai
+  sentences:
+  - parking space
+  - parking facility
+  - precise location
+- source_sentence: rooms kitnay hain
+  sentences:
+  - kitna bara
+  - number of rooms
+  - property rate
+- source_sentence: yeh jaga kahan hai
+  sentences:
+  - where is this place
+  - bedrooms
+  - property size
+- source_sentence: total area batao
+  sentences:
+  - location on map
+  - rate batao
+  - total area
+pipeline_tag: sentence-similarity
+library_name: sentence-transformers
+---
+
+# SentenceTransformer based on embedingHF/bilingual-roman-urdu-embedder
+
+This is a [sentence-transformers](https://www.SBERT.net) model finetuned from [embedingHF/bilingual-roman-urdu-embedder](https://huggingface.co/embedingHF/bilingual-roman-urdu-embedder). It maps sentences & paragraphs to a 384-dimensional dense vector space and can be used for retrieval.
+
+## Model Details
+
+### Model Description
+- **Model Type:** Sentence Transformer
+- **Base model:** [embedingHF/bilingual-roman-urdu-embedder](https://huggingface.co/embedingHF/bilingual-roman-urdu-embedder) <!-- at revision 733331b846073b4605769ad33ecf0931a3c35489 -->
+- **Maximum Sequence Length:** 256 tokens
+- **Output Dimensionality:** 384 dimensions
+- **Similarity Function:** Cosine Similarity
+- **Supported Modality:** Text
+<!-- - **Training Dataset:** Unknown -->
+<!-- - **Language:** Unknown -->
+<!-- - **License:** Unknown -->
+
+### Model Sources
+
+- **Documentation:** [Sentence Transformers Documentation](https://sbert.net)
+- **Repository:** [Sentence Transformers on GitHub](https://github.com/huggingface/sentence-transformers)
+- **Hugging Face:** [Sentence Transformers on Hugging Face](https://huggingface.co/models?library=sentence-transformers)
+
+### Full Model Architecture
+
+```
+SentenceTransformer(
+  (0): Transformer({'transformer_task': 'feature-extraction', 'modality_config': {'text': {'method': 'forward', 'method_output_name': 'last_hidden_state'}}, 'module_output_name': 'token_embeddings', 'architecture': 'BertModel'})
+  (1): Pooling({'embedding_dimension': 384, 'pooling_mode': 'mean', 'include_prompt': True})
+  (2): Normalize({})
+)
+```
+
+## Usage
+
+### Direct Usage (Sentence Transformers)
+
+First install the Sentence Transformers library:
+
+```bash
+pip install -U sentence-transformers
+```
+Then you can load this model and run inference.
+```python
+from sentence_transformers import SentenceTransformer
+
+# Download from the 🤗 Hub
+model = SentenceTransformer("sentence_transformers_model_id")
+# Run inference
+sentences = [
+    'total area batao',
+    'total area',
+    'location on map',
+]
+embeddings = model.encode(sentences)
+print(embeddings.shape)
+# [3, 384]
+
+# Get the similarity scores for the embeddings
+similarities = model.similarity(embeddings, embeddings)
+print(similarities)
+# tensor([[1.0000, 0.9458, 0.3963],
+#         [0.9458, 1.0000, 0.3714],
+#         [0.3963, 0.3714, 1.0000]])
+```
+<!--
+### Direct Usage (Transformers)
+
+<details><summary>Click to see the direct usage in Transformers</summary>
+
+</details>
+-->
+
+<!--
+### Downstream Usage (Sentence Transformers)
+
+You can finetune this model on your own dataset.
+
+<details><summary>Click to expand</summary>
+
+</details>
+-->
+
+<!--
+### Out-of-Scope Use
+
+*List how the model may foreseeably be misused and address what users ought not to do with the model.*
+-->
+
+<!--
+## Bias, Risks and Limitations
+
+*What are the known or foreseeable issues stemming from this model? You could also flag here known failure cases or weaknesses of the model.*
+-->
+
+<!--
+### Recommendations
+
+*What are recommendations with respect to the foreseeable issues? For example, filtering explicit content.*
+-->
+
+## Training Details
+
+### Training Dataset
+
+#### Unnamed Dataset
+
+* Size: 45 training samples
+* Columns: <code>sentence_0</code>, <code>sentence_1</code>, and <code>label</code>
+* Approximate statistics based on the first 45 samples:
+  |         | sentence_0                                                                       | sentence_1                                                                     | label                                                          |
+  |:--------|:---------------------------------------------------------------------------------|:-------------------------------------------------------------------------------|:---------------------------------------------------------------|
+  | type    | string                                                                           | string                                                                         | float                                                          |
+  | details | <ul><li>min: 3 tokens</li><li>mean: 5.69 tokens</li><li>max: 12 tokens</li></ul> | <ul><li>min: 3 tokens</li><li>mean: 5.4 tokens</li><li>max: 8 tokens</li></ul> | <ul><li>min: 0.0</li><li>mean: 0.67</li><li>max: 1.0</li></ul> |
+* Samples:
+  | sentence_0                    | sentence_1                       | label             |
+  |:------------------------------|:---------------------------------|:------------------|
+  | <code>near kahan hai</code>   | <code>where is it located</code> | <code>1.0</code>  |
+  | <code>total area batao</code> | <code>total area</code>          | <code>1.0</code>  |
+  | <code>size</code>             | <code>area</code>                | <code>0.84</code> |
+* Loss: [<code>MultipleNegativesRankingLoss</code>](https://sbert.net/docs/package_reference/sentence_transformer/losses.html#multiplenegativesrankingloss) with these parameters:
+  ```json
+  {
+      "scale": 20.0,
+      "similarity_fct": "cos_sim",
+      "gather_across_devices": false,
+      "directions": [
+          "query_to_doc"
+      ],
+      "partition_mode": "joint",
+      "hardness_mode": null,
+      "hardness_strength": 0.0
+  }
+  ```
+
+### Training Hyperparameters
+#### Non-Default Hyperparameters
+
+- `num_train_epochs`: 20
+- `multi_dataset_batch_sampler`: round_robin
+
+#### All Hyperparameters
+<details><summary>Click to expand</summary>
+
+- `per_device_train_batch_size`: 8
+- `num_train_epochs`: 20
+- `max_steps`: -1
+- `learning_rate`: 5e-05
+- `lr_scheduler_type`: linear
+- `lr_scheduler_kwargs`: None
+- `warmup_steps`: 0
+- `optim`: adamw_torch_fused
+- `optim_args`: None
+- `weight_decay`: 0.0
+- `adam_beta1`: 0.9
+- `adam_beta2`: 0.999
+- `adam_epsilon`: 1e-08
+- `optim_target_modules`: None
+- `gradient_accumulation_steps`: 1
+- `average_tokens_across_devices`: True
+- `max_grad_norm`: 1
+- `label_smoothing_factor`: 0.0
+- `bf16`: False
+- `fp16`: False
+- `bf16_full_eval`: False
+- `fp16_full_eval`: False
+- `tf32`: None
+- `gradient_checkpointing`: False
+- `gradient_checkpointing_kwargs`: None
+- `torch_compile`: False
+- `torch_compile_backend`: None
+- `torch_compile_mode`: None
+- `use_liger_kernel`: False
+- `liger_kernel_config`: None
+- `use_cache`: False
+- `neftune_noise_alpha`: None
+- `torch_empty_cache_steps`: None
+- `auto_find_batch_size`: False
+- `log_on_each_node`: True
+- `logging_nan_inf_filter`: True
+- `include_num_input_tokens_seen`: no
+- `log_level`: passive
+- `log_level_replica`: warning
+- `disable_tqdm`: False
+- `project`: huggingface
+- `trackio_space_id`: trackio
+- `per_device_eval_batch_size`: 8
+- `prediction_loss_only`: True
+- `eval_on_start`: False
+- `eval_do_concat_batches`: True
+- `eval_use_gather_object`: False
+- `eval_accumulation_steps`: None
+- `include_for_metrics`: []
+- `batch_eval_metrics`: False
+- `save_only_model`: False
+- `save_on_each_node`: False
+- `enable_jit_checkpoint`: False
+- `push_to_hub`: False
+- `hub_private_repo`: None
+- `hub_model_id`: None
+- `hub_strategy`: every_save
+- `hub_always_push`: False
+- `hub_revision`: None
+- `load_best_model_at_end`: False
+- `ignore_data_skip`: False
+- `restore_callback_states_from_checkpoint`: False
+- `full_determinism`: False
+- `seed`: 42
+- `data_seed`: None
+- `use_cpu`: False
+- `accelerator_config`: {'split_batches': False, 'dispatch_batches': None, 'even_batches': True, 'use_seedable_sampler': True, 'non_blocking': False, 'gradient_accumulation_kwargs': None}
+- `parallelism_config`: None
+- `dataloader_drop_last`: False
+- `dataloader_num_workers`: 0
+- `dataloader_pin_memory`: True
+- `dataloader_persistent_workers`: False
+- `dataloader_prefetch_factor`: None
+- `remove_unused_columns`: True
+- `label_names`: None
+- `train_sampling_strategy`: random
+- `length_column_name`: length
+- `ddp_find_unused_parameters`: None
+- `ddp_bucket_cap_mb`: None
+- `ddp_broadcast_buffers`: False
+- `ddp_backend`: None
+- `ddp_timeout`: 1800
+- `fsdp`: []
+- `fsdp_config`: {'min_num_params': 0, 'xla': False, 'xla_fsdp_v2': False, 'xla_fsdp_grad_ckpt': False}
+- `deepspeed`: None
+- `debug`: []
+- `skip_memory_metrics`: True
+- `do_predict`: False
+- `resume_from_checkpoint`: None
+- `warmup_ratio`: None
+- `local_rank`: -1
+- `prompts`: None
+- `batch_sampler`: batch_sampler
+- `multi_dataset_batch_sampler`: round_robin
+- `router_mapping`: {}
+- `learning_rate_mapping`: {}
+
+</details>
+
+### Training Time
+- **Training**: 39.7 seconds
+
+### Framework Versions
+- Python: 3.12.3
+- Sentence Transformers: 5.4.1
+- Transformers: 5.5.4
+- PyTorch: 2.11.0+cpu
+- Accelerate: 1.13.0
+- Datasets: 4.8.4
+- Tokenizers: 0.22.2
+
+## Citation
+
+### BibTeX
+
+#### Sentence Transformers
+```bibtex
+@inproceedings{reimers-2019-sentence-bert,
+    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
+    author = "Reimers, Nils and Gurevych, Iryna",
+    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
+    month = "11",
+    year = "2019",
+    publisher = "Association for Computational Linguistics",
+    url = "https://arxiv.org/abs/1908.10084",
+}
+```
+
+#### MultipleNegativesRankingLoss
+```bibtex
+@misc{oord2019representationlearningcontrastivepredictive,
+      title={Representation Learning with Contrastive Predictive Coding},
+      author={Aaron van den Oord and Yazhe Li and Oriol Vinyals},
+      year={2019},
+      eprint={1807.03748},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/1807.03748},
+}
+```
+
+<!--
+## Glossary
+
+*Clearly define terms in order to be accessible across audiences.*
+-->
+
+<!--
+## Model Card Authors
+
+*Lists the people who create the model card, providing recognition and accountability for the detailed work that goes into its construction.*
+-->
+
+<!--
+## Model Card Contact
+
+*Provides a way for people who have updates to the Model Card, suggestions, or questions, to contact the Model Card authors.*
+-->

models/fine_tuned_bilingual_model_v2/config.json

@@ -0,0 +1,30 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "BertModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": null,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "eos_token_id": null,
+  "gradient_checkpointing": false,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 384,
+  "initializer_range": 0.02,
+  "intermediate_size": 1536,
+  "is_decoder": false,
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "bert",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 6,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.5.4",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 30522
+}

models/fine_tuned_bilingual_model_v2/config_sentence_transformers.json

@@ -0,0 +1,14 @@
+{
+  "__version__": {
+    "pytorch": "2.11.0+cpu",
+    "sentence_transformers": "5.4.1",
+    "transformers": "5.5.4"
+  },
+  "default_prompt_name": null,
+  "model_type": "SentenceTransformer",
+  "prompts": {
+    "document": "",
+    "query": ""
+  },
+  "similarity_fn_name": "cosine"
+}

models/fine_tuned_bilingual_model_v2/model.safetensors

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

models/fine_tuned_bilingual_model_v2/modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.base.modules.transformer.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.sentence_transformer.modules.pooling.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.sentence_transformer.modules.normalize.Normalize"
+  }
+]

models/fine_tuned_bilingual_model_v2/sentence_bert_config.json

@@ -0,0 +1,10 @@
+{
+    "transformer_task": "feature-extraction",
+    "modality_config": {
+        "text": {
+            "method": "forward",
+            "method_output_name": "last_hidden_state"
+        }
+    },
+    "module_output_name": "token_embeddings"
+}

models/fine_tuned_bilingual_model_v2/tokenizer_config.json

@@ -0,0 +1,23 @@
+{
+  "backend": "tokenizers",
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": true,
+  "is_local": false,
+  "mask_token": "[MASK]",
+  "max_length": 128,
+  "model_max_length": 256,
+  "never_split": null,
+  "pad_to_multiple_of": null,
+  "pad_token": "[PAD]",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "[SEP]",
+  "stride": 0,
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "BertTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "[UNK]"
+}

serializers.py

@@ -0,0 +1,54 @@
+from rest_framework import serializers
+from .models import PropertyCustomQA
+
+class PropertyCustomQASerializer(serializers.ModelSerializer):
+    class Meta:
+        model = PropertyCustomQA
+        fields = ['id', 'question', 'answer', 'order', 'is_active']
+        read_only_fields = ['id', 'created_at', 'updated_at']
+    
+    def validate_question(self, value):
+        if len(value.strip()) < 5:
+            raise serializers.ValidationError("Question must be at least 5 characters")
+        return value.strip()
+    
+    def validate_answer(self, value):
+        if len(value.strip()) < 5:
+            raise serializers.ValidationError("Answer must be at least 5 characters")
+        return value.strip()
+
+
+class EnableAutoChatSerializer(serializers.Serializer):
+    """Serializer for enabling auto-chat with custom questions"""
+    property_id = serializers.UUIDField()
+    enable = serializers.BooleanField(default=True)
+    custom_questions = serializers.ListField(
+        child=PropertyCustomQASerializer(),
+        required=False,
+        max_length=5,  # Max 5 questions
+        min_length=0
+    )
+    
+    def validate_custom_questions(self, value):
+        if len(value) > 5:
+            raise serializers.ValidationError("Maximum 5 custom questions allowed")
+        return value
+    
+    def validate(self, data):
+        # Check if all master questions are answered first
+        from .models import MasterQuestion, PropertyQA
+        
+        property_id = data['property_id']
+        total_master = MasterQuestion.objects.filter(is_active=True).count()
+        answered_master = PropertyQA.objects.filter(
+            property_id=property_id,
+            master_question__is_active=True
+        ).count()
+        
+        if answered_master < total_master:
+            raise serializers.ValidationError(
+                f"Please answer all {total_master} master questions first. "
+                f"Currently answered: {answered_master}/{total_master}"
+            )
+        
+        return data

services.py

@@ -0,0 +1,488 @@
+import logging
+import threading
+from typing import List, Dict, Optional, Any
+
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from django.conf import settings
+from django.utils import timezone
+from pgvector.django import CosineDistance
+
+from .models import GlobalQA, PropertyCustomQA, PropertyQA, AgencyAutoChatSetting, PropertyAutoChatState
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingService:
+    """
+    FIX #7: Thread-safe singleton with per-thread model instances
+    Prevents memory leak and handles Django's multi-threaded environment
+    """
+    _instances: Dict[int, 'EmbeddingService'] = {}
+    _lock = threading.Lock()
+    _model_path = None
+    
+    def __new__(cls):
+        """Thread-aware singleton: different instance per thread"""
+        thread_id = threading.get_ident()
+        
+        if thread_id not in cls._instances:
+            with cls._lock:
+                if thread_id not in cls._instances:
+                    instance = super().__new__(cls)
+                    instance._loaded = False
+                    cls._instances[thread_id] = instance
+        
+        instance = cls._instances[thread_id]
+        if not instance._loaded:
+            instance._load_model()
+            instance._loaded = True
+        
+        return instance
+    
+    def __init__(self):
+        """Initialize but don't load model until needed"""
+        if not hasattr(self, '_loaded'):
+            self._loaded = False
+    
+    def _load_model(self):
+        """Load the sentence transformer model"""
+        try:
+            model_path = getattr(settings, 'AI_MODEL_PATH', 'all-MiniLM-L6-v2')
+            self._model = SentenceTransformer(model_path)
+            logger.info(f"✅ AI Model loaded in thread {threading.get_ident()} from {model_path}")
+        except Exception as e:
+            logger.error(f"❌ Failed to load model: {e}")
+            raise
+    
+    @classmethod
+    def cleanup_thread(cls):
+        """Clean up model for current thread (call when thread exits)"""
+        thread_id = threading.get_ident()
+        if thread_id in cls._instances:
+            del cls._instances[thread_id]
+            logger.info(f"🧹 Cleaned up AI model for thread {thread_id}")
+    
+    def generate_embedding(self, text: str) -> List[float]:
+        """Generate embedding vector for text"""
+        if not hasattr(self, '_model') or self._model is None:
+            self._load_model()
+        
+        embedding = self._model.encode(text)
+        return embedding.tolist()
+    
+    def find_best_answer_for_property(self, question: str, property_id: str, 
+                                       threshold: float = 0.6) -> Dict[str, Any]:
+        """Find best matching answer for this specific property"""
+        question_embedding = self.generate_embedding(question)
+        
+        # Check Global Q&A first (greetings)
+        best_global = GlobalQA.objects.filter(is_active=True).annotate(
+            distance=CosineDistance('question_embedding', question_embedding)
+        ).order_by('distance').first()
+        
+        if best_global:
+            confidence = 1 - best_global.distance
+            if confidence > threshold:
+                return {
+                    'answer': best_global.answer,
+                    'confidence': confidence,
+                    'matched_question': best_global.question,
+                    'type': 'global'
+                }
+        
+        # Check Property Q&A
+        if property_id:
+            best_prop = PropertyQA.objects.filter(
+                property_id=property_id, 
+                is_active=True
+            ).annotate(
+                distance=CosineDistance('question_embedding', question_embedding)
+            ).select_related('master_question').order_by('distance').first()
+            
+            if best_prop:
+                confidence = 1 - best_prop.distance
+                if confidence > threshold:
+                    return {
+                        'answer': best_prop.answer,
+                        'confidence': confidence,
+                        'matched_question': best_prop.master_question.question,
+                        'type': 'property'
+                    }
+        
+        return {
+            'answer': "Our agent will respond shortly. Thank you for your patience!",
+            'confidence': 0.0,
+            'matched_question': None,
+            'type': 'fallback'
+        }
+    
+
+    # ai_chatbot/services.py - Update find_best_answer_global_first
+
+    def find_best_answer_global_first(self, question: str, property_id: str = None, 
+                                    threshold: float = 0.6) -> Dict[str, Any]:
+        """
+        Priority: 1. Property Data (dynamic) | 2. Global Greetings | 3. Property Master QA | 4. Property Custom QA | 5. Fallback
+        """
+        
+        # ✅ NEW: Check property data first (highest priority)
+        if property_id:
+            property_data_answer = self.get_property_info_answer(question, property_id)
+            if property_data_answer:
+                return property_data_answer
+        
+        question_embedding = self.generate_embedding(question)
+        
+        # 1. Global Greetings
+        best_global = GlobalQA.objects.filter(is_active=True).annotate(
+            distance=CosineDistance('question_embedding', question_embedding)
+        ).order_by('distance').first()
+        
+        if best_global:
+            global_conf = 1 - best_global.distance
+            if global_conf > 0.92:
+                return {
+                    'answer': best_global.answer,
+                    'confidence': global_conf,
+                    'matched_question': best_global.question,
+                    'type': 'global'
+                }
+        
+        # 2. Property Master Q&A
+        if property_id:
+            best_prop = PropertyQA.objects.filter(
+                property_id=property_id, 
+                is_active=True
+            ).annotate(
+                distance=CosineDistance('question_embedding', question_embedding)
+            ).select_related('master_question').order_by('distance').first()
+            
+            if best_prop:
+                prop_conf = 1 - best_prop.distance
+                if prop_conf > threshold:
+                    return {
+                        'answer': best_prop.answer,
+                        'confidence': prop_conf,
+                        'matched_question': best_prop.master_question.question,
+                        'type': 'property_master'
+                    }
+        
+        # 3. Property Custom Q&A
+        if property_id:
+            best_custom = PropertyCustomQA.objects.filter(
+                property_id=property_id,
+                is_active=True
+            ).annotate(
+                distance=CosineDistance('question_embedding', question_embedding)
+            ).order_by('distance').first()
+            
+            if best_custom:
+                custom_conf = 1 - best_custom.distance
+                if custom_conf > threshold:
+                    return {
+                        'answer': best_custom.answer,
+                        'confidence': custom_conf,
+                        'matched_question': best_custom.question,
+                        'type': 'property_custom'
+                    }
+        
+        # 4. Fallback
+        return {
+            'answer': "Our agent will respond shortly. Thank you for your patience!",
+            'confidence': 0.0,
+            'matched_question': None,
+            'type': 'fallback'
+        }
+    
+    
+    def get_property_info_answer(self, question: str, property_id: str) -> Dict[str, Any]:
+        """Get answer from actual property data"""
+        from Property.models import Property
+        
+        try:
+            # ✅ Remove 'area' from select_related - it's not a foreign key
+            property_obj = Property.objects.select_related('city').get(id=property_id)
+        except Property.DoesNotExist:
+            return None
+        
+        question_lower = question.lower()
+        
+        # City/Location questions
+        if any(word in question_lower for word in ['city', 'location', 'which city', 'kahan', 'city name', 'shahar']):
+            city_name = getattr(property_obj, 'city', None)
+            if city_name:
+                if hasattr(city_name, 'city'):
+                    city = city_name.city
+                else:
+                    city = str(city_name)
+            else:
+                city = "Karachi"
+            return {
+                'answer': f"This property is located in {city}, Pakistan.",
+                'confidence': 0.98,
+                'type': 'property_data'
+            }
+        
+        # Area/Sector questions - handle area as a property field (not foreign key)
+        elif any(word in question_lower for word in ['area', 'sector', 'phase', 'block', 'location detail', 'area name']):
+            # ✅ 'area' is likely a direct field, not a foreign key
+            area = getattr(property_obj, 'area', None)
+            if area:
+                # If area is a string or has __str__ method
+                area_name = str(area)
+            else:
+                area_name = "the main area"
+            return {
+                'answer': f"This property is in {area_name} area.",
+                'confidence': 0.98,
+                'type': 'property_data'
+            }
+        
+        # Address questions
+        elif any(word in question_lower for word in ['address', 'exact location', 'full address', 'pata', 'complete address']):
+            address = getattr(property_obj, 'address', None)
+            if address:
+                return {
+                    'answer': f"Full address: {address}",
+                    'confidence': 0.98,
+                    'type': 'property_data'
+                }
+        
+        # Price/Rent questions
+        elif any(word in question_lower for word in ['price', 'rent', 'cost', 'kitna', 'rate', 'price kya hai', 'rent kya hai']):
+            price = getattr(property_obj, 'price', None)
+            if price:
+                return {
+                    'answer': f"The price for this property is PKR {price:,}.",
+                    'confidence': 0.98,
+                    'type': 'property_data'
+                }
+        
+        # Bedrooms
+        elif any(word in question_lower for word in ['bedroom', 'bed', 'rooms', 'kitne kamray', 'bed count']):
+            beds = getattr(property_obj, 'beds', None)
+            if beds:
+                return {
+                    'answer': f"This property has {beds} bedroom(s).",
+                    'confidence': 0.98,
+                    'type': 'property_data'
+                }
+        
+        # Bathrooms
+        elif any(word in question_lower for word in ['bathroom', 'bath', 'washroom', 'bathrooms', 'bath count']):
+            baths = getattr(property_obj, 'baths', None)
+            if baths:
+                return {
+                    'answer': f"This property has {baths} bathroom(s).",
+                    'confidence': 0.98,
+                    'type': 'property_data'
+                }
+        
+        # Property size
+        elif any(word in question_lower for word in ['size', 'area size', 'total area', 'square feet', 'sqft', 'marle']):
+            area_size = getattr(property_obj, 'area_unit', None) or getattr(property_obj, 'total_area', None) or getattr(property_obj, 'land_area', None)
+            if area_size:
+                return {
+                    'answer': f"The total area of this property is {area_size} sq ft.",
+                    'confidence': 0.98,
+                    'type': 'property_data'
+                }
+        
+        # Property type / Category
+        elif any(word in question_lower for word in ['type', 'property type', 'kind', 'category']):
+            category = getattr(property_obj, 'category', None)
+            if category:
+                if hasattr(category, 'category'):
+                    category_name = category.category
+                else:
+                    category_name = str(category)
+                return {
+                    'answer': f"This is a {category_name} property.",
+                    'confidence': 0.98,
+                    'type': 'property_data'
+                }
+        
+        elif any(word in question_lower for word in ['detail', 'property information', 'property detail kiya hai', 'description', 'description kiya hai']):
+                desc = getattr(property_obj, 'desc', None)
+                if desc:
+                    if hasattr(desc, 'desc'):
+                        description_name = desc.desc
+                    else:
+                        description_name = str(desc)
+                    return {
+                        'answer': f"iss property ki detail hai: {description_name}.",
+                        'confidence': 0.98,
+                        'type': 'property_data'
+                    }
+
+        return None
+    
+    def _cosine_similarity(self, embedding1: List[float], embedding2: List[float]) -> float:
+        """Calculate cosine similarity between two embeddings"""
+        vec1 = np.array(embedding1)
+        vec2 = np.array(embedding2)
+        dot = np.dot(vec1, vec2)
+        norm1 = np.linalg.norm(vec1)
+        norm2 = np.linalg.norm(vec2)
+        return float(dot / (norm1 * norm2)) if norm1 and norm2 else 0.0
+
+
+class AutoChatService:
+    """Orchestration service for auto-chat functionality"""
+    
+    def __init__(self):
+        self.embedding_service = EmbeddingService()
+    
+    def should_auto_reply(self, chat_id: str, property_id: str, 
+                          last_agency_reply_at=None, last_client_message_at=None) -> bool:
+        """Check if auto-reply should trigger"""
+        from Chat.models import Chat
+        
+        try:
+            # Get property auto-chat state
+            property_state = PropertyAutoChatState.objects.get(property_id=property_id)
+            
+            if not property_state.is_auto_chat_enabled:
+                return False
+            
+            # Get agency settings
+            property_obj = property_state.property
+            agency_setting = AgencyAutoChatSetting.objects.get(agency=property_obj.user)
+            
+            if not agency_setting.is_enabled:
+                return False
+            
+            if not last_client_message_at:
+                return False
+            
+            # If agency replied after last client message, don't auto-reply
+            if last_agency_reply_at and last_agency_reply_at > last_client_message_at:
+                return False
+            
+            # Check if configured delay passed
+            time_diff = (timezone.now() - last_client_message_at).total_seconds()
+            return time_diff >= agency_setting.delay_seconds
+            
+        except (PropertyAutoChatState.DoesNotExist, AgencyAutoChatSetting.DoesNotExist):
+            return False
+        except Exception as e:
+            logger.error(f"Error checking auto-reply: {e}")
+            return False
+    
+    def generate_auto_reply(self, client_message: str, property_id: str, 
+                            chat_id: str) -> Optional[Dict[str, Any]]:
+        """Generate auto-reply with proper thresholds"""
+        try:
+            from Property.models import Property
+            
+            property_obj = Property.objects.get(id=property_id)
+            agency_setting = AgencyAutoChatSetting.objects.get(agency=property_obj.user)
+            
+            # Use agency's configured threshold
+            result = self.embedding_service.find_best_answer_global_first(
+                client_message,
+                property_id,
+                agency_setting.confidence_threshold
+            )
+            
+            logger.info(f"🤖 Auto-reply | Type: {result['type']} | Confidence: {result['confidence']:.2f}")
+            
+            return {
+                'answer': result['answer'],
+                'confidence': result['confidence'],
+                'matched_question': result.get('matched_question'),
+                'is_auto_reply': True,
+                'reply_type': result['type'],
+                'is_fallback': result['type'] == 'fallback'
+            }
+            
+        except Property.DoesNotExist:
+            logger.error(f"Property {property_id} not found")
+            return None
+        except AgencyAutoChatSetting.DoesNotExist:
+            logger.warning(f"No agency settings for property {property_id}, using defaults")
+            # Fallback to defaults
+            result = self.embedding_service.find_best_answer_global_first(
+                client_message, property_id, 0.6
+            )
+            return {
+                'answer': result['answer'],
+                'confidence': result['confidence'],
+                'matched_question': result.get('matched_question'),
+                'is_auto_reply': True,
+                'reply_type': result['type'],
+                'is_fallback': result['type'] == 'fallback'
+            }
+        except Exception as e:
+            logger.error(f"Auto-reply error: {e}", exc_info=True)
+            return None
+    
+    def sync_property_listing_to_ai(self, property_id: str) -> bool:
+        """
+        Sync property data to AI Q&A
+        FIX #5: Don't delete existing, update in place
+        """
+        from .models import MasterQuestion, PropertyQA
+        from Property.models import Property
+        
+        try:
+            property_obj = Property.objects.get(id=property_id)
+            agency = property_obj.user
+            
+            # Mapping of listing fields to Master Questions
+            data_map = {
+                "What is the price or rent of this property?": f"The demand for this property is PKR {property_obj if hasattr(property_obj, 'price') else 'contact agent'}.",
+                "What is the location and area of this property?": f"This property is located in {getattr(property_obj, 'area', 'the area')}, {getattr(property_obj, 'city', 'the city')}.",
+                "How many bedrooms and bathrooms does it have?": f"It is a {getattr(property_obj, 'beds', 'N/A')} bedroom property with {getattr(property_obj, 'baths', 'N/A')} bathrooms.",
+                "What is the total size or area of the property?": f"The total size is {getattr(property_obj, 'area', 'N/A')} {getattr(property_obj, 'area_unit', 'sq ft')}.",
+                "What type of property is it?": f"This is a {getattr(property_obj, 'category', 'property')}.",
+                "How many kitchens and TV lounges does it have?": f"It has {getattr(property_obj, 'kitchen', 'N/A')} kitchens and {getattr(property_obj, 'tv_launch', 'N/A')} TV lounges.",
+                "What is contact number of the agent?": f"You can contact the agent at {getattr(property_obj, 'agent_two_phone_number', 'the provided number')}.",
+                "Information About this property": f"{getattr(property_obj, 'desc', 'Contact agent for details')}",
+
+            }
+            
+            updated_count = 0
+            created_count = 0
+            
+            for q_text, answer_text in data_map.items():
+                master_q = MasterQuestion.objects.filter(question=q_text, is_active=True).first()
+                
+                if master_q:
+                    embedding = self.embedding_service.generate_embedding(q_text)
+                    
+                    # FIX #5: Update or create without deleting
+                    obj, created = PropertyQA.objects.update_or_create(
+                        property=property_obj,
+                        master_question=master_q,
+                        defaults={
+                            'agency': agency,
+                            'answer': answer_text,
+                            'question_embedding': embedding,
+                            'is_active': True
+                        }
+                    )
+                    
+                    if created:
+                        created_count += 1
+                    else:
+                        updated_count += 1
+            
+            logger.info(f"✅ Sync complete for Property {property_id} | Created: {created_count} | Updated: {updated_count}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"❌ Sync error for property {property_id}: {e}", exc_info=True)
+            return False
+
+@receiver(post_save, sender='Property.Property')
+def auto_sync_ai_on_listing_save(sender, instance, created, **kwargs):
+    """Jab bhi property save ho, AI data sync karo"""
+    try:
+        from ai_chatbot.services import AutoChatService
+        service = AutoChatService()
+        service.sync_property_listing_to_ai(instance.id)
+    except Exception as e:
+        logger.error(f"Signal Error: {e}")  

tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

urls.py

@@ -0,0 +1,27 @@
+from django.urls import path
+from . import views
+
+urlpatterns = [
+    # Admin Global Q&A CRUD
+    path('admin/global-qa/', views.admin_global_qa),
+    path('admin/global-qa/<uuid:qa_id>/', views.admin_global_qa),
+    path('admin/global-qa/bulk/', views.admin_global_qa_bulk),
+    
+    # Admin CRUD (Single)
+    path('admin/master-questions/', views.admin_master_questions),
+    path('admin/master-questions/<uuid:question_id>/', views.admin_master_questions),
+    
+    # Admin Bulk Create
+    path('admin/master-questions/bulk/', views.admin_master_questions_bulk),
+    
+    # Agency endpoints
+    path('master-questions/', views.get_master_questions),
+    path('property-qa/save-bulk/', views.save_property_qa_bulk),
+    path('property-qa/status/<uuid:property_id>/', views.get_property_qa_status),
+    path('auto-chat/toggle/<uuid:property_id>/', views.toggle_auto_chat),
+    path('auto-chat/enable-with-questions/', views.enable_auto_chat_with_questions),
+    path('custom-questions/<uuid:property_id>/', views.get_custom_questions),
+    
+    # Webhook for Chat app
+    path('webhook/auto-reply/', views.webhook_auto_reply),
+]

views.py

@@ -0,0 +1,813 @@
+import logging
+import secrets
+from django.conf import settings
+from django.core.exceptions import ValidationError
+from rest_framework import status
+from rest_framework.decorators import api_view, authentication_classes, permission_classes
+from rest_framework.permissions import IsAuthenticated, AllowAny
+from rest_framework.response import Response
+from rest_framework_simplejwt.authentication import JWTAuthentication
+
+from ai_chatbot.serializers import EnableAutoChatSerializer, PropertyCustomQASerializer
+
+from .models import MasterQuestion, PropertyCustomQA, PropertyQA, AgencyAutoChatSetting, PropertyAutoChatState, GlobalQA
+from .services import EmbeddingService
+
+logger = logging.getLogger(__name__)
+embedding_service = EmbeddingService()
+
+
+# FIX #8: Add serializer validation
+from rest_framework import serializers
+
+class QAAnswerSerializer(serializers.Serializer):
+    master_question_id = serializers.UUIDField(required=True)
+    answer = serializers.CharField(max_length=5000, required=True, allow_blank=False)
+
+class BulkQASerializer(serializers.Serializer):
+    property_id = serializers.UUIDField(required=True)
+    answers = QAAnswerSerializer(many=True, required=True)
+
+
+# FIX #3: Webhook authentication
+class WebhookSecretAuthentication:
+    """Custom authentication for webhook endpoint"""
+    
+    def authenticate(self, request):
+        secret = request.headers.get('X-Webhook-Secret')
+        expected_secret = getattr(settings, 'AI_WEBHOOK_SECRET', None)
+        
+        if not expected_secret:
+            logger.warning("AI_WEBHOOK_SECRET not set in settings")
+            return None
+        
+        if secret and secrets.compare_digest(secret, expected_secret):
+            return (None, None)  # Valid
+        return None
+    
+    def authenticate_header(self, request):
+        return 'X-Webhook-Secret'
+
+
+@api_view(['GET'])
+@authentication_classes([JWTAuthentication])
+@permission_classes([IsAuthenticated])
+def get_master_questions(request):
+    """Get all master questions for agency to answer"""
+    questions = MasterQuestion.objects.filter(is_active=True).order_by('order')
+    data = [{'id': str(q.id), 'question': q.question, 'order': q.order} for q in questions]
+    return Response({'questions': data})
+
+
+@api_view(['GET'])
+@authentication_classes([JWTAuthentication])
+@permission_classes([IsAuthenticated])
+def get_property_qa_status(request, property_id):
+    """Get Q&A status for a property"""
+    user = request.user
+    
+    master_questions = MasterQuestion.objects.filter(is_active=True).order_by('order')
+    
+    # Get existing answers
+    existing_qa = {
+        str(qa.master_question_id): {
+            'answer': qa.answer,
+            'qa_id': str(qa.id),
+            'updated_at': qa.updated_at
+        }
+        for qa in PropertyQA.objects.filter(
+            property_id=property_id,
+            agency=user
+        ).select_related('master_question')
+    }
+    
+    questions_data = []
+    for mq in master_questions:
+        mq_id = str(mq.id)
+        questions_data.append({
+            'id': mq_id,
+            'question': mq.question,
+            'order': mq.order,
+            'is_answered': mq_id in existing_qa,
+            'answer': existing_qa[mq_id]['answer'] if mq_id in existing_qa else None,
+            'updated_at': existing_qa[mq_id]['updated_at'] if mq_id in existing_qa else None,
+        })
+    
+    # Get settings
+    try:
+        auto_chat_setting = AgencyAutoChatSetting.objects.get(agency=user)
+        auto_chat_enabled = auto_chat_setting.is_enabled
+        delay_seconds = auto_chat_setting.delay_seconds
+        confidence_threshold = auto_chat_setting.confidence_threshold
+    except AgencyAutoChatSetting.DoesNotExist:
+        auto_chat_enabled = False
+        delay_seconds = 30
+        confidence_threshold = 0.6
+    
+    try:
+        property_auto_state = PropertyAutoChatState.objects.get(property_id=property_id)
+        property_auto_enabled = property_auto_state.is_auto_chat_enabled
+    except PropertyAutoChatState.DoesNotExist:
+        property_auto_enabled = False
+    
+    answered_count = sum(1 for q in questions_data if q['is_answered'])
+    total_questions = len(questions_data)
+    
+    return Response({
+        'property_id': property_id,
+        'master_questions': questions_data,
+        'stats': {
+            'total_questions': total_questions,
+            'answered_count': answered_count,
+            'completion_percentage': round((answered_count / total_questions) * 100, 1) if total_questions > 0 else 0,
+            'remaining_count': total_questions - answered_count
+        },
+        'auto_chat_settings': {
+            'is_enabled': auto_chat_enabled,
+            'property_auto_enabled': property_auto_enabled,
+            'delay_seconds': delay_seconds,
+            'confidence_threshold': confidence_threshold
+        }
+    })
+
+
+@api_view(['POST'])
+@authentication_classes([JWTAuthentication])
+@permission_classes([IsAuthenticated])
+def save_property_qa_bulk(request):
+    """
+    FIX #5 & #9: Optimized bulk save with proper auto-enable logic
+    """
+    user = request.user
+    
+    # Check role
+    if not hasattr(user, 'role') or getattr(user.role, 'role_type', None) != 'agency':
+        return Response({'error': 'Only agencies can add Q&A'}, status=status.HTTP_403_FORBIDDEN)
+    
+    # FIX #8: Validate input
+    serializer = BulkQASerializer(data=request.data)
+    if not serializer.is_valid():
+        return Response({'error': 'Invalid data', 'details': serializer.errors}, 
+                       status=status.HTTP_400_BAD_REQUEST)
+    
+    validated_data = serializer.validated_data
+    property_id = validated_data['property_id']
+    answers = validated_data['answers']
+    
+    if not answers:
+        return Response({'error': 'No answers provided'}, status=status.HTTP_400_BAD_REQUEST)
+    
+    # FIX #5: Get existing answers to minimize database operations
+    existing_qa = {
+        str(qa.master_question_id): qa
+        for qa in PropertyQA.objects.filter(
+            property_id=property_id,
+            agency=user
+        ).select_related('master_question')
+    }
+    
+    # Track which master questions were answered
+    answered_master_ids = set()
+    created_count = 0
+    updated_count = 0
+    errors = []
+    
+    for item in answers:
+        master_q_id = str(item['master_question_id'])
+        answer = item['answer'].strip()
+        
+        if not answer:
+            continue
+        
+        try:
+            master_q = MasterQuestion.objects.get(id=master_q_id, is_active=True)
+            answered_master_ids.add(master_q_id)
+            
+            # Generate embedding
+            embedding = embedding_service.generate_embedding(master_q.question)
+            
+            # Update or create
+            if master_q_id in existing_qa:
+                # Update existing
+                qa = existing_qa[master_q_id]
+                qa.answer = answer
+                qa.question_embedding = embedding
+                qa.save(update_fields=['answer', 'question_embedding', 'updated_at'])
+                updated_count += 1
+            else:
+                # Create new
+                PropertyQA.objects.create(
+                    agency=user,
+                    property_id=property_id,
+                    master_question=master_q,
+                    answer=answer,
+                    question_embedding=embedding
+                )
+                created_count += 1
+                
+        except MasterQuestion.DoesNotExist:
+            errors.append(f'Master question not found: {master_q_id}')
+        except Exception as e:
+            errors.append(f'Error for question {master_q_id}: {str(e)}')
+    
+    # Delete answers that were removed (not in current submission)
+    to_delete_ids = set(existing_qa.keys()) - answered_master_ids
+    if to_delete_ids:
+        deleted_count = PropertyQA.objects.filter(
+            property_id=property_id,
+            master_question_id__in=to_delete_ids
+        ).delete()[0]
+        logger.info(f"Deleted {deleted_count} removed answers for property {property_id}")
+    
+    # FIX #9: Auto-enable only when ALL ACTIVE master questions are answered
+    total_active_questions = MasterQuestion.objects.filter(is_active=True).count()
+    total_answered = PropertyQA.objects.filter(
+        property_id=property_id,
+        master_question__is_active=True
+    ).count()
+    
+    auto_chat_enabled = False
+    if total_answered >= total_active_questions and total_active_questions > 0:
+        property_state, created = PropertyAutoChatState.objects.update_or_create(
+            property_id=property_id,
+            defaults={'is_auto_chat_enabled': True}
+        )
+        auto_chat_enabled = True
+        logger.info(f"✅ Auto-chat enabled for property {property_id} ({total_answered}/{total_active_questions} questions answered)")
+    
+    return Response({
+        'message': f'Saved answers for property',
+        'created': created_count,
+        'updated': updated_count,
+        'total': created_count + updated_count,
+        'auto_chat_enabled': auto_chat_enabled,
+        'completion': {
+            'answered': total_answered,
+            'total': total_active_questions,
+            'percentage': round((total_answered / total_active_questions) * 100, 1) if total_active_questions > 0 else 0
+        },
+        'errors': errors if errors else None
+    }, status=status.HTTP_200_OK if (created_count + updated_count) > 0 else status.HTTP_400_BAD_REQUEST)
+
+
+@api_view(['POST'])
+@authentication_classes([JWTAuthentication])
+@permission_classes([IsAuthenticated])
+def toggle_auto_chat(request, property_id):
+    """Enable/disable auto-chat for a specific property"""
+    user = request.user
+    
+    if not hasattr(user, 'role') or getattr(user.role, 'role_type', None) != 'agency':
+        return Response({'error': 'Only agencies can configure auto-chat'}, status=status.HTTP_403_FORBIDDEN)
+    
+    is_enabled = request.data.get('is_enabled', False)
+    
+    # Validate before enabling
+    if is_enabled:
+        total_required = MasterQuestion.objects.filter(is_active=True).count()
+        total_answered = PropertyQA.objects.filter(
+            property_id=property_id,
+            agency=user,
+            master_question__is_active=True
+        ).count()
+        
+        if total_answered < total_required:
+            return Response({
+                'error': f'Please answer all {total_required} active questions first. Currently answered: {total_answered}/{total_required}'
+            }, status=status.HTTP_400_BAD_REQUEST)
+    
+    # Update property auto-chat state
+    property_state, created = PropertyAutoChatState.objects.get_or_create(
+        property_id=property_id,
+        defaults={'is_auto_chat_enabled': is_enabled}
+    )
+    
+    if not created:
+        property_state.is_auto_chat_enabled = is_enabled
+        property_state.save()
+    
+    # Also update agency-wide setting
+    agency_setting, _ = AgencyAutoChatSetting.objects.get_or_create(
+        agency=user,
+        defaults={
+            'is_enabled': is_enabled,
+            'delay_seconds': 30,
+            'confidence_threshold': 0.6
+        }
+    )
+    
+    if not agency_setting.is_enabled and is_enabled:
+        agency_setting.is_enabled = True
+        agency_setting.save()
+    
+    return Response({
+        'property_id': property_id,
+        'is_enabled': property_state.is_auto_chat_enabled,
+        'message': f'Auto-chat {"enabled" if is_enabled else "disabled"} for this property'
+    })
+
+
+@api_view(['POST'])
+@authentication_classes([WebhookSecretAuthentication])  # FIX #3: Secure webhook
+@permission_classes([AllowAny])
+def webhook_auto_reply(request):
+    """
+    FIX #3: Secured webhook endpoint for Chat app to trigger auto-reply
+    """
+    from .services import AutoChatService
+    
+    # Validate required fields
+    required_fields = ['chat_id', 'property_id', 'message']
+    for field in required_fields:
+        if field not in request.data:
+            return Response({'error': f'Missing required field: {field}'}, 
+                          status=status.HTTP_400_BAD_REQUEST)
+    
+    data = request.data
+    chat_id = data.get('chat_id')
+    property_id = data.get('property_id')
+    client_message = data.get('message')
+    last_agency_reply_at = data.get('last_agency_reply_at')
+    last_client_message_at = data.get('last_client_message_at')
+    
+    auto_chat_service = AutoChatService()
+    
+    # Check if auto-reply should trigger
+    if auto_chat_service.should_auto_reply(chat_id, property_id, last_agency_reply_at, last_client_message_at):
+        reply = auto_chat_service.generate_auto_reply(client_message, property_id, chat_id)
+        if reply:
+            return Response(reply)
+        return Response({'should_auto_reply': False, 'error': 'Failed to generate reply'})
+    
+    return Response({'should_auto_reply': False})
+
+
+@api_view(['POST'])
+@authentication_classes([JWTAuthentication])
+@permission_classes([IsAuthenticated])
+def enable_auto_chat_with_questions(request):
+    """
+    Enable auto-chat for a property and add custom questions (max 5)
+    """
+    user = request.user
+    
+    # Check if agency
+    if not hasattr(user, 'role') or getattr(user.role, 'role_type', None) != 'agency':
+        return Response({'error': 'Only agencies can enable auto-chat'}, 
+                       status=status.HTTP_403_FORBIDDEN)
+    
+    # Validate input
+    serializer = EnableAutoChatSerializer(data=request.data)
+    if not serializer.is_valid():
+        return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
+    
+    validated_data = serializer.validated_data
+    property_id = validated_data['property_id']
+    enable = validated_data['enable']
+    custom_questions = validated_data.get('custom_questions', [])
+    
+    # Verify property belongs to this agency
+    from Property.models import Property
+    try:
+        property_obj = Property.objects.get(id=property_id, user=user)
+    except Property.DoesNotExist:
+        return Response({'error': 'Property not found or does not belong to you'}, 
+                       status=status.HTTP_404_NOT_FOUND)
+    
+    # Delete existing custom questions for this property
+    PropertyCustomQA.objects.filter(property_id=property_id).delete()
+    
+    # Add new custom questions with embeddings
+    created_questions = []
+    for idx, q_data in enumerate(custom_questions):
+        # Generate embedding for the question
+        embedding = embedding_service.generate_embedding(q_data['question'])
+        
+        custom_qa = PropertyCustomQA.objects.create(
+            agency=user,
+            property=property_obj,
+            question=q_data['question'],
+            answer=q_data['answer'],
+            question_embedding=embedding,
+            order=idx + 1,  # 1, 2, 3, 4, 5
+            is_active=True
+        )
+        created_questions.append({
+            'order': custom_qa.order,
+            'question': custom_qa.question,
+            'answer': custom_qa.answer
+        })
+    
+    # Enable or disable auto-chat
+    property_state, created = PropertyAutoChatState.objects.update_or_create(
+        property_id=property_id,
+        defaults={'is_auto_chat_enabled': enable}
+    )
+    
+    # Also update agency settings
+    agency_setting, _ = AgencyAutoChatSetting.objects.get_or_create(
+        agency=user,
+        defaults={
+            'is_enabled': enable,
+            'delay_seconds': 30,
+            'confidence_threshold': 0.7
+        }
+    )
+    if enable and not agency_setting.is_enabled:
+        agency_setting.is_enabled = True
+        agency_setting.save()
+    
+    return Response({
+        'success': True,
+        'property_id': str(property_id),
+        'auto_chat_enabled': property_state.is_auto_chat_enabled,
+        'custom_questions_added': len(created_questions),
+        'custom_questions': created_questions,
+        'message': f'Auto-chat {"enabled" if enable else "disabled"} with {len(created_questions)} custom questions'
+    }, status=status.HTTP_200_OK)
+
+
+@api_view(['GET'])
+@authentication_classes([JWTAuthentication])
+@permission_classes([IsAuthenticated])
+def get_custom_questions(request, property_id):
+    """
+    Get custom questions for a property (for editing)
+    """
+    user = request.user
+    
+    # Verify property belongs to agency
+    from Property.models import Property
+    try:
+        property_obj = Property.objects.get(id=property_id, user=user)
+    except Property.DoesNotExist:
+        return Response({'error': 'Property not found'}, status=status.HTTP_404_NOT_FOUND)
+    
+    custom_questions = PropertyCustomQA.objects.filter(
+        property_id=property_id,
+        is_active=True
+    ).order_by('order')
+    
+    serializer = PropertyCustomQASerializer(custom_questions, many=True)
+    
+    # Get auto-chat status
+    auto_chat_state = PropertyAutoChatState.objects.filter(property_id=property_id).first()
+    
+    return Response({
+        'property_id': str(property_id),
+        'auto_chat_enabled': auto_chat_state.is_auto_chat_enabled if auto_chat_state else False,
+        'custom_questions': serializer.data,
+        'max_allowed': 5,
+        'remaining_slots': 5 - len(serializer.data)
+    })
+
+import uuid
+from rest_framework.decorators import api_view, permission_classes
+from rest_framework.permissions import IsAdminUser
+
+
+@api_view(['GET', 'POST', 'PUT', 'DELETE'])
+@permission_classes([IsAdminUser])
+def admin_master_questions(request, question_id=None):
+    """
+    Admin CRUD for master questions
+    """
+    
+    # ==================== GET ====================
+    if request.method == 'GET':
+        if question_id:
+            try:
+                question = MasterQuestion.objects.get(id=question_id)
+                data = {
+                    'id': str(question.id),
+                    'question': question.question,
+                    'order': question.order,
+                    'is_active': question.is_active,
+                    'created_at': question.created_at
+                }
+                return Response(data)
+            except MasterQuestion.DoesNotExist:
+                return Response({'error': 'Question not found'}, status=404)
+        else:
+            questions = MasterQuestion.objects.all().order_by('order')
+            data = [{
+                'id': str(q.id),
+                'question': q.question,
+                'order': q.order,
+                'is_active': q.is_active
+            } for q in questions]
+            return Response({
+                'count': len(data),
+                'questions': data
+            })
+    
+    # ==================== CREATE (Single) ====================
+    elif request.method == 'POST':
+        question_text = request.data.get('question')
+        order = request.data.get('order')
+        is_active = request.data.get('is_active', True)
+        
+        if not question_text:
+            return Response({'error': 'Question text is required'}, status=400)
+        
+        # Check duplicate
+        if MasterQuestion.objects.filter(question=question_text).exists():
+            return Response({'error': 'Question already exists'}, status=400)
+        
+        # Auto assign order if not provided
+        if order is None:
+            order = MasterQuestion.objects.count() + 1
+        
+        question = MasterQuestion.objects.create(
+            id=uuid.uuid4(),
+            question=question_text,
+            order=order,
+            is_active=is_active
+        )
+        
+        return Response({
+            'id': str(question.id),
+            'question': question.question,
+            'order': question.order,
+            'is_active': question.is_active,
+            'message': 'Master question created successfully'
+        }, status=201)
+    
+    # ==================== UPDATE ====================
+    elif request.method == 'PUT':
+        if not question_id:
+            return Response({'error': 'Question ID required'}, status=400)
+        
+        try:
+            question = MasterQuestion.objects.get(id=question_id)
+        except MasterQuestion.DoesNotExist:
+            return Response({'error': 'Question not found'}, status=404)
+        
+        question_text = request.data.get('question', question.question)
+        order = request.data.get('order', question.order)
+        is_active = request.data.get('is_active', question.is_active)
+        
+        question.question = question_text
+        question.order = order
+        question.is_active = is_active
+        question.save()
+        
+        return Response({
+            'id': str(question.id),
+            'question': question.question,
+            'order': question.order,
+            'is_active': question.is_active,
+            'message': 'Master question updated successfully'
+        })
+    
+    # ==================== DELETE ====================
+    elif request.method == 'DELETE':
+        if not question_id:
+            return Response({'error': 'Question ID required'}, status=400)
+        
+        try:
+            question = MasterQuestion.objects.get(id=question_id)
+            question.delete()
+            return Response({'message': 'Master question deleted successfully'})
+        except MasterQuestion.DoesNotExist:
+            return Response({'error': 'Question not found'}, status=404)
+
+
+# ==================== NEW: BULK CREATE ====================
+@api_view(['POST'])
+@permission_classes([IsAdminUser])
+def admin_master_questions_bulk(request):
+    """
+    Admin can create multiple master questions at once
+    """
+    questions_data = request.data.get('questions', [])
+    
+    if not questions_data:
+        return Response({'error': 'Questions list is required'}, status=400)
+    
+    created = []
+    errors = []
+    
+    for idx, q_data in enumerate(questions_data):
+        question_text = q_data.get('question')
+        order = q_data.get('order', idx + 1)
+        is_active = q_data.get('is_active', True)
+        
+        if not question_text:
+            errors.append({'index': idx, 'error': 'Question text required'})
+            continue
+        
+        # Skip duplicates
+        if MasterQuestion.objects.filter(question=question_text).exists():
+            errors.append({'index': idx, 'question': question_text, 'error': 'Already exists'})
+            continue
+        
+        try:
+            question = MasterQuestion.objects.create(
+                id=uuid.uuid4(),
+                question=question_text,
+                order=order,
+                is_active=is_active
+            )
+            created.append({
+                'id': str(question.id),
+                'question': question.question,
+                'order': question.order
+            })
+        except Exception as e:
+            errors.append({'index': idx, 'question': question_text, 'error': str(e)})
+    
+    return Response({
+        'message': f'Created {len(created)} questions',
+        'created': created,
+        'errors': errors if errors else None
+    }, status=201 if created else 400)
+
+
+# ==================== GET ACTIVE QUESTIONS FOR AGENCY ====================
+@api_view(['GET'])
+@authentication_classes([JWTAuthentication])
+@permission_classes([IsAuthenticated])
+def get_master_questions(request):
+    """
+    Get all active master questions for agency to answer
+    """
+    questions = MasterQuestion.objects.filter(is_active=True).order_by('order')
+    data = [{
+        'id': str(q.id),
+        'question': q.question,
+        'order': q.order
+    } for q in questions]
+    return Response({
+        'total': len(data),
+        'questions': data
+    })
+
+# ==================== GLOBAL Q&A CRUD ====================
+
+@api_view(['GET', 'POST', 'PUT', 'DELETE'])
+@permission_classes([IsAdminUser])
+def admin_global_qa(request, qa_id=None):
+    """
+    Admin CRUD for Global Q&A (applies to ALL properties)
+    """
+    
+    # GET all or single
+    if request.method == 'GET':
+        if qa_id:
+            try:
+                qa = GlobalQA.objects.get(id=qa_id)
+                data = {
+                    'id': str(qa.id),
+                    'question': qa.question,
+                    'answer': qa.answer,
+                    'language': qa.language,
+                    'priority': qa.priority,
+                    'is_active': qa.is_active
+                }
+                return Response(data)
+            except GlobalQA.DoesNotExist:
+                return Response({'error': 'Not found'}, status=404)
+        else:
+            qa_list = GlobalQA.objects.all().order_by('-priority', 'question')
+            data = [{
+                'id': str(q.id),
+                'question': q.question,
+                'answer': q.answer[:100],
+                'language': q.language,
+                'priority': q.priority,
+                'is_active': q.is_active
+            } for q in qa_list]
+            return Response({'total': len(data), 'global_qa': data})
+    
+    # CREATE single
+    elif request.method == 'POST':
+        question = request.data.get('question')
+        answer = request.data.get('answer')
+        language = request.data.get('language', 'both')
+        priority = request.data.get('priority', 0)
+        is_active = request.data.get('is_active', True)
+        
+        if not question or not answer:
+            return Response({'error': 'Question and answer required'}, status=400)
+        
+        if GlobalQA.objects.filter(question=question).exists():
+            return Response({'error': 'Question already exists'}, status=400)
+        
+        # Generate embedding
+        embedding = embedding_service.generate_embedding(question)
+        
+        qa = GlobalQA.objects.create(
+            id=uuid.uuid4(),
+            question=question,
+            answer=answer,
+            question_embedding=embedding,
+            language=language,
+            priority=priority,
+            is_active=is_active
+        )
+        
+        return Response({
+            'id': str(qa.id),
+            'question': qa.question,
+            'answer': qa.answer,
+            'message': 'Global Q&A created successfully'
+        }, status=201)
+    
+    # UPDATE
+    elif request.method == 'PUT':
+        if not qa_id:
+            return Response({'error': 'ID required'}, status=400)
+        
+        try:
+            qa = GlobalQA.objects.get(id=qa_id)
+        except GlobalQA.DoesNotExist:
+            return Response({'error': 'Not found'}, status=404)
+        
+        question = request.data.get('question', qa.question)
+        answer = request.data.get('answer', qa.answer)
+        language = request.data.get('language', qa.language)
+        priority = request.data.get('priority', qa.priority)
+        is_active = request.data.get('is_active', qa.is_active)
+        
+        # Update embedding if question changed
+        if question != qa.question:
+            embedding = embedding_service.generate_embedding(question)
+            qa.question_embedding = embedding
+        
+        qa.question = question
+        qa.answer = answer
+        qa.language = language
+        qa.priority = priority
+        qa.is_active = is_active
+        qa.save()
+        
+        return Response({'message': 'Global Q&A updated successfully'})
+    
+    # DELETE
+    elif request.method == 'DELETE':
+        if not qa_id:
+            return Response({'error': 'ID required'}, status=400)
+        
+        try:
+            qa = GlobalQA.objects.get(id=qa_id)
+            qa.delete()
+            return Response({'message': 'Global Q&A deleted successfully'})
+        except GlobalQA.DoesNotExist:
+            return Response({'error': 'Not found'}, status=404)
+
+
+# ==================== BULK CREATE GLOBAL Q&A ====================
+
+@api_view(['POST'])
+@permission_classes([IsAdminUser])
+def admin_global_qa_bulk(request):
+    """
+    Admin can create multiple Global Q&A at once
+    """
+    items = request.data.get('items', [])
+    
+    if not items:
+        return Response({'error': 'Items list required'}, status=400)
+    
+    created = []
+    errors = []
+    
+    for idx, item in enumerate(items):
+        question = item.get('question')
+        answer = item.get('answer')
+        language = item.get('language', 'both')
+        priority = item.get('priority', 0)
+        
+        if not question or not answer:
+            errors.append({'index': idx, 'error': 'Question and answer required'})
+            continue
+        
+        if GlobalQA.objects.filter(question=question).exists():
+            errors.append({'index': idx, 'question': question, 'error': 'Already exists'})
+            continue
+        
+        try:
+            embedding = embedding_service.generate_embedding(question)
+            qa = GlobalQA.objects.create(
+                id=uuid.uuid4(),
+                question=question,
+                answer=answer,
+                question_embedding=embedding,
+                language=language,
+                priority=priority,
+                is_active=True
+            )
+            created.append({
+                'id': str(qa.id),
+                'question': qa.question,
+                'answer': qa.answer[:50]
+            })
+        except Exception as e:
+            errors.append({'index': idx, 'question': question, 'error': str(e)})
+    
+    return Response({
+        'message': f'Created {len(created)} Global Q&A',
+        'created': created,
+        'errors': errors if errors else None
+    }, status=201 if created else 400)