Implement immediate Celery Beat schedule updates

Add immediate Celery Beat schedule updates on schedule creation and deletion
Update Celery Beat configuration to use full task path
Refactor Celery task imports and configurations
Add logging for Celery tasks
Update frontend components to reflect changes

CELERY_SCHEDULING_SETUP.md

@@ -0,0 +1,241 @@
+# Celery Scheduling Setup Guide
+
+This guide explains how to set up and use the Celery scheduling system with your Lin application.
+
+## Overview
+
+The updated `start_app.py` now automatically starts both the Flask application and Celery components (worker and beat scheduler) when you run the application. This ensures that your scheduled tasks will execute properly.
+
+## Prerequisites
+
+### 1. Redis Server
+Celery requires Redis as a message broker. Make sure Redis is installed and running:
+
+**Windows:**
+```bash
+# Install Redis (if not installed)
+# Download from https://github.com/microsoftarchive/redis/releases
+
+# Start Redis server
+redis-server
+```
+
+**Linux/Mac:**
+```bash
+# Install Redis
+sudo apt-get install redis-server  # Ubuntu/Debian
+brew install redis                 # macOS
+
+# Start Redis
+sudo systemctl start redis
+sudo systemctl enable redis
+```
+
+### 2. Python Dependencies
+Install the required packages:
+```bash
+pip install -r backend/requirements.txt
+```
+
+## Starting the Application
+
+### Using start_app.py (Recommended)
+```bash
+python start_app.py
+```
+
+This will:
+1. Check Redis connection
+2. Start Celery worker in the background
+3. Start Celery beat scheduler in the background
+4. Start the Flask application
+
+### Using Backend Scripts (Alternative)
+```bash
+# Start both worker and beat
+cd backend
+python start_celery.py all
+
+# Or start individually
+python start_celery.py worker  # Start Celery worker
+python start_celery.py beat   # Start Celery beat scheduler
+```
+
+## Configuration
+
+### Environment Variables
+Make sure these are set in your `.env` file:
+
+```env
+# Supabase configuration
+SUPABASE_URL="your_supabase_url"
+SUPABASE_KEY="your_supabase_key"
+
+# Redis configuration (if not using defaults)
+CELERY_BROKER_URL="redis://localhost:6379/0"
+CELERY_RESULT_BACKEND="redis://localhost:6379/0"
+
+# Scheduler configuration
+SCHEDULER_ENABLED=True
+```
+
+### Celery Configuration
+The unified configuration is in `backend/celery_config.py`:
+
+```python
+celery_app.conf.beat_schedule = {
+    'load-schedules': {
+        'task': 'backend.celery_tasks.schedule_loader.load_schedules_task',
+        'schedule': crontab(minute='*/5'),  # Every 5 minutes
+    },
+}
+```
+
+## How Scheduling Works
+
+### 1. Schedule Loading
+- **Immediate Updates**: When you create or delete a schedule via the API, Celery Beat is updated immediately
+- **Periodic Updates**: Celery Beat also runs every 5 minutes as a backup
+- Executes `load_schedules_task`
+- Fetches schedules from Supabase database
+- Creates individual periodic tasks for each schedule
+
+### 2. Task Execution
+- **Content Generation**: Runs 5 minutes before scheduled time
+- **Post Publishing**: Runs at the scheduled time
+- Tasks are queued in appropriate queues (content, publish)
+
+### 3. Database Integration
+- Uses Supabase for schedule storage
+- Automatically creates tasks based on schedule data
+- Handles social network authentication
+
+## Monitoring and Debugging
+
+### Checking Celery Status
+```bash
+# Check worker status
+celery -A celery_config inspect stats
+
+# Check scheduled tasks
+celery -A celery_config inspect scheduled
+
+# Check active tasks
+celery -A celery_config inspect active
+```
+
+### Viewing Logs
+- **Flask Application**: Check console output
+- **Celery Worker**: Look for worker process logs
+- **Celery Beat**: Look for beat process logs
+
+### Common Issues
+
+**1. Redis Connection Failed**
+```
+Solution: Start Redis server first
+```
+
+**2. Tasks Not Executing**
+```bash
+# Check if Celery worker is running
+celery -A celery_config inspect ping
+
+# Check if beat scheduler is running
+ps aux | grep celery
+```
+
+**3. Schedule Not Loading**
+- Check Supabase database connection
+- Verify schedule data in database
+- Check task registration in Celery
+
+## Testing the Scheduling System
+
+### Manual Testing
+```python
+# Test schedule loading task
+from backend.celery_tasks.schedule_loader import load_schedules_task
+result = load_schedules_task()
+print(result)
+```
+
+### API Testing (Recommended)
+1. **Create a schedule via the API**:
+   ```bash
+   curl -X POST http://localhost:5000/api/schedules/ \
+     -H "Content-Type: application/json" \
+     -H "Authorization: Bearer YOUR_JWT_TOKEN" \
+     -d '{
+       "social_network": "1",
+       "schedule_time": "09:00",
+       "days": ["Monday", "Wednesday", "Friday"]
+     }'
+   ```
+   
+2. **Check the response**: You should see a `celery_update_task_id` field indicating the scheduler was updated immediately
+
+3. **Verify in Celery**: Check if the individual tasks were created:
+   ```bash
+   celery -A celery_config inspect scheduled
+   ```
+
+### Database Testing
+1. Add a schedule directly in the Supabase database
+2. Wait 5 minutes for the loader task to run (or trigger via API)
+3. Check if individual tasks were created
+4. Verify task execution times
+
+## Production Deployment
+
+### Using Docker
+```bash
+# Build and start all services
+docker-compose up -d
+
+# Check logs
+docker-compose logs -f
+```
+
+### Using Supervisor (Linux)
+Create `/etc/supervisor/conf.d/lin.conf`:
+```ini
+[program:lin_worker]
+command=python start_app.py
+directory=/path/to/lin
+autostart=true
+autorestart=true
+user=www-data
+environment=PATH="/path/to/venv/bin"
+
+[program:lin_beat]
+command=python -m celery -A celery_config beat
+directory=/path/to/lin
+autostart=true
+autorestart=true
+user=www-data
+environment=PATH="/path/to/venv/bin"
+```
+
+## Troubleshooting Checklist
+
+1. ✅ Redis server is running
+2. ✅ All Python dependencies are installed
+3. ✅ Environment variables are set correctly
+4. ✅ Supabase database connection works
+5. ✅ Celery worker is running
+6. ✅ Celery beat scheduler is running
+7. ✅ Schedule data exists in database
+8. ✅ Tasks are properly registered
+9. ✅ Task execution permissions are correct
+
+## Support
+
+If you encounter issues:
+1. Check this guide first
+2. Review the logs for error messages
+3. Verify all prerequisites are met
+4. Test components individually
+5. Check the Celery documentation
+
+For additional help, refer to the Celery documentation at: https://docs.celeryq.dev/

