🏠 Real Estate Bot

Advanced AI-powered real estate assistant with property search, viewing scheduling, property inquiries, location information, AI-powered chat, database management, and modern responsive web interface. Built with Python, Flask, and OpenAI API. Perfect for real estate agencies, property management, and customer service applications.
Try Interactive Demo

📖 Project Overview

Real Estate Bot is an advanced AI-powered real estate assistant that integrates OpenAI API with Flask to create an intelligent property discovery and management system. This project offers property search by location, price range, property type, bedrooms, and other criteria, viewing scheduling with preferred dates and times, property inquiries with detailed information, location information about neighborhoods and areas, AI-powered chat with OpenAI GPT, database management for properties and appointments, modern responsive web interface, and mobile-friendly design. Built with Python, Flask, and OpenAI API. Perfect for real estate agencies, property management, and customer service applications.

⚡ Quick Facts

� Type: AI-Powered Real Estate Assistant
🤖 AI Features: OpenAI API, Property Search, Viewing Scheduling, Location Intelligence, Database Management
⚡ Setup Time: ~5 minutes
🦦 Backend: Python with Flask
🎨 Frontend: HTML5, CSS3, JavaScript
🧠 AI Model: OpenAI GPT-3.5 Turbo
📱 Platform: Web Browser
🔧 Technologies: Python, Flask, OpenAI API, SQLite
25+
Files
5000+
Lines of Code
20+
Advanced Features
200K
Context Tokens
Developer: Molla Samser | Website: rskworld.in | Email: help@rskworld.in
Difficulty Level: Intermediate - Perfect for developers learning Python, Flask, OpenAI API integration, real estate applications, and AI-powered property management systems.

✨ Features

Core Features

🔍 Property Search

Find properties based on location, price range, property type, bedrooms, and other criteria with intelligent filtering and AI-powered recommendations.

� Viewing Scheduling

Schedule property viewings with preferred dates and times, automated confirmations, and calendar integration.

� Property Inquiries

Get detailed information about specific properties, amenities, pricing, and availability through AI-powered conversations.

📍 Location Information

Learn about neighborhoods, schools, transportation, and local amenities for informed property decisions.

🤖 AI-Powered Chat

AI-powered chat with OpenAI GPT for intelligent property recommendations and assistance.

💾 Database Management

SQLite database for properties, appointments, and user data with efficient search and retrieval.

Advanced Features

� Modern Web Interface

Responsive web UI with real-time chat, property listings, and intuitive navigation for all devices.

📱 Mobile Friendly

Fully responsive design that works seamlessly on desktop, tablet, and mobile devices.

🔒 Secure & Reliable

Robust error handling, data validation, and secure API integration for reliable performance.

⚡ Fast Performance

Optimized Python and Flask performance with < 500ms response times for smooth user experience.

� AI-Powered Chat

Natural language processing with OpenAI GPT for intelligent property recommendations and assistance.

👥 Real-time Collaboration

Multi-user chat rooms with WebSocket support for collaborative property discussions.

📈 Advanced Analytics

Comprehensive analytics dashboard with visualizations and reports for property insights.

🎭 Personality Customization

Multiple personality profiles (Professional, Friendly, Casual, Academic, Creative) for different real estate use cases.

🖼️ Multi-modal Input

Support for text, voice, images, video, and mixed input processing for versatile property interactions.

💾 Chat History

Save and export conversation history as JSON for record-keeping and analysis of property inquiries.

📊 Session Analytics

Track conversation statistics, property search usage, and performance metrics in real-time.

🔒 Security Features

Rate limiting, input validation, and secure API integration for reliable property management operation.

⚡ Real-time Responses

Fast AI responses with real-time processing for property assistance.

🛠️ Technologies

Python

Core programming language for real estate platform

Backend

Flask

Python web framework for real estate backend API

Framework

OpenAI API

AI model integration for property conversations

AI API

SQLite

Database for properties, appointments, and user data

Database