backend/api/schedules.py

@@ -1,6 +1,7 @@
 from flask import Blueprint, request, jsonify, current_app
 from flask_jwt_extended import jwt_required, get_jwt_identity
 from backend.services.schedule_service import ScheduleService
+from backend.celery_tasks.schedule_loader import load_schedules_task
 
 schedules_bp = Blueprint('schedules', __name__)
 
@@ -131,6 +132,21 @@ def create_schedule():
         result = schedule_service.create_schedule(user_id, social_network, schedule_time, days)
         
         if result['success']:
+            # Trigger immediate Celery Beat schedule update
+            try:
+                print("[INFO] Triggering immediate Celery Beat schedule update...")
+                # Execute the schedule loader task immediately to update Celery Beat
+                celery_result = load_schedules_task.delay()
+                print(f"[INFO] Celery Beat update task queued: {celery_result.id}")
+                
+                # Add the task ID to the response for tracking
+                result['celery_update_task_id'] = celery_result.id
+                result['message'] += ' (Scheduler updated immediately)'
+            except Exception as e:
+                print(f"[WARNING] Failed to trigger immediate Celery update: {str(e)}")
+                # Don't fail the schedule creation if Celery update fails
+                result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
+            
             # Add CORS headers to success response
             response_data = jsonify(result)
             response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')
@@ -209,6 +225,21 @@ def delete_schedule(schedule_id):
         result = schedule_service.delete_schedule(schedule_id)
         
         if result['success']:
+            # Trigger immediate Celery Beat schedule update
+            try:
+                print("[INFO] Triggering immediate Celery Beat schedule update after deletion...")
+                # Execute the schedule loader task immediately to update Celery Beat
+                celery_result = load_schedules_task.delay()
+                print(f"[INFO] Celery Beat update task queued: {celery_result.id}")
+                
+                # Add the task ID to the response for tracking
+                result['celery_update_task_id'] = celery_result.id
+                result['message'] += ' (Scheduler updated immediately)'
+            except Exception as e:
+                print(f"[WARNING] Failed to trigger immediate Celery update: {str(e)}")
+                # Don't fail the schedule deletion if Celery update fails
+                result['message'] += ' (Note: Scheduler update will occur in 5 minutes)'
+            
             # Add CORS headers to success response
             response_data = jsonify(result)
             response_data.headers.add('Access-Control-Allow-Origin', 'http://localhost:3000')

backend/celery_beat_config.py

@@ -2,6 +2,9 @@ from celery import Celery
 from celery.schedules import crontab
 import os
 
+# Import the task function
+from backend.celery_tasks.schedule_loader import load_schedules_task
+
 # Create Celery instance for Beat scheduler
 celery_beat = Celery('lin_scheduler')
 