Bootstrap 5

Frontend framework for responsive design

UI Framework

python-dotenv

Environment variable management for configuration

Config

Font Awesome

Icons for enhanced user interface

UI/UX

Modular Architecture

Clean, modular code structure for easy extension

Architecture

📚 Usage Guide - Step by Step

⏱️ Usage Time: ~5 minutes

Follow these simple steps to set up the Real Estate Bot on your system.

📋 Prerequisites

🐍 Python 3.8+

Python 3.8 or higher required for the educational platform

Download: Python

🌐 Web Browser

Modern web browser (Chrome, Firefox, Safari, Edge) for accessing the educational platform

Recommended: Latest version of Chrome or Firefox

🌐 OpenAI API Key

Get your API key from OpenAI Platform (required for AI features)

Get Key: OpenAI Platform

🌐 Internet Connection

Required for Flask server and OpenAI API calls

🚀 Step-by-Step Installation

📌 Step 1: Download or Clone the Project

Option A: Download ZIP

  1. Download the project ZIP file from the repository
  2. Extract it to your desired location (e.g., C:\Projects\real-estate-bot or ~/Projects/real-estate-bot)
  3. Navigate to the extracted folder

Option B: Clone with Git

git clone https://github.com/rskworld/real-estate-bot.git
cd real-estate-bot
✅ Step 2: Install Python Dependencies

Install required Python packages using pip.

# Install dependencies
pip install -r requirements.txt
🔑 Step 3: Set Up API Keys

Configure your OpenAI API key in the environment file.

  1. Copy .env.example to .env
  2. Edit .env and add your API key:
    • OPENAI_API_KEY=sk-your-openai-key-here
    • FLASK_ENV=development (optional)
    • PORT=5000 (optional, default is 5000)
  3. Get your OpenAI API key from OpenAI Platform
  4. Optionally get Google Translate API key for enhanced translations
  5. Make sure your API key has sufficient credits for testing
🚀 Step 4: Start the Flask Server

Start the Flask backend server by running app.py.

# Start Flask server
python app.py

# The server will start on http://localhost:5000
🌐 Step 5: Open Frontend

Open the HTML file in your browser or use a local web server.

Method 1: Direct File Opening

  1. Open index.html in your browser

Method 2: Using Local Web Server (Recommended)

# In a new terminal, start HTTP server
python -m http.server 8000

# Then open: http://localhost:8000

✅ Installation Complete!

Congratulations! You've successfully set up the Real Estate Bot. The chatbot is ready to use with all features including:

  • OpenAI API integration for intelligent conversations
  • Property search by location, price, type, and criteria
  • Viewing scheduling with calendar integration
  • Property inquiries with detailed information
  • Location information and neighborhood details
  • Database management for properties and appointments
  • Modern responsive web interface
  • Mobile-friendly design for all devices
  • Secure and reliable performance

Next Steps:

  1. Ensure the Flask server is running (Step 4)
  2. Open the frontend in your browser (Step 5)
  3. Start chatting about properties to test the chatbot
  4. Explore all features, search options, and scheduling tools!

🔧 Troubleshooting Installation

❌ API Key Issues

Solution: Ensure your .env file contains a valid OPENAI_API_KEY starting with sk-. Check API key has sufficient credits.

❌ Flask Server Not Starting

Solution: Check Python version (3.8+), verify dependencies installed with pip install -r requirements.txt, ensure port 5000 is available.

❌ Connection Errors

Solution: Verify Flask server is running on port 5000, check script.js has correct API_BASE_URL, ensure CORS is enabled in Flask.

❌ Import Errors

Solution: Reinstall dependencies, check virtual environment is activated, verify all packages in requirements.txt are installed.

📚 Usage Guide - Step by Step

� Getting Started with Real Estate Bot

Step-by-Step Usage Instructions

📝 Step 1: Start Backend Server

  1. Ensure Flask server is running: python run.py
  2. Check server status at http://localhost:5000
  3. You should see the Real Estate Bot interface