@@ -13,7 +16,7 @@ celery_beat.conf.result_backend = os.environ.get('CELERY_RESULT_BACKEND', 'redis
 celery_beat.conf.beat_schedule = {
     # This task will run every 5 minutes to load schedules from the database
     'load-schedules': {
-        'task': 'load_schedules_task',
+        'task': 'backend.celery_tasks.schedule_loader.load_schedules_task',
         'schedule': crontab(minute='*/5'),
     },
 }

backend/celery_config.py

@@ -0,0 +1,75 @@
+"""
+Unified Celery configuration for the Lin application.
+This centralizes all Celery configuration to avoid conflicts.
+"""
+
+import os
+from celery import Celery
+from celery.schedules import crontab
+from backend.config import Config
+
+# Create Celery instance
+celery_app = Celery('lin_app')
+
+# Configure Celery with broker and result backend
+celery_app.conf.broker_url = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
+celery_app.conf.result_backend = os.environ.get('CELERY_RESULT_BACKEND', 'redis://localhost:6379/0')
+
+# Additional Celery configuration
+celery_app.conf.update(
+    # Task serialization
+    task_serializer='json',
+    accept_content=['json'],
+    result_serializer='json',
+    timezone='UTC',
+    enable_utc=True,
+    
+    # Task routing
+    task_routes={
+        'backend.celery_tasks.content_tasks.generate_content_task': {'queue': 'content'},
+        'backend.celery_tasks.content_tasks.publish_post_task': {'queue': 'publish'},
+        'backend.celery_tasks.schedule_loader.load_schedules_task': {'queue': 'scheduler'},
+    },
+    
+    # Worker configuration
+    worker_prefetch_multiplier=1,
+    task_acks_late=True,
+    worker_max_tasks_per_child=100,
+    
+    # Beat scheduler configuration
+    beat_scheduler='django_celery_beat.schedulers:DatabaseScheduler',
+    beat_schedule={
+        # This task will run every 5 minutes to load schedules from the database
+        'load-schedules': {
+            'task': 'backend.celery_tasks.schedule_loader.load_schedules_task',
+            'schedule': crontab(minute='*/5'),
+        },
+    },
+    
+    # Task result expiration
+    result_expires=3600,  # 1 hour
+    
+    # Task time limits
+    task_soft_time_limit=300,  # 5 minutes
+    task_time_limit=600,  # 10 minutes
+    
+    # Rate limiting
+    task_annotations=(
+        ('backend.celery_tasks.content_tasks.generate_content_task', {'rate_limit': '10/h'}),
+        ('backend.celery_tasks.content_tasks.publish_post_task', {'rate_limit': '30/h'}),
+    ),
+    
+    # Error handling
+    task_reject_on_worker_lost=True,
+    worker_disable_rate_limits=False,
+    
+    # Security
+    result_backend_transport_options={'visibility': 'hidden'},
+    broker_connection_max_retries=3,
+    broker_connection_retry_delay=5,
+)
+
+# Import tasks to ensure they're registered
+from backend import celery_tasks
+
+__all__ = ['celery_app']

backend/celery_tasks/content_tasks.py

@@ -1,12 +1,14 @@
-from celery import Celery, current_task
+from celery import current_task
 from backend.services.content_service import ContentService
 from backend.services.linkedin_service import LinkedInService
 from backend.utils.database import init_supabase
+from backend.celery_config import celery_app
 
 # Configure logging
+import logging
 logger = logging.getLogger(__name__)
 
-@celery.task(bind=True)
+@celery_app.task(bind=True)
 def generate_content_task(self, user_id: str, schedule_id: str, supabase_client_config: dict):
     """
     Celery task to generate content for a scheduled post.

backend/celery_tasks/schedule_loader.py

@@ -3,9 +3,9 @@ from celery.schedules import crontab
 from datetime import datetime
 import logging
 from backend.utils.database import init_supabase
-# Use relative import for the Config class to work with Hugging Face Spaces
 from backend.config import Config
 from backend.celery_tasks.scheduler import schedule_content_generation, schedule_post_publishing
+from backend.celery_config import celery_app
 
 # Configure logging
 logger = logging.getLogger(__name__)

backend/start_celery.bat

@@ -11,14 +11,14 @@ if not exist "app.py" (
 REM Function to start Celery worker
 :start_worker
 echo Starting Celery worker...
-start "Celery Worker" cmd /k "celery -A celery_app worker --loglevel=info"
+start "Celery Worker" cmd /k "python start_celery.py worker"
 echo Celery worker started
 goto :eof
 
 REM Function to start Celery Beat scheduler
 :start_beat
 echo Starting Celery Beat scheduler...
-start "Celery Beat" cmd /k "celery -A celery_beat_config beat --loglevel=info"
+start "Celery Beat" cmd /k "python start_celery.py beat"
 echo Celery Beat scheduler started
 goto :eof
 
@@ -30,11 +30,15 @@ if "%1"=="worker" (
 ) else if "%1"=="all" (
     call :start_worker
     call :start_beat
+) else if "%1"=="check" (
+    echo Checking system requirements...
+    python start_celery.py check
 ) else (
-    echo Usage: %0 {worker^|beat^|all}
+    echo Usage: %0 {worker^|beat^|all^|check}
     echo   worker - Start Celery worker
     echo   beat   - Start Celery Beat scheduler
     echo   all    - Start both worker and scheduler
+    echo   check  - Check system requirements
     pause
     exit /b 1
 )

backend/start_celery.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Script to start Celery components for the Lin application.
+This script provides a unified way to start Celery worker and beat scheduler.
+"""
+
+import os
+import sys
+import subprocess
+import platform
+from pathlib import Path
+
+# Add the backend directory to Python path
+backend_dir = Path(__file__).parent
+sys.path.insert(0, str(backend_dir))
+
+def check_redis():
+    """Check if Redis is running."""
+    try:
+        import redis
+        client = redis.Redis(host='localhost', port=6379, db=0)
+        client.ping()
+        print("✓ Redis connection successful")
+        return True
+    except Exception as e:
+        print(f"✗ Redis connection failed: {e}")
+        print("Please start Redis server first:")
+        print("  Windows: redis-server")
+        print("  Linux/Mac: sudo systemctl start redis")
+        return False
+
+def start_worker():
+    """Start Celery worker."""
+    print("Starting Celery worker...")
+    cmd = [
+        sys.executable, "-m", "celery",
+        "-A", "celery_config",
+        "worker",
+        "--loglevel=info",
+        "--pool=solo",
+        "--max-tasks-per-child=100"
+    ]
+    
+    if platform.system() == "Windows":
+        subprocess.Popen(cmd, cwd=backend_dir)
+    else:
+        subprocess.Popen(cmd, cwd=backend_dir)
+    
+    print("Celery worker started")
+
+def start_beat():
+    """Start Celery Beat scheduler."""
+    print("Starting Celery Beat scheduler...")
+    cmd = [
+        sys.executable, "-m", "celery",
+        "-A", "celery_config",
+        "beat",
+        "--loglevel=info",
+        "--scheduler=django_celery_beat.schedulers:DatabaseScheduler"
+    ]
+    
+    if platform.system() == "Windows":
+        subprocess.Popen(cmd, cwd=backend_dir)
+    else:
+        subprocess.Popen(cmd, cwd=backend_dir)
+    
+    print("Celery Beat scheduler started")
+
+def start_all():
+    """Start both worker and beat."""
+    if not check_redis():
+        return False
+    
+    print("Starting all Celery components...")
+    start_worker()
+    start_beat()
+    print("All Celery components started")
+    return True
+
+def main():
+    """Main function."""
+    if len(sys.argv) < 2:
+        print("Usage: python start_celery.py <command>")
+        print("Commands:")
+        print("  worker    - Start Celery worker only")
+        print("  beat      - Start Celery Beat scheduler only")
+        print("  all       - Start both worker and beat")
+        print("  check     - Check system requirements")
+        sys.exit(1)
+    
+    command = sys.argv[1].lower()
+    
+    if command == "worker":
+        if not check_redis():
+            sys.exit(1)
+        start_worker()
+    elif command == "beat":
+        if not check_redis():
+            sys.exit(1)
+        start_beat()
+    elif command == "all":
+        if not start_all():
+            sys.exit(1)
+    elif command == "check":
+        print("Checking system requirements...")
+        if check_redis():
+            print("✓ All requirements met")
+        else:
+            print("✗ Some requirements not met")
+            sys.exit(1)
+    else:
+        print(f"Unknown command: {command}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

backend/start_celery.sh

@@ -10,14 +10,14 @@ fi
 # Function to start Celery worker
 start_worker() {
     echo "Starting Celery worker..."
-    celery -A celery_app worker --loglevel=info &
+    python start_celery.py worker &
     echo "Celery worker started with PID $!"
 }
 
 # Function to start Celery Beat scheduler
 start_beat() {
     echo "Starting Celery Beat scheduler..."
-    celery -A celery_beat_config beat --loglevel=info &
+    python start_celery.py beat &
     echo "Celery Beat scheduler started with PID $!"
 }
 
@@ -27,6 +27,12 @@ start_all() {
     start_beat
 }
 
+# Function to check system requirements
+check_requirements() {
+    echo "Checking system requirements..."
+    python start_celery.py check
+}
+
 # Main script logic
 case "$1" in
     worker)
@@ -38,11 +44,15 @@ case "$1" in
     all)
         start_all
         ;;
+    check)
+        check_requirements
+        ;;
     *)
-        echo "Usage: $0 {worker|beat|all}"
+        echo "Usage: $0 {worker|beat|all|check}"
         echo "  worker - Start Celery worker"
         echo "  beat   - Start Celery Beat scheduler"
         echo "  all    - Start both worker and scheduler"
+        echo "  check  - Check system requirements"
         exit 1
         ;;
 esac

frontend/src/components/Sidebar/Sidebar.jsx

@@ -84,7 +84,6 @@ const Sidebar = ({ isCollapsed, toggleSidebar }) => {
       label: 'Dashboard',
       icon: 'dashboard',
       description: 'Overview and analytics',
-      badge: 'New',
       iconColor: 'text-primary-600',
       animationDelay: 0,
       ariaLabel: 'Dashboard - Overview and analytics',
@@ -105,7 +104,6 @@ const Sidebar = ({ isCollapsed, toggleSidebar }) => {
       label: 'Accounts',
       icon: 'account_circle',
       description: 'Social media accounts',
-      count: 3,
       iconColor: 'text-success-600',
       animationDelay: 200,
       ariaLabel: 'Accounts - Social media accounts',
@@ -116,7 +114,6 @@ const Sidebar = ({ isCollapsed, toggleSidebar }) => {
       label: 'Posts',
       icon: 'post_add',
       description: 'Content posts',
-      count: 12,
       iconColor: 'text-warning-600',
       animationDelay: 300,
       ariaLabel: 'Posts - Content posts',

frontend/src/pages/Home.jsx

@@ -186,29 +186,6 @@ const Home = () => {
               </Link>
             </div>
 
-            {/* Trust indicators */}
-            <div className={`mt-12 sm:mt-16 flex flex-wrap justify-center items-center gap-4 sm:gap-6 lg:gap-8 text-secondary-600 transition-all duration-1000 ${
-              isVisible ? 'animate-slide-up opacity-100' : 'opacity-0 translate-y-8'
-            }`} style={{ animationDelay: '0.5s' }}>
-              <div className="flex items-center gap-2">
-                <svg className="w-5 h-5 sm:w-6 sm:h-6 text-primary-600" fill="currentColor" viewBox="0 0 20 20">
-                  <path fillRule="evenodd" d="M6.267 3.455a3.066 3.066 0 001.745-.723 3.066 3.066 0 013.976 0 3.066 3.066 0 001.745.723 3.066 3.066 0 012.812 2.812c.051.643.304 1.254.723 1.745a3.066 3.066 0 010 3.976 3.066 3.066 0 00-.723 1.745 3.066 3.066 0 01-2.812 2.812 3.066 3.066 0 00-1.745.723 3.066 3.066 0 01-3.976 0 3.066 3.066 0 00-1.745-.723 3.066 3.066 0 01-2.812-2.812 3.066 3.066 0 00-.723-1.745 3.066 3.066 0 010-3.976 3.066 3.066 0 00.723-1.745 3.066 3.066 0 012.812-2.812zm7.44 5.252a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clipRule="evenodd" />
-                </svg>
-                <span className="text-sm sm:text-base font-medium">10,000+ Active Users</span>
-              </div>
-              <div className="flex items-center gap-2">
-                <svg className="w-5 h-5 sm:w-6 sm:h-6 text-primary-600" fill="currentColor" viewBox="0 0 20 20">
-                  <path fillRule="evenodd" d="M3 17a1 1 0 011-1h12a1 1 0 110 2H4a1 1 0 01-1-1zm3.293-7.707a1 1 0 011.414 0L9 10.586V3a1 1 0 112 0v7.586l1.293-1.293a1 1 0 111.414 1.414l-3 3a1 1 0 01-1.414 0l-3-3a1 1 0 010-1.414z" clipRule="evenodd" />
-                </svg>
-                <span className="text-sm sm:text-base font-medium">50M+ Posts Managed</span>
-              </div>
-              <div className="flex items-center gap-2">
-                <svg className="w-5 h-5 sm:w-6 sm:h-6 text-primary-600" fill="currentColor" viewBox="0 0 20 20">
-                  <path d="M9.049 2.927c.3-.921 1.603-.921 1.902 0l1.07 3.292a1 1 0 00.95.69h3.462c.969 0 1.371 1.24.588 1.81l-2.8 2.034a1 1 0 00-.364 1.118l1.07 3.292c.3.921-.755 1.688-1.54 1.118l-2.8-2.034a1 1 0 00-1.175 0l-2.8 2.034c-.784.57-1.838-.197-1.539-1.118l1.07-3.292a1 1 0 00-.364-1.118L2.98 8.72c-.783-.57-.38-1.81.588-1.81h3.461a1 1 0 00.951-.69l1.07-3.292z" />
-                </svg>
-                <span className="text-sm sm:text-base font-medium">4.9/5 User Rating</span>
-              </div>
-            </div>
           </div>
         </div>
       </section>

start_app.py

@@ -1,10 +1,72 @@
 #!/usr/bin/env python
 """
 Entry point for the Lin application.
-This is an alternative entry point that can be used if needed.
+This script starts both the Flask application and Celery scheduler components.
 """
 import os
 import sys
+import subprocess
+import platform
+import time
+from pathlib import Path
+
+def check_redis():
+    """Check if Redis is running."""
+    try:
+        import redis
+        client = redis.Redis(host='localhost', port=6379, db=0)
+        client.ping()
+        print("✓ Redis connection successful")
+        return True
+    except Exception as e:
+        print(f"✗ Redis connection failed: {e}")
+        print("Please start Redis server first:")
+        print("  Windows: redis-server")
+        print("  Linux/Mac: sudo systemctl start redis")
+        return False
+
+def start_celery_components():
+    """Start Celery worker and beat scheduler in background processes."""
+    print("Starting Celery components...")
+    
+    backend_dir = Path(__file__).parent / "backend"
+    
+    # Start Celery worker
+    worker_cmd = [
+        sys.executable, "-m", "celery",
+        "-A", "celery_config",
+        "worker",
+        "--loglevel=info",
+        "--pool=solo",
+        "--max-tasks-per-child=100"
+    ]
+    
+    # Start Celery beat
+    beat_cmd = [
+        sys.executable, "-m", "celery",
+        "-A", "celery_config",
+        "beat",
+        "--loglevel=info",
+        "--scheduler=django_celery_beat.schedulers:DatabaseScheduler"
+    ]
+    
+    if platform.system() == "Windows":
+        # Windows: Use subprocess to start background processes
+        subprocess.Popen(worker_cmd, cwd=backend_dir,
+                        stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                        creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
+        subprocess.Popen(beat_cmd, cwd=backend_dir,
+                        stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                        creationflags=subprocess.CREATE_NEW_PROCESS_GROUP)
+    else:
+        # Linux/Mac: Use subprocess with proper signal handling
+        subprocess.Popen(worker_cmd, cwd=backend_dir,
+                        stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        subprocess.Popen(beat_cmd, cwd=backend_dir,
+                        stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    
+    print("Celery worker and beat scheduler started in background")
+    time.sleep(2)  # Give Celery components time to start
 
 if __name__ == "__main__":
     # Set the port for Hugging Face Spaces
@@ -12,16 +74,41 @@ if __name__ == "__main__":
     os.environ.setdefault('PORT', port)
     
     print(f"Starting Lin application on port {port}...")
+    print("=" * 60)
+    
+    # Check if Redis is available
+    if not check_redis():
+        print("Warning: Redis not available. Celery may not function properly.")
+        print("Continuing with Flask app only...")
+        print("=" * 60)
     
     try:
+        # Start Celery components first
+        start_celery_components()
+        
         # Import and run the backend Flask app directly
         from backend.app import create_app
         app = create_app()
+        
+        print("=" * 60)
+        print("Flask application starting...")
+        print("Access the application at:")
+        print(f"  http://localhost:{port}")
+        print(f"  http://127.0.0.1:{port}")
+        print("=" * 60)
+        
         app.run(
             host='0.0.0.0',
             port=int(port),
-            debug=False
+            debug=False,
+            threaded=True
         )
+        
+    except KeyboardInterrupt:
+        print("\nShutting down application...")
+        sys.exit(0)
     except Exception as e:
         print(f"Failed to start Lin application: {e}")
+        import traceback
+        traceback.print_exc()
         sys.exit(1)