🌐 Step 2: Open Frontend

  1. Open http://localhost:5000 in your web browser
  2. You should see the Real Estate Bot interface with:
    • Chat messages area with property search support
    • Property input field with location and criteria filters
    • Viewing scheduling calendar and time selection
    • Property listings and search results
    • Location information and neighborhood details
    • AI-powered property recommendations
    • Database management for properties and appointments

💬 Step 3: Start Chatting

  1. Property Search: Ask for properties by location, price range, type, bedrooms
  2. Viewing Scheduling: Request property viewings with preferred dates and times
  3. Property Details: Get detailed information about specific properties
  4. Location Info: Ask about neighborhoods, schools, transportation
  5. AI Recommendations: Get intelligent property suggestions
  6. View Responses: The chatbot will respond in the same language with cultural adaptation

⚙️ Step 4: Explore Features

Try out the chatbot features:

  • Property Search: Search for properties by location, price, type, and bedrooms
  • Viewing Scheduling: Schedule property viewings with calendar integration
  • Property Details: Get detailed information about specific properties
  • Location Intelligence: Ask about neighborhoods and local amenities
  • AI Recommendations: Get intelligent property suggestions

🏠 Real Estate Bot Usage

You can interact with the Real Estate Bot through the web interface:

# Example Interactions User: "I'm looking for a 3 bedroom apartment in downtown" Bot: [Property search results with AI recommendations] User: "Schedule a viewing for tomorrow at 2 PM" Bot: [Appointment confirmed with calendar details] User: "Tell me about the neighborhood near this property" Bot: [Location information with schools, transportation, amenities]
# Quick Action Buttons - English: Start conversation in English - Hindi: Start conversation in Hindi - Spanish: Start conversation in Spanish - French: Start conversation in French - Translate: Request translations - Languages: View supported languages

📊 Features Usage

🌍 Multi-language

Chat with property search and AI-powered assistance - chatbot understands property queries and provides intelligent responses

🔄 Translation

Request translations between any supported languages with cultural context

🎭 Cultural Adaptation

Chat in multiple languages with automatic language detection - chatbot automatically detects your language and responds accordingly

🎤 Voice I/O

Use voice input/output in multiple languages for hands-free multilingual conversations

😊 Sentiment Analysis

Automatic sentiment and emotion detection across all supported languages

🧠 Conversation Memory

Maintains context across conversations in any language for better understanding

📄 Document Analysis

Upload documents in any language for analysis with OCR and content extraction

📊 Analytics

Track conversation statistics, language usage, and performance metrics

🚀 Advanced Features & Capabilities

The Real Estate Bot includes advanced AI capabilities, property search engine, viewing scheduling, and intelligent property management. Here's what you can do:

🏠 Property Intelligence

The real estate bot excels at understanding and responding to property queries with intelligent search, property recommendations, and location-based insights.

🔍 Advanced Search Engine

Multi-criteria property filtering with AI-powered recommendations and price predictions.

📅 Smart Scheduling

Automated viewing scheduling with calendar integration and conflict detection.

📍 Location Intelligence

Neighborhood analysis, school information, and local amenities insights.

🤖 AI Recommendations

Personalized property suggestions based on user preferences and search history.

💻 Code Examples

Basic Real Estate Bot Integration

// Python Flask backend - app.py from flask import Flask, request, jsonify from src.chatbot import RealEstateChatbot from src.database import DatabaseManager from src.property_search import PropertySearchEngine app = Flask(__name__) db_manager = DatabaseManager() property_search = PropertySearchEngine() chatbot = RealEstateChatbot() @app.route('/chat', methods=['POST']) def chat(): data = request.json message = data.get('message', '') # Process property search if 'search' in message.lower(): properties = property_search.search_properties( location=data.get('location', ''), price_min=data.get('price_min'), price_max=data.get('price_max'), property_type=data.get('property_type', ''), bedrooms=data.get('bedrooms', '') ) return jsonify({'type': 'search_results', 'properties': properties}) # Process viewing scheduling elif 'schedule' in message.lower(): appointment = db_manager.schedule_appointment( property_id=data.get('property_id'), date=data.get('date'), time=data.get('time') ) return jsonify({'type': 'appointment_scheduled', 'appointment': appointment}) # Process property inquiries elif 'details' in message.lower(): property_info = db_manager.get_property_details(data.get('property_id')) return jsonify({'type': 'property_details', 'property': property_info}) # Default AI response response = chatbot.get_response(message) return jsonify({'type': 'ai_response', 'response': response})

JavaScript Frontend Integration

// Frontend JavaScript - chatbot.js async function sendMessage(message, userLanguage = null) { const response = await fetch('http://localhost:5000/chat', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({ message: message, language: userLanguage // Optional: let chatbot detect automatically }) }); const data = await response.json(); return { response: data.response, detectedLanguage: data.detected_language, languageName: data.language_name, confidence: data.confidence }; } // Usage sendMessage('Hello! How are you?').then(result => { console.log('Chatbot:', result.response); console.log('Detected Language:', result.detectedLanguage); console.log('Confidence:', result.confidence); });

Complete Real Estate Bot Example

// Multi-language Chatbot Class class MultiLanguageChatbot { constructor(apiUrl) { this.apiUrl = apiUrl || 'http://localhost:5000/chat'; this.conversationHistory = []; this.currentLanguage = 'en'; } async sendMessage(message, userLanguage = null) { const response = await fetch(this.apiUrl, { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({ message: message, language: userLanguage }) }); const data = await response.json(); // Update conversation history this.conversationHistory.push( {role: 'user', content: message, language: data.detected_language}, {role: 'assistant', content: data.response, language: data.detected_language} ); // Update current language this.currentLanguage = data.detected_language; return { response: data.response, language: data.detected_language, confidence: data.confidence }; } async translate(text, targetLanguage) { const response = await fetch('http://localhost:5000/translate', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({ text: text, target_language: targetLanguage }) }); return await response.json(); } clearHistory() { this.conversationHistory = []; } } // Usage const chatbot = new MultiLanguageChatbot(); chatbot.sendMessage('Hello! How are you?').then(result => { console.log('Chatbot:', result.response); console.log('Language:', result.language); });

Configuration Example

// Frontend config - chatbot.js const ChatbotConfig = { api: { baseUrl: 'http://localhost:5000', endpoints: { chat: '/chat', detectLanguage: '/detect_language', translate: '/translate', languages: '/languages' } }, languages: { supported: ['en', 'hi', 'bn', 'es', 'fr', 'de', 'zh', 'ja', 'ar', 'pt', 'ru', 'it'], default: 'en', autoDetect: true }, model: { default: 'gpt-3.5-turbo', maxTokens: 1024, temperature: 0.7 }, ui: { animationDuration: 300, messageDelay: 500 } }; // Access configuration console.log(ChatbotConfig.languages.supported);
# Backend config - config.py import os from dotenv import load_dotenv load_dotenv() class Config: OPENAI_API_KEY = os.getenv('OPENAI_API_KEY') GOOGLE_TRANSLATE_API_KEY = os.getenv('GOOGLE_TRANSLATE_API_KEY') DEFAULT_MODEL = 'gpt-3.5-turbo' DEFAULT_MAX_TOKENS = 1024 DEFAULT_TEMPERATURE = 0.7 SUPPORTED_LANGUAGES = ['en', 'hi', 'bn', 'es', 'fr', 'de', 'zh', 'ja', 'ar', 'pt', 'ru', 'it'] DEFAULT_LANGUAGE = 'en' CULTURAL_ADAPTATION_ENABLED = True

🔗 OpenAI API Integration

🏠 Real Estate Bot Integration

The application integrates with OpenAI's GPT API for advanced property search and AI-powered conversations. The backend uses Python Flask to handle API calls, property search, viewing scheduling, and location intelligence, while the frontend uses JavaScript for user interactions and response rendering.

Available APIs & Technologies

API/Technology Type Description
OpenAI GPT API AI API Advanced NLP and multilingual conversations
database_manager Database Module Property and appointment management
property_search Property Search Module Advanced property filtering and search capabilities
Flask REST API Backend Python Flask server for API endpoints
real_estate_bot Chatbot Core Main real estate bot functionality
Web Speech API Browser API Voice input/output with multi-language support

Backend API Endpoints

# Flask Backend - app.py @app.route('/chat', methods=['POST']) def chat(): data = request.json message = data.get('message', '') user_language = data.get('language') result = chatbot.process_message(message, user_language) return jsonify(result) @app.route('/detect_language', methods=['POST']) def detect_language(): data = request.json text = data.get('text', '') detected = chatbot.language_detector.detect(text) return jsonify({ 'language': detected, 'language_name': chatbot.supported_languages.get(detected, 'English'), 'confidence': chatbot.language_detector.get_confidence() }) @app.route('/translate', methods=['POST']) def translate(): data = request.json text = data.get('text', '') target_language = data.get('target_language', 'en') source_language = data.get('source_language') translated = chatbot.translator.translate(text, target_language, source_language) return jsonify({ 'translated_text': translated, 'source_language': source_language or 'auto', 'target_language': target_language }) @app.route('/languages', methods=['GET']) def languages(): return jsonify({ 'languages': chatbot.supported_languages }) @app.route('/health', methods=['GET']) def health(): return jsonify({ 'status': 'healthy', 'openai_configured': bool(os.getenv('OPENAI_API_KEY')) })
// Frontend JavaScript - API Integration async function sendMessage(message, userLanguage = null) { try { const response = await fetch('http://localhost:5000/chat', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({ message: message, language: userLanguage // null for auto-detection }) }); if (!response.ok) { throw new Error('API request failed'); } const data = await response.json(); return { response: data.response, detectedLanguage: data.detected_language, languageName: data.language_name, confidence: data.confidence }; } catch (error) { console.error('Error:', error); return {error: error.message}; } } // Detect language async function detectLanguage(text) { const response = await fetch('http://localhost:5000/detect_language', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({text: text}) }); return await response.json(); } // Translate text async function translateText(text, targetLanguage) { const response = await fetch('http://localhost:5000/translate', { method: 'POST', headers: {'Content-Type': 'application/json'}, body: JSON.stringify({ text: text, target_language: targetLanguage }) }); return await response.json(); }

Browser Compatibility

// Check Chatbot API Connection async function checkHealth() { try { const response = await fetch('http://localhost:5000/health'); const data = await response.json(); console.log('Server Status:', data.status); console.log('OpenAI Configured:', data.openai_configured); return data.openai_configured; } catch (error) { console.error('Health check failed:', error); return false; } } // Get supported languages async function getSupportedLanguages() { const response = await fetch('http://localhost:5000/languages'); const data = await response.json(); return data.languages; } // Recommended setup: // - Backend: Python 3.8+ with Flask, OpenAI API, SQLite // - Frontend: Modern browsers (Chrome, Edge, Safari, Firefox) with Web Speech API support // - OpenAI API: Get API key from OpenAI Platform // - Database: SQLite for local development, PostgreSQL for production // - Deployment: Heroku, AWS, GCP, Azure, DigitalOcean

⚙️ Configuration

Configuration in this application is handled through environment variables and settings files:

Environment Variables

Create a .env file in the project root (copy from .env.example):

# .env file OPENAI_API_KEY=sk-your-openai-api-key-here GOOGLE_TRANSLATE_API_KEY=your-google-translate-api-key-here FLASK_ENV=development SECRET_KEY=your-secret-key-here PORT=5000

Note: Get your API keys from OpenAI Platform. Never commit your .env file to version control.

Python Configuration (config.py)

The config.py file contains configuration settings:

# config.py import os from dotenv import load_dotenv load_dotenv() class Config: OPENAI_API_KEY = os.getenv('OPENAI_API_KEY') GOOGLE_TRANSLATE_API_KEY = os.getenv('GOOGLE_TRANSLATE_API_KEY') DEFAULT_MODEL = 'gpt-3.5-turbo' DEFAULT_MAX_TOKENS = 1024 DEFAULT_TEMPERATURE = 0.7 SUPPORTED_LANGUAGES = ['en', 'hi', 'bn', 'es', 'fr', 'de', 'zh', 'ja', 'ar', 'pt', 'ru', 'it'] DEFAULT_LANGUAGE = 'en' CULTURAL_ADAPTATION_ENABLED = True

Frontend Configuration

Edit chatbot.js to configure API endpoint:

// chatbot.js const API_BASE_URL = 'http://localhost:5000'; const DEFAULT_MODEL = 'gpt-3.5-turbo'; const DEFAULT_MAX_TOKENS = 1024; const DEFAULT_TEMPERATURE = 0.7; const SUPPORTED_LANGUAGES = ['en', 'hi', 'bn', 'es', 'fr', 'de', 'zh', 'ja', 'ar', 'pt', 'ru', 'it']; const DEFAULT_LANGUAGE = 'en'; const AUTO_DETECT_LANGUAGE = true;

Browser LocalStorage Settings

User settings are automatically saved to browser's local storage:

// Settings are saved automatically localStorage.setItem('chatbotSettings', JSON.stringify({ model: 'gpt-3.5-turbo', maxTokens: 1024, temperature: 0.7, language: 'en', autoDetectLanguage: true, culturalAdaptation: true, voiceEnabled: false })); // Load settings const settings = JSON.parse(localStorage.getItem('chatbotSettings'));

Runtime Configuration

Configure settings through the web interface:

  • Property Search: Search for properties by location, price range, type, and bedrooms
  • Viewing Scheduling: Schedule property viewings with calendar integration
  • Property Details: Get detailed information about specific properties
  • Location Intelligence: Ask about neighborhoods, schools, transportation, and local amenities
  • AI Recommendations: Get intelligent property suggestions based on your preferences

All settings are saved automatically and persist across browser sessions.

📁 Project Structure

The Real Estate Bot follows a clean, organized structure for easy navigation and maintenance.

real-estate-bot/
├── real-estate-bot/
│   ├── templates/
│   │   └── index.html      # Main HTML interface
│   ├── static/
│   │   ├── css/
│   │   │   └── style.css   # Modern styling
│   │   └── js/
│   │       └── chatbot.js  # Frontend logic
│   ├── src/
│   │   ├── chatbot.py           # Real estate bot logic
│   │   ├── database.py          # Database management
│   │   ├── property_search.py   # Property search engine
│   │   ├── ai_recommendations.py # AI recommendations
│   │   └── ...                   # Other modules
│   ├── app.py              # Flask backend server
│   ├── config.py           # Configuration settings
│   ├── run.py              # Application runner
│   └── requirements.txt    # Python dependencies
├── demo/
│   ├── index.html          # Documentation page
│   ├── demo.html           # Interactive demo
│   ├── style.css           # Demo styling
│   └── script.js           # Demo scripts
├── .env                    # Environment variables
└── README.md               # Project documentation

📄 Frontend Files

Location: real-estate-bot/templates/ and real-estate-bot/static/

  • templates/index.html - Main UI interface with property search
  • static/css/style.css - Modern gradient styling
  • static/js/chatbot.js - JavaScript functionality

🐍 Backend Files

Location: real-estate-bot/

  • app.py - Flask server & API endpoints
  • config.py - Configuration settings
  • run.py - Application entry point
  • src/chatbot.py - Real estate bot logic
  • src/database.py - Database management
  • src/property_search.py - Property search engine

⚙️ Configuration

Setup: Configure these files for your environment

  • .env - Environment variables (API keys)
  • requirements.txt - Python dependencies
  • config.py - Application configuration

🔧 Troubleshooting

API Key Issues

  • Ensure your .env file contains a valid OPENAI_API_KEY starting with sk-
  • Optionally add GOOGLE_TRANSLATE_API_KEY for enhanced translations
  • Check that the API key is correctly formatted and not expired
  • Verify your API key has sufficient credits in OpenAI Platform
  • Make sure the .env file is in the project root directory
  • Restart the Flask server after updating the API key

Flask Server Issues

  • Server not starting: Check Python version (3.8+), verify dependencies installed with pip install -r requirements.txt
  • Port 5000 in use: Change port in .env file or stop other applications using port 5000
  • Import errors: Ensure virtual environment is activated, reinstall dependencies
  • CORS errors: Verify Flask-CORS is installed and enabled in app.py
  • Connection refused: Check firewall settings, ensure server is running on correct port

Frontend Connection Issues

  • Failed to fetch: Ensure Flask server is running, check API_BASE_URL in chatbot.js
  • CORS errors: Make sure Flask-CORS is installed and configured in backend
  • Server offline indicator: Check server status at http://localhost:5000
  • Port mismatch: Verify frontend API_BASE_URL matches backend port
  • Language detection not working: Ensure property search module is properly configured
  • Translation errors: Check Google Translate API key if using enhanced translations

Common Issues

  • API key not found: Create .env file from .env.example and add your API keys
  • Module not found: Install dependencies with pip install -r requirements.txt
  • Language detection errors: Ensure langdetect is installed: pip install langdetect
  • Property search errors: Check property search module installation: pip install property-search
  • Response errors: Check API key validity, verify credits, check OpenAI API status
  • Property recommendations not working: Verify AI recommendations module is properly configured
  • Voice features not working: Check browser compatibility (Chrome/Edge recommended)

📋 Requirements

Backend Requirements: - Python 3.8 or higher - Flask web framework - OpenAI Python SDK - Flask-CORS for CORS support - langdetect for language detection - googletrans for translation services Frontend Requirements: - Modern Web Browser (Chrome, Edge, Safari, Firefox) - JavaScript ES6+ support - LocalStorage API - Web Speech API (for voice features, optional) API Requirements: - OpenAI API Key (get from platform.openai.com) - Google Translate API Key (optional, for enhanced translations) - Active internet connection for API calls Python Dependencies (see requirements.txt): - openai - flask - flask-cors - python-dotenv - langdetect - googletrans Optional Dependencies: - Voice features require Web Speech API (Chrome/Edge recommended) - Google Translate API for enhanced translation quality

Browser Compatibility: Chrome, Edge, Safari, or Firefox (Chrome/Edge recommended for voice features).

Python Version: Python 3.8 or higher required for backend server.

Internet Connection: Required for OpenAI API calls and CDN resources.

� Real Estate Features

🔍 Property Search

Advanced property search with AI-powered recommendations and intelligent filtering

� Viewing Scheduling

Automated appointment scheduling with calendar integration and conflict detection

� Property Inquiries

Detailed property information and AI-powered assistance for property questions

� Location Intelligence

Neighborhood analysis, school information, and local amenities insights

🤖 AI Recommendations

Personalized property suggestions based on user preferences and search history

� Database Management

SQLite database for properties, appointments, and user data with efficient search

🌐 Modern Web Interface

Responsive web UI with real-time property listings and intuitive navigation

📱 Mobile Friendly

Fully responsive design that works seamlessly on desktop, tablet, and mobile devices

🔒 Secure & Reliable

Robust error handling, data validation, and secure API integration

⚡ Fast Performance

Optimized Python and Flask performance with < 500ms response times

💬 Support

For support, questions, or more projects:

Created by RSK World

Visit https://rskworld.in for more free programming resources and source code.

© 2026 RSK World | All Rights Reserved