Upload 13 files

Add application files

.env

@@ -0,0 +1,63 @@
+# Azure Speech Services Configuration
+AZURE_SPEECH_KEY=8wLwSSfcB0Z35xFx9HavbzBBvVwN4zalR42HeVig2NKe81AkbwFPJQQJ99BGACYeBjFXJ3w3AAAYACOGnAXF
+AZURE_SPEECH_KEY_ENDPOINT=https://eastus.api.cognitive.microsoft.com/
+AZURE_REGION=eastus
+
+# Azure Blob Storage Configuration
+AZURE_BLOB_CONNECTION=DefaultEndpointsProtocol=https;AccountName=speechtotextservice01;AccountKey=GAFbqMBvIHkRXLIx9173jFVb7W96lQ02t7bGgKwq6LbpU2gqaUeU+pWAKcbdn38rQYfKnOFVy5ar+AStxXjAJA==;EndpointSuffix=core.windows.net
+AZURE_CONTAINER=history
+AZURE_CONTAINER_CHAT=response-chat
+AZURE_BLOB_SAS_TOKEN=sp=racwdl&st=2025-07-08T15:31:37Z&se=2030-07-08T23:31:37Z&sv=2024-11-04&sr=c&sig=FF8Nh6eOvx08ouMEV6u7tWxn9viD7OFJXmAbiO2BeK8%3D
+
+# Computer Vision Services Configuration (NEW)
+COMPUTER_VISION_ENDPOINT=https://image-process-256808.cognitiveservices.azure.com/
+COMPUTER_VISION_KEY=64PKopBssiMAEHVtqRySNxv5HRWsza7mN27KgDoXqaOcgIv5Z3AFJQQJ99BHACYeBjFXJ3w3AAAFACOG8rdi
+COMPUTER_VISION_REGION=eastus
+
+# AI Agents Configuration (NEW)
+AI_PROJECT_ENDPOINT=https://aiservicetesting001.services.ai.azure.com/api/projects/aiagentdeplyomentproject
+AI_PROJECT_KEY=9qYUFJwW1qDvF05Qz8RPuL0r1JbO123WSKMdRcnh76jO2VGB4Z6oJQQJ99BCAC77bzfXJ3w3AAAAACOGlbzd
+AI_AGENT_ID=asst_8isTjrGPs8M0d1RhkNONDtHK
+
+# Azure OpenAI Configuration
+AZURE_OPENAI_ENDPOINT=https://openaiservice2568.openai.azure.com/
+AZURE_OPENAI_KEY=8CZSXFphWviu1KBpweiUntRKrJgYR2hApSUT76f5MlBsSjuvKulnJQQJ99BCACYeBjFXJ3w3AAABACOGc2vU
+AZURE_OPENAI_DEPLOYMENT=gpt-4.1-mini
+AZURE_OPENAI_API_VERSION=2024-12-01-preview
+
+# API Configuration
+API_VERSION=v3.2
+
+# Allowed Languages Configuration
+ALLOWED_LANGS={"en-US": "English (US)", "en-GB": "English (UK)", "es-ES": "Spanish", "fr-FR": "French", "de-DE": "German", "it-IT": "Italian", "pt-BR": "Portuguese (Brazil)", "zh-CN": "Chinese (Simplified)", "ja-JP": "Japanese", "ko-KR": "Korean", "ru-RU": "Russian", "ar-SA": "Arabic", "hi-IN": "Hindi", "th-TH": "Thai", "vi-VN": "Vietnamese", "nl-NL": "Dutch", "sv-SE": "Swedish", "da-DK": "Danish", "no-NO": "Norwegian", "fi-FI": "Finnish", "pl-PL": "Polish", "cs-CZ": "Czech", "hu-HU": "Hungarian", "ro-RO": "Romanian", "bg-BG": "Bulgarian", "hr-HR": "Croatian", "sk-SK": "Slovak", "sl-SI": "Slovenian", "et-EE": "Estonian", "lv-LV": "Latvian", "lt-LT": "Lithuanian", "uk-UA": "Ukrainian", "el-GR": "Greek", "tr-TR": "Turkish", "he-IL": "Hebrew", "fa-IR": "Persian", "ur-PK": "Urdu", "bn-BD": "Bengali", "ta-IN": "Tamil", "te-IN": "Telugu", "ml-IN": "Malayalam", "kn-IN": "Kannada", "gu-IN": "Gujarati", "pa-IN": "Punjabi", "mr-IN": "Marathi", "ne-NP": "Nepali", "si-LK": "Sinhala", "my-MM": "Myanmar", "km-KH": "Khmer", "lo-LA": "Lao", "ka-GE": "Georgian", "am-ET": "Amharic", "sw-TZ": "Swahili", "zu-ZA": "Zulu", "af-ZA": "Afrikaans", "is-IS": "Icelandic", "mt-MT": "Maltese", "cy-GB": "Welsh", "ga-IE": "Irish", "eu-ES": "Basque", "ca-ES": "Catalan", "gl-ES": "Galician", "pt-PT": "Portuguese (Portugal)", "fr-CA": "French (Canada)", "en-AU": "English (Australia)", "en-IN": "English (India)", "en-CA": "English (Canada)", "en-NZ": "English (New Zealand)", "en-ZA": "English (South Africa)", "es-MX": "Spanish (Mexico)", "es-AR": "Spanish (Argentina)", "es-CO": "Spanish (Colombia)", "es-CL": "Spanish (Chile)", "es-PE": "Spanish (Peru)", "es-VE": "Spanish (Venezuela)", "es-EC": "Spanish (Ecuador)", "es-GT": "Spanish (Guatemala)", "es-CR": "Spanish (Costa Rica)", "es-PA": "Spanish (Panama)", "es-DO": "Spanish (Dominican Republic)", "es-PR": "Spanish (Puerto Rico)", "es-UY": "Spanish (Uruguay)", "es-PY": "Spanish (Paraguay)", "es-BO": "Spanish (Bolivia)", "es-SV": "Spanish (El Salvador)", "es-HN": "Spanish (Honduras)", "es-NI": "Spanish (Nicaragua)", "zh-TW": "Chinese (Traditional)", "zh-HK": "Chinese (Hong Kong)"}
+
+# Application Settings
+DEBUG=False
+UPLOAD_MAX_SIZE_MB=500
+MAX_CONCURRENT_JOBS=5
+DATABASE_PATH=database/transcriptions.db
+CLEANUP_OLDER_THAN_DAYS=30
+
+# # Security Settings (Optional - for enhanced security)
+# SECRET_KEY=your_secret_key_for_sessions
+# ENCRYPTION_KEY=your_encryption_key_for_sensitive_data
+
+# Logging Settings
+LOG_LEVEL=INFO
+LOG_FILE=app.log
+
+# Performance Settings
+FRAME_EXTRACTION_MAX_FRAMES=50
+FRAME_SIMILARITY_THRESHOLD=0.85
+MIN_TIME_BETWEEN_FRAMES=2.0
+
+# File Processing Settings
+SUPPORTED_VIDEO_FORMATS=mp4,mov,avi,mkv,webm,flv,3gp,wmv
+SUPPORTED_AUDIO_FORMATS=wav,mp3,ogg,opus,flac,wma,aac,m4a,amr,speex
+SUPPORTED_DOCUMENT_FORMATS=pdf,docx,doc,pptx,ppt,xlsx,xls,csv,txt,json
+SUPPORTED_IMAGE_FORMATS=jpg,jpeg,png,bmp,gif,tiff,webp
+
+# Database Settings
+DATABASE_BACKUP_INTERVAL=30
+DATABASE_LOCATION=database/transcriptions.db
+TEMP_FILES_CLEANUP_HOURS=24

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Developer.md

@@ -0,0 +1,1904 @@
+# 🛠️ Azure Speech Transcription - Developer Guide
+
+## 📋 Table of Contents
+
+- [System Architecture](#-system-architecture)
+- [Development Environment](#-development-environment)
+- [Deployment Guide](#-deployment-guide)
+- [API Documentation](#-api-documentation)
+- [Database Schema](#-database-schema)
+- [Security Implementation](#-security-implementation)
+- [Monitoring & Maintenance](#-monitoring--maintenance)
+- [Contributing Guidelines](#-contributing-guidelines)
+- [Advanced Configuration](#-advanced-configuration)
+- [Troubleshooting](#-troubleshooting)
+
+---
+
+## 🏗️ System Architecture
+
+### Overview
+
+The Azure Speech Transcription service is built with a modern, secure architecture focusing on user privacy, PDPA compliance, and scalability.
+
+```
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   Frontend UI   │    │   Backend API   │    │ Azure Services  │
+│   (Gradio)      │◄──►│   (Python)      │◄──►│ Speech & Blob   │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+         │                       │                       │
+         │                       │                       │
+         ▼                       ▼                       ▼
+┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
+│   User Session  │    │ SQLite Database │    │  User Storage   │
+│   Management    │    │   (Metadata)    │    │   (Isolated)    │
+└─────────────────┘    └─────────────────┘    └─────────────────┘
+```
+
+### Core Components
+
+#### 1. Frontend Layer (`gradio_app.py`)
+- **Technology**: Gradio with custom CSS
+- **Purpose**: User interface and session management
+- **Features**: Authentication, file upload, real-time status, history management
+
+#### 2. Backend Layer (`app_core.py`)
+- **Technology**: Python with threading and async processing
+- **Purpose**: Business logic, authentication, and Azure integration
+- **Features**: User management, transcription processing, PDPA compliance
+
+#### 3. Data Layer
+- **Database**: SQLite with Azure Blob backup
+- **Storage**: Azure Blob Storage with user separation
+- **Security**: User-isolated folders and encrypted connections
+
+#### 4. External Services
+- **Azure Speech Services**: Transcription processing
+- **Azure Blob Storage**: File and database storage
+- **FFmpeg**: Audio/video conversion
+
+### Data Flow
+
+```
+1. User uploads file → 2. Authentication check → 3. File validation
+        ↓                       ↓                       ↓
+8. Download results ← 7. Store transcript ← 6. Process with Azure
+        ↑                       ↑                       ↑
+9. Update UI status ← 4. Save to user folder ← 5. Background processing
+```
+
+---
+
+## 💻 Development Environment
+
+### Prerequisites
+
+- **Python**: 3.8 or higher
+- **Azure Account**: With Speech Services and Blob Storage
+- **FFmpeg**: For audio/video processing
+- **Git**: For version control
+
+### Environment Setup
+
+#### 1. Clone Repository
+```bash
+git clone <repository-url>
+cd azure-speech-transcription
+```
+
+#### 2. Virtual Environment
+```bash
+# Create virtual environment
+python -m venv venv
+
+# Activate (Windows)
+venv\Scripts\activate
+
+# Activate (macOS/Linux)
+source venv/bin/activate
+```
+
+#### 3. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+#### 4. Environment Configuration
+```bash
+# Copy environment template
+cp .env.example .env
+
+# Edit with your Azure credentials
+nano .env
+```
+
+#### 5. Install FFmpeg
+
+**Windows (Chocolatey):**
+```bash
+choco install ffmpeg
+```
+
+**macOS (Homebrew):**
+```bash
+brew install ffmpeg
+```
+
+**Ubuntu/Debian:**
+```bash
+sudo apt update
+sudo apt install ffmpeg
+```
+
+#### 6. Verify Installation
+```python
+python -c "
+import gradio as gr
+from azure.storage.blob import BlobServiceClient
+import subprocess
+print('Gradio:', gr.__version__)
+print('FFmpeg:', subprocess.run(['ffmpeg', '-version'], capture_output=True).returncode == 0)
+print('Azure Blob:', 'OK')
+"
+```
+
+### Development Server
+
+```bash
+# Start development server
+python gradio_app.py
+
+# Server will be available at:
+# http://localhost:7860
+```
+
+### Development Tools
+
+#### Recommended IDE Setup
+- **VS Code**: With Python, Azure, and Git extensions
+- **PyCharm**: Professional edition with Azure toolkit
+- **Vim/Emacs**: With appropriate Python plugins
+
+#### Useful Extensions
+```json
+{
+  "recommendations": [
+    "ms-python.python",
+    "ms-vscode.azure-cli",
+    "ms-azuretools.azure-cli-tools",
+    "ms-python.black-formatter",
+    "ms-python.flake8"
+  ]
+}
+```
+
+#### Code Quality Tools
+```bash
+# Install development tools
+pip install black flake8 pytest mypy
+
+# Format code
+black .
+
+# Lint code
+flake8 .
+
+# Type checking
+mypy app_core.py gradio_app.py
+```
+
+---
+
+## 🚀 Deployment Guide
+
+### Production Deployment Options
+
+#### Option 1: Traditional Server Deployment
+
+**1. Server Preparation**
+```bash
+# Update system
+sudo apt update && sudo apt upgrade -y
+
+# Install Python and dependencies
+sudo apt install python3 python3-pip python3-venv nginx ffmpeg -y
+
+# Create application user
+sudo useradd -m -s /bin/bash transcription
+sudo su - transcription
+```
+
+**2. Application Setup**
+```bash
+# Clone repository
+git clone <repository-url> /home/transcription/app
+cd /home/transcription/app
+
+# Setup virtual environment
+python3 -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+
+# Configure environment
+cp .env.example .env
+# Edit .env with production values
+```
+
+**3. Systemd Service**
+```ini
+# /etc/systemd/system/transcription.service
+[Unit]
+Description=Azure Speech Transcription Service
+After=network.target
+
+[Service]
+Type=simple
+User=transcription
+Group=transcription
+WorkingDirectory=/home/transcription/app
+Environment=PATH=/home/transcription/app/venv/bin
+ExecStart=/home/transcription/app/venv/bin/python gradio_app.py
+Restart=always
+RestartSec=10
+
+[Install]
+WantedBy=multi-user.target
+```
+
+**4. Nginx Configuration**
+```nginx
+# /etc/nginx/sites-available/transcription
+server {
+    listen 80;
+    server_name your-domain.com;
+    client_max_body_size 500M;
+
+    location / {
+        proxy_pass http://127.0.0.1:7860;
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 300s;
+        proxy_connect_timeout 75s;
+    }
+}
+```
+
+**5. SSL Certificate**
+```bash
+# Install Certbot
+sudo apt install certbot python3-certbot-nginx -y
+
+# Get SSL certificate
+sudo certbot --nginx -d your-domain.com
+
+# Verify auto-renewal
+sudo certbot renew --dry-run
+```
+
+**6. Start Services**
+```bash
+# Enable and start application
+sudo systemctl enable transcription
+sudo systemctl start transcription
+
+# Enable and restart nginx
+sudo systemctl enable nginx
+sudo systemctl restart nginx
+
+# Check status
+sudo systemctl status transcription
+sudo systemctl status nginx
+```
+
+#### Option 2: Docker Deployment
+
+**1. Dockerfile**
+```dockerfile
+FROM python:3.9-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements and install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create necessary directories
+RUN mkdir -p uploads database temp
+
+# Expose port
+EXPOSE 7860
+
+# Run application
+CMD ["python", "gradio_app.py"]
+```
+
+**2. Docker Compose**
+```yaml
+# docker-compose.yml
+version: '3.8'
+
+services:
+  transcription:
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      - AZURE_SPEECH_KEY=${AZURE_SPEECH_KEY}
+      - AZURE_SPEECH_KEY_ENDPOINT=${AZURE_SPEECH_KEY_ENDPOINT}
+      - AZURE_REGION=${AZURE_REGION}
+      - AZURE_BLOB_CONNECTION=${AZURE_BLOB_CONNECTION}
+      - AZURE_CONTAINER=${AZURE_CONTAINER}
+      - AZURE_BLOB_SAS_TOKEN=${AZURE_BLOB_SAS_TOKEN}
+      - ALLOWED_LANGS=${ALLOWED_LANGS}
+    volumes:
+      - ./uploads:/app/uploads
+      - ./database:/app/database
+      - ./temp:/app/temp
+    restart: unless-stopped
+
+  nginx:
+    image: nginx:alpine
+    ports:
+      - "80:80"
+      - "443:443"
+    volumes:
+      - ./nginx.conf:/etc/nginx/nginx.conf
+      - ./ssl:/etc/ssl/certs
+    depends_on:
+      - transcription
+    restart: unless-stopped
+```
+
+**3. Deploy with Docker**
+```bash
+# Build and start
+docker-compose up -d
+
+# View logs
+docker-compose logs -f transcription
+
+# Update application
+git pull
+docker-compose build transcription
+docker-compose up -d transcription
+```
+
+#### Option 3: Cloud Deployment (Azure Container Instances)
+
+**1. Create Container Registry**
+```bash
+# Create ACR
+az acr create --resource-group myResourceGroup \
+  --name myregistry --sku Basic
+
+# Login to ACR
+az acr login --name myregistry
+
+# Build and push image
+docker build -t myregistry.azurecr.io/transcription:latest .
+docker push myregistry.azurecr.io/transcription:latest
+```
+
+**2. Deploy Container Instance**
+```bash
+# Create container instance
+az container create \
+  --resource-group myResourceGroup \
+  --name transcription-app \
+  --image myregistry.azurecr.io/transcription:latest \
+  --cpu 2 --memory 4 \
+  --port 7860 \
+  --environment-variables \
+    AZURE_SPEECH_KEY=$AZURE_SPEECH_KEY \
+    AZURE_SPEECH_KEY_ENDPOINT=$AZURE_SPEECH_KEY_ENDPOINT \
+    AZURE_REGION=$AZURE_REGION \
+    AZURE_BLOB_CONNECTION="$AZURE_BLOB_CONNECTION" \
+    AZURE_CONTAINER=$AZURE_CONTAINER \
+    AZURE_BLOB_SAS_TOKEN="$AZURE_BLOB_SAS_TOKEN"
+```
+
+---
+
+## 📡 API Documentation
+
+### Core Classes and Methods
+
+#### TranscriptionManager Class
+
+**Purpose**: Main service class handling all transcription operations
+
+```python
+class TranscriptionManager:
+    def __init__(self)
+    
+    # User Authentication
+    def register_user(email: str, username: str, password: str, 
+                     gdpr_consent: bool, data_retention_agreed: bool, 
+                     marketing_consent: bool) -> Tuple[bool, str, Optional[str]]
+    
+    def login_user(login: str, password: str) -> Tuple[bool, str, Optional[User]]
+    
+    # Transcription Operations  
+    def submit_transcription(file_bytes: bytes, original_filename: str,
+                           user_id: str, language: str, 
+                           settings: Dict) -> str
+    
+    def get_job_status(job_id: str) -> Optional[TranscriptionJob]
+    
+    # Data Management
+    def get_user_history(user_id: str, limit: int) -> List[TranscriptionJob]
+    def get_user_stats(user_id: str) -> Dict
+    def export_user_data(user_id: str) -> Dict
+    def delete_user_account(user_id: str) -> bool
+```
+
+#### DatabaseManager Class
+
+**Purpose**: Handle database operations and Azure blob synchronization
+
+```python
+class DatabaseManager:
+    def __init__(db_path: str = None)
+    
+    # User Operations
+    def create_user(...) -> Tuple[bool, str, Optional[str]]
+    def authenticate_user(login: str, password: str) -> Tuple[bool, str, Optional[User]]
+    def get_user_by_id(user_id: str) -> Optional[User]
+    
+    # Job Operations
+    def save_job(job: TranscriptionJob)
+    def get_job(job_id: str) -> Optional[TranscriptionJob]
+    def get_user_jobs(user_id: str, limit: int) -> List[TranscriptionJob]
+    def get_pending_jobs() -> List[TranscriptionJob]
+```
+
+#### AuthManager Class
+
+**Purpose**: Authentication utilities and validation
+
+```python
+class AuthManager:
+    @staticmethod
+    def hash_password(password: str) -> str
+    def verify_password(password: str, password_hash: str) -> bool
+    def validate_email(email: str) -> bool
+    def validate_username(username: str) -> bool
+    def validate_password(password: str) -> Tuple[bool, str]
+```
+
+### Data Models
+
+#### User Model
+```python
+@dataclass
+class User:
+    user_id: str
+    email: str
+    username: str
+    password_hash: str
+    created_at: str
+    last_login: Optional[str] = None
+    is_active: bool = True
+    gdpr_consent: bool = False
+    data_retention_agreed: bool = False
+    marketing_consent: bool = False
+```
+
+#### TranscriptionJob Model
+```python
+@dataclass
+class TranscriptionJob:
+    job_id: str
+    user_id: str
+    original_filename: str
+    audio_url: str
+    language: str
+    status: str  # pending, processing, completed, failed
+    created_at: str
+    completed_at: Optional[str] = None
+    transcript_text: Optional[str] = None
+    transcript_url: Optional[str] = None
+    error_message: Optional[str] = None
+    azure_trans_id: Optional[str] = None
+    settings: Optional[Dict] = None
+```
+
+### Configuration Parameters
+
+#### Environment Variables
+```python
+# Required
+AZURE_SPEECH_KEY: str
+AZURE_SPEECH_KEY_ENDPOINT: str  
+AZURE_REGION: str
+AZURE_BLOB_CONNECTION: str
+AZURE_CONTAINER: str
+AZURE_BLOB_SAS_TOKEN: str
+
+# Optional
+ALLOWED_LANGS: str  # JSON string
+API_VERSION: str = "v3.2"
+PASSWORD_SALT: str = "default_salt"
+MAX_FILE_SIZE_MB: int = 500
+```
+
+#### Transcription Settings
+```python
+settings = {
+    'audio_format': str,           # wav, mp3, etc.
+    'diarization_enabled': bool,   # Speaker identification
+    'speakers': int,               # Max speakers (1-10)
+    'profanity': str,              # masked, removed, raw
+    'punctuation': str,            # automatic, dictated, none
+    'timestamps': bool,            # Include timestamps
+    'lexical': bool,               # Include lexical forms
+    'language_id_enabled': bool,   # Auto language detection
+    'candidate_locales': List[str] # Language candidates
+}
+```
+
+---
+
+## 🗄️ Database Schema
+
+### SQLite Database Structure
+
+#### Users Table
+```sql
+CREATE TABLE users (
+    user_id TEXT PRIMARY KEY,
+    email TEXT UNIQUE NOT NULL,
+    username TEXT UNIQUE NOT NULL,
+    password_hash TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    last_login TEXT,
+    is_active BOOLEAN DEFAULT 1,
+    gdpr_consent BOOLEAN DEFAULT 0,
+    data_retention_agreed BOOLEAN DEFAULT 0,
+    marketing_consent BOOLEAN DEFAULT 0
+);
+
+-- Indexes
+CREATE INDEX idx_users_email ON users(email);
+CREATE INDEX idx_users_username ON users(username);
+```
+
+#### Transcriptions Table
+```sql
+CREATE TABLE transcriptions (
+    job_id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL,
+    original_filename TEXT NOT NULL,
+    audio_url TEXT,
+    language TEXT NOT NULL,
+    status TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    completed_at TEXT,
+    transcript_text TEXT,
+    transcript_url TEXT,
+    error_message TEXT,
+    azure_trans_id TEXT,
+    settings TEXT,
+    FOREIGN KEY (user_id) REFERENCES users (user_id)
+);
+
+-- Indexes
+CREATE INDEX idx_transcriptions_user_id ON transcriptions(user_id);
+CREATE INDEX idx_transcriptions_status ON transcriptions(status);
+CREATE INDEX idx_transcriptions_created_at ON transcriptions(created_at DESC);
+CREATE INDEX idx_transcriptions_user_created ON transcriptions(user_id, created_at DESC);
+```
+
+### Azure Blob Storage Structure
+
+```
+Container: {AZURE_CONTAINER}/
+├── shared/
+│   └── database/
+│       └── transcriptions.db           # Shared database backup
+├── users/
+│   ├── {user-id-1}/
+│   │   ├── audio/                      # Processed audio files
+│   │   │   ├── {job-id-1}.wav
+│   │   │   └── {job-id-2}.wav
+│   │   ├── transcripts/                # Transcript files
+│   │   │   ├── {job-id-1}.txt
+│   │   │   └── {job-id-2}.txt
+│   │   └── originals/                  # Original uploaded files
+│   │       ├── {job-id-1}_{filename}.mp4
+│   │       └── {job-id-2}_{filename}.wav
+│   └── {user-id-2}/
+│       ├── audio/
+│       ├── transcripts/
+│       └── originals/
+```
+
+### Database Operations
+
+#### User Management Queries
+```sql
+-- Create user
+INSERT INTO users (user_id, email, username, password_hash, created_at, 
+                   gdpr_consent, data_retention_agreed, marketing_consent)
+VALUES (?, ?, ?, ?, ?, ?, ?, ?);
+
+-- Authenticate user
+SELECT * FROM users 
+WHERE (email = ? OR username = ?) AND is_active = 1;
+
+-- Update last login
+UPDATE users SET last_login = ? WHERE user_id = ?;
+
+-- Get user stats
+SELECT status, COUNT(*) FROM transcriptions 
+WHERE user_id = ? GROUP BY status;
+```
+
+#### Job Management Queries
+```sql
+-- Create job
+INSERT INTO transcriptions (job_id, user_id, original_filename, language, 
+                           status, created_at, settings)
+VALUES (?, ?, ?, ?, 'pending', ?, ?);
+
+-- Update job status
+UPDATE transcriptions 
+SET status = ?, completed_at = ?, transcript_text = ?, transcript_url = ?
+WHERE job_id = ?;
+
+-- Get user jobs
+SELECT * FROM transcriptions 
+WHERE user_id = ? 
+ORDER BY created_at DESC LIMIT ?;
+
+-- Get pending jobs for background processor
+SELECT * FROM transcriptions 
+WHERE status IN ('pending', 'processing');
+```
+
+---
+
+## 🔒 Security Implementation
+
+### Authentication Security
+
+#### Password Security
+```python
+# Password hashing with salt
+def hash_password(password: str) -> str:
+    salt = os.environ.get("PASSWORD_SALT", "default_salt")
+    return hashlib.sha256((password + salt).encode()).hexdigest()
+
+# Password validation
+def validate_password(password: str) -> Tuple[bool, str]:
+    if len(password) < 8:
+        return False, "Password must be at least 8 characters"
+    if not re.search(r'[A-Z]', password):
+        return False, "Password must contain uppercase letter"
+    if not re.search(r'[a-z]', password):
+        return False, "Password must contain lowercase letter"
+    if not re.search(r'\d', password):
+        return False, "Password must contain number"
+    return True, "Valid"
+```
+
+#### Session Management
+```python
+# User session state
+session_state = {
+    'user_id': str,
+    'username': str,
+    'logged_in_at': datetime,
+    'last_activity': datetime
+}
+
+# Session validation
+def validate_session(session_state: dict) -> bool:
+    if not session_state or 'user_id' not in session_state:
+        return False
+    
+    # Check session timeout (if implemented)
+    last_activity = session_state.get('last_activity')
+    if last_activity:
+        timeout = timedelta(hours=24)  # 24-hour sessions
+        if datetime.now() - last_activity > timeout:
+            return False
+    
+    return True
+```
+
+### Data Security
+
+#### Access Control
+```python
+# User data access verification
+def verify_user_access(job_id: str, user_id: str) -> bool:
+    job = get_job(job_id)
+    return job and job.user_id == user_id
+
+# File path security
+def get_user_blob_path(user_id: str, blob_type: str, filename: str) -> str:
+    # Ensure user can only access their own folder
+    safe_filename = os.path.basename(filename)  # Prevent path traversal
+    return f"users/{user_id}/{blob_type}/{safe_filename}"
+```
+
+#### Data Encryption
+```python
+# Azure Blob Storage encryption (configured at Azure level)
+# - Encryption at rest: Enabled by default
+# - Encryption in transit: HTTPS enforced
+# - Customer-managed keys: Optional enhancement
+
+# Database encryption (for sensitive fields)
+from cryptography.fernet import Fernet
+
+def encrypt_sensitive_data(data: str, key: bytes) -> str:
+    f = Fernet(key)
+    return f.encrypt(data.encode()).decode()
+
+def decrypt_sensitive_data(encrypted_data: str, key: bytes) -> str:
+    f = Fernet(key)
+    return f.decrypt(encrypted_data.encode()).decode()
+```
+
+### Azure Security
+
+#### Blob Storage Security
+```python
+# SAS token configuration for least privilege
+sas_permissions = BlobSasPermissions(
+    read=True,
+    write=True,
+    delete=True,
+    list=True
+)
+
+# IP restrictions (optional)
+sas_ip_range = "192.168.1.0/24"  # Restrict to specific IP range
+
+# Time-limited tokens
+sas_expiry = datetime.utcnow() + timedelta(hours=1)
+```
+
+#### Speech Service Security
+```python
+# Secure API calls
+headers = {
+    "Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY,
+    "Content-Type": "application/json"
+}
+
+# Request timeout and retry logic
+response = requests.post(
+    url, 
+    headers=headers, 
+    json=body,
+    timeout=30,
+    verify=True  # Verify SSL certificates
+)
+```
+
+### Input Validation
+
+#### File Upload Security
+```python
+def validate_uploaded_file(file_path: str, max_size: int = 500 * 1024 * 1024) -> Tuple[bool, str]:
+    try:
+        # Check file exists
+        if not os.path.exists(file_path):
+            return False, "File not found"
+        
+        # Check file size
+        file_size = os.path.getsize(file_path)
+        if file_size > max_size:
+            return False, f"File too large: {file_size / 1024 / 1024:.1f}MB"
+        
+        # Check file type by content (not just extension)
+        import magic
+        mime_type = magic.from_file(file_path, mime=True)
+        allowed_types = ['audio/', 'video/']
+        if not any(mime_type.startswith(t) for t in allowed_types):
+            return False, f"Invalid file type: {mime_type}"
+        
+        return True, "Valid"
+    
+    except Exception as e:
+        return False, f"Validation error: {str(e)}"
+```
+
+#### SQL Injection Prevention
+```python
+# Use parameterized queries (already implemented)
+cursor.execute(
+    "SELECT * FROM users WHERE email = ? AND password_hash = ?",
+    (email, password_hash)
+)
+
+# Input sanitization
+def sanitize_input(user_input: str) -> str:
+    # Remove dangerous characters
+    import html
+    sanitized = html.escape(user_input)
+    # Limit length
+    return sanitized[:1000]
+```
+
+---
+
+## 📊 Monitoring & Maintenance
+
+### Application Monitoring
+
+#### Health Checks
+```python
+def health_check() -> Dict[str, Any]:
+    """System health check endpoint"""
+    try:
+        # Database check
+        db_status = check_database_connection()
+        
+        # Azure services check
+        blob_status = check_blob_storage()
+        speech_status = check_speech_service()
+        
+        # FFmpeg check
+        ffmpeg_status = check_ffmpeg_installation()
+        
+        # Disk space check
+        disk_status = check_disk_space()
+        
+        return {
+            'status': 'healthy' if all([db_status, blob_status, speech_status, ffmpeg_status]) else 'unhealthy',
+            'timestamp': datetime.now().isoformat(),
+            'services': {
+                'database': db_status,
+                'blob_storage': blob_status,
+                'speech_service': speech_status,
+                'ffmpeg': ffmpeg_status,
+                'disk_space': disk_status
+            }
+        }
+    
+    except Exception as e:
+        return {
+            'status': 'error',
+            'timestamp': datetime.now().isoformat(),
+            'error': str(e)
+        }
+
+def check_database_connection() -> bool:
+    try:
+        with transcription_manager.db.get_connection() as conn:
+            conn.execute("SELECT 1").fetchone()
+        return True
+    except:
+        return False
+
+def check_blob_storage() -> bool:
+    try:
+        client = BlobServiceClient.from_connection_string(AZURE_BLOB_CONNECTION)
+        client.list_containers(max_results=1)
+        return True
+    except:
+        return False
+```
+
+#### Logging Configuration
+```python
+import logging
+from logging.handlers import RotatingFileHandler
+
+def setup_logging():
+    """Configure application logging"""
+    
+    # Create formatter
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    
+    # Console handler
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(logging.INFO)
+    
+    # File handler with rotation
+    file_handler = RotatingFileHandler(
+        'logs/transcription.log',
+        maxBytes=10*1024*1024,  # 10MB
+        backupCount=5
+    )
+    file_handler.setFormatter(formatter)
+    file_handler.setLevel(logging.DEBUG)
+    
+    # Configure root logger
+    logger = logging.getLogger()
+    logger.setLevel(logging.DEBUG)
+    logger.addHandler(console_handler)
+    logger.addHandler(file_handler)
+    
+    # Separate logger for sensitive operations
+    auth_logger = logging.getLogger('auth')
+    auth_handler = RotatingFileHandler(
+        'logs/auth.log',
+        maxBytes=5*1024*1024,  # 5MB
+        backupCount=10
+    )
+    auth_handler.setFormatter(formatter)
+    auth_logger.addHandler(auth_handler)
+    auth_logger.setLevel(logging.INFO)
+```
+
+#### Performance Monitoring
+```python
+import time
+from functools import wraps
+
+def monitor_performance(func):
+    """Decorator to monitor function performance"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        try:
+            result = func(*args, **kwargs)
+            duration = time.time() - start_time
+            logging.info(f"{func.__name__} completed in {duration:.2f}s")
+            return result
+        except Exception as e:
+            duration = time.time() - start_time
+            logging.error(f"{func.__name__} failed after {duration:.2f}s: {str(e)}")
+            raise
+    return wrapper
+
+# Usage
+@monitor_performance
+def submit_transcription(self, file_bytes, filename, user_id, language, settings):
+    # Implementation here
+    pass
+```
+
+### Database Maintenance
+
+#### Backup Strategy
+```python
+def backup_database():
+    """Backup database to Azure Blob Storage"""
+    try:
+        # Create timestamped backup
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_name = f"shared/backups/transcriptions_backup_{timestamp}.db"
+        
+        # Upload current database
+        blob_client = blob_service.get_blob_client(
+            container=AZURE_CONTAINER, 
+            blob=backup_name
+        )
+        
+        with open(db_path, "rb") as data:
+            blob_client.upload_blob(data)
+        
+        logging.info(f"Database backup created: {backup_name}")
+        
+        # Clean old backups (keep last 30 days)
+        cleanup_old_backups()
+        
+    except Exception as e:
+        logging.error(f"Database backup failed: {str(e)}")
+
+def cleanup_old_backups():
+    """Remove backups older than 30 days"""
+    try:
+        cutoff_date = datetime.now() - timedelta(days=30)
+        container_client = blob_service.get_container_client(AZURE_CONTAINER)
+        
+        for blob in container_client.list_blobs(name_starts_with="shared/backups/"):
+            if blob.last_modified < cutoff_date:
+                blob_service.delete_blob(AZURE_CONTAINER, blob.name)
+                logging.info(f"Deleted old backup: {blob.name}")
+                
+    except Exception as e:
+        logging.error(f"Backup cleanup failed: {str(e)}")
+```
+
+#### Database Optimization
+```python
+def optimize_database():
+    """Optimize database performance"""
+    try:
+        with transcription_manager.db.get_connection() as conn:
+            # Analyze tables
+            conn.execute("ANALYZE")
+            
+            # Vacuum database (compact)
+            conn.execute("VACUUM")
+            
+            # Update statistics
+            conn.execute("PRAGMA optimize")
+            
+        logging.info("Database optimization completed")
+        
+    except Exception as e:
+        logging.error(f"Database optimization failed: {str(e)}")
+
+# Schedule optimization (run weekly)
+import schedule
+
+schedule.every().week.do(optimize_database)
+schedule.every().day.at("02:00").do(backup_database)
+```
+
+### Resource Management
+
+#### Cleanup Tasks
+```python
+def cleanup_temporary_files():
+    """Clean up temporary files older than 24 hours"""
+    try:
+        cutoff_time = time.time() - (24 * 60 * 60)  # 24 hours ago
+        temp_dirs = ['uploads', 'temp']
+        
+        for temp_dir in temp_dirs:
+            if os.path.exists(temp_dir):
+                for filename in os.listdir(temp_dir):
+                    filepath = os.path.join(temp_dir, filename)
+                    if os.path.isfile(filepath) and os.path.getmtime(filepath) < cutoff_time:
+                        os.remove(filepath)
+                        logging.info(f"Cleaned up temporary file: {filepath}")
+                        
+    except Exception as e:
+        logging.error(f"Temporary file cleanup failed: {str(e)}")
+
+def monitor_disk_space():
+    """Monitor and alert on disk space"""
+    try:
+        import shutil
+        total, used, free = shutil.disk_usage("/")
+        
+        # Convert to GB
+        free_gb = free // (1024**3)
+        total_gb = total // (1024**3)
+        usage_percent = (used / total) * 100
+        
+        if usage_percent > 85:
+            logging.warning(f"High disk usage: {usage_percent:.1f}% ({free_gb}GB free)")
+            
+        if free_gb < 5:
+            logging.critical(f"Low disk space: {free_gb}GB remaining")
+            
+    except Exception as e:
+        logging.error(f"Disk space monitoring failed: {str(e)}")
+```
+
+### Monitoring Alerts
+
+#### Email Alerts (Optional)
+```python
+import smtplib
+from email.mime.text import MIMEText
+
+def send_alert(subject: str, message: str):
+    """Send email alert for critical issues"""
+    try:
+        smtp_server = os.environ.get("SMTP_SERVER")
+        smtp_port = int(os.environ.get("SMTP_PORT", "587"))
+        smtp_user = os.environ.get("SMTP_USER")
+        smtp_pass = os.environ.get("SMTP_PASS")
+        alert_email = os.environ.get("ALERT_EMAIL")
+        
+        if not all([smtp_server, smtp_user, smtp_pass, alert_email]):
+            return  # Email not configured
+        
+        msg = MIMEText(message)
+        msg['Subject'] = f"[Transcription Service] {subject}"
+        msg['From'] = smtp_user
+        msg['To'] = alert_email
+        
+        with smtplib.SMTP(smtp_server, smtp_port) as server:
+            server.starttls()
+            server.login(smtp_user, smtp_pass)
+            server.send_message(msg)
+            
+    except Exception as e:
+        logging.error(f"Failed to send alert: {str(e)}")
+```
+
+---
+
+## 🤝 Contributing Guidelines
+
+### Development Workflow
+
+#### 1. Setup Development Environment
+```bash
+# Fork repository
+git clone https://github.com/your-username/azure-speech-transcription.git
+cd azure-speech-transcription
+
+# Create feature branch
+git checkout -b feature/your-feature-name
+
+# Setup environment
+python -m venv venv
+source venv/bin/activate  # or venv\Scripts\activate on Windows
+pip install -r requirements.txt
+pip install -r requirements-dev.txt  # Development dependencies
+```
+
+#### 2. Code Quality Standards
+
+**Python Style Guide**
+- Follow PEP 8 style guidelines
+- Use type hints for function parameters and return values
+- Maximum line length: 88 characters (Black formatter)
+- Use meaningful variable and function names
+
+**Code Formatting**
+```bash
+# Install development tools
+pip install black flake8 mypy pytest
+
+# Format code
+black .
+
+# Check style
+flake8 .
+
+# Type checking
+mypy app_core.py gradio_app.py
+
+# Run tests
+pytest tests/
+```
+
+**Documentation Standards**
+- All functions must have docstrings
+- Include type hints
+- Document complex logic with inline comments
+- Update README.md for new features
+
+```python
+def submit_transcription(
+    self, 
+    file_bytes: bytes, 
+    original_filename: str,
+    user_id: str,
+    language: str,
+    settings: Dict[str, Any]
+) -> str:
+    """
+    Submit a new transcription job for processing.
+    
+    Args:
+        file_bytes: Raw bytes of the audio/video file
+        original_filename: Original name of the uploaded file
+        user_id: ID of the authenticated user
+        language: Language code for transcription (e.g., 'en-US')
+        settings: Transcription configuration options
+        
+    Returns:
+        str: Unique job ID for tracking transcription progress
+        
+    Raises:
+        ValueError: If user_id is invalid or file is too large
+        ConnectionError: If Azure services are unavailable
+    """
+```
+
+#### 3. Testing Requirements
+
+**Unit Tests**
+```python
+import pytest
+from unittest.mock import Mock, patch
+from app_core import TranscriptionManager, AuthManager
+
+class TestAuthManager:
+    def test_password_hashing(self):
+        password = "TestPassword123"
+        hashed = AuthManager.hash_password(password)
+        
+        assert hashed != password
+        assert AuthManager.verify_password(password, hashed)
+        assert not AuthManager.verify_password("wrong", hashed)
+    
+    def test_email_validation(self):
+        assert AuthManager.validate_email("test@example.com")
+        assert not AuthManager.validate_email("invalid-email")
+        assert not AuthManager.validate_email("")
+
+class TestTranscriptionManager:
+    @patch('app_core.BlobServiceClient')
+    def test_submit_transcription(self, mock_blob):
+        manager = TranscriptionManager()
+        
+        job_id = manager.submit_transcription(
+            b"fake audio data",
+            "test.wav",
+            "user123",
+            "en-US",
+            {"audio_format": "wav"}
+        )
+        
+        assert isinstance(job_id, str)
+        assert len(job_id) == 36  # UUID length
+```
+
+**Integration Tests**
+```python
+class TestIntegration:
+    def test_full_transcription_workflow(self):
+        # Test complete workflow from upload to download
+        pass
+    
+    def test_user_registration_and_login(self):
+        # Test complete auth workflow
+        pass
+```
+
+#### 4. Commit Guidelines
+
+**Commit Message Format**
+```
+type(scope): brief description
+
+Detailed explanation of changes if needed
+
+- List specific changes
+- Include any breaking changes
+- Reference issue numbers
+
+Closes #123
+```
+
+**Commit Types**
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `style`: Code style changes (formatting, etc.)
+- `refactor`: Code refactoring
+- `test`: Adding or updating tests
+- `chore`: Maintenance tasks
+
+**Example Commits**
+```bash
+git commit -m "feat(auth): add password strength validation
+
+- Implement password complexity requirements
+- Add client-side validation feedback
+- Update registration form UI
+
+Closes #45"
+
+git commit -m "fix(transcription): handle Azure service timeouts
+
+- Add retry logic for failed API calls
+- Improve error messages for users
+- Log detailed error information
+
+Fixes #67"
+```
+
+#### 5. Pull Request Process
+
+**PR Checklist**
+- [ ] Code follows style guidelines
+- [ ] All tests pass
+- [ ] Documentation updated
+- [ ] Security considerations reviewed
+- [ ] Performance impact assessed
+- [ ] Breaking changes documented
+
+**PR Template**
+```markdown
+## Description
+Brief description of changes
+
+## Type of Change
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Breaking change
+- [ ] Documentation update
+
+## Testing
+- [ ] Unit tests added/updated
+- [ ] Integration tests pass
+- [ ] Manual testing completed
+
+## Security
+- [ ] No sensitive data exposed
+- [ ] Input validation implemented
+- [ ] Access controls maintained
+
+## Performance
+- [ ] No performance degradation
+- [ ] Database queries optimized
+- [ ] Resource usage considered
+```
+
+### Feature Development
+
+#### Adding New Languages
+```python
+# 1. Update environment configuration
+ALLOWED_LANGS = {
+    "en-US": "English (United States)",
+    "es-ES": "Spanish (Spain)",
+    "new-LANG": "New Language Name"
+}
+
+# 2. Test language support
+def test_new_language():
+    # Verify Azure Speech Services supports the language
+    # Test transcription accuracy
+    # Update documentation
+```
+
+#### Adding New Audio Formats
+```python
+# 1. Update supported formats list
+AUDIO_FORMATS = [
+    "wav", "mp3", "ogg", "opus", "flac", 
+    "new_format"  # Add new format
+]
+
+# 2. Update FFmpeg conversion logic
+def _convert_to_audio(self, input_path, output_path, audio_format="wav"):
+    if audio_format == "new_format":
+        # Add specific conversion parameters
+        cmd = ["ffmpeg", "-i", input_path, "-codec", "new_codec", output_path]
+```
+
+#### Adding New Features
+```python
+# 1. Database schema updates
+def upgrade_database_schema():
+    with self.get_connection() as conn:
+        conn.execute("""
+            ALTER TABLE transcriptions 
+            ADD COLUMN new_feature_data TEXT
+        """)
+
+# 2. API endpoint updates
+def new_feature_endpoint(user_id: str, feature_data: Dict) -> Dict:
+    # Implement new feature logic
+    pass
+
+# 3. UI updates
+def add_new_feature_ui():
+    new_feature_input = gr.Textbox(label="New Feature")
+    new_feature_button = gr.Button("Use New Feature")
+```
+
+---
+
+## ⚙️ Advanced Configuration
+
+### Performance Optimization
+
+#### Concurrent Processing
+```python
+# Adjust worker thread pool size based on server capacity
+class TranscriptionManager:
+    def __init__(self, max_workers: int = None):
+        if max_workers is None:
+            # Auto-detect based on CPU cores
+            import multiprocessing
+            max_workers = min(multiprocessing.cpu_count(), 10)
+        
+        self.executor = ThreadPoolExecutor(max_workers=max_workers)
+
+# Configure based on server specs
+# Small server: max_workers=2-4
+# Medium server: max_workers=5-8  
+# Large server: max_workers=10+
+```
+
+#### Database Optimization
+```python
+# SQLite performance tuning
+def configure_database_performance(db_path: str):
+    with sqlite3.connect(db_path) as conn:
+        # Enable WAL mode for better concurrency
+        conn.execute("PRAGMA journal_mode=WAL")
+        
+        # Increase cache size (in KB)
+        conn.execute("PRAGMA cache_size=10000")
+        
+        # Optimize synchronization
+        conn.execute("PRAGMA synchronous=NORMAL")
+        
+        # Enable foreign keys
+        conn.execute("PRAGMA foreign_keys=ON")
+```
+
+#### Memory Management
+```python
+# Large file handling
+def process_large_file(file_path: str):
+    """Process large files in chunks to manage memory"""
+    chunk_size = 64 * 1024 * 1024  # 64MB chunks
+    
+    with open(file_path, 'rb') as f:
+        while chunk := f.read(chunk_size):
+            # Process chunk
+            yield chunk
+
+# Garbage collection for long-running processes
+import gc
+
+def cleanup_memory():
+    """Force garbage collection"""
+    gc.collect()
+    
+# Schedule periodic cleanup
+schedule.every(30).minutes.do(cleanup_memory)
+```
+
+### Security Hardening
+
+#### Rate Limiting
+```python
+from collections import defaultdict
+from time import time
+
+class RateLimiter:
+    def __init__(self, max_requests: int = 100, window: int = 3600):
+        self.max_requests = max_requests
+        self.window = window
+        self.requests = defaultdict(list)
+    
+    def is_allowed(self, user_id: str) -> bool:
+        now = time()
+        user_requests = self.requests[user_id]
+        
+        # Clean old requests
+        user_requests[:] = [req_time for req_time in user_requests 
+                           if now - req_time < self.window]
+        
+        # Check limit
+        if len(user_requests) >= self.max_requests:
+            return False
+        
+        user_requests.append(now)
+        return True
+
+# Usage in endpoints
+rate_limiter = RateLimiter(max_requests=50, window=3600)  # 50 per hour
+
+def submit_transcription(self, user_id: str, ...):
+    if not rate_limiter.is_allowed(user_id):
+        raise Exception("Rate limit exceeded")
+```
+
+#### Input Sanitization
+```python
+import bleach
+import re
+
+def sanitize_filename(filename: str) -> str:
+    """Sanitize uploaded filename"""
+    # Remove path traversal attempts
+    filename = os.path.basename(filename)
+    
+    # Remove dangerous characters
+    filename = re.sub(r'[<>:"/\\|?*]', '_', filename)
+    
+    # Limit length
+    if len(filename) > 255:
+        name, ext = os.path.splitext(filename)
+        filename = name[:250] + ext
+    
+    return filename
+
+def sanitize_user_input(text: str) -> str:
+    """Sanitize user text input"""
+    # Remove HTML tags
+    text = bleach.clean(text, tags=[], strip=True)
+    
+    # Limit length
+    text = text[:1000]
+    
+    return text.strip()
+```
+
+#### Audit Logging
+```python
+class AuditLogger:
+    def __init__(self):
+        self.logger = logging.getLogger('audit')
+    
+    def log_user_action(self, user_id: str, action: str, details: Dict = None):
+        """Log user actions for security auditing"""
+        audit_entry = {
+            'timestamp': datetime.now().isoformat(),
+            'user_id': user_id,
+            'action': action,
+            'details': details or {},
+            'ip_address': self._get_client_ip(),
+            'user_agent': self._get_user_agent()
+        }
+        
+        self.logger.info(json.dumps(audit_entry))
+    
+    def _get_client_ip(self) -> str:
+        # Implementation depends on deployment setup
+        return "unknown"
+    
+    def _get_user_agent(self) -> str:
+        # Implementation depends on deployment setup
+        return "unknown"
+
+# Usage
+audit = AuditLogger()
+audit.log_user_action(user_id, "login", {"success": True})
+audit.log_user_action(user_id, "transcription_submit", {"filename": filename})
+```
+
+### Custom Extensions
+
+#### Plugin Architecture
+```python
+class TranscriptionPlugin:
+    """Base class for transcription plugins"""
+    
+    def pre_process(self, file_bytes: bytes, settings: Dict) -> bytes:
+        """Pre-process audio before transcription"""
+        return file_bytes
+    
+    def post_process(self, transcript: str, settings: Dict) -> str:
+        """Post-process transcript text"""
+        return transcript
+    
+    def get_name(self) -> str:
+        """Return plugin name"""
+        raise NotImplementedError
+
+class NoiseReductionPlugin(TranscriptionPlugin):
+    def get_name(self) -> str:
+        return "noise_reduction"
+    
+    def pre_process(self, file_bytes: bytes, settings: Dict) -> bytes:
+        # Implement noise reduction using audio processing library
+        # This is a placeholder - actual implementation would use
+        # libraries like librosa, scipy, or pydub
+        return file_bytes
+
+class LanguageDetectionPlugin(TranscriptionPlugin):
+    def get_name(self) -> str:
+        return "language_detection"
+    
+    def pre_process(self, file_bytes: bytes, settings: Dict) -> bytes:
+        # Detect language and update settings
+        detected_language = self._detect_language(file_bytes)
+        settings['detected_language'] = detected_language
+        return file_bytes
+
+# Plugin manager
+class PluginManager:
+    def __init__(self):
+        self.plugins: List[TranscriptionPlugin] = []
+    
+    def register_plugin(self, plugin: TranscriptionPlugin):
+        self.plugins.append(plugin)
+    
+    def apply_pre_processing(self, file_bytes: bytes, settings: Dict) -> bytes:
+        for plugin in self.plugins:
+            file_bytes = plugin.pre_process(file_bytes, settings)
+        return file_bytes
+    
+    def apply_post_processing(self, transcript: str, settings: Dict) -> str:
+        for plugin in self.plugins:
+            transcript = plugin.post_process(transcript, settings)
+        return transcript
+```
+
+---
+
+## 🔧 Troubleshooting
+
+### Common Development Issues
+
+#### Environment Setup Problems
+
+**Issue**: Azure connection fails
+```bash
+# Check environment variables
+python -c "
+import os
+print('AZURE_SPEECH_KEY:', bool(os.getenv('AZURE_SPEECH_KEY')))
+print('AZURE_BLOB_CONNECTION:', bool(os.getenv('AZURE_BLOB_CONNECTION')))
+"
+
+# Test Azure connection
+python -c "
+from azure.storage.blob import BlobServiceClient
+client = BlobServiceClient.from_connection_string('$AZURE_BLOB_CONNECTION')
+print('Containers:', list(client.list_containers()))
+"
+```
+
+**Issue**: FFmpeg not found
+```bash
+# Check FFmpeg installation
+ffmpeg -version
+
+# Install FFmpeg (Ubuntu/Debian)
+sudo apt update && sudo apt install ffmpeg
+
+# Install FFmpeg (Windows with Chocolatey)
+choco install ffmpeg
+
+# Install FFmpeg (macOS with Homebrew)
+brew install ffmpeg
+```
+
+**Issue**: Database initialization fails
+```python
+# Check database permissions
+import os
+db_dir = "database"
+if not os.path.exists(db_dir):
+    os.makedirs(db_dir)
+    print(f"Created directory: {db_dir}")
+
+# Test database creation
+import sqlite3
+conn = sqlite3.connect("database/test.db")
+conn.execute("CREATE TABLE test (id INTEGER)")
+conn.close()
+print("Database test successful")
+```
+
+#### Runtime Issues
+
+**Issue**: Memory errors with large files
+```python
+# Monitor memory usage
+import psutil
+
+def check_memory():
+    memory = psutil.virtual_memory()
+    print(f"Memory usage: {memory.percent}%")
+    print(f"Available: {memory.available / 1024**3:.1f}GB")
+
+# Implement file chunking for large uploads
+def process_large_file_in_chunks(file_path: str, chunk_size: int = 64*1024*1024):
+    with open(file_path, 'rb') as f:
+        while chunk := f.read(chunk_size):
+            yield chunk
+```
+
+**Issue**: Transcription jobs stuck
+```python
+# Check pending jobs
+def diagnose_stuck_jobs():
+    pending_jobs = transcription_manager.db.get_pending_jobs()
+    print(f"Pending jobs: {len(pending_jobs)}")
+    
+    for job in pending_jobs:
+        duration = datetime.now() - datetime.fromisoformat(job.created_at)
+        print(f"Job {job.job_id}: {job.status} for {duration}")
+        
+        if duration.total_seconds() > 3600:  # 1 hour
+            print(f"⚠️ Job {job.job_id} may be stuck")
+
+# Reset stuck jobs
+def reset_stuck_jobs():
+    with transcription_manager.db.get_connection() as conn:
+        conn.execute("""
+            UPDATE transcriptions 
+            SET status = 'pending', azure_trans_id = NULL
+            WHERE status = 'processing' 
+            AND created_at < datetime('now', '-1 hour')
+        """)
+```
+
+**Issue**: Azure API errors
+```python
+# Test Azure Speech Service
+def test_azure_speech():
+    try:
+        url = f"{AZURE_SPEECH_KEY_ENDPOINT}/speechtotext/v3.2/transcriptions"
+        headers = {"Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY}
+        
+        response = requests.get(url, headers=headers)
+        print(f"Status: {response.status_code}")
+        print(f"Response: {response.text[:200]}")
+        
+    except Exception as e:
+        print(f"Azure Speech test failed: {e}")
+
+# Check Azure service status
+def check_azure_status():
+    # Check Azure status page
+    status_url = "https://status.azure.com/en-us/status"
+    print(f"Check Azure status: {status_url}")
+```
+
+### Debugging Tools
+
+#### Debug Mode Configuration
+```python
+# Enable debug mode
+DEBUG = os.environ.get("DEBUG", "false").lower() == "true"
+
+if DEBUG:
+    logging.basicConfig(level=logging.DEBUG)
+    
+    # Enable Gradio debug mode
+    demo.launch(debug=True, show_error=True)
+```
+
+#### Performance Profiling
+```python
+import cProfile
+import pstats
+
+def profile_function(func):
+    """Profile function performance"""
+    profiler = cProfile.Profile()
+    
+    def wrapper(*args, **kwargs):
+        profiler.enable()
+        result = func(*args, **kwargs)
+        profiler.disable()
+        
+        # Print stats
+        stats = pstats.Stats(profiler)
+        stats.sort_stats('cumulative')
+        stats.print_stats(10)  # Top 10 functions
+        
+        return result
+    
+    return wrapper
+
+# Usage
+@profile_function
+def submit_transcription(self, ...):
+    # Function implementation
+    pass
+```
+
+#### Log Analysis
+```python
+def analyze_logs(log_file: str = "logs/transcription.log"):
+    """Analyze application logs for issues"""
+    
+    errors = []
+    warnings = []
+    performance_issues = []
+    
+    with open(log_file, 'r') as f:
+        for line in f:
+            if 'ERROR' in line:
+                errors.append(line.strip())
+            elif 'WARNING' in line:
+                warnings.append(line.strip())
+            elif 'completed in' in line:
+                # Extract timing information
+                import re
+                match = re.search(r'completed in (\d+\.\d+)s', line)
+                if match and float(match.group(1)) > 30:  # > 30 seconds
+                    performance_issues.append(line.strip())
+    
+    print(f"Errors: {len(errors)}")
+    print(f"Warnings: {len(warnings)}")
+    print(f"Performance issues: {len(performance_issues)}")
+    
+    return {
+        'errors': errors[-10:],  # Last 10 errors
+        'warnings': warnings[-10:],  # Last 10 warnings
+        'performance_issues': performance_issues[-10:]
+    }
+```
+
+### Production Troubleshooting
+
+#### Service Health Check
+```bash
+#!/bin/bash
+# health_check.sh
+
+echo "=== System Health Check ==="
+
+# Check service status
+systemctl is-active transcription
+systemctl is-active nginx
+
+# Check disk space
+df -h
+
+# Check memory usage
+free -h
+
+# Check CPU usage
+top -b -n1 | grep "Cpu(s)"
+
+# Check logs for errors
+tail -n 50 /home/transcription/app/logs/transcription.log | grep ERROR
+
+# Check Azure connectivity
+curl -s -o /dev/null -w "%{http_code}" https://azure.microsoft.com/
+
+echo "=== Health Check Complete ==="
+```
+
+#### Database Recovery
+```python
+def recover_database():
+    """Recover database from Azure backup"""
+    try:
+        # List available backups
+        container_client = blob_service.get_container_client(AZURE_CONTAINER)
+        backups = []
+        
+        for blob in container_client.list_blobs(name_starts_with="shared/backups/"):
+            backups.append({
+                'name': blob.name,
+                'modified': blob.last_modified
+            })
+        
+        # Sort by date (newest first)
+        backups.sort(key=lambda x: x['modified'], reverse=True)
+        
+        if not backups:
+            print("No backups found")
+            return
+        
+        # Download latest backup
+        latest_backup = backups[0]['name']
+        print(f"Restoring from: {latest_backup}")
+        
+        blob_client = blob_service.get_blob_client(
+            container=AZURE_CONTAINER,
+            blob=latest_backup
+        )
+        
+        # Download backup
+        with open("database/transcriptions_restored.db", "wb") as f:
+            f.write(blob_client.download_blob().readall())
+        
+        print("Database restored successfully")
+        print("Restart the application to use restored database")
+        
+    except Exception as e:
+        print(f"Database recovery failed: {str(e)}")
+```
+
+---
+
+## 📚 Additional Resources
+
+### Documentation Links
+- [Azure Speech Services Documentation](https://docs.microsoft.com/en-us/azure/cognitive-services/speech-service/)
+- [Azure Blob Storage Documentation](https://docs.microsoft.com/en-us/azure/storage/blobs/)
+- [Gradio Documentation](https://gradio.app/docs/)
+- [SQLite Documentation](https://www.sqlite.org/docs.html)
+- [FFmpeg Documentation](https://ffmpeg.org/documentation.html)
+
+### Useful Tools
+- **Azure Storage Explorer**: GUI for managing blob storage
+- **DB Browser for SQLite**: Visual database management
+- **Postman**: API testing and development
+- **Azure CLI**: Command-line Azure management
+- **Visual Studio Code**: Recommended IDE with Azure extensions
+
+### Community Resources
+- [Azure Speech Services Community](https://docs.microsoft.com/en-us/answers/topics/azure-speech-services.html)
+- [Gradio Community](https://github.com/gradio-app/gradio/discussions)
+- [Python Audio Processing Libraries](https://github.com/topics/audio-processing)
+
+---
+
+**This developer guide provides comprehensive information for setting up, developing, deploying, and maintaining the Azure Speech Transcription service. For additional help, refer to the linked documentation and community resources.** 🚀

README.md

@@ -1,14 +1,12 @@
----
-title: Azure Powered AI Summary
-emoji: 🌍
-colorFrom: pink
-colorTo: green
-sdk: gradio
-sdk_version: 5.44.1
-app_file: app.py
-pinned: false
-license: apache-2.0
-short_description: Azure Powered AI Summary with GPT 4.1 mini
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Azure Transcipt Service
+emoji: 🔥
+colorFrom: blue
+colorTo: pink
+sdk: gradio
+sdk_version: 5.35.0
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

USER.md

@@ -0,0 +1,459 @@
+# 🎙️ Azure Speech Transcription - User Guide
+
+## 📋 Table of Contents
+
+- [Getting Started](#-getting-started)
+- [Account Management](#-account-management)
+- [Using Transcription Services](#-using-transcription-services)
+- [Managing Your History](#-managing-your-history)
+- [Privacy & Data Control](#-privacy--data-control)
+- [Troubleshooting](#-troubleshooting)
+- [FAQ](#-faq)
+
+---
+
+## 🚀 Getting Started
+
+### What is Azure Speech Transcription?
+
+Azure Speech Transcription is a secure, PDPA-compliant service that converts your audio and video files into accurate text transcripts with speaker identification and precise timestamps. Your data is stored securely in your own private folder, ensuring complete privacy and compliance with data protection regulations.
+
+### Key Features
+
+- 🎯 **High Accuracy**: Powered by Microsoft Azure Speech Services
+- 🗣️ **Speaker Identification**: Automatically identifies different speakers
+- ⏰ **Precise Timestamps**: Every sentence includes exact timing (HH:MM:SS)
+- 🔒 **Privacy Compliant**: GDPR, PDPA, and data protection compliant
+- 📁 **Multiple Formats**: Supports audio and video files
+- 🌍 **Multi-Language**: Support for multiple languages
+- 📊 **Personal Dashboard**: Track your usage and history
+
+---
+
+## 🔐 Account Management
+
+### Creating Your Account
+
+1. **Go to Registration Tab**
+   - Open the application in your web browser
+   - Click on the "📝 Register" tab
+
+2. **Fill Your Information**
+   - **Email**: Enter a valid email address
+   - **Username**: Choose 3-30 characters (letters, numbers, underscore only)
+   - **Password**: Create a strong password (minimum 8 characters with uppercase, lowercase, and numbers)
+   - **Confirm Password**: Re-enter your password
+
+3. **Privacy Consents** (Required)
+   - ✅ **GDPR Consent**: Required for account creation
+   - ✅ **Data Retention**: Required for service functionality
+   - ☐ **Marketing**: Optional - receive updates and news
+
+4. **Create Account**
+   - Click "📝 Create Account"
+   - You'll see a success message
+   - Click "🔑 Go to Login" to proceed
+
+### Logging In
+
+1. **Go to Login Tab**
+   - Click on the "🔑 Login" tab
+
+2. **Enter Credentials**
+   - **Email or Username**: Enter either your email or username
+   - **Password**: Enter your password
+
+3. **Access Your Account**
+   - Click "🔑 Login"
+   - You'll be taken to your personal dashboard
+
+### Password Requirements
+
+Your password must include:
+- ✅ At least 8 characters
+- ✅ One uppercase letter (A-Z)
+- ✅ One lowercase letter (a-z)
+- ✅ One number (0-9)
+
+**Strong Password Examples:**
+- `MySecure123!`
+- `Transcribe2024#`
+- `AudioFiles456$`
+
+---
+
+## 🎙️ Using Transcription Services
+
+### Supported File Formats
+
+#### Audio Formats
+- **WAV** (recommended for fastest processing)
+- **MP3**, **OGG**, **OPUS**, **FLAC**
+- **WMA**, **AAC**, **M4A**, **AMR**
+- **WebM**, **Speex**
+
+#### Video Formats
+- **MP4**, **MOV**, **AVI**, **MKV**
+- **WMV**, **FLV**, **3GP**
+
+### File Size Limits
+- **Maximum**: 500MB per file
+- **Recommended**: Under 100MB for faster processing
+
+### Step-by-Step Transcription
+
+1. **Upload Your File**
+   - Click "Browse" under "Audio or Video File"
+   - Select your file from your computer
+   - Wait for upload confirmation
+
+2. **Configure Settings**
+   
+   **Basic Settings:**
+   - **Language**: Choose the primary language spoken
+   - **Output Format**: Select audio format (WAV recommended)
+
+   **Advanced Settings:**
+   - **Speaker Identification**: Enable to identify different speakers
+   - **Max Speakers**: Set expected number of speakers (1-10)
+   - **Timestamps**: Include precise timing information
+   - **Profanity Filter**: Choose how to handle profanity
+     - `Masked`: Replace with ***
+     - `Removed`: Remove completely
+     - `Raw`: Keep original
+   - **Punctuation**: Automatic punctuation insertion
+   - **Lexical Form**: Include alternative word forms
+
+3. **Start Transcription**
+   - Click "🚀 Start Transcription"
+   - Processing begins automatically
+   - Status updates every 10 seconds
+
+4. **Monitor Progress**
+   - **⏳ Queued**: Waiting to start
+   - **🔄 Processing**: Converting and analyzing
+   - **✅ Done**: Transcription complete
+
+5. **Download Results**
+   - View transcript in the text area
+   - Download the transcript file
+   - Access from your history anytime
+
+### Understanding Your Transcript
+
+Your transcript includes:
+- **Timestamps**: `[00:02:15]` (hours:minutes:seconds)
+- **Speaker Labels**: `Speaker 0:`, `Speaker 1:`, etc.
+- **Formatted Text**: Proper punctuation and capitalization
+
+**Example Output:**
+```
+[00:00:12] Speaker 0: Welcome to today's meeting. Let's start with the agenda.
+
+[00:00:18] Speaker 1: Thank you. First item is the quarterly review.
+
+[00:00:25] Speaker 0: Perfect. Let me share the presentation now.
+```
+
+---
+
+## 📚 Managing Your History
+
+### Viewing Your Transcriptions
+
+1. **Go to History Tab**
+   - Click "📚 My History" tab
+   - Your transcriptions appear automatically
+
+2. **Understanding the Table**
+   - **Date**: When transcription was created
+   - **Filename**: Original file name
+   - **Language**: Language used for transcription
+   - **Status**: Current status (Done, Processing, etc.)
+   - **Duration**: How long processing took
+   - **Job ID**: Unique identifier
+   - **Download**: Availability status
+
+3. **View Options**
+   - **Recent 20**: Default view of recent transcriptions
+   - **Show All**: Check box to see all your transcriptions
+
+### Downloading Transcripts
+
+**Method 1: From Results**
+- Complete transcription → Download button appears
+- Click to download immediately
+
+**Method 2: From History**
+- Go to "📚 My History" tab
+- Click "🔄 Refresh My History & Downloads"
+- Download files appear below the table
+- Click any available download link
+
+**Method 3: From Downloads Section**
+- Scroll to "📥 Download Your Completed Transcripts"
+- Available transcripts show as file download buttons
+- Click to download specific transcripts
+
+### Personal Statistics
+
+Your dashboard shows:
+- **Total Jobs**: All transcriptions you've created
+- **Completed**: Successfully finished transcriptions
+- **Processing**: Currently in progress
+- **Pending**: Waiting to start
+- **Failed**: Transcriptions that encountered errors
+- **Last 7 Days**: Recent activity
+
+---
+
+## 🔒 Privacy & Data Control
+
+### GDPR & Data Rights
+
+You have complete control over your data:
+
+#### 📊 Data Export
+1. Go to "🔒 Privacy & Data" tab
+2. Click "📦 Export My Data"
+3. Download complete data archive (JSON format)
+
+**What's Included:**
+- Account information
+- All transcription history
+- Usage statistics
+- Privacy preferences
+
+#### 📧 Marketing Preferences
+1. Go to "🔒 Privacy & Data" tab
+2. Update "Marketing Consent" checkbox
+3. Click "✅ Update Consent"
+
+#### 🗑️ Account Deletion
+1. Go to "🔒 Privacy & Data" tab
+2. Type "DELETE MY ACCOUNT" in confirmation field
+3. Click "🗑️ Delete My Account"
+
+**⚠️ Warning**: This permanently deletes:
+- Your account and profile
+- All transcription files
+- Usage history and statistics
+- Data stored in Azure
+
+### Data Security
+
+Your data is protected by:
+- **Encryption**: All data encrypted in transit and at rest
+- **Isolation**: Your files stored in private user folder
+- **Access Control**: Only you can access your data
+- **Compliance**: GDPR, PDPA, and privacy regulation compliant
+- **Audit Trail**: Complete logging for security
+
+### Where Your Data is Stored
+
+- **User Folder**: `users/{your-user-id}/`
+  - `audio/`: Processed audio files
+  - `transcripts/`: Text transcriptions
+  - `originals/`: Original uploaded files
+- **Location**: Secure Azure Blob Storage
+- **Retention**: Until you delete your account
+
+---
+
+## 🛠️ Troubleshooting
+
+### Common Issues
+
+#### Authentication Problems
+
+**Problem**: Can't log in
+- ✅ Check username/email spelling
+- ✅ Verify password (case-sensitive)
+- ✅ Ensure caps lock is off
+- ✅ Try password reset if available
+
+**Problem**: Registration fails
+- ✅ Check email format (must be valid email)
+- ✅ Username requirements (3-30 chars, alphanumeric + underscore)
+- ✅ Password requirements (8+ chars, mixed case, numbers)
+- ✅ Required consents must be checked
+
+#### File Upload Issues
+
+**Problem**: File won't upload
+- ✅ Check file size (max 500MB)
+- ✅ Verify file format is supported
+- ✅ Ensure stable internet connection
+- ✅ Try smaller file first
+
+**Problem**: Unsupported format error
+- ✅ Convert to supported format (WAV, MP3, MP4)
+- ✅ Check file isn't corrupted
+- ✅ Try different file
+
+#### Processing Issues
+
+**Problem**: Transcription stuck in "Processing"
+- ✅ Wait - large files take time
+- ✅ Check auto-refresh is active
+- ✅ Refresh browser if needed
+- ✅ Check Azure service status
+
+**Problem**: Transcription failed
+- ✅ Check error message for details
+- ✅ Verify audio quality is good
+- ✅ Try different audio format
+- ✅ Ensure speakers are clearly audible
+
+#### Results Issues
+
+**Problem**: Poor transcription quality
+- ✅ Use clear, high-quality audio
+- ✅ Minimize background noise
+- ✅ Ensure speakers speak clearly
+- ✅ Select correct language
+- ✅ Try WAV format for best results
+
+**Problem**: Speakers not identified correctly
+- ✅ Enable "Speaker Identification"
+- ✅ Set correct number of speakers
+- ✅ Ensure speakers have distinct voices
+- ✅ Minimize speaker overlap
+
+### Performance Tips
+
+#### For Best Results
+- **Audio Quality**: Use high-quality recordings
+- **File Format**: WAV files process fastest
+- **Speaker Separation**: Clear pauses between speakers
+- **Background Noise**: Minimize environmental noise
+- **Language Selection**: Choose correct primary language
+
+#### For Faster Processing
+- **File Size**: Smaller files process faster
+- **Format**: WAV > MP3 > other formats
+- **Settings**: Disable unused features
+- **Timing**: Process during off-peak hours
+
+---
+
+## ❓ FAQ
+
+### General Questions
+
+**Q: Is my data secure?**
+A: Yes, your data is stored in encrypted, user-separated Azure Blob Storage with enterprise-grade security.
+
+**Q: Can others see my transcriptions?**
+A: No, your data is completely private. Only you can access your transcriptions.
+
+**Q: How long are transcriptions stored?**
+A: Indefinitely, until you delete your account or individual transcriptions.
+
+**Q: Is there a usage limit?**
+A: Check with your administrator for any usage limits or quotas.
+
+### Technical Questions
+
+**Q: What languages are supported?**
+A: Multiple languages including English, Thai, Chinese, Japanese, Korean, Spanish, French, German, and others.
+
+**Q: How accurate are the transcriptions?**
+A: Very high accuracy using Microsoft Azure Speech Services, typically 85-95% depending on audio quality.
+
+**Q: Can I edit transcriptions?**
+A: You can copy and edit the text after download, but the original transcript is preserved.
+
+**Q: Do you store my original files?**
+A: Yes, originals are stored in your private folder and can be downloaded anytime.
+
+### Privacy Questions
+
+**Q: Can I export all my data?**
+A: Yes, use the "Export My Data" feature to download everything in JSON format.
+
+**Q: How do I delete my account?**
+A: Go to Privacy & Data tab and follow the account deletion process.
+
+**Q: What happens to my data if I delete my account?**
+A: All data is permanently deleted from Azure storage within 24 hours.
+
+**Q: Do you use my data for training?**
+A: No, your data is never used for training or shared with third parties.
+
+### Billing Questions
+
+**Q: How much does it cost?**
+A: Contact your administrator for pricing information.
+
+**Q: Are there free tiers available?**
+A: Depends on your organization's setup and Azure subscription.
+
+---
+
+## 📞 Getting Help
+
+### Support Resources
+
+1. **This User Guide**: Comprehensive information for all features
+2. **Error Messages**: Pay attention to specific error descriptions
+3. **System Status**: Check if Azure services are operational
+4. **Administrator**: Contact your system administrator for account issues
+
+### Reporting Issues
+
+When reporting problems, include:
+- **What you were trying to do**
+- **What happened instead**
+- **Error messages (exact text)**
+- **File type and size**
+- **Browser and operating system**
+- **Steps to reproduce the issue**
+
+---
+
+## 🎯 Tips for Success
+
+### Getting the Best Transcriptions
+
+1. **Audio Quality Matters**
+   - Use good microphones
+   - Record in quiet environments
+   - Ensure clear speech
+   - Avoid speaker overlap
+
+2. **File Preparation**
+   - Convert to WAV for best results
+   - Trim unnecessary silence
+   - Normalize audio levels
+   - Remove background music if possible
+
+3. **Settings Optimization**
+   - Choose correct language
+   - Set appropriate speaker count
+   - Enable relevant features only
+   - Use appropriate profanity filter
+
+4. **Workflow Efficiency**
+   - Process multiple files in batches
+   - Use consistent naming conventions
+   - Download transcripts promptly
+   - Keep originals as backups
+
+### Privacy Best Practices
+
+1. **Account Security**
+   - Use strong, unique passwords
+   - Log out when finished
+   - Don't share login credentials
+   - Review account regularly
+
+2. **Data Management**
+   - Export data periodically
+   - Delete unnecessary transcriptions
+   - Review privacy settings
+   - Understand data retention
+
+---
+
+**Welcome to Azure Speech Transcription! We hope this guide helps you make the most of our service. For the best experience, keep your audio quality high and your data organized.** 🎉

ai_summary.py

@@ -0,0 +1,796 @@
+import os
+import json
+import uuid
+import time
+import base64
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple
+from dataclasses import dataclass, asdict
+import tempfile
+import shutil
+from dotenv import load_dotenv
+import tiktoken
+import requests
+
+from azure.cognitiveservices.vision.computervision import ComputerVisionClient
+from azure.cognitiveservices.vision.computervision.models import OperationStatusCodes
+from msrest.authentication import CognitiveServicesCredentials
+
+from file_processors import FileProcessor
+from image_extraction import VideoFrameExtractor
+
+# Load Environment
+load_dotenv()
+
+@dataclass
+class SummaryJob:
+    job_id: str
+    user_id: str
+    original_files: List[str]
+    summary_type: str
+    user_prompt: str
+    status: str
+    created_at: str
+    completed_at: Optional[str] = None
+    summary_text: Optional[str] = None
+    processed_files: Optional[Dict] = None
+    extracted_images: Optional[List[str]] = None
+    transcript_text: Optional[str] = None
+    error_message: Optional[str] = None
+    settings: Optional[Dict] = None
+
+class TokenManager:
+    """Manage token counting and content truncation for GPT models"""
+    
+    def __init__(self, model_name: str = "gpt-4o-mini"):
+        try:
+            # Map common model names to encodings
+            model_encoding_map = {
+                "gpt-4o": "o200k_base",
+                "gpt-4o-mini": "o200k_base", 
+                "gpt-4": "cl100k_base",
+                "gpt-4-turbo": "cl100k_base",
+                "gpt-35-turbo": "cl100k_base"
+            }
+            
+            encoding_name = model_encoding_map.get(model_name, "cl100k_base")
+            self.encoder = tiktoken.get_encoding(encoding_name)
+        except Exception as e:
+            print(f"Warning: Could not load tokenizer for {model_name}, using fallback: {e}")
+            self.encoder = tiktoken.get_encoding("cl100k_base")
+        
+        # Token limits based on model
+        if "gpt-4o" in model_name:
+            self.max_input_tokens = 120000  # 128k context window
+        else:
+            self.max_input_tokens = 100000  # Conservative limit
+            
+        self.max_transcript_tokens = 80000
+        self.max_document_tokens = 30000
+        self.max_image_analysis_tokens = 10000
+    
+    def count_tokens(self, text: str) -> int:
+        """Count tokens in text"""
+        try:
+            return len(self.encoder.encode(text))
+        except Exception:
+            # Fallback estimation: ~4 characters per token
+            return len(text) // 4
+    
+    def truncate_text(self, text: str, max_tokens: int) -> str:
+        """Truncate text to fit within token limit"""
+        if not text:
+            return text
+        
+        current_tokens = self.count_tokens(text)
+        if current_tokens <= max_tokens:
+            return text
+        
+        lines = text.split('\n')
+        if len(lines) == 1:
+            # Single line - truncate by character estimation
+            chars_per_token = len(text) / current_tokens
+            target_chars = int(max_tokens * chars_per_token * 0.9)
+            return text[:target_chars] + "\n[Content truncated due to length]"
+        
+        # Multi-line - truncate by lines
+        truncated_lines = []
+        current_tokens = 0
+        
+        for line in lines:
+            line_tokens = self.count_tokens(line + '\n')
+            if current_tokens + line_tokens > max_tokens:
+                truncated_lines.append("[Content truncated due to length]")
+                break
+            truncated_lines.append(line)
+            current_tokens += line_tokens
+        
+        return '\n'.join(truncated_lines)
+    
+    def optimize_content_for_tokens(self, transcripts: List[Dict], documents: List[Dict], 
+                                  image_insights: List[Dict], user_prompt: str) -> Tuple[List[Dict], List[Dict], List[Dict]]:
+        """Optimize content to fit within token limits"""
+        
+        # Truncate transcripts
+        total_transcript_text = ""
+        for transcript in transcripts:
+            total_transcript_text += transcript.get('content', '') + "\n\n"
+        
+        transcript_tokens = self.count_tokens(total_transcript_text)
+        if transcript_tokens > self.max_transcript_tokens:
+            print(f"Transcripts too long ({transcript_tokens} tokens), truncating to {self.max_transcript_tokens}")
+            tokens_per_transcript = self.max_transcript_tokens // len(transcripts) if transcripts else 0
+            for transcript in transcripts:
+                transcript['content'] = self.truncate_text(
+                    transcript['content'], tokens_per_transcript
+                )
+        
+        # Truncate documents
+        total_document_text = ""
+        for doc in documents:
+            total_document_text += doc.get('content', '') + "\n\n"
+        
+        doc_tokens = self.count_tokens(total_document_text)
+        if doc_tokens > self.max_document_tokens:
+            print(f"Documents too long ({doc_tokens} tokens), truncating to {self.max_document_tokens}")
+            tokens_per_doc = self.max_document_tokens // len(documents) if documents else 0
+            for doc in documents:
+                doc['content'] = self.truncate_text(
+                    doc['content'], tokens_per_doc
+                )
+        
+        # Truncate image analysis
+        if len(image_insights) > 10:
+            print(f"Too many images ({len(image_insights)}), limiting to 10")
+            image_insights = image_insights[:10]
+            
+        for img in image_insights:
+            if 'analysis' in img:
+                desc = img['analysis'].get('description', '')
+                text = img['analysis'].get('extracted_text', '')
+                if desc:
+                    img['analysis']['description'] = self.truncate_text(desc, 200)
+                if text:
+                    img['analysis']['extracted_text'] = self.truncate_text(text, 300)
+        
+        return transcripts, documents, image_insights
+
+class AISummaryManager:
+    """AI-powered conference summarization using Azure OpenAI with enhanced backend integration"""
+    
+    def __init__(self):
+        # Azure OpenAI Configuration
+        self.azure_openai_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
+        self.azure_openai_key = os.environ.get("AZURE_OPENAI_KEY")
+        self.azure_openai_deployment = os.environ.get("AZURE_OPENAI_DEPLOYMENT", "gpt-4o-mini")
+        self.azure_openai_api_version = os.environ.get("AZURE_OPENAI_API_VERSION", "2024-08-01-preview")
+        
+        # Computer Vision Configuration
+        self.cv_endpoint = os.environ.get("COMPUTER_VISION_ENDPOINT")
+        self.cv_key = os.environ.get("COMPUTER_VISION_KEY")
+        
+        # Initialize services
+        self.cv_client = None
+        self.file_processor = FileProcessor()
+        self.frame_extractor = VideoFrameExtractor()
+        self.token_manager = TokenManager(self.azure_openai_deployment)
+        
+        # Initialize backend integration
+        self.backend_manager = None
+        self._init_backend_integration()
+        
+        self._init_services()
+    
+    def _init_backend_integration(self):
+        """Initialize integration with the enhanced backend"""
+        try:
+            # Import the transcription manager from backend
+            from backend import transcription_manager
+            self.backend_manager = transcription_manager
+            print("Backend integration initialized successfully")
+        except ImportError as e:
+            print(f"Warning: Could not initialize backend integration: {e}")
+            self.backend_manager = None
+    
+    def _init_services(self):
+        """Initialize services with validation"""
+        # Validate Azure OpenAI configuration
+        if not all([self.azure_openai_endpoint, self.azure_openai_key, self.azure_openai_deployment]):
+            print("ERROR: Missing Azure OpenAI configuration")
+            print("Required environment variables:")
+            print("- AZURE_OPENAI_ENDPOINT")
+            print("- AZURE_OPENAI_KEY") 
+            print("- AZURE_OPENAI_DEPLOYMENT")
+            raise ValueError("Azure OpenAI configuration incomplete")
+        
+        # Validate endpoint format
+        if not self.azure_openai_endpoint.startswith("https://"):
+            raise ValueError("AZURE_OPENAI_ENDPOINT must be a valid HTTPS URL")
+        
+        # Remove trailing slash from endpoint
+        self.azure_openai_endpoint = self.azure_openai_endpoint.rstrip('/')
+        
+        print(f"Azure OpenAI initialized: {self.azure_openai_deployment} at {self.azure_openai_endpoint}")
+        
+        # Test Azure OpenAI connection
+        try:
+            self._test_azure_openai_connection()
+        except Exception as e:
+            print(f"WARNING: Azure OpenAI connection test failed: {e}")
+        
+        # Initialize Computer Vision Client
+        if self.cv_key and self.cv_endpoint:
+            try:
+                self.cv_client = ComputerVisionClient(
+                    self.cv_endpoint,
+                    CognitiveServicesCredentials(self.cv_key)
+                )
+                print("Computer Vision Client initialized")
+            except Exception as e:
+                print(f"WARNING: Computer Vision initialization failed: {e}")
+        else:
+            print("Computer Vision key/endpoint not found - image processing disabled")
+    
+    def _test_azure_openai_connection(self):
+        """Test Azure OpenAI connection"""
+        url = f"{self.azure_openai_endpoint}/openai/deployments/{self.azure_openai_deployment}/chat/completions?api-version={self.azure_openai_api_version}"
+        
+        headers = {
+            "Content-Type": "application/json",
+            "api-key": self.azure_openai_key
+        }
+        
+        test_data = {
+            "messages": [{"role": "user", "content": "Hello"}],
+            "max_tokens": 5,
+            "temperature": 0
+        }
+        
+        try:
+            response = requests.post(url, headers=headers, json=test_data, timeout=10)
+            if response.status_code == 200:
+                print("Azure OpenAI connection test: SUCCESS")
+            else:
+                print(f"Azure OpenAI connection test failed: {response.status_code} - {response.text}")
+                raise Exception(f"Connection test failed: {response.status_code}")
+        except requests.exceptions.RequestException as e:
+            print(f"Azure OpenAI connection test error: {e}")
+            raise
+    
+    def submit_summary_job(
+        self, 
+        user_id: str,
+        summary_type: str,
+        user_prompt: str,
+        files: List = None,
+        transcript_job_ids: List[str] = None,
+        settings: Dict = None
+    ) -> str:
+        """Submit a new AI summary job with enhanced backend integration"""
+        job_id = str(uuid.uuid4())
+        
+        original_files = []
+        if files:
+            original_files.extend([f.name if hasattr(f, 'name') else str(f) for f in files])
+        if transcript_job_ids:
+            original_files.extend([f"transcript_{tid[:8]}..." for tid in transcript_job_ids])
+        
+        print(f"[{user_id[:8]}...] New AI summary job: {summary_type}")
+        print(f"User prompt: {user_prompt[:100]}{'...' if len(user_prompt) > 100 else ''}")
+        
+        job = SummaryJob(
+            job_id=job_id,
+            user_id=user_id,
+            original_files=original_files,
+            summary_type=summary_type,
+            user_prompt=user_prompt,
+            status="pending",
+            created_at=datetime.now().isoformat(),
+            settings=settings or {}
+        )
+        
+        # Save job to backend database
+        if self.backend_manager:
+            self.backend_manager.save_summary_job(job)
+        else:
+            self._save_summary_job_fallback(job)
+        
+        # Start background processing
+        from concurrent.futures import ThreadPoolExecutor
+        executor = ThreadPoolExecutor(max_workers=1)
+        executor.submit(self._process_summary_job, job_id, files, transcript_job_ids)
+        
+        return job_id
+    
+    def _save_summary_job_fallback(self, job: SummaryJob):
+        """Fallback method to save summary job if backend is not available"""
+        try:
+            # Create a simple local storage fallback
+            os.makedirs("temp/summary_jobs", exist_ok=True)
+            job_file = f"temp/summary_jobs/{job.job_id}.json"
+            
+            with open(job_file, 'w', encoding='utf-8') as f:
+                json.dump(asdict(job), f, ensure_ascii=False, indent=2)
+            
+            print(f"Job saved to fallback storage: {job_file}")
+        except Exception as e:
+            print(f"Error saving job to fallback storage: {e}")
+    
+    def _process_summary_job(self, job_id: str, files: List = None, transcript_job_ids: List[str] = None):
+        """Process AI summary job using Azure OpenAI with enhanced error handling and chat storage"""
+        job = None
+        try:
+            job = self.get_summary_status(job_id)
+            if not job:
+                print(f"Job {job_id[:8]}... not found")
+                return
+            
+            print(f"[{job.user_id[:8]}...] Processing AI summary job: {job_id[:8]}...")
+            
+            job.status = "processing"
+            self._update_job_status(job)
+            
+            # Process all input sources
+            processed_content = {
+                'transcripts': [],
+                'documents': [],
+                'images': [],
+                'extracted_frames': []
+            }
+            
+            # Process existing transcripts
+            if transcript_job_ids:
+                processed_content['transcripts'] = self._get_existing_transcripts(transcript_job_ids, job.user_id)
+                print(f"Processed {len(processed_content['transcripts'])} existing transcripts")
+            
+            # Process uploaded files
+            if files:
+                for i, file in enumerate(files):
+                    print(f"Processing file {i+1}/{len(files)}: {getattr(file, 'name', 'unknown')}")
+                    file_content = self._process_uploaded_file(file, job.user_id)
+                    if file_content:
+                        if file_content['type'] == 'video':
+                            frames = self._extract_significant_frames(file_content['path'])
+                            processed_content['extracted_frames'].extend(frames)
+                            print(f"Extracted {len(frames)} frames from video")
+                        elif file_content['type'] == 'document':
+                            processed_content['documents'].append(file_content)
+                        elif file_content['type'] == 'image':
+                            processed_content['images'].append(file_content)
+            
+            # Analyze images with Computer Vision
+            image_insights = []
+            all_images = processed_content['images'] + processed_content['extracted_frames']
+            
+            print(f"Analyzing {len(all_images)} images...")
+            for image_info in all_images:
+                analysis = self._analyze_image_content(image_info['path'])
+                if analysis:
+                    image_insights.append({
+                        'source': image_info['filename'],
+                        'analysis': analysis
+                    })
+            
+            print(f"Analysis complete: {len(processed_content['transcripts'])} transcripts, {len(processed_content['documents'])} documents, {len(image_insights)} images")
+            
+            # Optimize content for token limits
+            optimized_transcripts, optimized_documents, optimized_images = self.token_manager.optimize_content_for_tokens(
+                processed_content['transcripts'],
+                processed_content['documents'], 
+                image_insights,
+                job.user_prompt
+            )
+            
+            output_language = job.settings.get('output_language', 'English') if job.settings else 'English'
+            
+            # Generate AI summary using Azure OpenAI
+            summary_result = self._generate_ai_summary_with_openai(
+                transcripts=optimized_transcripts,
+                documents=optimized_documents,
+                image_insights=optimized_images,
+                user_prompt=job.user_prompt,
+                output_language=output_language
+            )
+            
+            # Store response to chat container using backend integration
+            if self.backend_manager and hasattr(self.backend_manager.db, '_store_chat_response'):
+                try:
+                    chat_url = self.backend_manager.db._store_chat_response(job_id, summary_result, job.user_id)
+                    print(f"💬 Chat response stored successfully: {chat_url}")
+                except Exception as e:
+                    print(f"⚠️ Warning: Could not store chat response: {e}")
+            
+            # Update job with results
+            job.status = "completed"
+            job.summary_text = summary_result
+            job.completed_at = datetime.now().isoformat()
+            job.processed_files = {
+                'transcript_count': len(processed_content['transcripts']),
+                'document_count': len(processed_content['documents']),
+                'image_count': len(all_images),
+                'extracted_frames': len(processed_content['extracted_frames'])
+            }
+            job.extracted_images = [img['filename'] for img in processed_content['extracted_frames']]
+            
+            self._update_job_status(job)
+            
+            print(f"[{job.user_id[:8]}...] AI summary completed: {job_id[:8]}...")
+            
+        except Exception as e:
+            print(f"AI summary processing failed: {e}")
+            if job:
+                job.status = "failed"
+                job.error_message = str(e)
+                job.completed_at = datetime.now().isoformat()
+                self._update_job_status(job)
+    
+    def _update_job_status(self, job: SummaryJob):
+        """Update job status in backend or fallback storage"""
+        if self.backend_manager:
+            self.backend_manager.save_summary_job(job)
+        else:
+            self._save_summary_job_fallback(job)
+    
+    def _generate_ai_summary_with_openai(
+        self, 
+        transcripts: List[Dict], 
+        documents: List[Dict], 
+        image_insights: List[Dict],
+        user_prompt: str,
+        output_language: str = "English"
+    ) -> str:
+        """Generate AI summary using Azure OpenAI with proper error handling"""
+        try:
+            print("Generating AI summary with Azure OpenAI...")
+            
+            # Prepare the context
+            context = self._prepare_text_content(transcripts, documents, image_insights, user_prompt, output_language)
+            
+            # Check final token count
+            final_tokens = self.token_manager.count_tokens(context)
+            print(f"Final input tokens: {final_tokens} / {self.token_manager.max_input_tokens}")
+            
+            if final_tokens > self.token_manager.max_input_tokens:
+                print("Content too long, applying emergency truncation")
+                context = self.token_manager.truncate_text(context, self.token_manager.max_input_tokens)
+            
+            # Prepare the Azure OpenAI API request with correct URL format
+            url = f"{self.azure_openai_endpoint}/openai/deployments/{self.azure_openai_deployment}/chat/completions?api-version={self.azure_openai_api_version}"
+            
+            headers = {
+                "Content-Type": "application/json",
+                "api-key": self.azure_openai_key
+            }
+            
+            # Adjust max tokens based on model
+            max_completion_tokens = 4000
+            if "gpt-4o" in self.azure_openai_deployment:
+                max_completion_tokens = 8000
+            
+            data = {
+                "messages": [
+                    {
+                        "role": "system", 
+                        "content": f"You are an expert conference analyst. Create comprehensive summaries in {output_language}. Focus on key insights, decisions, action items, and important discussions. Integrate information from all sources provided."
+                    },
+                    {
+                        "role": "user",
+                        "content": context
+                    }
+                ],
+                "max_tokens": max_completion_tokens,
+                "temperature": 0.2,
+                "top_p": 0.3,
+                "frequency_penalty": 0,
+                "presence_penalty": 0
+            }
+            
+            print(f"Making API request to: {url}")
+            print(f"Using model: {self.azure_openai_deployment}")
+            
+            # Make the API request with retries
+            max_retries = 3
+            for attempt in range(max_retries):
+                try:
+                    response = requests.post(
+                        url,
+                        headers=headers,
+                        json=data,
+                        timeout=300  # 5 minute timeout
+                    )
+                    
+                    print(f"API Response Status: {response.status_code}")
+                    
+                    if response.status_code == 200:
+                        break
+                    elif response.status_code == 429:
+                        # Rate limit - wait and retry
+                        wait_time = 2 ** attempt
+                        print(f"Rate limited, waiting {wait_time} seconds...")
+                        time.sleep(wait_time)
+                        continue
+                    else:
+                        error_msg = f"Azure OpenAI API error: {response.status_code} - {response.text}"
+                        print(error_msg)
+                        if attempt == max_retries - 1:
+                            raise Exception(error_msg)
+                        time.sleep(1)
+                        continue
+                        
+                except requests.exceptions.Timeout:
+                    if attempt == max_retries - 1:
+                        raise Exception("Azure OpenAI request timed out after multiple retries")
+                    print(f"Request timeout, retrying... (attempt {attempt + 1})")
+                    time.sleep(2)
+                    continue
+                except requests.exceptions.RequestException as e:
+                    if attempt == max_retries - 1:
+                        raise Exception(f"Azure OpenAI request failed: {str(e)}")
+                    print(f"Request error, retrying... (attempt {attempt + 1}): {e}")
+                    time.sleep(2)
+                    continue
+            
+            try:
+                result = response.json()
+            except json.JSONDecodeError as e:
+                raise Exception(f"Invalid JSON response from Azure OpenAI: {str(e)}")
+            
+            # Extract the AI response
+            if 'choices' in result and len(result['choices']) > 0:
+                choice = result['choices'][0]
+                
+                if 'message' in choice and 'content' in choice['message']:
+                    ai_response = choice['message']['content']
+                    
+                    # Check for completion reason
+                    finish_reason = choice.get('finish_reason', '')
+                    if finish_reason == 'content_filter':
+                        raise Exception("Content was filtered by Azure OpenAI safety systems")
+                    elif finish_reason == 'length':
+                        print("Response was truncated due to length limit")
+                        ai_response += "\n\n[Response was truncated due to length limit]"
+                    
+                    print(f"AI summary generated successfully in {output_language}")
+                    return ai_response
+                else:
+                    raise Exception(f"Unexpected response format: {result}")
+            else:
+                raise Exception(f"No response generated from Azure OpenAI: {result}")
+            
+        except Exception as e:
+            error_msg = f"Azure OpenAI generation failed: {str(e)}"
+            print(error_msg)
+            raise Exception(error_msg)
+    
+    def _prepare_text_content(self, transcripts, documents, image_insights, user_prompt, output_language="English"):
+        """Prepare comprehensive text content for AI analysis"""
+        context_parts = [
+            "# Conference Summary Request",
+            f"**User Instructions:** {user_prompt}",
+            f"**Output Language:** {output_language}",
+            "",
+            "## Content to Analyze:",
+            ""
+        ]
+        
+        # Add transcript content
+        if transcripts:
+            context_parts.append("### Transcripts:")
+            for i, transcript in enumerate(transcripts, 1):
+                context_parts.append(f"**Source {i}: {transcript['source']}**")
+                context_parts.append(transcript['content'])
+                context_parts.append("")
+        
+        # Add document content
+        if documents:
+            context_parts.append("### Documents:")
+            for i, doc in enumerate(documents, 1):
+                context_parts.append(f"**Document {i}: {doc['filename']}**")
+                context_parts.append(doc['content'])
+                context_parts.append("")
+        
+        # Add image analysis
+        if image_insights:
+            context_parts.append("### Visual Content:")
+            for i, img in enumerate(image_insights, 1):
+                context_parts.append(f"**Image {i}: {img['source']}**")
+                analysis = img['analysis']
+                context_parts.append(f"Description: {analysis.get('description', 'N/A')}")
+                if analysis.get('extracted_text'):
+                    context_parts.append(f"Text: {analysis['extracted_text']}")
+                context_parts.append("")
+        
+        context_parts.extend([
+            "## Instructions:",
+            f"Create a comprehensive conference summary in {output_language}.",
+            "Follow the user's specific instructions for format and focus areas.",
+            "Integrate information from all sources (transcripts, documents, visual content).",
+            "Highlight key insights, decisions, action items, and important discussions.",
+            "Provide actionable recommendations based on the content.",
+        ])
+        
+        return "\n".join(context_parts)
+    
+    def _process_uploaded_file(self, file, user_id: str) -> Optional[Dict]:
+        """Process uploaded file"""
+        try:
+            if hasattr(file, 'name'):
+                file_path = file.name
+                filename = os.path.basename(file_path)
+            elif isinstance(file, str):
+                file_path = file
+                filename = os.path.basename(file_path)
+            else:
+                return None
+            
+            if not os.path.exists(file_path):
+                return None
+            
+            file_size = os.path.getsize(file_path)
+            if file_size > 500 * 1024 * 1024:  # 500MB limit
+                return None
+            
+            ext = filename.split('.')[-1].lower() if '.' in filename else ''
+            
+            if ext in ['mp4', 'mov', 'avi', 'mkv', 'webm', 'flv', '3gp', 'wmv']:
+                return {
+                    'type': 'video',
+                    'filename': filename,
+                    'path': file_path,
+                    'extension': ext,
+                    'size': file_size
+                }
+            elif ext in ['jpg', 'jpeg', 'png', 'bmp', 'gif', 'tiff', 'webp']:
+                return {
+                    'type': 'image',
+                    'filename': filename,
+                    'path': file_path,
+                    'extension': ext,
+                    'size': file_size
+                }
+            elif ext in ['pdf', 'docx', 'doc', 'pptx', 'ppt', 'xlsx', 'xls', 'txt', 'json', 'csv']:
+                content = self.file_processor.process_file(file_path, ext)
+                if content:
+                    return {
+                        'type': 'document',
+                        'filename': filename,
+                        'path': file_path,
+                        'extension': ext,
+                        'content': content,
+                        'size': file_size
+                    }
+            
+            return None
+                
+        except Exception as e:
+            print(f"Error processing file: {e}")
+            return None
+    
+    def _extract_significant_frames(self, video_path: str) -> List[Dict]:
+        """Extract significant frames from video"""
+        try:
+            frames = self.frame_extractor.extract_frames(video_path)
+            return frames if frames else []
+        except Exception as e:
+            print(f"Frame extraction failed: {e}")
+            return []
+    
+    def _analyze_image_content(self, image_path: str) -> Optional[Dict]:
+        """Analyze image content with Computer Vision"""
+        if not self.cv_client:
+            return None
+        
+        try:
+            with open(image_path, 'rb') as image_stream:
+                # OCR
+                ocr_result = self.cv_client.read_in_stream(image_stream, raw=True)
+                operation_id = ocr_result.headers["Operation-Location"].split("/")[-1]
+                
+                # Wait for completion
+                timeout = 30
+                start_time = time.time()
+                while True:
+                    if time.time() - start_time > timeout:
+                        break
+                        
+                    read_result = self.cv_client.get_read_result(operation_id)
+                    if read_result.status not in ['notStarted', 'running']:
+                        break
+                    time.sleep(1)
+                
+                # Extract text
+                extracted_text = ""
+                if read_result.status == OperationStatusCodes.succeeded:
+                    for text_result in read_result.analyze_result.read_results:
+                        for line in text_result.lines:
+                            extracted_text += line.text + "\n"
+                
+                # Get description
+                image_stream.seek(0)
+                description_result = self.cv_client.describe_image_in_stream(
+                    image_stream,
+                    max_candidates=3,
+                    language='en'
+                )
+                
+                return {
+                    'extracted_text': extracted_text.strip(),
+                    'description': description_result.captions[0].text if description_result.captions else "",
+                    'confidence': description_result.captions[0].confidence if description_result.captions else 0
+                }
+                
+        except Exception as e:
+            print(f"Image analysis failed: {e}")
+            return None
+    
+    def _get_existing_transcripts(self, transcript_job_ids: List[str], user_id: str) -> List[Dict]:
+        """Get existing transcripts using backend integration"""
+        transcripts = []
+        
+        if self.backend_manager:
+            for job_id in transcript_job_ids:
+                try:
+                    job = self.backend_manager.get_job_status(job_id)
+                    if job and job.user_id == user_id and job.transcript_text:
+                        transcripts.append({
+                            'source': f"Previous transcript: {job.original_filename}",
+                            'content': job.transcript_text
+                        })
+                except Exception as e:
+                    print(f"Error getting transcript {job_id[:8]}...: {e}")
+        else:
+            print("Backend manager not available, cannot retrieve existing transcripts")
+        
+        return transcripts
+    
+    def get_summary_status(self, job_id: str) -> Optional[SummaryJob]:
+        """Get current summary job status using backend integration"""
+        if self.backend_manager:
+            return self.backend_manager.get_summary_job(job_id)
+        else:
+            # Fallback to local storage
+            try:
+                job_file = f"temp/summary_jobs/{job_id}.json"
+                if os.path.exists(job_file):
+                    with open(job_file, 'r', encoding='utf-8') as f:
+                        job_data = json.load(f)
+                    
+                    # Convert back to SummaryJob object
+                    return SummaryJob(**job_data)
+            except Exception as e:
+                print(f"Error loading job from fallback storage: {e}")
+        
+        return None
+    
+    def get_user_summary_history(self, user_id: str, limit: int = 20) -> List[SummaryJob]:
+        """Get user's summary history using backend integration"""
+        if self.backend_manager:
+            return self.backend_manager.get_user_summary_history(user_id, limit)
+        else:
+            # Fallback to local storage
+            try:
+                history = []
+                jobs_dir = "temp/summary_jobs"
+                if os.path.exists(jobs_dir):
+                    for filename in os.listdir(jobs_dir):
+                        if filename.endswith('.json'):
+                            job_file = os.path.join(jobs_dir, filename)
+                            try:
+                                with open(job_file, 'r', encoding='utf-8') as f:
+                                    job_data = json.load(f)
+                                
+                                if job_data.get('user_id') == user_id:
+                                    history.append(SummaryJob(**job_data))
+                            except Exception as e:
+                                print(f"Error loading job file {filename}: {e}")
+                
+                # Sort by creation date and limit
+                history.sort(key=lambda x: x.created_at, reverse=True)
+                return history[:limit]
+            except Exception as e:
+                print(f"Error getting user history from fallback storage: {e}")
+        
+        return []
+
+# Global AI summary manager instance with enhanced backend integration
+ai_summary_manager = AISummaryManager()

app.py

@@ -0,0 +1,1661 @@
+import gradio as gr
+import time
+import json
+import os
+import subprocess
+from datetime import datetime, timedelta
+from typing import List, Tuple, Optional
+from backend import (
+    ALLOWED_LANGS, AUDIO_FORMATS, transcription_manager, 
+    allowed_file, User
+)
+
+# Import new AI Summary components
+try:
+    from ai_summary import ai_summary_manager, SummaryJob
+    from file_processors import FileProcessor
+    from image_extraction import VideoFrameExtractor
+    AI_FEATURES_AVAILABLE = True
+    print("✅ AI Summary features loaded successfully")
+except ImportError as e:
+    AI_FEATURES_AVAILABLE = False
+    print(f"⚠️ AI Summary features not available: {e}")
+    ai_summary_manager = None
+
+def format_status(status):
+    """Convert status to user-friendly format"""
+    status_map = {
+        'pending': '⏳ Queued',
+        'processing': '🔄 Processing',
+        'completed': '✅ Done',
+        'failed': '❌ Failed'
+    }
+    return status_map.get(status, status)
+
+def format_processing_time(created_at, completed_at=None):
+    """Calculate and format processing time"""
+    try:
+        start_time = datetime.fromisoformat(created_at)
+        if completed_at:
+            end_time = datetime.fromisoformat(completed_at)
+            duration = end_time - start_time
+        else:
+            duration = datetime.now() - start_time
+        
+        total_seconds = int(duration.total_seconds())
+        if total_seconds < 60:
+            return f"{total_seconds}s"
+        elif total_seconds < 3600:
+            minutes = total_seconds // 60
+            seconds = total_seconds % 60
+            return f"{minutes}m {seconds}s"
+        else:
+            hours = total_seconds // 3600
+            minutes = (total_seconds % 3600) // 60
+            return f"{hours}h {minutes}m"
+    except:
+        return "Unknown"
+
+def get_user_stats_display(user: User):
+    """Get user statistics for display"""
+    if not user:
+        return "👤 Please log in to view statistics"
+    
+    try:
+        # Use extended stats that include AI summaries
+        if hasattr(transcription_manager, 'get_user_stats_extended'):
+            stats = transcription_manager.get_user_stats_extended(user.user_id)
+        else:
+            stats = transcription_manager.get_user_stats(user.user_id)
+        
+        total = stats.get('total_jobs', 0)
+        summary_total = stats.get('total_summary_jobs', 0)
+        recent = stats.get('recent_jobs', 0)
+        by_status = stats.get('by_status', {})
+        
+        completed = by_status.get('completed', 0)
+        processing = by_status.get('processing', 0)
+        pending = by_status.get('pending', 0)
+        failed = by_status.get('failed', 0)
+        
+        stats_text = f"👤 {user.username} | 📊 Transcripts: {total} | 🤖 AI Summaries: {summary_total} | ✅ Completed: {completed}"
+        if processing > 0:
+            stats_text += f" | 🔄 Processing: {processing}"
+        if pending > 0:
+            stats_text += f" | ⏳ Pending: {pending}"
+        if failed > 0:
+            stats_text += f" | ❌ Failed: {failed}"
+        if recent > 0:
+            stats_text += f" | 📅 Last 7 days: {recent}"
+            
+        return stats_text
+        
+    except Exception as e:
+        return f"👤 {user.username} | Stats error: {str(e)}"
+
+# Authentication Functions
+def register_user(email, username, password, confirm_password, gdpr_consent, data_retention_consent, marketing_consent):
+    """Register new user account"""
+    try:
+        print(f"📝 Registration attempt for: {username} ({email})")
+        
+        # Validate inputs
+        if not email or not username or not password:
+            return "❌ All fields are required", gr.update(visible=False)
+        
+        if password != confirm_password:
+            return "❌ Passwords do not match", gr.update(visible=False)
+        
+        if not gdpr_consent:
+            return "❌ GDPR consent is required to create an account", gr.update(visible=False)
+        
+        if not data_retention_consent:
+            return "❌ Data retention agreement is required", gr.update(visible=False)
+        
+        # Attempt registration
+        success, message, user_id = transcription_manager.register_user(
+            email, username, password, gdpr_consent, data_retention_consent, marketing_consent
+        )
+        
+        print(f"📝 Registration result: success={success}, message={message}")
+        
+        if success:
+            print(f"✅ User registered successfully: {username}")
+            return f"✅ {message}! Please log in with your credentials.", gr.update(visible=True)
+        else:
+            print(f"❌ Registration failed: {message}")
+            return f"❌ {message}", gr.update(visible=False)
+            
+    except Exception as e:
+        print(f"❌ Registration error: {str(e)}")
+        return f"❌ Registration error: {str(e)}", gr.update(visible=False)
+
+def login_user(login, password):
+    """Login user"""
+    try:
+        print(f"🔑 Login attempt for: {login}")
+        
+        if not login or not password:
+            return "❌ Please enter both username/email and password", None, gr.update(visible=True), gr.update(visible=False), "👤 Please log in to view your statistics..."
+        
+        success, message, user = transcription_manager.login_user(login, password)
+        print(f"🔑 Login result: success={success}, message={message}")
+        
+        if success and user:
+            print(f"✅ User logged in successfully: {user.username}")
+            stats_display = get_user_stats_display(user)
+            return f"✅ Welcome back, {user.username}!", user, gr.update(visible=False), gr.update(visible=True), stats_display
+        else:
+            print(f"❌ Login failed: {message}")
+            return f"❌ {message}", None, gr.update(visible=True), gr.update(visible=False), "👤 Please log in to view your statistics..."
+            
+    except Exception as e:
+        print(f"❌ Login error: {str(e)}")
+        return f"❌ Login error: {str(e)}", None, gr.update(visible=True), gr.update(visible=False), "👤 Please log in to view your statistics..."
+
+def logout_user():
+    """Logout user"""
+    print("👋 User logged out")
+    return None, "👋 You have been logged out. Please log in to continue.", gr.update(visible=True), gr.update(visible=False), "👤 Please log in to view your statistics..."
+
+# Transcription Functions
+def submit_transcription(file, language, audio_format, diarization_enabled, speakers, 
+                        profanity, punctuation, timestamps, lexical, user):
+    """Submit transcription job - requires authenticated user"""
+    if not user:
+        return (
+            "❌ Please log in to submit transcriptions",
+            "",
+            gr.update(visible=False),
+            "",
+            {},
+            gr.update(visible=False),
+            gr.update()
+        )
+    
+    if file is None:
+        return (
+            "Please upload an audio or video file first.",
+            "",
+            gr.update(visible=False),
+            "",
+            {},
+            gr.update(visible=False),
+            gr.update()
+        )
+    
+    try:
+        # Get file data
+        try:
+            if isinstance(file, str):
+                if os.path.exists(file):
+                    with open(file, 'rb') as f:
+                        file_bytes = f.read()
+                    original_filename = os.path.basename(file)
+                else:
+                    return (
+                        "File not found. Please try uploading again.",
+                        "",
+                        gr.update(visible=False),
+                        "",
+                        {},
+                        gr.update(visible=False),
+                        gr.update()
+                    )
+            else:
+                file_path = str(file)
+                if os.path.exists(file_path):
+                    with open(file_path, 'rb') as f:
+                        file_bytes = f.read()
+                    original_filename = os.path.basename(file_path)
+                else:
+                    return (
+                        "Unable to process file. Please try again.",
+                        "",
+                        gr.update(visible=False),
+                        "",
+                        {},
+                        gr.update(visible=False),
+                        gr.update()
+                    )
+        except Exception as e:
+            return (
+                f"Error reading file: {str(e)}",
+                "",
+                gr.update(visible=False),
+                "",
+                {},
+                gr.update(visible=False),
+                gr.update()
+            )
+        
+        # Validate file
+        file_extension = original_filename.split('.')[-1].lower() if '.' in original_filename else ""
+        supported_extensions = set(AUDIO_FORMATS) | {
+            'mp4', 'mov', 'avi', 'mkv', 'webm', 'm4a', '3gp', 'f4v', 
+            'wmv', 'asf', 'rm', 'rmvb', 'flv', 'mpg', 'mpeg', 'mts', 'vob'
+        }
+        
+        if file_extension not in supported_extensions and file_extension != "":
+            return (
+                f"Unsupported file format: .{file_extension}",
+                "",
+                gr.update(visible=False),
+                "",
+                {},
+                gr.update(visible=False),
+                gr.update()
+            )
+        
+        # Basic file size check
+        if len(file_bytes) > 500 * 1024 * 1024:  # 500MB limit
+            return (
+                "File too large. Please upload files smaller than 500MB.",
+                "",
+                gr.update(visible=False),
+                "",
+                {},
+                gr.update(visible=False),
+                gr.update()
+            )
+        
+        # Prepare settings
+        settings = {
+            'audio_format': audio_format,
+            'diarization_enabled': diarization_enabled,
+            'speakers': speakers,
+            'profanity': profanity,
+            'punctuation': punctuation,
+            'timestamps': timestamps,
+            'lexical': lexical
+        }
+        
+        # Submit job
+        job_id = transcription_manager.submit_transcription(
+            file_bytes, original_filename, user.user_id, language, settings
+        )
+        
+        # Update job state
+        job_state = {
+            'current_job_id': job_id,
+            'start_time': datetime.now().isoformat(),
+            'auto_refresh_active': True,
+            'last_status': 'pending'
+        }
+        
+        # Get updated user stats
+        stats_display = get_user_stats_display(user)
+        
+        return (
+            f"🚀 Transcription started for: {original_filename}\n🔄 Auto-refreshing every 10 seconds...",
+            "",
+            gr.update(visible=False),
+            f"Job ID: {job_id}",
+            job_state,
+            gr.update(visible=True, value="🔄 Auto-refresh active"),
+            stats_display
+        )
+        
+    except Exception as e:
+        print(f"❌ Error submitting transcription: {str(e)}")
+        return (
+            f"Error: {str(e)}",
+            "",
+            gr.update(visible=False),
+            "",
+            {},
+            gr.update(visible=False),
+            gr.update()
+        )
+
+def check_transcription_status(job_state, user):
+    """Check transcription status"""
+    if not user:
+        return "❌ Please log in to check status", "", gr.update(visible=False)
+    
+    if not job_state or 'current_job_id' not in job_state:
+        return "No active transcription job", "", gr.update(visible=False)
+    
+    try:
+        job_id = job_state['current_job_id']
+        job = transcription_manager.get_job_status(job_id)
+        
+        if not job:
+            return "❌ Job not found", "", gr.update(visible=False)
+        
+        if job.user_id != user.user_id:
+            return "❌ Access denied", "", gr.update(visible=False)
+        
+        processing_time = format_processing_time(job.created_at, job.completed_at)
+        
+        if job.status == 'completed' and job.transcript_text:
+            job_state['auto_refresh_active'] = False
+            
+            # Create downloadable file
+            transcript_file = create_transcript_file(job.transcript_text, job_id, job.original_filename)
+            
+            stats_display = get_user_stats_display(user)
+            
+            return (
+                f"✅ Transcription completed in {processing_time}!\n📚 Result saved to your history.",
+                job.transcript_text,
+                gr.update(visible=True, value=transcript_file) if transcript_file else gr.update(visible=False)
+            )
+            
+        elif job.status == 'failed':
+            job_state['auto_refresh_active'] = False
+            error_msg = job.error_message[:100] + "..." if job.error_message and len(job.error_message) > 100 else job.error_message or "Unknown error"
+            return (
+                f"❌ Transcription failed after {processing_time}: {error_msg}",
+                "",
+                gr.update(visible=False)
+            )
+            
+        elif job.status == 'processing':
+            return (
+                f"🔄 Transcription in progress... ({processing_time} elapsed)\n🎯 Converting speech to text with Azure AI...",
+                "",
+                gr.update(visible=False)
+            )
+        else:
+            return (
+                f"⏳ Transcription queued... ({processing_time} waiting)\n🚀 Your job will start processing shortly...",
+                "",
+                gr.update(visible=False)
+            )
+    
+    except Exception as e:
+        print(f"❌ Error checking status: {e}")
+        return f"❌ Error checking status: {str(e)}", "", gr.update(visible=False)
+
+def create_transcript_file(transcript_text, job_id, filename):
+    """Create downloadable transcript file"""
+    try:
+        os.makedirs("temp", exist_ok=True)
+        safe_filename = "".join(c for c in filename if c.isalnum() or c in (' ', '-', '_', '.')).rstrip()
+        output_filename = f"temp/transcript_{job_id}_{safe_filename}.txt"
+        
+        content = f"TRANSCRIPT: {filename}\n"
+        content += f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+        content += f"Job ID: {job_id}\n"
+        content += "=" * 50 + "\n\n"
+        content += transcript_text
+        
+        with open(output_filename, "w", encoding="utf-8") as f:
+            f.write(content)
+        
+        return output_filename
+    except Exception as e:
+        print(f"❌ Error creating transcript file: {e}")
+        return None
+
+# AI Summary Functions
+def get_available_transcripts(user):
+    """Get available transcripts for dropdown selection"""
+    if not user or not AI_FEATURES_AVAILABLE:
+        return gr.update(choices=[], value=[])
+    
+    try:
+        jobs = transcription_manager.get_user_history(user.user_id, limit=50)
+        completed_jobs = [job for job in jobs if job.status == 'completed' and job.transcript_text]
+        
+        choices = []
+        for job in completed_jobs:
+            date_str = job.created_at[:10]
+            char_count = len(job.transcript_text) if job.transcript_text else 0
+            display_text = f"{job.original_filename} ({date_str}) - {char_count:,} chars"
+            choices.append((display_text, job.job_id))
+        
+        return gr.update(choices=choices, value=[])
+        
+    except Exception as e:
+        print(f"❌ Error getting available transcripts: {e}")
+        return gr.update(choices=[], value=[])
+
+def submit_ai_summary(
+    user, 
+    processing_mode, 
+    selected_transcripts, 
+    media_files,
+    support_files, 
+    user_prompt,
+    output_format,
+    output_language,
+    focus_areas,
+    include_timestamps,
+    include_action_items
+):
+    """Submit AI summary job with improved validation and UI handling"""
+    if not user:
+        return "❌ Please log in to use AI summarization", "", gr.update(visible=False), {}, gr.update(selected=0)
+    
+    if not AI_FEATURES_AVAILABLE:
+        return "❌ AI features are not available. Please check service configuration.", "", gr.update(visible=False), {}, gr.update(selected=0)
+    
+    try:
+        # Validate inputs based on processing mode
+        if processing_mode == "existing_transcripts":
+            if not selected_transcripts:
+                return "❌ Please select at least one transcript", "", gr.update(visible=False), {}, gr.update()
+            files_to_process = None
+            transcript_ids = selected_transcripts
+            
+        elif processing_mode == "new_media":
+            if not media_files:
+                return "❌ Please upload at least one media file", "", gr.update(visible=False), {}, gr.update()
+            files_to_process = media_files
+            transcript_ids = None
+            
+        else:
+            return "❌ Invalid processing mode selected", "", gr.update(visible=False), {}, gr.update()
+        
+        if not user_prompt.strip():
+            return "❌ Please provide instructions for the AI summary", "", gr.update(visible=False), {}, gr.update()
+        
+        # Combine all files for processing
+        all_files = []
+        if files_to_process:
+            all_files.extend(files_to_process)
+        if support_files:
+            all_files.extend(support_files)
+        
+        # Prepare enhanced user prompt
+        enhanced_prompt = f"""
+        User Instructions: {user_prompt}
+        
+        Output Format: {output_format}
+        Focus Areas: {focus_areas if focus_areas else 'General summary'}
+        Include Timestamps: {'Yes' if include_timestamps else 'No'}
+        Include Action Items: {'Yes' if include_action_items else 'No'}
+        
+        Please create a comprehensive conference summary following these specifications.
+        """
+        
+        # Prepare settings
+        settings = {
+            'output_format': output_format,
+            'output_language': output_language,
+            'focus_areas': focus_areas,
+            'include_timestamps': include_timestamps,
+            'include_action_items': include_action_items,
+            'processing_mode': processing_mode
+        }
+        
+        # Submit AI summary job
+        job_id = ai_summary_manager.submit_summary_job(
+            user_id=user.user_id,
+            summary_type=processing_mode,
+            user_prompt=enhanced_prompt,
+            files=all_files if all_files else None,
+            transcript_job_ids=transcript_ids,
+            settings=settings
+        )
+        
+        print(f"🤖 [{user.username}] AI summary job submitted: {job_id[:8]}...")
+        
+        # Update job state for tracking
+        summary_job_state = {
+            'current_summary_job_id': job_id,
+            'start_time': datetime.now().isoformat(),
+            'auto_refresh_active': True,
+            'last_status': 'pending'
+        }
+        
+        return (
+            f"🤖 AI Summary started!\n🔄 Processing your content with advanced AI...\nJob ID: {job_id[:8]}...\n\n⬆️ You can navigate to other tabs while processing continues in background.",
+            "",
+            gr.update(visible=False),
+            summary_job_state,
+            gr.update(selected=0)
+        )
+        
+    except Exception as e:
+        print(f"❌ Error submitting AI summary: {e}")
+        return f"❌ Error: {str(e)}", "", gr.update(visible=False), {}, gr.update()
+
+def check_summary_status(summary_job_state, user):
+    """Check AI summary job status"""
+    if not user or not AI_FEATURES_AVAILABLE:
+        return "❌ Please log in to check status", "", gr.update(visible=False)
+    
+    if not summary_job_state or 'current_summary_job_id' not in summary_job_state:
+        return "No active AI summary job", "", gr.update(visible=False)
+    
+    try:
+        job_id = summary_job_state['current_summary_job_id']
+        job = ai_summary_manager.get_summary_status(job_id)
+        
+        if not job:
+            return "❌ Summary job not found", "", gr.update(visible=False)
+        
+        processing_time = format_processing_time(job.created_at, job.completed_at)
+        
+        if job.status == 'completed' and job.summary_text:
+            summary_job_state['auto_refresh_active'] = False
+            
+            summary_file = create_summary_file(job.summary_text, job_id)
+            stats_display = get_user_stats_display(user)
+            
+            return (
+                f"✅ AI Summary completed in {processing_time}!\n📚 Result saved to your history.",
+                job.summary_text,
+                gr.update(visible=True, value=summary_file) if summary_file else gr.update(visible=False)
+            )
+            
+        elif job.status == 'failed':
+            summary_job_state['auto_refresh_active'] = False
+            error_msg = job.error_message[:100] + "..." if job.error_message and len(job.error_message) > 100 else job.error_message or "Unknown error"
+            return (
+                f"❌ AI Summary failed after {processing_time}: {error_msg}",
+                "",
+                gr.update(visible=False)
+            )
+            
+        elif job.status == 'processing':
+            processed_info = ""
+            if job.processed_files:
+                info_parts = []
+                if job.processed_files.get('transcript_count', 0) > 0:
+                    info_parts.append(f"{job.processed_files['transcript_count']} transcripts")
+                if job.processed_files.get('document_count', 0) > 0:
+                    info_parts.append(f"{job.processed_files['document_count']} documents") 
+                if job.processed_files.get('image_count', 0) > 0:
+                    info_parts.append(f"{job.processed_files['image_count']} images")
+                
+                if info_parts:
+                    processed_info = f"\n📊 Processing: {', '.join(info_parts)}"
+            
+            return (
+                f"🤖 AI Analysis in progress... ({processing_time} elapsed){processed_info}\n🔄 Using advanced AI to analyze your content...",
+                "",
+                gr.update(visible=False)
+            )
+        else:
+            return (
+                f"⏳ AI Summary queued... ({processing_time} waiting)\n🔄 Your job will start processing shortly...",
+                "",
+                gr.update(visible=False)
+            )
+    
+    except Exception as e:
+        print(f"❌ Error checking summary status: {e}")
+        return f"❌ Error checking status: {str(e)}", "", gr.update(visible=False)
+
+def create_summary_file(summary_text, job_id):
+    """Create downloadable summary file"""
+    try:
+        os.makedirs("temp", exist_ok=True)
+        filename = f"temp/ai_summary_{job_id}.md"
+        
+        content = f"""# AI Conference Summary
+*Generated on {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*
+*Job ID: {job_id}*
+
+---
+
+{summary_text}
+
+---
+*Generated by AI Conference Summarization Service*
+"""
+        
+        with open(filename, "w", encoding="utf-8") as f:
+            f.write(content)
+        
+        return filename
+    except Exception as e:
+        print(f"❌ Error creating summary file: {e}")
+        return None
+
+# Download Functions
+def download_transcript_by_id(user, job_id):
+    """Download transcript by job ID"""
+    if not user or not job_id:
+        return None
+    
+    try:
+        # Get transcript content
+        transcript_content = transcription_manager.download_transcript(job_id, user.user_id)
+        if not transcript_content:
+            return None
+        
+        # Get job info
+        job = transcription_manager.get_job_status(job_id)
+        if not job:
+            return None
+        
+        # Create file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        safe_filename = "".join(c for c in job.original_filename if c.isalnum() or c in (' ', '-', '_', '.')).rstrip()
+        
+        import tempfile
+        temp_file = tempfile.NamedTemporaryFile(
+            mode='w',
+            suffix='.txt',
+            prefix=f"transcript_{timestamp}_",
+            delete=False,
+            encoding='utf-8'
+        )
+        
+        # Write content
+        content = f"TRANSCRIPT\n"
+        content += f"File: {job.original_filename}\n"
+        content += f"Language: {ALLOWED_LANGS.get(job.language, job.language)}\n"
+        content += f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+        content += f"Job ID: {job_id}\n"
+        content += f"User: {user.username}\n"
+        content += "=" * 60 + "\n\n"
+        content += transcript_content
+        content += f"\n\n" + "=" * 60
+        content += f"\nGenerated by Azure Speech Transcription Service"
+        
+        temp_file.write(content)
+        temp_file.close()
+        
+        return temp_file.name
+        
+    except Exception as e:
+        print(f"Error downloading transcript: {e}")
+        return None
+
+def download_summary_by_id(user, job_id):
+    """Download summary by job ID"""
+    if not user or not job_id or not AI_FEATURES_AVAILABLE:
+        return None
+    
+    try:
+        # Get summary job
+        job = None
+        if hasattr(ai_summary_manager, 'get_summary_status'):
+            job = ai_summary_manager.get_summary_status(job_id)
+        elif hasattr(transcription_manager, 'get_summary_job'):
+            job = transcription_manager.get_summary_job(job_id)
+        
+        if not job or not job.summary_text or job.user_id != user.user_id:
+            return None
+        
+        # Create file
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        topic_name = "AI_Summary"
+        if hasattr(job, 'original_files') and job.original_files:
+            topic_name = str(job.original_files[0])
+            topic_name = "".join(c for c in topic_name if c.isalnum() or c in (' ', '-', '_')).strip()
+            topic_name = topic_name.replace(' ', '_')
+        
+        import tempfile
+        temp_file = tempfile.NamedTemporaryFile(
+            mode='w',
+            suffix='.md',
+            prefix=f"summary_{timestamp}_",
+            delete=False,
+            encoding='utf-8'
+        )
+        
+        # Write content
+        content = f"# AI Conference Summary\n\n"
+        content += f"**Topic:** {topic_name.replace('_', ' ')}\n"
+        content += f"**Type:** {getattr(job, 'summary_type', 'Conference Summary')}\n"
+        content += f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+        content += f"**Job ID:** {job_id}\n"
+        content += f"**User:** {user.username}\n\n"
+        content += "---\n\n"
+        content += job.summary_text
+        content += f"\n\n---\n\n"
+        content += "*Generated by AI Conference Summarization Service*"
+        
+        temp_file.write(content)
+        temp_file.close()
+        
+        return temp_file.name
+        
+    except Exception as e:
+        print(f"Error downloading summary: {e}")
+        return None
+
+# IMPROVED History Functions with Interactive Downloads
+def get_transcript_history_with_downloads(user, show_all=False):
+    """Get transcription history with downloadable links"""
+    if not user:
+        return [], "👤 Please log in to view transcription history", []
+    
+    try:
+        limit = 100 if show_all else 20
+        jobs = transcription_manager.get_user_history(user.user_id, limit=limit)
+        
+        if not jobs:
+            return [], f"📂 No transcriptions found for {user.username}", []
+        
+        table_data = []
+        download_data = []  # Store job IDs for downloads
+        completed_count = 0
+        
+        for job in jobs:
+            try:
+                created_time = datetime.fromisoformat(job.created_at)
+                formatted_date = created_time.strftime("%Y-%m-%d %H:%M")
+            except:
+                formatted_date = job.created_at[:16] if job.created_at else "Unknown"
+            
+            status_display = format_status(job.status)
+            time_display = format_processing_time(job.created_at, job.completed_at)
+            language_display = ALLOWED_LANGS.get(job.language, job.language)
+            job_id_short = job.job_id[:8] + "..."
+            
+            # Download link
+            if job.status == 'completed' and job.transcript_text:
+                completed_count += 1
+                download_text = f"📥 Download"
+                download_data.append(job.job_id)
+            else:
+                download_text = "Not Available"
+                download_data.append("")
+            
+            table_data.append([
+                formatted_date,
+                job.original_filename,
+                language_display,
+                status_display,
+                time_display,
+                job_id_short,
+                download_text
+            ])
+        
+        summary_text = f"📊 {len(jobs)} transcriptions ({completed_count} completed)"
+        return table_data, summary_text, download_data
+        
+    except Exception as e:
+        return [], f"❌ Error: {str(e)}", []
+
+def get_summary_history_with_downloads(user, show_all=False):
+    """Get AI summary history with downloadable links"""
+    if not user:
+        return [], "👤 Please log in to view AI summary history", []
+    
+    if not AI_FEATURES_AVAILABLE:
+        return [], "AI Summary features not available", []
+    
+    try:
+        limit = 100 if show_all else 20
+        jobs = []
+        
+        if hasattr(transcription_manager, 'get_user_summary_history'):
+            jobs = transcription_manager.get_user_summary_history(user.user_id, limit=limit)
+        elif hasattr(ai_summary_manager, 'get_user_summary_history'):
+            jobs = ai_summary_manager.get_user_summary_history(user.user_id, limit=limit)
+        
+        if not jobs:
+            return [], f"📂 No AI summaries found for {user.username}", []
+        
+        table_data = []
+        download_data = []  # Store job IDs for downloads
+        completed_count = 0
+        
+        for job in jobs:
+            try:
+                created_time = datetime.fromisoformat(job.created_at)
+                formatted_date = created_time.strftime("%Y-%m-%d %H:%M")
+            except:
+                formatted_date = job.created_at[:16] if job.created_at else "Unknown"
+            
+            status_display = format_status(job.status)
+            time_display = format_processing_time(job.created_at, job.completed_at)
+            job_id_short = job.job_id[:8] + "..."
+            
+            # Get topic name
+            topic_name = "AI Summary"
+            if hasattr(job, 'original_files') and job.original_files:
+                topic_name = str(job.original_files[0])
+                if len(topic_name) > 40:
+                    topic_name = topic_name[:37] + "..."
+            
+            type_display = getattr(job, 'summary_type', 'Conference')
+            
+            # Download link
+            if job.status == 'completed' and job.summary_text:
+                completed_count += 1
+                download_text = f"📥 Download"
+                download_data.append(job.job_id)
+            else:
+                download_text = "Not Available"
+                download_data.append("")
+            
+            table_data.append([
+                formatted_date,
+                topic_name,
+                type_display,
+                status_display,
+                time_display,
+                job_id_short,
+                download_text
+            ])
+        
+        summary_text = f"🤖 {len(jobs)} AI summaries ({completed_count} completed)"
+        return table_data, summary_text, download_data
+        
+    except Exception as e:
+        return [], f"❌ Error: {str(e)}", []
+
+def handle_transcript_table_select(user, evt: gr.SelectData):
+    """Handle transcript table row selection for download"""
+    if not user or not evt:
+        return None
+    
+    try:
+        # Get the current table data and download data
+        table_data, _, download_data = get_transcript_history_with_downloads(user)
+        
+        if evt.index[0] < len(download_data):
+            job_id = download_data[evt.index[0]]
+            if job_id:  # Only download if job_id exists (completed jobs)
+                download_file = download_transcript_by_id(user, job_id)
+                return download_file
+        
+        return None
+        
+    except Exception as e:
+        print(f"Error handling transcript table selection: {e}")
+        return None
+
+def handle_summary_table_select(user, evt: gr.SelectData):
+    """Handle summary table row selection for download"""
+    if not user or not evt:
+        return None
+    
+    try:
+        # Get the current table data and download data
+        table_data, _, download_data = get_summary_history_with_downloads(user)
+        
+        if evt.index[0] < len(download_data):
+            job_id = download_data[evt.index[0]]
+            if job_id:  # Only download if job_id exists (completed jobs)
+                download_file = download_summary_by_id(user, job_id)
+                return download_file
+        
+        return None
+        
+    except Exception as e:
+        print(f"Error handling summary table selection: {e}")
+        return None
+
+def refresh_all_history(user, show_all):
+    """Refresh all history"""
+    if not user:
+        empty_msg = "👤 Please log in to view your history"
+        return [], empty_msg, [], empty_msg
+    
+    # Get transcript data
+    transcript_data, transcript_summary, _ = get_transcript_history_with_downloads(user, show_all)
+    
+    # Get summary data  
+    summary_data, summary_summary, _ = get_summary_history_with_downloads(user, show_all)
+    
+    return transcript_data, transcript_summary, summary_data, summary_summary
+
+# Enhanced CSS with better table styling
+enhanced_css = """
+/* Main container styling */
+.gradio-container {
+    background: linear-gradient(135deg, #f8f9fa 0%, #e9ecef 100%);
+    font-family: 'Segoe UI', system-ui, sans-serif;
+    color: #212529;
+}
+
+/* Card styling */
+.gr-box {
+    background: white;
+    border: 1px solid #dee2e6;
+    border-radius: 12px;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.08);
+    padding: 20px;
+    margin: 10px 0;
+}
+
+/* Button styling */
+.gr-button {
+    background: linear-gradient(135deg, #007bff, #0056b3);
+    border: none;
+    border-radius: 8px;
+    color: white;
+    font-weight: 500;
+    padding: 12px 24px;
+    transition: all 0.2s ease;
+    box-shadow: 0 2px 4px rgba(0,123,255,0.2);
+}
+
+.gr-button:hover {
+    background: linear-gradient(135deg, #0056b3, #004085);
+    transform: translateY(-1px);
+    box-shadow: 0 4px 8px rgba(0,123,255,0.3);
+}
+
+/* Table styling for history */
+.history-table table {
+    width: 100% !important;
+}
+
+.history-table td:last-child {
+    cursor: pointer !important;
+    color: #007bff !important;
+    font-weight: 600 !important;
+}
+
+.history-table td:last-child:hover {
+    background-color: #e7f3ff !important;
+    text-decoration: underline !important;
+}
+
+/* Section headers */
+.section-header {
+    background: linear-gradient(135deg, #007bff, #0056b3);
+    color: white;
+    padding: 10px 15px;
+    border-radius: 8px;
+    margin: 15px 0 10px 0;
+    font-weight: 600;
+}
+
+/* User stats styling */
+.user-stats {
+    background: linear-gradient(135deg, #e8f5e8, #c8e6c9);
+    border: 1px solid #c8e6c9;
+    border-radius: 6px;
+    padding: 8px 12px;
+    font-size: 12px;
+    color: #2e7d32;
+    text-align: center;
+    font-weight: 500;
+}
+
+/* History table styling */
+.history-table {
+    background: white;
+    border-radius: 8px;
+    overflow: hidden;
+    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+}
+
+/* Download instruction styling */
+.download-instructions {
+    background: #e8f5e8;
+    border: 1px solid #c8e6c9;
+    border-radius: 6px;
+    padding: 10px;
+    margin: 10px 0;
+    font-style: italic;
+    color: #2e7d32;
+    text-align: center;
+}
+"""
+
+# Create the main interface with improved History tab
+with gr.Blocks(
+    theme=gr.themes.Soft(
+        primary_hue="blue",
+        secondary_hue="gray",
+        neutral_hue="gray",
+        font=["system-ui", "sans-serif"]
+    ),
+    css=enhanced_css,
+    title="🎙️ AI Conference Summarization Service - Enhanced with Computer Vision & Multi-format Processing"
+) as demo:
+    
+    # Global state
+    current_user = gr.State(None)
+    job_state = gr.State({})
+    summary_job_state = gr.State({})
+    
+    # Header
+    with gr.Row():
+        gr.HTML("""
+        <div class="main-header">
+            <h1>🎙️ AI Conference Summarization Service</h1>
+            <p>Advanced AI-powered conference analysis with transcription, computer vision, and multi-format processing</p>
+        </div>
+        """)
+    
+    # User stats display
+    user_stats_display = gr.Textbox(
+        label="",
+        lines=1,
+        interactive=False,
+        show_label=False,
+        placeholder="👤 Please log in to view your statistics...",
+        elem_classes=["user-stats"]
+    )
+    
+    # Authentication Section
+    with gr.Column(visible=True, elem_classes=["auth-form"]) as auth_section:
+        gr.Markdown("## 🔐 Authentication Required")
+        gr.Markdown("Please log in or create an account to use the AI conference summarization service.")
+        
+        with gr.Tabs() as auth_tabs:
+            # Login Tab
+            with gr.Tab("🔑 Login") as login_tab:
+                with gr.Column():
+                    login_email = gr.Textbox(
+                        label="Email or Username",
+                        placeholder="Enter your email or username"
+                    )
+                    login_password = gr.Textbox(
+                        label="Password",
+                        type="password",
+                        placeholder="Enter your password"
+                    )
+                    
+                    with gr.Row():
+                        login_btn = gr.Button("🔑 Login", variant="primary", elem_classes=["auth-button"])
+                    
+                    login_status = gr.Textbox(
+                        label="",
+                        show_label=False,
+                        interactive=False,
+                        placeholder="Enter your credentials and click Login"
+                    )
+            
+            # Register Tab
+            with gr.Tab("📝 Register") as register_tab:
+                with gr.Column():
+                    reg_email = gr.Textbox(
+                        label="Email",
+                        placeholder="Enter your email address"
+                    )
+                    reg_username = gr.Textbox(
+                        label="Username", 
+                        placeholder="Choose a username (3-30 characters, alphanumeric and underscore)"
+                    )
+                    reg_password = gr.Textbox(
+                        label="Password",
+                        type="password",
+                        placeholder="Create a strong password (min 8 chars, mixed case, numbers)"
+                    )
+                    reg_confirm_password = gr.Textbox(
+                        label="Confirm Password",
+                        type="password",
+                        placeholder="Confirm your password"
+                    )
+                    
+                    gr.Markdown("### 📋 Privacy & Data Consent")
+                    
+                    with gr.Column(elem_classes=["privacy-notice"]):
+                        gr.Markdown("""
+                        **Privacy Notice**: By creating an account, you acknowledge that:
+                        - Your data will be stored securely in user-separated Azure Blob Storage
+                        - AI processing uses Azure Cognitive Services (Speech, Computer Vision, AI Agents)
+                        - You can export or delete your data at any time
+                        - We comply with GDPR and data protection regulations
+                        """)
+                    
+                    gdpr_consent = gr.Checkbox(
+                        label="I consent to the processing of my personal data as described in the Privacy Notice (Required)",
+                        value=False
+                    )
+                    data_retention_consent = gr.Checkbox(
+                        label="I agree to data retention for transcription and AI service functionality (Required)",
+                        value=False
+                    )
+                    marketing_consent = gr.Checkbox(
+                        label="I consent to receiving marketing communications (Optional)",
+                        value=False
+                    )
+                    
+                    with gr.Row():
+                        register_btn = gr.Button("📝 Create Account", variant="primary", elem_classes=["auth-button"])
+                    
+                    register_status = gr.Textbox(
+                        label="",
+                        show_label=False,
+                        interactive=False,
+                        placeholder="Fill out the form and agree to the required consents to create your account"
+                    )
+                    
+                    login_after_register = gr.Button(
+                        "🔑 Go to Login",
+                        visible=False,
+                        variant="secondary"
+                    )
+    
+    # Main Application (visible only when logged in)
+    with gr.Column(visible=False) as main_app:
+        
+        # Logout button
+        with gr.Row():
+            with gr.Column(scale=3):
+                pass
+            with gr.Column(scale=1):
+                logout_btn = gr.Button("👋 Logout", variant="secondary")
+        
+        with gr.Tabs() as main_tabs:
+            
+            # AI Summary Conference Tab
+            with gr.Tab("🤖 AI Summary Conference"):
+                gr.Markdown("### 🎯 AI-Powered Conference Summarization")
+                
+                with gr.Row():
+                    # First Column - Content Sources
+                    with gr.Column(scale=1):
+                        gr.HTML('<div class="section-header">📥 Content Sources</div>')
+                        
+                        processing_mode = gr.Radio(
+                            choices=[
+                                ("Existing Transcripts", "existing_transcripts"),
+                                ("New Media Files", "new_media")
+                            ],
+                            value="existing_transcripts",
+                            label="Mode",
+                            elem_classes=["processing-mode"]
+                        )
+                        
+                        with gr.Column() as existing_transcripts_section:
+                            available_transcripts = gr.Dropdown(
+                                choices=[],
+                                label="Available Transcripts",
+                                multiselect=True,
+                                interactive=True,
+                                elem_classes=["transcript-dropdown"]
+                            )
+                            refresh_transcripts_btn = gr.Button("🔄 Refresh", variant="secondary", size="sm")
+                        
+                        with gr.Column(visible=False) as new_media_section:
+                            media_files = gr.Files(
+                                label="Media Files",
+                                file_types=[".mp4", ".mov", ".avi", ".mkv", ".webm", ".flv", ".wav", ".mp3", ".ogg", ".opus", ".flac", ".m4a", ".aac"],
+                                file_count="multiple"
+                            )
+                        
+                        support_files = gr.Files(
+                            label="Supporting Files",
+                            file_types=[".pdf", ".docx", ".doc", ".pptx", ".ppt", ".xlsx", ".xls", ".csv", ".txt", ".json", ".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff", ".webp"],
+                            file_count="multiple"
+                        )
+                    
+                    # Second Column - AI Instructions
+                    with gr.Column(scale=1):
+                        gr.HTML('<div class="section-header">🎯 AI Instructions</div>')
+                        
+                        user_prompt = gr.Textbox(
+                            label="Instructions for AI",
+                            placeholder="Describe the conference type, desired format, and any corrections...",
+                            lines=6
+                        )
+                        
+                        with gr.Row():
+                            output_format = gr.Dropdown(
+                                choices=["Executive Summary", "Detailed Report", "Meeting Minutes", "Action Items List", "Key Insights & Decisions"],
+                                value="Executive Summary",
+                                label="Format"
+                            )
+                            output_language = gr.Dropdown(
+                                choices=["English", "Thai", "Spanish", "French", "German", "Japanese", "Chinese"],
+                                value="English",
+                                label="Language"
+                            )
+                        
+                        focus_areas = gr.Textbox(
+                            label="Focus Areas",
+                            placeholder="e.g., financial results, decisions, technical discussions",
+                            lines=1
+                        )
+                        
+                        with gr.Row():
+                            include_timestamps = gr.Checkbox(label="Timestamps", value=True)
+                            include_action_items = gr.Checkbox(label="Action Items", value=True)
+                        
+                        submit_summary_btn = gr.Button("🚀 Generate AI Summary", variant="primary", size="lg")
+                    
+                    # Third Column - Status & Results
+                    with gr.Column(scale=1):
+                        gr.HTML('<div class="section-header">🤖 Status & Results</div>')
+                        
+                        summary_status_display = gr.Textbox(
+                            label="",
+                            lines=3,
+                            interactive=False,
+                            show_label=False,
+                            placeholder="Configure sources and click 'Generate AI Summary'...",
+                            elem_classes=["status-display"]
+                        )
+                        
+                        refresh_summary_btn = gr.Button("🔄 Check Status", variant="secondary")
+                        
+                        summary_output = gr.Textbox(
+                            label="AI Summary Results",
+                            lines=12,
+                            interactive=False,
+                            placeholder="Generated summary will appear here..."
+                        )
+                        
+                        summary_download_file = gr.File(
+                            label="Download",
+                            interactive=False,
+                            visible=False
+                        )
+                    
+            # Traditional Transcription Tab
+            with gr.Tab("🎙️ Transcribe"):
+                with gr.Row():
+                    # Left column - Input settings
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📁 Upload File")
+                        
+                        file_upload = gr.File(
+                            label="Audio or Video File",
+                            type="filepath",
+                            file_types=[
+                                ".wav", ".mp3", ".ogg", ".opus", ".flac", ".wma", ".aac", 
+                                ".m4a", ".amr", ".webm", ".speex",
+                                ".mp4", ".mov", ".avi", ".mkv", ".wmv", ".flv", ".3gp"
+                            ]
+                        )
+                        
+                        with gr.Row():
+                            language = gr.Dropdown(
+                                choices=[(v, k) for k, v in ALLOWED_LANGS.items()],
+                                label="Language",
+                                value="th-TH"
+                            )
+                            audio_format = gr.Dropdown(
+                                choices=AUDIO_FORMATS,
+                                value="wav",
+                                label="Output Format"
+                            )
+                        
+                        gr.Markdown("### ⚙️ Settings")
+                        
+                        with gr.Row():
+                            diarization_enabled = gr.Checkbox(
+                                label="Speaker Identification",
+                                value=True
+                            )
+                            speakers = gr.Slider(
+                                minimum=1,
+                                maximum=10,
+                                step=1,
+                                value=2,
+                                label="Max Speakers"
+                            )
+                        
+                        with gr.Row():
+                            timestamps = gr.Checkbox(
+                                label="Timestamps",
+                                value=True
+                            )
+                            profanity = gr.Dropdown(
+                                choices=["masked", "removed", "raw"],
+                                value="masked",
+                                label="Profanity Filter"
+                            )
+                        
+                        with gr.Row():
+                            punctuation = gr.Dropdown(
+                                choices=["automatic", "dictated", "none"],
+                                value="automatic",
+                                label="Punctuation"
+                            )
+                            lexical = gr.Checkbox(
+                                label="Lexical Form",
+                                value=False
+                            )
+                        
+                        submit_btn = gr.Button(
+                            "🚀 Start Transcription",
+                            variant="primary",
+                            size="lg"
+                        )
+                    
+                    # Right column - Results
+                    with gr.Column(scale=1):
+                        gr.Markdown("### 📊 Status")
+                        
+                        auto_refresh_status_display = gr.Textbox(
+                            label="",
+                            lines=1,
+                            interactive=False,
+                            show_label=False,
+                            visible=False,
+                            elem_classes=["auto-refresh-indicator"]
+                        )
+                        
+                        status_display = gr.Textbox(
+                            label="",
+                            lines=3,
+                            interactive=False,
+                            show_label=False,
+                            placeholder="Upload a file and click 'Start Transcription' to begin..."
+                        )
+                        
+                        job_info = gr.Textbox(
+                            label="",
+                            lines=1,
+                            interactive=False,
+                            show_label=False,
+                            placeholder=""
+                        )
+                        
+                        with gr.Row():
+                            refresh_btn = gr.Button(
+                                "🔄 Check Status",
+                                variant="secondary"
+                            )
+                            stop_refresh_btn = gr.Button(
+                                "ℹ️ Stop Auto-Refresh",
+                                variant="secondary"
+                            )
+                        
+                        gr.Markdown("### 📄 Results")
+                        
+                        transcript_output = gr.Textbox(
+                            label="Transcript",
+                            lines=12,
+                            interactive=False,
+                            placeholder="Your transcript with speaker identification and precise timestamps will appear here..."
+                        )
+                        
+                        download_file = gr.File(
+                            label="Download",
+                            interactive=False,
+                            visible=False
+                        )
+                
+            # History tab - COMPLETELY REDESIGNED WITH CLICKABLE DOWNLOADS
+            with gr.Tab("📚 My History"):
+                gr.Markdown("### 📋 Your Processing History")
+                
+                with gr.Row():
+                    refresh_history_btn = gr.Button("🔄 Refresh History", variant="primary")
+                    show_all_checkbox = gr.Checkbox(label="Show All Jobs", value=False)
+                
+                # TRANSCRIPTION HISTORY SECTION
+                gr.Markdown("## 🎙️ Transcription History")
+                gr.HTML('<div class="download-instructions">💡 Click on the "📥 Download" link in the table to instantly download completed transcripts</div>')
+                
+                transcript_summary = gr.Textbox(
+                    label="", lines=1, interactive=False, show_label=False,
+                    placeholder="📂 Your transcription history will appear here..."
+                )
+                
+                transcript_table = gr.Dataframe(
+                    headers=["Date", "Filename", "Language", "Status", "Duration", "Job ID", "Download"],
+                    datatype=["str", "str", "str", "str", "str", "str", "str"],
+                    col_count=(7, "fixed"),
+                    row_count=(15, "dynamic"),
+                    interactive=False,
+                    elem_classes=["history-table"]
+                )
+                
+                # Hidden file component for transcript downloads
+                transcript_download_file = gr.File(
+                    label="Downloaded Transcript",
+                    visible=True
+                )
+                
+                # AI SUMMARY HISTORY SECTION
+                gr.Markdown("## 🤖 AI Summary History")
+                gr.HTML('<div class="download-instructions">💡 Click on the "📥 Download" link in the table to instantly download completed AI summaries</div>')
+                
+                summary_summary = gr.Textbox(
+                    label="", lines=1, interactive=False, show_label=False,
+                    placeholder="📂 Your AI summary history will appear here..."
+                )
+                
+                summary_table = gr.Dataframe(
+                    headers=["Date", "Topic", "Type", "Status", "Duration", "Job ID", "Download"],
+                    datatype=["str", "str", "str", "str", "str", "str", "str"],
+                    col_count=(7, "fixed"),
+                    row_count=(15, "dynamic"),
+                    interactive=False,
+                    elem_classes=["history-table"]
+                )
+                
+                # Hidden file component for summary downloads
+                summary_download_file = gr.File(
+                    label="Downloaded Summary",
+                    visible=True
+                )
+            
+            # Help Tab
+            with gr.Tab("❓ Help"):
+                gr.Markdown("# 📋 AI Conference Summarization Service Guide")
+                
+                with gr.Row():
+                    # Column 1: AI Conference Summarization
+                    with gr.Column(scale=1):
+                        gr.Markdown("""
+                        ## 🤖 AI Conference Summarization
+                        
+                        **Advanced AI-powered service that creates comprehensive conference summaries**
+                        
+                        ### Key Features
+                        - Multi-source processing (transcripts, documents, images, videos)
+                        - Computer vision extracts text from slides automatically
+                        - Custom AI instructions for personalized summaries
+                        - Multiple output formats and languages
+                        - Action items and key insights extraction
+                        
+                        ### How to Use
+                        1. **Choose Mode**: Use existing transcripts OR upload new media
+                        2. **Add Content**: Include supporting files (presentations, images, documents)
+                        3. **AI Instructions**: Describe meeting context, desired format, corrections needed
+                        4. **Generate**: Click "Generate AI Summary" - processing continues in background
+                        
+                        ### Supported Files
+                        - **Media**: MP4, MOV, AVI, WAV, MP3, OGG
+                        - **Documents**: PDF, Word, PowerPoint, Excel
+                        - **Images**: JPG, PNG, BMP, GIF, TIFF
+                        - **Data**: CSV, JSON, TXT
+                        """)
+                    
+                    # Column 2: Speech Transcription
+                    with gr.Column(scale=1):
+                        gr.Markdown("""
+                        ## 🎙️ Speech Transcription Service
+                        
+                        **High-accuracy speech-to-text with speaker identification and timestamps**
+                        
+                        ### Key Features
+                        - Enterprise-grade Azure speech recognition
+                        - Automatic speaker identification and separation
+                        - Precise HH:MM:SS timestamps
+                        - 50+ languages and dialects supported
+                        - Multiple audio/video format support
+                        
+                        ### How to Use
+                        1. **Upload**: Drag/drop audio or video file (max 500MB)
+                        2. **Configure**: Select language, speakers, output format
+                        3. **Settings**: Enable timestamps, speaker ID, profanity filtering
+                        4. **Process**: Click "Start Transcription" - auto-refresh shows progress
+                        
+                        ### Easy Downloads in History Tab
+                        - All results saved to your private history
+                        - **Simply click the "📥 Download" link in any table row**
+                        - Instant downloads for all completed jobs
+                        - Files include full content plus metadata
+                        - Transcripts saved as TXT, summaries as Markdown
+                        """)
+            
+            # Privacy & Data Tab
+            with gr.Tab("🔒 Privacy & Data"):
+                gr.Markdown("## 🔒 Privacy & Data Protection")
+                gr.Markdown("Complete information about data handling, privacy protections, and licensing.")
+                
+                with gr.Accordion("🔐 Data Privacy & Security", open=True):
+                    gr.Markdown("""
+                    ### GDPR Compliance & Data Protection
+                    
+                    **Your Rights:**
+                    - Right to access your data
+                    - Right to rectify incorrect information  
+                    - Right to erasure ("right to be forgotten")
+                    - Right to data portability
+                    - Right to object to processing
+                    
+                    **Data Security:**
+                    - All data encrypted in transit (HTTPS/TLS)
+                    - User-isolated Azure Blob Storage
+                    - Enterprise-grade security infrastructure
+                    - Regular security updates and monitoring
+                    
+                    **Data Processing:**
+                    - Azure Speech Services (transcription)
+                    - Azure Computer Vision (image analysis)
+                    - Azure OpenAI (AI summarization)
+                    - No data sharing with third parties
+                    """)
+    
+    # Auto-refresh timer
+    timer = gr.Timer(10.0)
+    summary_timer = gr.Timer(15.0)
+    
+    # Event handlers
+    
+    # Authentication events
+    login_btn.click(
+        login_user,
+        inputs=[login_email, login_password],
+        outputs=[login_status, current_user, auth_section, main_app, user_stats_display]
+    ).then(
+        lambda user: ("", "") if user else (gr.update(), gr.update()),
+        inputs=[current_user],
+        outputs=[login_email, login_password]
+    ).then(
+        get_available_transcripts,
+        inputs=[current_user],
+        outputs=[available_transcripts]
+    ).then(
+        refresh_all_history,
+        inputs=[current_user, show_all_checkbox],
+        outputs=[transcript_table, transcript_summary, summary_table, summary_summary]
+    )
+    
+    register_btn.click(
+        register_user,
+        inputs=[reg_email, reg_username, reg_password, reg_confirm_password, 
+                gdpr_consent, data_retention_consent, marketing_consent],
+        outputs=[register_status, login_after_register]
+    )
+    
+    login_after_register.click(
+        lambda: (gr.update(selected=0), ""),
+        outputs=[auth_tabs, register_status]
+    )
+    
+    logout_btn.click(
+        logout_user,
+        outputs=[current_user, login_status, auth_section, main_app, user_stats_display]
+    )
+    
+    # Transcription events
+    submit_btn.click(
+        submit_transcription,
+        inputs=[
+            file_upload, language, audio_format, diarization_enabled,
+            speakers, profanity, punctuation, timestamps, lexical, current_user
+        ],
+        outputs=[status_display, transcript_output, download_file, job_info, job_state, auto_refresh_status_display, user_stats_display]
+    )
+    
+    refresh_btn.click(
+        check_transcription_status,
+        inputs=[job_state, current_user],
+        outputs=[status_display, transcript_output, download_file]
+    )
+    
+    timer.tick(
+        check_transcription_status,
+        inputs=[job_state, current_user],
+        outputs=[status_display, transcript_output, download_file]
+    )
+    
+    # AI Summary events
+    refresh_transcripts_btn.click(
+        get_available_transcripts,
+        inputs=[current_user],
+        outputs=[available_transcripts]
+    )
+    
+    # Show/hide sections based on processing mode
+    processing_mode.change(
+        lambda choice: (
+            gr.update(visible=choice == "existing_transcripts"),
+            gr.update(visible=choice == "new_media")
+        ),
+        inputs=[processing_mode],
+        outputs=[existing_transcripts_section, new_media_section]
+    )
+    
+    submit_summary_btn.click(
+        submit_ai_summary,
+        inputs=[
+            current_user, processing_mode, available_transcripts, media_files,
+            support_files, user_prompt, output_format, output_language, focus_areas, 
+            include_timestamps, include_action_items
+        ],
+        outputs=[summary_status_display, summary_output, summary_download_file, summary_job_state, main_tabs]
+    ).then(
+        lambda user: get_user_stats_display(user) if user else "👤 Please log in to view your statistics...",
+        inputs=[current_user],
+        outputs=[user_stats_display]
+    )
+    
+    refresh_summary_btn.click(
+        check_summary_status,
+        inputs=[summary_job_state, current_user],
+        outputs=[summary_status_display, summary_output, summary_download_file]
+    )
+    
+    summary_timer.tick(
+        check_summary_status,
+        inputs=[summary_job_state, current_user],
+        outputs=[summary_status_display, summary_output, summary_download_file]
+    )
+    
+    # History and Download events - IMPROVED WITH TABLE SELECTION
+    refresh_history_btn.click(
+        refresh_all_history,
+        inputs=[current_user, show_all_checkbox],
+        outputs=[transcript_table, transcript_summary, summary_table, summary_summary]
+    )
+    
+    show_all_checkbox.change(
+        refresh_all_history,
+        inputs=[current_user, show_all_checkbox], 
+        outputs=[transcript_table, transcript_summary, summary_table, summary_summary]
+    )
+    
+    # NEW: Table click handlers for instant downloads
+    transcript_table.select(
+        handle_transcript_table_select,
+        inputs=[current_user],
+        outputs=[transcript_download_file]
+    )
+    
+    summary_table.select(
+        handle_summary_table_select,
+        inputs=[current_user],
+        outputs=[summary_download_file]
+    )
+    
+    # Load history on login
+    current_user.change(
+        refresh_all_history,
+        inputs=[current_user, show_all_checkbox],
+        outputs=[transcript_table, transcript_summary, summary_table, summary_summary]
+    )
+    
+    demo.load(
+        lambda: "👤 Please log in to view your statistics...",
+        outputs=[user_stats_display]
+    )
+
+if __name__ == "__main__":
+    print("🚀 Starting AI Conference Summarization Service...")
+    if AI_FEATURES_AVAILABLE:
+        print("✅ AI features enabled")
+    else:
+        print("⚠️ AI features disabled - check configuration")
+    
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

backend.py

@@ -0,0 +1,1472 @@
+import os
+import time
+import uuid
+import json
+import requests
+import subprocess
+import asyncio
+import threading
+import hashlib
+import re
+from datetime import datetime, timedelta
+from typing import Optional, Dict, List, Tuple
+from dataclasses import dataclass, asdict
+from concurrent.futures import ThreadPoolExecutor
+import sqlite3
+from contextlib import contextmanager
+from dotenv import load_dotenv
+from azure.storage.blob import BlobServiceClient
+import tempfile
+import shutil
+
+# Load Environment
+load_dotenv()
+
+def _require_env_var(varname):
+    value = os.environ.get(varname)
+    if not value or value.strip() == "" or "your" in value.lower():
+        raise ValueError(f"Environment variable {varname} is missing or invalid. Check your .env file.")
+    return value
+
+# Environment variables
+AZURE_SPEECH_KEY = _require_env_var("AZURE_SPEECH_KEY")
+AZURE_SPEECH_KEY_ENDPOINT = _require_env_var("AZURE_SPEECH_KEY_ENDPOINT").rstrip('/')
+AZURE_REGION = _require_env_var("AZURE_REGION")
+AZURE_BLOB_CONNECTION = _require_env_var("AZURE_BLOB_CONNECTION")
+AZURE_CONTAINER = _require_env_var("AZURE_CONTAINER")
+AZURE_CONTAINER_CHAT = os.environ.get("AZURE_CONTAINER_CHAT", "response-chat")  # New chat container
+AZURE_BLOB_SAS_TOKEN = _require_env_var("AZURE_BLOB_SAS_TOKEN")
+ALLOWED_LANGS = json.loads(os.environ.get("ALLOWED_LANGS", "{}"))
+API_VERSION = os.environ.get("API_VERSION", "v3.2")
+
+# Directories
+UPLOAD_DIR = "uploads"
+DB_DIR = "database"
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(DB_DIR, exist_ok=True)
+
+AUDIO_FORMATS = [
+    "wav", "mp3", "ogg", "opus", "flac", "wma", "aac", "alaw", "mulaw", "amr", "webm", "speex"
+]
+
+@dataclass
+class User:
+    user_id: str
+    email: str
+    username: str
+    password_hash: str
+    created_at: str
+    last_login: Optional[str] = None
+    is_active: bool = True
+    gdpr_consent: bool = False
+    data_retention_agreed: bool = False
+    marketing_consent: bool = False
+
+@dataclass
+class TranscriptionJob:
+    job_id: str
+    user_id: str  # Keep user_id for authentication but use simpler transcription logic
+    original_filename: str
+    audio_url: str
+    language: str
+    status: str  # pending, processing, completed, failed
+    created_at: str
+    completed_at: Optional[str] = None
+    transcript_text: Optional[str] = None
+    transcript_url: Optional[str] = None
+    error_message: Optional[str] = None
+    azure_trans_id: Optional[str] = None
+    settings: Optional[Dict] = None
+
+@dataclass
+class SummaryJob:
+    job_id: str
+    user_id: str
+    original_files: List[str]
+    summary_type: str
+    user_prompt: str
+    status: str
+    created_at: str
+    completed_at: Optional[str] = None
+    summary_text: Optional[str] = None
+    processed_files: Optional[Dict] = None
+    extracted_images: Optional[List[str]] = None
+    transcript_text: Optional[str] = None
+    error_message: Optional[str] = None
+    settings: Optional[Dict] = None
+
+class AuthManager:
+    """Handle user authentication and PDPA compliance"""
+    
+    @staticmethod
+    def hash_password(password: str) -> str:
+        """Hash password using SHA-256 with salt"""
+        salt = "azure_speech_transcription_salt_2024"  # In production, use environment variable
+        return hashlib.sha256((password + salt).encode()).hexdigest()
+    
+    @staticmethod
+    def verify_password(password: str, password_hash: str) -> bool:
+        """Verify password against hash"""
+        return AuthManager.hash_password(password) == password_hash
+    
+    @staticmethod
+    def validate_email(email: str) -> bool:
+        """Validate email format"""
+        pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        return re.match(pattern, email) is not None
+    
+    @staticmethod
+    def validate_username(username: str) -> bool:
+        """Validate username format"""
+        # Username: 3-30 characters, alphanumeric and underscore only
+        pattern = r'^[a-zA-Z0-9_]{3,30}$'
+        return re.match(pattern, username) is not None
+    
+    @staticmethod
+    def validate_password(password: str) -> Tuple[bool, str]:
+        """Validate password strength"""
+        if len(password) < 8:
+            return False, "Password must be at least 8 characters long"
+        if not re.search(r'[A-Z]', password):
+            return False, "Password must contain at least one uppercase letter"
+        if not re.search(r'[a-z]', password):
+            return False, "Password must contain at least one lowercase letter"
+        if not re.search(r'\d', password):
+            return False, "Password must contain at least one number"
+        return True, "Password is valid"
+
+class ExtendedDatabaseManager:
+    """Enhanced database manager with AI summary support"""
+    
+    def __init__(self, db_path: str = None):
+        self.db_path = db_path or os.path.join(DB_DIR, "transcriptions.db")
+        self.blob_service = BlobServiceClient.from_connection_string(AZURE_BLOB_CONNECTION)
+        self.db_blob_name = "shared/database/transcriptions.db"  # Shared database location
+        self._lock = threading.Lock()
+        self._last_backup_time = 0
+        self._backup_interval = 30  # Backup every 30 seconds at most
+        
+        # Download existing database from blob storage or create new one
+        self.init_database()
+    
+    def _download_db_from_blob(self):
+        """Download database from Azure Blob Storage if it exists"""
+        try:
+            blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER, blob=self.db_blob_name)
+            
+            # Check if blob exists
+            if blob_client.exists():
+                print("📥 Downloading existing shared database from Azure Blob Storage...")
+                
+                # Create temporary file
+                with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+                    temp_path = temp_file.name
+                
+                # Download blob to temporary file
+                with open(temp_path, "wb") as download_file:
+                    download_file.write(blob_client.download_blob().readall())
+                
+                # Move to final location
+                os.makedirs(os.path.dirname(self.db_path), exist_ok=True)
+                shutil.move(temp_path, self.db_path)
+                
+                print("✅ Shared database downloaded successfully")
+                return True
+            else:
+                print("📁 No existing shared database found in blob storage, will create new one")
+                return False
+                
+        except Exception as e:
+            print(f"⚠️ Warning: Could not download shared database from blob storage: {e}")
+            print("📁 Will create new local database")
+            return False
+    
+    def _upload_db_to_blob(self):
+        """Upload database to Azure Blob Storage with rate limiting"""
+        try:
+            current_time = time.time()
+            if current_time - self._last_backup_time < self._backup_interval:
+                return  # Skip backup if too recent
+            
+            if not os.path.exists(self.db_path):
+                return
+            
+            blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER, blob=self.db_blob_name)
+            
+            with open(self.db_path, "rb") as data:
+                blob_client.upload_blob(data, overwrite=True)
+            
+            self._last_backup_time = current_time
+            
+        except Exception as e:
+            print(f"⚠️ Warning: Could not upload shared database to blob storage: {e}")
+    
+    @contextmanager
+    def get_connection(self):
+        with self._lock:
+            conn = sqlite3.connect(self.db_path, timeout=30.0)
+            conn.row_factory = sqlite3.Row
+            try:
+                yield conn
+            finally:
+                conn.close()
+                # Auto-backup after any database operation (rate limited)
+                threading.Thread(target=self._upload_db_to_blob, daemon=True).start()
+    
+    def init_database(self):
+        # Try to download existing database first
+        self._download_db_from_blob()
+        
+        # Initialize database structure
+        with self.get_connection() as conn:
+            # Users table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS users (
+                    user_id TEXT PRIMARY KEY,
+                    email TEXT UNIQUE NOT NULL,
+                    username TEXT UNIQUE NOT NULL,
+                    password_hash TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    last_login TEXT,
+                    is_active BOOLEAN DEFAULT 1,
+                    gdpr_consent BOOLEAN DEFAULT 0,
+                    data_retention_agreed BOOLEAN DEFAULT 0,
+                    marketing_consent BOOLEAN DEFAULT 0
+                )
+            """)
+            
+            # Transcriptions table
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS transcriptions (
+                    job_id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    original_filename TEXT NOT NULL,
+                    audio_url TEXT,
+                    language TEXT NOT NULL,
+                    status TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    completed_at TEXT,
+                    transcript_text TEXT,
+                    transcript_url TEXT,
+                    error_message TEXT,
+                    azure_trans_id TEXT,
+                    settings TEXT,
+                    FOREIGN KEY (user_id) REFERENCES users (user_id)
+                )
+            """)
+            
+            # AI Summary jobs table - ENHANCED for better storage
+            conn.execute("""
+                CREATE TABLE IF NOT EXISTS summary_jobs (
+                    job_id TEXT PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    summary_type TEXT NOT NULL,
+                    user_prompt TEXT,
+                    status TEXT NOT NULL,
+                    created_at TEXT NOT NULL,
+                    completed_at TEXT,
+                    summary_text TEXT,
+                    summary_url TEXT,  -- URL to blob storage file
+                    processed_files TEXT,  -- JSON string
+                    extracted_images TEXT,  -- JSON string of image URLs
+                    transcript_job_ids TEXT,  -- JSON string of referenced transcript job IDs
+                    original_files TEXT,  -- JSON string of original file names
+                    error_message TEXT,
+                    settings TEXT,  -- JSON string
+                    FOREIGN KEY (user_id) REFERENCES users (user_id)
+                )
+            """)
+            
+            # Create indexes
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_users_email ON users(email)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_users_username ON users(username)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_transcriptions_user_id ON transcriptions(user_id)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_transcriptions_status ON transcriptions(status)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_transcriptions_created_at ON transcriptions(created_at DESC)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_transcriptions_user_created ON transcriptions(user_id, created_at DESC)")
+            
+            # Summary job indexes
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_summary_jobs_user_id ON summary_jobs(user_id)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_summary_jobs_status ON summary_jobs(status)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_summary_jobs_created_at ON summary_jobs(created_at DESC)")
+            conn.execute("CREATE INDEX IF NOT EXISTS idx_summary_jobs_user_created ON summary_jobs(user_id, created_at DESC)")
+            
+            conn.commit()
+            print("✅ Database initialized with AI summary support")
+    
+    # User management methods
+    def create_user(self, email: str, username: str, password: str, gdpr_consent: bool = True, 
+                   data_retention_agreed: bool = True, marketing_consent: bool = False) -> Tuple[bool, str, Optional[str]]:
+        """Create new user account"""
+        try:
+            # Validate inputs
+            if not AuthManager.validate_email(email):
+                return False, "Invalid email format", None
+            
+            if not AuthManager.validate_username(username):
+                return False, "Username must be 3-30 characters, alphanumeric and underscore only", None
+            
+            is_valid, message = AuthManager.validate_password(password)
+            if not is_valid:
+                return False, message, None
+            
+            if not gdpr_consent:
+                return False, "GDPR consent is required to create an account", None
+            
+            if not data_retention_agreed:
+                return False, "Data retention agreement is required", None
+            
+            user_id = str(uuid.uuid4())
+            password_hash = AuthManager.hash_password(password)
+            
+            with self.get_connection() as conn:
+                # Check if email or username already exists
+                existing = conn.execute(
+                    "SELECT email, username FROM users WHERE email = ? OR username = ?",
+                    (email, username)
+                ).fetchone()
+                
+                if existing:
+                    if existing['email'] == email:
+                        return False, "Email already registered", None
+                    else:
+                        return False, "Username already taken", None
+                
+                # Create user
+                user = User(
+                    user_id=user_id,
+                    email=email,
+                    username=username,
+                    password_hash=password_hash,
+                    created_at=datetime.now().isoformat(),
+                    gdpr_consent=gdpr_consent,
+                    data_retention_agreed=data_retention_agreed,
+                    marketing_consent=marketing_consent
+                )
+                
+                conn.execute("""
+                    INSERT INTO users 
+                    (user_id, email, username, password_hash, created_at, is_active, 
+                     gdpr_consent, data_retention_agreed, marketing_consent)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    user.user_id, user.email, user.username, user.password_hash,
+                    user.created_at, user.is_active, user.gdpr_consent,
+                    user.data_retention_agreed, user.marketing_consent
+                ))
+                conn.commit()
+                
+                print(f"👤 New user registered: {username} ({email})")
+                return True, "Account created successfully", user_id
+                
+        except Exception as e:
+            print(f"❌ Error creating user: {str(e)}")
+            return False, f"Registration failed: {str(e)}", None
+    
+    def authenticate_user(self, login: str, password: str) -> Tuple[bool, str, Optional[User]]:
+        """Authenticate user by email or username"""
+        try:
+            with self.get_connection() as conn:
+                # Find user by email or username
+                user_row = conn.execute("""
+                    SELECT * FROM users 
+                    WHERE (email = ? OR username = ?) AND is_active = 1
+                """, (login, login)).fetchone()
+                
+                if not user_row:
+                    return False, "Invalid credentials", None
+                
+                # Verify password
+                if not AuthManager.verify_password(password, user_row['password_hash']):
+                    return False, "Invalid credentials", None
+                
+                # Update last login
+                conn.execute(
+                    "UPDATE users SET last_login = ? WHERE user_id = ?",
+                    (datetime.now().isoformat(), user_row['user_id'])
+                )
+                conn.commit()
+                
+                # Convert to User object
+                user = User(
+                    user_id=user_row['user_id'],
+                    email=user_row['email'],
+                    username=user_row['username'],
+                    password_hash=user_row['password_hash'],
+                    created_at=user_row['created_at'],
+                    last_login=datetime.now().isoformat(),
+                    is_active=bool(user_row['is_active']),
+                    gdpr_consent=bool(user_row['gdpr_consent']),
+                    data_retention_agreed=bool(user_row['data_retention_agreed']),
+                    marketing_consent=bool(user_row['marketing_consent'])
+                )
+                
+                print(f"🔐 User logged in: {user.username} ({user.email})")
+                return True, "Login successful", user
+                
+        except Exception as e:
+            print(f"❌ Authentication error: {str(e)}")
+            return False, f"Login failed: {str(e)}", None
+    
+    def get_user_by_id(self, user_id: str) -> Optional[User]:
+        """Get user by ID"""
+        try:
+            with self.get_connection() as conn:
+                user_row = conn.execute(
+                    "SELECT * FROM users WHERE user_id = ? AND is_active = 1",
+                    (user_id,)
+                ).fetchone()
+                
+                if user_row:
+                    return User(
+                        user_id=user_row['user_id'],
+                        email=user_row['email'],
+                        username=user_row['username'],
+                        password_hash=user_row['password_hash'],
+                        created_at=user_row['created_at'],
+                        last_login=user_row['last_login'],
+                        is_active=bool(user_row['is_active']),
+                        gdpr_consent=bool(user_row['gdpr_consent']),
+                        data_retention_agreed=bool(user_row['data_retention_agreed']),
+                        marketing_consent=bool(user_row['marketing_consent'])
+                    )
+        except Exception as e:
+            print(f"❌ Error getting user: {str(e)}")
+        return None
+    
+    def update_user_consent(self, user_id: str, marketing_consent: bool) -> bool:
+        """Update user marketing consent"""
+        try:
+            with self.get_connection() as conn:
+                conn.execute(
+                    "UPDATE users SET marketing_consent = ? WHERE user_id = ?",
+                    (marketing_consent, user_id)
+                )
+                conn.commit()
+                return True
+        except Exception as e:
+            print(f"❌ Error updating consent: {str(e)}")
+            return False
+    
+    def delete_user_account(self, user_id: str) -> bool:
+        """Delete user account and all associated data (GDPR compliance)"""
+        try:
+            with self.get_connection() as conn:
+                # Delete all transcriptions and summaries
+                conn.execute("DELETE FROM transcriptions WHERE user_id = ?", (user_id,))
+                conn.execute("DELETE FROM summary_jobs WHERE user_id = ?", (user_id,))
+                
+                # Deactivate user (for audit trail) rather than delete
+                conn.execute(
+                    "UPDATE users SET is_active = 0, email = ?, username = ? WHERE user_id = ?",
+                    (f"deleted_{user_id}@deleted.com", f"deleted_{user_id}", user_id)
+                )
+                conn.commit()
+                print(f"🗑️ User account deleted: {user_id}")
+                return True
+        except Exception as e:
+            print(f"❌ Error deleting user account: {str(e)}")
+            return False
+    
+    # Transcription methods
+    def save_job(self, job: TranscriptionJob):
+        with self.get_connection() as conn:
+            conn.execute("""
+                INSERT OR REPLACE INTO transcriptions 
+                (job_id, user_id, original_filename, audio_url, language, status, 
+                 created_at, completed_at, transcript_text, transcript_url, error_message, 
+                 azure_trans_id, settings)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, (
+                job.job_id, job.user_id, job.original_filename, job.audio_url,
+                job.language, job.status, job.created_at, job.completed_at,
+                job.transcript_text, job.transcript_url, job.error_message,
+                job.azure_trans_id, json.dumps(job.settings) if job.settings else None
+            ))
+            conn.commit()
+    
+    def get_job(self, job_id: str) -> Optional[TranscriptionJob]:
+        with self.get_connection() as conn:
+            row = conn.execute(
+                "SELECT * FROM transcriptions WHERE job_id = ?", (job_id,)
+            ).fetchone()
+            if row:
+                return self._row_to_job(row)
+        return None
+    
+    def get_user_jobs(self, user_id: str, limit: int = 50) -> List[TranscriptionJob]:
+        """Get all transcription jobs for a specific user - PDPA compliant"""
+        with self.get_connection() as conn:
+            rows = conn.execute("""
+                SELECT * FROM transcriptions 
+                WHERE user_id = ? 
+                ORDER BY created_at DESC 
+                LIMIT ?
+            """, (user_id, limit)).fetchall()
+            return [self._row_to_job(row) for row in rows]
+    
+    def get_all_jobs(self, limit: int = 100) -> List[TranscriptionJob]:
+        """Get all jobs across all users (for admin/global view)"""
+        with self.get_connection() as conn:
+            rows = conn.execute("""
+                SELECT * FROM transcriptions 
+                ORDER BY created_at DESC 
+                LIMIT ?
+            """, (limit,)).fetchall()
+            return [self._row_to_job(row) for row in rows]
+    
+    def get_pending_jobs(self) -> List[TranscriptionJob]:
+        """Get pending jobs across all users for background processing"""
+        with self.get_connection() as conn:
+            rows = conn.execute(
+                "SELECT * FROM transcriptions WHERE status IN ('pending', 'processing')"
+            ).fetchall()
+            return [self._row_to_job(row) for row in rows]
+    
+    # AI Summary methods - ENHANCED
+    def save_summary_job(self, job: SummaryJob):
+        """Save AI summary job to database with enhanced storage"""
+        try:
+            with self.get_connection() as conn:
+                # Store summary text to blob storage if completed
+                summary_url = None
+                if job.summary_text and job.status == 'completed':
+                    summary_url = self._store_summary_to_blob(job.job_id, job.summary_text, job.user_id)
+                
+                conn.execute("""
+                    INSERT OR REPLACE INTO summary_jobs 
+                    (job_id, user_id, summary_type, user_prompt, status, created_at, 
+                     completed_at, summary_text, summary_url, processed_files, extracted_images,
+                     transcript_job_ids, original_files, error_message, settings)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """, (
+                    job.job_id, job.user_id, job.summary_type, job.user_prompt,
+                    job.status, job.created_at, job.completed_at, 
+                    job.summary_text, summary_url,
+                    json.dumps(job.processed_files) if job.processed_files else None,
+                    json.dumps(job.extracted_images) if job.extracted_images else None,
+                    json.dumps(job.transcript_text) if hasattr(job, 'transcript_job_ids') and job.transcript_text else None,
+                    json.dumps(job.original_files) if job.original_files else None,
+                    job.error_message,
+                    json.dumps(job.settings) if job.settings else None
+                ))
+                conn.commit()
+                print(f"💾 Summary job saved: {job.job_id[:8]}... (status: {job.status})")
+        except Exception as e:
+            print(f"❌ Error saving summary job: {e}")
+    
+    def _store_summary_to_blob(self, job_id: str, summary_text: str, user_id: str) -> Optional[str]:
+        """Store summary text to Azure Blob Storage"""
+        try:
+            # Create blob path for user's summary in main container
+            blob_name = f"users/{user_id}/summaries/{job_id}_summary.md"
+            
+            # Create markdown content with metadata
+            content = f"""# AI Conference Summary
+*Job ID: {job_id}*
+*Generated: {datetime.now().isoformat()}*
+*User: {user_id}*
+
+---
+
+{summary_text}
+
+---
+*Generated by AI Conference Summarization Service*
+"""
+            
+            # Upload to main blob storage
+            blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER, blob=blob_name)
+            blob_client.upload_blob(content.encode('utf-8'), overwrite=True)
+            
+            # Also store to chat response container
+            self._store_chat_response(job_id, summary_text, user_id)
+            
+            # Return blob URL with SAS token
+            sas = AZURE_BLOB_SAS_TOKEN.lstrip("?")
+            summary_url = f"{blob_client.url}?{sas}"
+            
+            print(f"☁️ Summary stored to blob: {blob_name}")
+            return summary_url
+            
+        except Exception as e:
+            print(f"❌ Error storing summary to blob: {e}")
+            return None
+    
+    def _store_chat_response(self, job_id: str, response_text: str, user_id: str) -> Optional[str]:
+        """Store chat response to dedicated response-chat container"""
+        try:
+            # Create blob path for chat response
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            chat_blob_name = f"users/{user_id}/responses/{timestamp}_{job_id}.txt"
+            
+            # Create response content with metadata
+            content = f"""User ID: {user_id}
+Job ID: {job_id}
+Timestamp: {datetime.now().isoformat()}
+Type: AI_Summary_Response
+
+---
+
+{response_text}
+"""
+            
+            # Upload to chat response container
+            chat_blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER_CHAT, blob=chat_blob_name)
+            chat_blob_client.upload_blob(content.encode('utf-8'), overwrite=True)
+            
+            # Return chat blob URL with SAS token
+            sas = AZURE_BLOB_SAS_TOKEN.lstrip("?")
+            chat_url = f"{chat_blob_client.url}?{sas}"
+            
+            print(f"💬 Chat response stored to: {AZURE_CONTAINER_CHAT}/{chat_blob_name}")
+            return chat_url
+            
+        except Exception as e:
+            print(f"❌ Error storing chat response: {e}")
+            return None
+    
+    def get_user_chat_responses(self, user_id: str, limit: int = 50) -> List[Dict]:
+        """Get user's chat responses from the response-chat container"""
+        try:
+            container_client = self.blob_service.get_container_client(AZURE_CONTAINER_CHAT)
+            responses = []
+            
+            # List blobs for this user
+            blob_prefix = f"users/{user_id}/responses/"
+            blob_list = container_client.list_blobs(name_starts_with=blob_prefix)
+            
+            # Sort by last modified (newest first) and limit
+            sorted_blobs = sorted(blob_list, key=lambda x: x.last_modified, reverse=True)[:limit]
+            
+            for blob in sorted_blobs:
+                try:
+                    # Download blob content
+                    blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER_CHAT, blob=blob.name)
+                    content = blob_client.download_blob().readall().decode('utf-8')
+                    
+                    # Parse metadata from content
+                    lines = content.split('\n')
+                    metadata = {}
+                    content_start = 0
+                    
+                    for i, line in enumerate(lines):
+                        if line.strip() == '---':
+                            content_start = i + 1
+                            break
+                        if ':' in line:
+                            key, value = line.split(':', 1)
+                            metadata[key.strip()] = value.strip()
+                    
+                    response_content = '\n'.join(lines[content_start:]).strip()
+                    
+                    responses.append({
+                        'blob_name': blob.name,
+                        'job_id': metadata.get('Job ID', ''),
+                        'timestamp': metadata.get('Timestamp', ''),
+                        'type': metadata.get('Type', 'Unknown'),
+                        'content': response_content,
+                        'last_modified': blob.last_modified.isoformat(),
+                        'size': blob.size
+                    })
+                    
+                except Exception as e:
+                    print(f"Error processing chat response blob {blob.name}: {e}")
+                    continue
+            
+            return responses
+            
+        except Exception as e:
+            print(f"❌ Error getting user chat responses: {e}")
+            return []
+    
+    def get_summary_job(self, job_id: str) -> Optional[SummaryJob]:
+        """Get AI summary job by ID"""
+        with self.get_connection() as conn:
+            row = conn.execute(
+                "SELECT * FROM summary_jobs WHERE job_id = ?", (job_id,)
+            ).fetchone()
+            if row:
+                return self._row_to_summary_job(row)
+        return None
+    
+    def get_user_summary_jobs(self, user_id: str, limit: int = 50) -> List[SummaryJob]:
+        """Get AI summary jobs for a specific user"""
+        with self.get_connection() as conn:
+            rows = conn.execute("""
+                SELECT * FROM summary_jobs 
+                WHERE user_id = ? 
+                ORDER BY created_at DESC 
+                LIMIT ?
+            """, (user_id, limit)).fetchall()
+            return [self._row_to_summary_job(row) for row in rows]
+    
+    def get_pending_summary_jobs(self) -> List[SummaryJob]:
+        """Get pending AI summary jobs for background processing"""
+        with self.get_connection() as conn:
+            rows = conn.execute(
+                "SELECT * FROM summary_jobs WHERE status IN ('pending', 'processing')"
+            ).fetchall()
+            return [self._row_to_summary_job(row) for row in rows]
+    
+    # Statistics methods - ENHANCED
+    def get_user_stats(self, user_id: str) -> Dict:
+        """Get basic statistics for a specific user"""
+        with self.get_connection() as conn:
+            stats = {}
+            
+            # Total transcription jobs
+            result = conn.execute("""
+                SELECT COUNT(*) FROM transcriptions WHERE user_id = ?
+            """, (user_id,)).fetchone()
+            stats['total_jobs'] = result[0] if result else 0
+            
+            # Transcription jobs by status
+            result = conn.execute("""
+                SELECT status, COUNT(*) FROM transcriptions 
+                WHERE user_id = ? 
+                GROUP BY status
+            """, (user_id,)).fetchall()
+            stats['by_status'] = {row[0]: row[1] for row in result}
+            
+            # Recent activity (last 7 days)
+            week_ago = (datetime.now() - timedelta(days=7)).isoformat()
+            result = conn.execute("""
+                SELECT COUNT(*) FROM transcriptions 
+                WHERE user_id = ? AND created_at >= ?
+            """, (user_id, week_ago)).fetchone()
+            stats['recent_jobs'] = result[0] if result else 0
+            
+            return stats
+    
+    def get_user_stats_extended(self, user_id: str) -> Dict:
+        """Get extended user statistics including AI summaries"""
+        stats = self.get_user_stats(user_id)  # Get existing transcription stats
+        
+        with self.get_connection() as conn:
+            # Add summary job stats
+            result = conn.execute("""
+                SELECT COUNT(*) FROM summary_jobs WHERE user_id = ?
+            """, (user_id,)).fetchone()
+            stats['total_summary_jobs'] = result[0] if result else 0
+            
+            # Summary jobs by status
+            result = conn.execute("""
+                SELECT status, COUNT(*) FROM summary_jobs 
+                WHERE user_id = ? 
+                GROUP BY status
+            """, (user_id,)).fetchall()
+            stats['summary_by_status'] = {row[0]: row[1] for row in result}
+            
+            # Recent summary activity (last 7 days)
+            week_ago = (datetime.now() - timedelta(days=7)).isoformat()
+            result = conn.execute("""
+                SELECT COUNT(*) FROM summary_jobs 
+                WHERE user_id = ? AND created_at >= ?
+            """, (user_id, week_ago)).fetchone()
+            stats['recent_summary_jobs'] = result[0] if result else 0
+        
+        return stats
+    
+    def export_user_data(self, user_id: str) -> Dict:
+        """Export all user data for GDPR compliance"""
+        try:
+            with self.get_connection() as conn:
+                # Get user info
+                user_row = conn.execute(
+                    "SELECT * FROM users WHERE user_id = ?", (user_id,)
+                ).fetchone()
+                
+                # Get all transcriptions
+                transcription_rows = conn.execute(
+                    "SELECT * FROM transcriptions WHERE user_id = ?", (user_id,)
+                ).fetchall()
+                
+                # Get all AI summaries
+                summary_rows = conn.execute(
+                    "SELECT * FROM summary_jobs WHERE user_id = ?", (user_id,)
+                ).fetchall()
+                
+                export_data = {
+                    "export_date": datetime.now().isoformat(),
+                    "user_info": dict(user_row) if user_row else {},
+                    "transcriptions": [dict(row) for row in transcription_rows],
+                    "ai_summaries": [dict(row) for row in summary_rows],
+                    "statistics": self.get_user_stats_extended(user_id)
+                }
+                
+                return export_data
+                
+        except Exception as e:
+            print(f"❌ Error exporting user data: {str(e)}")
+            return {}
+    
+    def _row_to_job(self, row) -> TranscriptionJob:
+        settings = json.loads(row['settings']) if row['settings'] else None
+        return TranscriptionJob(
+            job_id=row['job_id'],
+            user_id=row['user_id'],
+            original_filename=row['original_filename'],
+            audio_url=row['audio_url'],
+            language=row['language'],
+            status=row['status'],
+            created_at=row['created_at'],
+            completed_at=row['completed_at'],
+            transcript_text=row['transcript_text'],
+            transcript_url=row['transcript_url'],
+            error_message=row['error_message'],
+            azure_trans_id=row['azure_trans_id'],
+            settings=settings
+        )
+    
+    def _row_to_summary_job(self, row) -> SummaryJob:
+        """Convert database row to SummaryJob object"""
+        processed_files = json.loads(row['processed_files']) if row['processed_files'] else None
+        extracted_images = json.loads(row['extracted_images']) if row['extracted_images'] else None
+        original_files = json.loads(row['original_files']) if row['original_files'] else []
+        settings = json.loads(row['settings']) if row['settings'] else None
+        
+        return SummaryJob(
+            job_id=row['job_id'],
+            user_id=row['user_id'],
+            original_files=original_files,
+            summary_type=row['summary_type'],
+            user_prompt=row['user_prompt'],
+            status=row['status'],
+            created_at=row['created_at'],
+            completed_at=row['completed_at'],
+            summary_text=row['summary_text'],
+            processed_files=processed_files,
+            extracted_images=extracted_images,
+            error_message=row['error_message'],
+            settings=settings
+        )
+
+class TranscriptionManager:
+    def __init__(self):
+        self.db = ExtendedDatabaseManager()
+        self.executor = ThreadPoolExecutor(max_workers=5)
+        self.blob_service = BlobServiceClient.from_connection_string(AZURE_BLOB_CONNECTION)
+        self._job_status_cache = {}  # Cache to track status changes
+        
+        # Start background worker
+        self.running = True
+        self.worker_thread = threading.Thread(target=self._background_worker, daemon=True)
+        self.worker_thread.start()
+    
+    def _log_status_change(self, job_id: str, old_status: str, new_status: str, filename: str = "", user_id: str = ""):
+        """Only log when status actually changes"""
+        cache_key = f"{job_id}_{old_status}_{new_status}"
+        if cache_key not in self._job_status_cache:
+            self._job_status_cache[cache_key] = True
+            user_display = f"[{user_id[:8]}...]" if user_id else ""
+            if filename:
+                print(f"🔄 {user_display} Job {job_id[:8]}... ({filename}): {old_status} → {new_status}")
+            else:
+                print(f"🔄 {user_display} Job {job_id[:8]}...: {old_status} → {new_status}")
+    
+    def _background_worker(self):
+        """Background worker to process pending transcriptions - minimal logging"""
+        iteration_count = 0
+        while self.running:
+            try:
+                pending_jobs = self.db.get_pending_jobs()
+                
+                # Only log if there are jobs to process
+                if pending_jobs and iteration_count % 6 == 0:  # Log every minute (6 * 10 seconds)
+                    active_jobs = len([j for j in pending_jobs if j.status == 'processing'])
+                    queued_jobs = len([j for j in pending_jobs if j.status == 'pending'])
+                    if active_jobs > 0 or queued_jobs > 0:
+                        print(f"📊 Background worker: {active_jobs} processing, {queued_jobs} queued")
+                
+                for job in pending_jobs:
+                    if job.status == 'pending':
+                        self.executor.submit(self._process_transcription_job, job.job_id)
+                    elif job.status == 'processing' and job.azure_trans_id:
+                        self.executor.submit(self._check_transcription_status, job.job_id)
+                
+                time.sleep(10)  # Check every 10 seconds
+                iteration_count += 1
+                
+            except Exception as e:
+                print(f"❌ Background worker error: {e}")
+                time.sleep(30)
+    
+    def submit_transcription(
+        self, 
+        file_bytes: bytes, 
+        original_filename: str,
+        user_id: str,  # Use user_id for authentication
+        language: str,
+        settings: Dict
+    ) -> str:
+        """Submit a new transcription job for authenticated user"""
+        job_id = str(uuid.uuid4())
+        
+        print(f"🚀 [{user_id[:8]}...] New transcription: {original_filename} ({len(file_bytes):,} bytes)")
+        
+        # Create job record
+        job = TranscriptionJob(
+            job_id=job_id,
+            user_id=user_id,
+            original_filename=original_filename,
+            audio_url="",  # Will be set after upload
+            language=language,
+            status="pending",
+            created_at=datetime.now().isoformat(),
+            settings=settings
+        )
+        
+        # Save job to database
+        self.db.save_job(job)
+        
+        # Submit file processing to thread pool
+        self.executor.submit(self._prepare_audio_file, job_id, file_bytes, original_filename, settings)
+        
+        return job_id
+    
+    def _prepare_audio_file(self, job_id: str, file_bytes: bytes, original_filename: str, settings: Dict):
+        """Prepare audio file and upload to blob storage"""
+        try:
+            job = self.db.get_job(job_id)
+            if not job:
+                return
+            
+            user_id = job.user_id
+            
+            # Save original file
+            src_ext = original_filename.split('.')[-1].lower() if '.' in original_filename else "bin"
+            upload_path = os.path.join(UPLOAD_DIR, f"{job_id}_original.{src_ext}")
+            
+            with open(upload_path, "wb") as f:
+                f.write(file_bytes)
+            
+            # Determine if conversion is needed
+            audio_format = settings.get('audio_format', 'wav')
+            
+            # Check if file is already in target format and specs
+            if src_ext == audio_format and audio_format == 'wav':
+                # Check if it's already 16kHz mono (Azure Speech preferred format)
+                try:
+                    probe_cmd = [
+                        'ffprobe', '-v', 'quiet', '-print_format', 'json', 
+                        '-show_streams', upload_path
+                    ]
+                    result = subprocess.run(probe_cmd, capture_output=True, text=True, timeout=30)
+                    
+                    if result.returncode == 0:
+                        import json
+                        probe_data = json.loads(result.stdout)
+                        audio_stream = probe_data.get('streams', [{}])[0]
+                        
+                        sample_rate = int(audio_stream.get('sample_rate', 0))
+                        channels = int(audio_stream.get('channels', 0))
+                        
+                        # If already optimal format, use as-is
+                        if sample_rate == 16000 and channels == 1:
+                            out_path = upload_path  # Use original file
+                        else:
+                            print(f"🔄 [{user_id[:8]}...] Converting {original_filename} to 16kHz mono")
+                            out_path = os.path.join(UPLOAD_DIR, f"{job_id}_converted.{audio_format}")
+                            self._convert_to_audio(upload_path, out_path, audio_format)
+                    else:
+                        out_path = os.path.join(UPLOAD_DIR, f"{job_id}_converted.{audio_format}")
+                        self._convert_to_audio(upload_path, out_path, audio_format)
+                        
+                except Exception as e:
+                    print(f"⚠️ [{user_id[:8]}...] Audio probing failed for {original_filename}: {e}")
+                    out_path = os.path.join(UPLOAD_DIR, f"{job_id}_converted.{audio_format}")
+                    self._convert_to_audio(upload_path, out_path, audio_format)
+            else:
+                # Different format, need conversion
+                print(f"🔄 [{user_id[:8]}...] Converting {original_filename}: {src_ext} → {audio_format}")
+                out_path = os.path.join(UPLOAD_DIR, f"{job_id}_converted.{audio_format}")
+                
+                try:
+                    self._convert_to_audio(upload_path, out_path, audio_format)
+                except Exception as e:
+                    print(f"❌ [{user_id[:8]}...] Audio conversion failed for {original_filename}: {str(e)}")
+                    job.status = "failed"
+                    job.error_message = f"Audio conversion failed: {str(e)}"
+                    job.completed_at = datetime.now().isoformat()
+                    self.db.save_job(job)
+                    
+                    # Clean up files
+                    try:
+                        os.remove(upload_path)
+                    except:
+                        pass
+                    return
+            
+            # Upload to blob storage
+            try:
+                # Upload the processed audio file
+                final_audio_name = f"users/{user_id}/audio/{job_id}.{audio_format}"
+                audio_url = self._upload_blob(out_path, final_audio_name)
+                
+                # Upload original file to blob storage (only if different from processed)
+                if out_path != upload_path:
+                    orig_blob_name = f"users/{user_id}/originals/{job_id}_{original_filename}"
+                    self._upload_blob(upload_path, orig_blob_name)
+                else:
+                    # If we used the original file as-is, still store it as original
+                    orig_blob_name = f"users/{user_id}/originals/{job_id}_{original_filename}"
+                    self._upload_blob(upload_path, orig_blob_name)
+                
+                print(f"☁️ [{user_id[:8]}...] {original_filename} uploaded to blob storage")
+                
+                # Update job with audio URL
+                job.audio_url = audio_url
+                job.status = "pending"
+                self.db.save_job(job)
+                
+            except Exception as e:
+                print(f"❌ [{user_id[:8]}...] Blob upload failed for {original_filename}: {str(e)}")
+                job.status = "failed"
+                job.error_message = f"Blob storage upload failed: {str(e)}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+                
+            # Clean up local files
+            try:
+                if os.path.exists(upload_path):
+                    os.remove(upload_path)
+                if out_path != upload_path and os.path.exists(out_path):
+                    os.remove(out_path)
+            except Exception as e:
+                print(f"⚠️ [{user_id[:8]}...] Warning: Could not clean up local files for {original_filename}: {e}")
+                
+        except Exception as e:
+            print(f"❌ File preparation error for {original_filename}: {e}")
+            job = self.db.get_job(job_id)
+            if job:
+                job.status = "failed"
+                job.error_message = f"File preparation failed: {str(e)}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+    
+    def _process_transcription_job(self, job_id: str):
+        """Process a transcription job"""
+        try:
+            job = self.db.get_job(job_id)
+            if not job or job.status != 'pending' or not job.audio_url:
+                return
+            
+            old_status = job.status
+            # Update status to processing
+            job.status = "processing"
+            self.db.save_job(job)
+            
+            self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+            
+            # Create Azure transcription
+            settings = job.settings or {}
+            azure_trans_id = self._create_transcription(
+                job.audio_url,
+                job.language,
+                settings.get('diarization_enabled', False),
+                settings.get('speakers', 2),
+                settings.get('profanity', 'masked'),
+                settings.get('punctuation', 'automatic'),
+                settings.get('timestamps', True),
+                settings.get('lexical', False),
+                settings.get('language_id_enabled', False),
+                settings.get('candidate_locales', None)
+            )
+            
+            # Update job with Azure transcription ID
+            job.azure_trans_id = azure_trans_id
+            self.db.save_job(job)
+            
+        except Exception as e:
+            print(f"❌ Transcription submission failed for job {job_id[:8]}...: {str(e)}")
+            job = self.db.get_job(job_id)
+            if job:
+                old_status = job.status
+                job.status = "failed"
+                job.error_message = f"Transcription submission failed: {str(e)}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+                self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+    
+    def _check_transcription_status(self, job_id: str):
+        """Check status of Azure transcription"""
+        try:
+            job = self.db.get_job(job_id)
+            if not job or job.status != 'processing' or not job.azure_trans_id:
+                return
+            
+            # Check Azure transcription status
+            url = f"{AZURE_SPEECH_KEY_ENDPOINT}/speechtotext/{API_VERSION}/transcriptions/{job.azure_trans_id}"
+            headers = {"Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY}
+            
+            r = requests.get(url, headers=headers)
+            data = r.json()
+            
+            if data.get("status") == "Succeeded":
+                # Get transcription result
+                content_url = self._get_transcription_result_url(job.azure_trans_id)
+                if content_url:
+                    transcript = self._fetch_transcript(content_url)
+                    
+                    # Save transcript to blob storage
+                    transcript_blob_name = f"users/{job.user_id}/transcripts/{job_id}.txt"
+                    transcript_path = os.path.join(UPLOAD_DIR, f"{job_id}_transcript.txt")
+                    
+                    with open(transcript_path, "w", encoding="utf-8") as f:
+                        f.write(transcript)
+                    
+                    transcript_url = self._upload_blob(transcript_path, transcript_blob_name)
+                    
+                    # Update job
+                    old_status = job.status
+                    job.status = "completed"
+                    job.transcript_text = transcript
+                    job.transcript_url = transcript_url
+                    job.completed_at = datetime.now().isoformat()
+                    self.db.save_job(job)
+                    
+                    self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+                    print(f"✅ [{job.user_id[:8]}...] Transcription completed: {job.original_filename}")
+                    
+                    # Clean up
+                    try:
+                        os.remove(transcript_path)
+                    except:
+                        pass
+                        
+            elif data.get("status") in ("Failed", "FailedWithPartialResults"):
+                error_message = ""
+                if "properties" in data and "error" in data["properties"]:
+                    error_message = data["properties"]["error"].get("message", "")
+                elif "error" in data:
+                    error_message = data["error"].get("message", "")
+                
+                old_status = job.status
+                job.status = "failed"
+                job.error_message = f"Azure transcription failed: {error_message}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+                
+                self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+                print(f"❌ [{job.user_id[:8]}...] Transcription failed: {job.original_filename} - {error_message}")
+                
+        except Exception as e:
+            print(f"❌ Status check failed for job {job_id[:8]}...: {str(e)}")
+            job = self.db.get_job(job_id)
+            if job:
+                old_status = job.status
+                job.status = "failed"
+                job.error_message = f"Status check failed: {str(e)}"
+                job.completed_at = datetime.now().isoformat()
+                self.db.save_job(job)
+                self._log_status_change(job_id, old_status, job.status, job.original_filename, job.user_id)
+    
+    def get_job_status(self, job_id: str) -> Optional[TranscriptionJob]:
+        """Get current job status"""
+        return self.db.get_job(job_id)
+    
+    def get_user_history(self, user_id: str, limit: int = 50) -> List[TranscriptionJob]:
+        """Get user's transcription history - PDPA compliant"""
+        return self.db.get_user_jobs(user_id, limit)
+    
+    def get_all_history(self, limit: int = 100) -> List[TranscriptionJob]:
+        """Get all transcription history across all users (admin view)"""
+        return self.db.get_all_jobs(limit)
+    
+    def get_user_stats(self, user_id: str) -> Dict:
+        """Get user statistics"""
+        return self.db.get_user_stats(user_id)
+    
+    def get_user_stats_extended(self, user_id: str) -> Dict:
+        """Get extended user statistics including AI summaries"""
+        return self.db.get_user_stats_extended(user_id)
+    
+    def download_transcript(self, job_id: str, user_id: str) -> Optional[str]:
+        """Download transcript content - with user verification for PDPA compliance"""
+        job = self.db.get_job(job_id)
+        if job and job.user_id == user_id and job.transcript_text:
+            return job.transcript_text
+        return None
+    
+    # AI Summary methods - ENHANCED integration
+    def save_summary_job(self, job: SummaryJob):
+        """Save AI summary job"""
+        self.db.save_summary_job(job)
+    
+    def get_summary_job(self, job_id: str) -> Optional[SummaryJob]:
+        """Get AI summary job by ID"""
+        return self.db.get_summary_job(job_id)
+    
+    def get_user_summary_history(self, user_id: str, limit: int = 50) -> List[SummaryJob]:
+        """Get user's AI summary history"""
+        return self.db.get_user_summary_jobs(user_id, limit)
+    
+    # Authentication methods
+    def register_user(self, email: str, username: str, password: str, gdpr_consent: bool = True,
+                     data_retention_agreed: bool = True, marketing_consent: bool = False) -> Tuple[bool, str, Optional[str]]:
+        """Register new user"""
+        return self.db.create_user(email, username, password, gdpr_consent, data_retention_agreed, marketing_consent)
+    
+    def login_user(self, login: str, password: str) -> Tuple[bool, str, Optional[User]]:
+        """Login user"""
+        return self.db.authenticate_user(login, password)
+    
+    def get_user(self, user_id: str) -> Optional[User]:
+        """Get user by ID"""
+        return self.db.get_user_by_id(user_id)
+    
+    def update_user_consent(self, user_id: str, marketing_consent: bool) -> bool:
+        """Update user marketing consent"""
+        return self.db.update_user_consent(user_id, marketing_consent)
+    
+    def export_user_data(self, user_id: str) -> Dict:
+        """Export all user data for GDPR compliance"""
+        return self.db.export_user_data(user_id)
+    
+    def delete_user_account(self, user_id: str) -> bool:
+        """Delete user account and all data"""
+        return self.db.delete_user_account(user_id)
+    
+    # Helper methods (using existing implementations)
+    def _convert_to_audio(self, input_path, output_path, audio_format="wav"):
+        """Convert audio/video file to specified audio format"""
+        # Ensure output directory exists
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        
+        if audio_format in {"wav", "alaw", "mulaw"}:
+            cmd = [
+                "ffmpeg", "-y", "-i", input_path,
+                "-ar", "16000", "-ac", "1",
+                output_path
+            ]
+        else:
+            cmd = [
+                "ffmpeg", "-y", "-i", input_path,
+                output_path
+            ]
+        
+        try:
+            result = subprocess.run(
+                cmd, 
+                stdout=subprocess.PIPE, 
+                stderr=subprocess.PIPE, 
+                timeout=300,  # 5 minute timeout
+                text=True
+            )
+            
+            if result.returncode != 0:
+                error_output = result.stderr
+                raise Exception(f"FFmpeg conversion failed: {error_output}")
+                
+            # Verify output file exists and has content
+            if not os.path.exists(output_path):
+                raise Exception(f"Output file was not created: {output_path}")
+            
+            file_size = os.path.getsize(output_path)
+            if file_size == 0:
+                raise Exception(f"Output file is empty: {output_path}")
+            
+        except subprocess.TimeoutExpired:
+            raise Exception(f"FFmpeg conversion timed out after 5 minutes")
+        except Exception as e:
+            if "FFmpeg conversion failed" in str(e):
+                raise  # Re-raise our detailed error
+            else:
+                raise Exception(f"FFmpeg error: {str(e)}")
+    
+    def _upload_blob(self, local_file, blob_name):
+        blob_client = self.blob_service.get_blob_client(container=AZURE_CONTAINER, blob=blob_name)
+        with open(local_file, "rb") as data:
+            blob_client.upload_blob(data, overwrite=True)
+        sas = AZURE_BLOB_SAS_TOKEN.lstrip("?")
+        return f"{blob_client.url}?{sas}"
+    
+    def _create_transcription(self, audio_url, language, diarization_enabled, speakers, 
+                            profanity, punctuation, timestamps, lexical, 
+                            language_id_enabled=False, candidate_locales=None):
+        url = f"{AZURE_SPEECH_KEY_ENDPOINT}/speechtotext/{API_VERSION}/transcriptions"
+        headers = {
+            "Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY,
+            "Content-Type": "application/json"
+        }
+
+        properties = {
+            "profanityFilterMode": profanity,
+            "punctuationMode": punctuation,
+            "wordLevelTimestampsEnabled": timestamps,
+            "displayFormWordLevelTimestampsEnabled": timestamps,
+            "lexical": lexical
+        }
+        if diarization_enabled:
+            properties["diarizationEnabled"] = True
+            properties["diarization"] = {
+                "speakers": {
+                    "minCount": 1,
+                    "maxCount": int(speakers)
+                }
+            }
+        if language_id_enabled and candidate_locales:
+            properties["languageIdentification"] = {
+                "mode": "continuous",
+                "candidateLocales": candidate_locales
+            }
+        
+        properties = {k: v for k, v in properties.items() if v is not None}
+        body = {
+            "displayName": f"Transcription_{uuid.uuid4()}",
+            "description": "Batch speech-to-text with advanced options",
+            "locale": language,
+            "contentUrls": [audio_url],
+            "properties": properties,
+            "customProperties": {}
+        }
+        r = requests.post(url, headers=headers, json=body)
+        r.raise_for_status()
+        trans_id = r.headers["Location"].split("/")[-1].split("?")[0]
+        return trans_id
+    
+    def _get_transcription_result_url(self, trans_id):
+        url = f"{AZURE_SPEECH_KEY_ENDPOINT}/speechtotext/{API_VERSION}/transcriptions/{trans_id}"
+        headers = {"Ocp-Apim-Subscription-Key": AZURE_SPEECH_KEY}
+        
+        r = requests.get(url, headers=headers)
+        data = r.json()
+        
+        if data.get("status") == "Succeeded":
+            files_url = None
+            if "links" in data and "files" in data["links"]:
+                files_url = data["links"]["files"]
+            if files_url:
+                r2 = requests.get(files_url, headers=headers)
+                file_list = r2.json().get("values", [])
+                for f in file_list:
+                    if f.get("kind", "").lower() == "transcription":
+                        return f["links"]["contentUrl"]
+        return None
+    
+    def _fetch_transcript(self, content_url):
+        """Enhanced transcript fetching with improved timestamp handling"""
+        r = requests.get(content_url)
+        try:
+            j = r.json()
+            out = []
+            
+            def get_text(phrase):
+                if 'nBest' in phrase and phrase['nBest']:
+                    return phrase['nBest'][0].get('display', '') or phrase.get('display', '')
+                return phrase.get('display', '')
+
+            def safe_offset(val):
+                try:
+                    return int(val)
+                except (ValueError, TypeError):
+                    return None
+
+            def format_time(seconds):
+                """Format seconds into HH:MM:SS format"""
+                try:
+                    td = timedelta(seconds=int(seconds))
+                    hours, remainder = divmod(td.total_seconds(), 3600)
+                    minutes, seconds = divmod(remainder, 60)
+                    return f"{int(hours):02d}:{int(minutes):02d}:{int(seconds):02d}"
+                except:
+                    return "00:00:00"
+
+            # Check if this is a diarization result or regular transcription
+            if 'recognizedPhrases' in j:
+                for phrase in j['recognizedPhrases']:
+                    speaker_id = phrase.get('speaker', 0)  # Default to speaker 0 if not present
+                    text = get_text(phrase)
+                    
+                    if not text.strip():
+                        continue
+                    
+                    # Try to get timestamp from multiple possible locations
+                    timestamp_seconds = None
+                    
+                    # Method 1: Direct offset from phrase
+                    if 'offset' in phrase and phrase['offset'] is not None:
+                        offset_100ns = safe_offset(phrase['offset'])
+                        if offset_100ns is not None:
+                            timestamp_seconds = offset_100ns / 10_000_000
+                    
+                    # Method 2: Offset from first word
+                    if timestamp_seconds is None and 'words' in phrase and phrase['words']:
+                        first_word = phrase['words'][0]
+                        if 'offset' in first_word and first_word['offset'] is not None:
+                            offset_100ns = safe_offset(first_word['offset'])
+                            if offset_100ns is not None:
+                                timestamp_seconds = offset_100ns / 10_000_000
+                    
+                    # Method 3: offsetInTicks (alternative field name)
+                    if timestamp_seconds is None and 'offsetInTicks' in phrase:
+                        offset_ticks = safe_offset(phrase['offsetInTicks'])
+                        if offset_ticks is not None:
+                            timestamp_seconds = offset_ticks / 10_000_000
+                    
+                    # Format output based on whether we have speaker diarization and timestamps
+                    if timestamp_seconds is not None:
+                        time_str = format_time(timestamp_seconds)
+                        if 'speaker' in phrase:
+                            # Speaker diarization with timestamp
+                            out.append(f"[{time_str}] Speaker {speaker_id}: {text}")
+                        else:
+                            # Just timestamp, no speaker
+                            out.append(f"[{time_str}] {text}")
+                    else:
+                        # No timestamp available
+                        if 'speaker' in phrase:
+                            out.append(f"Speaker {speaker_id}: {text}")
+                        else:
+                            out.append(text)
+                
+                if out:
+                    return '\n\n'.join(out)
+            
+            # Fallback: handle combined results or other formats
+            if 'combinedRecognizedPhrases' in j:
+                combined_results = []
+                for combined_phrase in j['combinedRecognizedPhrases']:
+                    text = combined_phrase.get('display', '')
+                    if text.strip():
+                        combined_results.append(text)
+                
+                if combined_results:
+                    return '\n\n'.join(combined_results)
+            
+            # Last resort: return raw JSON for debugging
+            return json.dumps(j, ensure_ascii=False, indent=2)
+            
+        except Exception as e:
+            return f"Unable to parse transcription result: {str(e)}\n\nRaw response: {r.text[:1000]}..."
+
+# Global transcription manager instance with AI summary support
+transcription_manager = TranscriptionManager()
+
+# Backward compatibility functions
+def allowed_file(filename):
+    """Check if file extension is supported"""
+    if not filename or filename in ["upload.unknown", ""]:
+        return True  # Let FFmpeg handle unknown formats
+    
+    if '.' not in filename:
+        return True  # No extension, let FFmpeg try
+    
+    ext = filename.rsplit('.', 1)[1].lower()
+    supported_extensions = set(AUDIO_FORMATS) | {
+        'mp4', 'mov', 'avi', 'mkv', 'webm', 'm4a', '3gp', 'f4v', 
+        'wmv', 'asf', 'rm', 'rmvb', 'flv', 'mpg', 'mpeg', 'mts', 'vob'
+    }
+    
+    return ext in supported_extensions
+
+def generate_user_session():
+    """Generate a unique user session ID - kept for compatibility"""
+    return str(uuid.uuid4())
+
+# Keep all existing exports for backward compatibility
+ALLOWED_LANGS = ALLOWED_LANGS
+AUDIO_FORMATS = AUDIO_FORMATS
+allowed_file = allowed_file
+User = User

env_template.sh

@@ -0,0 +1,62 @@
+# Azure Speech Services Configuration
+AZURE_SPEECH_KEY=xxx
+AZURE_SPEECH_KEY_ENDPOINT=https://xxx
+AZURE_REGION=xxx
+
+# Azure Blob Storage Configuration
+AZURE_BLOB_CONNECTION=xxx
+AZURE_CONTAINER=xxx
+AZURE_BLOB_SAS_TOKEN=xxx
+
+# Computer Vision Services Configuration (NEW)
+COMPUTER_VISION_ENDPOINT=https://xxx
+COMPUTER_VISION_KEY=xxx
+COMPUTER_VISION_REGION=xxx
+
+# AI Agents Configuration (NEW)
+AI_PROJECT_ENDPOINT=https://xxx
+AI_PROJECT_KEY=xxx
+AI_AGENT_ID=xxx
+
+# Azure OpenAI Configuration
+AZURE_OPENAI_ENDPOINT=https://xxx
+AZURE_OPENAI_KEY=xxx
+AZURE_OPENAI_DEPLOYMENT=xxx
+AZURE_OPENAI_API_VERSION=xxx
+
+# API Configuration
+API_VERSION=v3.2
+
+# Allowed Languages Configuration
+ALLOWED_LANGS={"en-US": "English (US)", "en-GB": "English (UK)", "es-ES": "Spanish", "fr-FR": "French", "de-DE": "German", "it-IT": "Italian", "pt-BR": "Portuguese (Brazil)", "zh-CN": "Chinese (Simplified)", "ja-JP": "Japanese", "ko-KR": "Korean", "ru-RU": "Russian", "ar-SA": "Arabic", "hi-IN": "Hindi", "th-TH": "Thai", "vi-VN": "Vietnamese", "nl-NL": "Dutch", "sv-SE": "Swedish", "da-DK": "Danish", "no-NO": "Norwegian", "fi-FI": "Finnish", "pl-PL": "Polish", "cs-CZ": "Czech", "hu-HU": "Hungarian", "ro-RO": "Romanian", "bg-BG": "Bulgarian", "hr-HR": "Croatian", "sk-SK": "Slovak", "sl-SI": "Slovenian", "et-EE": "Estonian", "lv-LV": "Latvian", "lt-LT": "Lithuanian", "uk-UA": "Ukrainian", "el-GR": "Greek", "tr-TR": "Turkish", "he-IL": "Hebrew", "fa-IR": "Persian", "ur-PK": "Urdu", "bn-BD": "Bengali", "ta-IN": "Tamil", "te-IN": "Telugu", "ml-IN": "Malayalam", "kn-IN": "Kannada", "gu-IN": "Gujarati", "pa-IN": "Punjabi", "mr-IN": "Marathi", "ne-NP": "Nepali", "si-LK": "Sinhala", "my-MM": "Myanmar", "km-KH": "Khmer", "lo-LA": "Lao", "ka-GE": "Georgian", "am-ET": "Amharic", "sw-TZ": "Swahili", "zu-ZA": "Zulu", "af-ZA": "Afrikaans", "is-IS": "Icelandic", "mt-MT": "Maltese", "cy-GB": "Welsh", "ga-IE": "Irish", "eu-ES": "Basque", "ca-ES": "Catalan", "gl-ES": "Galician", "pt-PT": "Portuguese (Portugal)", "fr-CA": "French (Canada)", "en-AU": "English (Australia)", "en-IN": "English (India)", "en-CA": "English (Canada)", "en-NZ": "English (New Zealand)", "en-ZA": "English (South Africa)", "es-MX": "Spanish (Mexico)", "es-AR": "Spanish (Argentina)", "es-CO": "Spanish (Colombia)", "es-CL": "Spanish (Chile)", "es-PE": "Spanish (Peru)", "es-VE": "Spanish (Venezuela)", "es-EC": "Spanish (Ecuador)", "es-GT": "Spanish (Guatemala)", "es-CR": "Spanish (Costa Rica)", "es-PA": "Spanish (Panama)", "es-DO": "Spanish (Dominican Republic)", "es-PR": "Spanish (Puerto Rico)", "es-UY": "Spanish (Uruguay)", "es-PY": "Spanish (Paraguay)", "es-BO": "Spanish (Bolivia)", "es-SV": "Spanish (El Salvador)", "es-HN": "Spanish (Honduras)", "es-NI": "Spanish (Nicaragua)", "zh-TW": "Chinese (Traditional)", "zh-HK": "Chinese (Hong Kong)"}
+
+# Application Settings
+DEBUG=False
+UPLOAD_MAX_SIZE_MB=500
+MAX_CONCURRENT_JOBS=5
+DATABASE_PATH=xxx/xxx
+CLEANUP_OLDER_THAN_DAYS=30
+
+# # Security Settings (Optional - for enhanced security)
+# SECRET_KEY=your_secret_key_for_sessions
+# ENCRYPTION_KEY=your_encryption_key_for_sensitive_data
+
+# Logging Settings
+LOG_LEVEL=INFO
+LOG_FILE=app.log
+
+# Performance Settings
+FRAME_EXTRACTION_MAX_FRAMES=50
+FRAME_SIMILARITY_THRESHOLD=0.85
+MIN_TIME_BETWEEN_FRAMES=2.0
+
+# File Processing Settings
+SUPPORTED_VIDEO_FORMATS=mp4,mov,avi,mkv,webm,flv,3gp,wmv
+SUPPORTED_AUDIO_FORMATS=wav,mp3,ogg,opus,flac,wma,aac,m4a,amr,speex
+SUPPORTED_DOCUMENT_FORMATS=pdf,docx,doc,pptx,ppt,xlsx,xls,csv,txt,json
+SUPPORTED_IMAGE_FORMATS=jpg,jpeg,png,bmp,gif,tiff,webp
+
+# Database Settings
+DATABASE_BACKUP_INTERVAL=30
+DATABASE_LOCATION=xxx
+TEMP_FILES_CLEANUP_HOURS=24

file_processors.py

@@ -0,0 +1,442 @@
+import os
+import json
+import tempfile
+import subprocess
+from typing import Optional, Dict, Any
+import PyPDF2
+import docx
+from openpyxl import load_workbook
+import pandas as pd
+from pptx import Presentation
+from PIL import Image
+import zipfile
+
+class FileProcessor:
+    """Process various file types and extract text content"""
+    
+    def __init__(self):
+        self.supported_extensions = {
+            'pdf': self._process_pdf,
+            'docx': self._process_docx,
+            'doc': self._process_doc,
+            'pptx': self._process_pptx,
+            'ppt': self._process_ppt,
+            'xlsx': self._process_xlsx,
+            'xls': self._process_xls,
+            'csv': self._process_csv,
+            'txt': self._process_txt,
+            'json': self._process_json,
+            'rtf': self._process_rtf,
+            'odt': self._process_odt,
+            'ods': self._process_ods,
+            'odp': self._process_odp
+        }
+    
+    def process_file(self, file_path: str, extension: str = None) -> Optional[str]:
+        """Process a file and extract its text content"""
+        try:
+            if not os.path.exists(file_path):
+                print(f"❌ File not found: {file_path}")
+                return None
+            
+            # Determine extension if not provided
+            if not extension:
+                extension = file_path.split('.')[-1].lower() if '.' in file_path else ''
+            
+            extension = extension.lower().strip('.')
+            
+            if extension not in self.supported_extensions:
+                print(f"⚠️ Unsupported file extension: {extension}")
+                return f"Unsupported file type: .{extension}"
+            
+            # Process file based on extension
+            processor = self.supported_extensions[extension]
+            content = processor(file_path)
+            
+            if content:
+                print(f"✅ Successfully processed {extension.upper()} file: {os.path.basename(file_path)}")
+                return content
+            else:
+                print(f"⚠️ No content extracted from: {os.path.basename(file_path)}")
+                return f"Could not extract content from {extension.upper()} file"
+                
+        except Exception as e:
+            print(f"❌ Error processing file {file_path}: {e}")
+            return f"Error processing file: {str(e)}"
+    
+    def _process_pdf(self, file_path: str) -> Optional[str]:
+        """Extract text from PDF files"""
+        try:
+            text_content = []
+            
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                
+                for page_num, page in enumerate(pdf_reader.pages):
+                    try:
+                        page_text = page.extract_text()
+                        if page_text.strip():
+                            text_content.append(f"--- Page {page_num + 1} ---")
+                            text_content.append(page_text)
+                            text_content.append("")
+                    except Exception as e:
+                        text_content.append(f"--- Page {page_num + 1} (Error reading) ---")
+                        print(f"⚠️ Error reading PDF page {page_num + 1}: {e}")
+                
+                if not text_content:
+                    # Try alternative PDF processing with pdfplumber if available
+                    try:
+                        import pdfplumber
+                        with pdfplumber.open(file_path) as pdf:
+                            for page_num, page in enumerate(pdf.pages):
+                                page_text = page.extract_text()
+                                if page_text:
+                                    text_content.append(f"--- Page {page_num + 1} ---")
+                                    text_content.append(page_text)
+                                    text_content.append("")
+                    except ImportError:
+                        return "PDF contains non-text content or requires advanced processing"
+                
+                return "\n".join(text_content) if text_content else None
+                
+        except Exception as e:
+            print(f"❌ Error processing PDF: {e}")
+            return None
+    
+    def _process_docx(self, file_path: str) -> Optional[str]:
+        """Extract text from DOCX files"""
+        try:
+            doc = docx.Document(file_path)
+            text_content = []
+            
+            # Extract paragraphs
+            for paragraph in doc.paragraphs:
+                if paragraph.text.strip():
+                    text_content.append(paragraph.text)
+            
+            # Extract tables
+            for table in doc.tables:
+                text_content.append("\n--- Table ---")
+                for row in table.rows:
+                    row_text = []
+                    for cell in row.cells:
+                        row_text.append(cell.text.strip())
+                    text_content.append(" | ".join(row_text))
+                text_content.append("--- End Table ---\n")
+            
+            return "\n".join(text_content) if text_content else None
+            
+        except Exception as e:
+            print(f"❌ Error processing DOCX: {e}")
+            return None
+    
+    def _process_doc(self, file_path: str) -> Optional[str]:
+        """Extract text from DOC files using python-docx2txt or antiword"""
+        try:
+            # Try with docx2txt first
+            try:
+                import docx2txt
+                text = docx2txt.process(file_path)
+                return text if text.strip() else None
+            except ImportError:
+                pass
+            
+            # Try with antiword (if available on system)
+            try:
+                result = subprocess.run(
+                    ['antiword', file_path],
+                    capture_output=True,
+                    text=True,
+                    timeout=30
+                )
+                if result.returncode == 0:
+                    return result.stdout
+            except (subprocess.SubprocessError, FileNotFoundError):
+                pass
+            
+            return "DOC file processing requires additional tools (docx2txt or antiword)"
+            
+        except Exception as e:
+            print(f"❌ Error processing DOC: {e}")
+            return None
+    
+    def _process_pptx(self, file_path: str) -> Optional[str]:
+        """Extract text from PPTX files"""
+        try:
+            presentation = Presentation(file_path)
+            text_content = []
+            
+            for slide_num, slide in enumerate(presentation.slides, 1):
+                slide_text = []
+                slide_text.append(f"--- Slide {slide_num} ---")
+                
+                # Extract text from shapes
+                for shape in slide.shapes:
+                    if hasattr(shape, "text") and shape.text.strip():
+                        slide_text.append(shape.text)
+                
+                # Extract notes
+                if slide.has_notes_slide:
+                    notes_text = slide.notes_slide.notes_text_frame.text
+                    if notes_text.strip():
+                        slide_text.append(f"Notes: {notes_text}")
+                
+                if len(slide_text) > 1:  # More than just the slide header
+                    text_content.extend(slide_text)
+                    text_content.append("")
+            
+            return "\n".join(text_content) if text_content else None
+            
+        except Exception as e:
+            print(f"❌ Error processing PPTX: {e}")
+            return None
+    
+    def _process_ppt(self, file_path: str) -> Optional[str]:
+        """Extract text from PPT files"""
+        try:
+            # Try with python-pptx if the file can be converted
+            # For legacy PPT files, this is more complex
+            return "PPT file processing requires conversion to PPTX format"
+            
+        except Exception as e:
+            print(f"❌ Error processing PPT: {e}")
+            return None
+    
+    def _process_xlsx(self, file_path: str) -> Optional[str]:
+        """Extract text from XLSX files"""
+        try:
+            workbook = load_workbook(file_path, data_only=True)
+            text_content = []
+            
+            for sheet_name in workbook.sheetnames:
+                sheet = workbook[sheet_name]
+                text_content.append(f"--- Sheet: {sheet_name} ---")
+                
+                # Convert to DataFrame for easier processing
+                data = []
+                for row in sheet.iter_rows(values_only=True):
+                    if any(cell is not None for cell in row):
+                        data.append([str(cell) if cell is not None else "" for cell in row])
+                
+                if data:
+                    # Create a simple table representation
+                    for row in data[:100]:  # Limit to first 100 rows
+                        text_content.append(" | ".join(row))
+                
+                text_content.append("")
+            
+            return "\n".join(text_content) if text_content else None
+            
+        except Exception as e:
+            print(f"❌ Error processing XLSX: {e}")
+            return None
+    
+    def _process_xls(self, file_path: str) -> Optional[str]:
+        """Extract text from XLS files"""
+        try:
+            # Use pandas to read XLS files
+            xl_file = pd.ExcelFile(file_path)
+            text_content = []
+            
+            for sheet_name in xl_file.sheet_names:
+                text_content.append(f"--- Sheet: {sheet_name} ---")
+                
+                df = pd.read_excel(file_path, sheet_name=sheet_name)
+                
+                # Convert DataFrame to string representation
+                if not df.empty:
+                    # Get first 100 rows
+                    limited_df = df.head(100)
+                    text_content.append(limited_df.to_string(index=False))
+                
+                text_content.append("")
+            
+            return "\n".join(text_content) if text_content else None
+            
+        except Exception as e:
+            print(f"❌ Error processing XLS: {e}")
+            return None
+    
+    def _process_csv(self, file_path: str) -> Optional[str]:
+        """Extract text from CSV files"""
+        try:
+            df = pd.read_csv(file_path, encoding='utf-8')
+            
+            text_content = []
+            text_content.append("--- CSV Data ---")
+            text_content.append(f"Columns: {', '.join(df.columns.tolist())}")
+            text_content.append(f"Total rows: {len(df)}")
+            text_content.append("")
+            
+            # Show first 50 rows
+            limited_df = df.head(50)
+            text_content.append(limited_df.to_string(index=False))
+            
+            if len(df) > 50:
+                text_content.append(f"\n... and {len(df) - 50} more rows")
+            
+            return "\n".join(text_content)
+            
+        except Exception as e:
+            print(f"❌ Error processing CSV: {e}")
+            return None
+    
+    def _process_txt(self, file_path: str) -> Optional[str]:
+        """Extract text from TXT files"""
+        try:
+            encodings = ['utf-8', 'utf-16', 'latin-1', 'cp1252']
+            
+            for encoding in encodings:
+                try:
+                    with open(file_path, 'r', encoding=encoding) as file:
+                        content = file.read()
+                        return content if content.strip() else None
+                except UnicodeDecodeError:
+                    continue
+            
+            # If all encodings fail, try with error handling
+            with open(file_path, 'r', encoding='utf-8', errors='replace') as file:
+                return file.read()
+                
+        except Exception as e:
+            print(f"❌ Error processing TXT: {e}")
+            return None
+    
+    def _process_json(self, file_path: str) -> Optional[str]:
+        """Extract text from JSON files"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as file:
+                data = json.load(file)
+            
+            # Convert JSON to readable text format
+            if isinstance(data, dict):
+                text_content = ["--- JSON Data ---"]
+                text_content.append(json.dumps(data, indent=2, ensure_ascii=False))
+            elif isinstance(data, list):
+                text_content = ["--- JSON Array ---"]
+                text_content.append(f"Array with {len(data)} items:")
+                text_content.append(json.dumps(data[:10], indent=2, ensure_ascii=False))
+                if len(data) > 10:
+                    text_content.append(f"... and {len(data) - 10} more items")
+            else:
+                text_content = [str(data)]
+            
+            return "\n".join(text_content)
+            
+        except Exception as e:
+            print(f"❌ Error processing JSON: {e}")
+            return None
+    
+    def _process_rtf(self, file_path: str) -> Optional[str]:
+        """Extract text from RTF files"""
+        try:
+            # Try with striprtf if available
+            try:
+                from striprtf.striprtf import rtf_to_text
+                with open(file_path, 'r', encoding='utf-8') as file:
+                    rtf_content = file.read()
+                return rtf_to_text(rtf_content)
+            except ImportError:
+                return "RTF file processing requires striprtf package"
+            
+        except Exception as e:
+            print(f"❌ Error processing RTF: {e}")
+            return None
+    
+    def _process_odt(self, file_path: str) -> Optional[str]:
+        """Extract text from ODT files"""
+        try:
+            # ODT files are actually ZIP archives
+            text_content = []
+            
+            with zipfile.ZipFile(file_path, 'r') as zip_file:
+                # Try to read content.xml
+                if 'content.xml' in zip_file.namelist():
+                    content_xml = zip_file.read('content.xml')
+                    # This would need XML parsing to extract actual text
+                    # For now, return a placeholder
+                    return "ODT file detected - requires XML parsing for full text extraction"
+            
+            return "Could not process ODT file"
+            
+        except Exception as e:
+            print(f"❌ Error processing ODT: {e}")
+            return None
+    
+    def _process_ods(self, file_path: str) -> Optional[str]:
+        """Extract text from ODS files"""
+        try:
+            return "ODS file processing not yet implemented"
+        except Exception as e:
+            print(f"❌ Error processing ODS: {e}")
+            return None
+    
+    def _process_odp(self, file_path: str) -> Optional[str]:
+        """Extract text from ODP files"""
+        try:
+            return "ODP file processing not yet implemented"
+        except Exception as e:
+            print(f"❌ Error processing ODP: {e}")
+            return None
+    
+    def get_file_info(self, file_path: str) -> Dict[str, Any]:
+        """Get basic information about a file"""
+        try:
+            stat = os.stat(file_path)
+            return {
+                'filename': os.path.basename(file_path),
+                'size': stat.st_size,
+                'size_mb': round(stat.st_size / (1024 * 1024), 2),
+                'extension': file_path.split('.')[-1].lower() if '.' in file_path else '',
+                'supported': file_path.split('.')[-1].lower() in self.supported_extensions,
+                'modified': stat.st_mtime
+            }
+        except Exception as e:
+            return {
+                'filename': os.path.basename(file_path) if file_path else 'unknown',
+                'error': str(e),
+                'supported': False
+            }
+    
+    def batch_process_files(self, file_paths: list) -> Dict[str, Any]:
+        """Process multiple files and return combined results"""
+        results = {
+            'successful': [],
+            'failed': [],
+            'combined_content': [],
+            'total_files': len(file_paths)
+        }
+        
+        for file_path in file_paths:
+            try:
+                file_info = self.get_file_info(file_path)
+                if file_info.get('supported', False):
+                    content = self.process_file(file_path)
+                    if content:
+                        results['successful'].append({
+                            'filename': file_info['filename'],
+                            'content': content,
+                            'size_mb': file_info['size_mb']
+                        })
+                        results['combined_content'].append(f"=== {file_info['filename']} ===")
+                        results['combined_content'].append(content)
+                        results['combined_content'].append("")
+                    else:
+                        results['failed'].append({
+                            'filename': file_info['filename'],
+                            'reason': 'No content extracted'
+                        })
+                else:
+                    results['failed'].append({
+                        'filename': file_info['filename'],
+                        'reason': 'Unsupported file type'
+                    })
+                    
+            except Exception as e:
+                results['failed'].append({
+                    'filename': os.path.basename(file_path) if file_path else 'unknown',
+                    'reason': str(e)
+                })
+        
+        results['combined_text'] = "\n".join(results['combined_content'])
+        return results

image_extraction.py

@@ -0,0 +1,417 @@
+import os
+import cv2
+import numpy as np
+import tempfile
+import uuid
+from typing import List, Dict, Optional, Tuple
+from datetime import datetime
+import subprocess
+from PIL import Image
+import hashlib
+
+class VideoFrameExtractor:
+    """Extract significant frames from videos using computer vision techniques"""
+    
+    def __init__(self):
+        self.temp_dir = tempfile.gettempdir()
+        self.similarity_threshold = 0.85  # Threshold for frame similarity
+        self.min_time_between_frames = 2.0  # Minimum seconds between extracted frames
+        self.max_frames = 50  # Maximum number of frames to extract
+        
+    def extract_frames(self, video_path: str) -> List[Dict]:
+        """
+        Extract significant frames from video that represent content changes
+        (like slide transitions, not mouse movements)
+        """
+        try:
+            if not os.path.exists(video_path):
+                print(f"Video file not found: {video_path}")
+                return []
+            
+            # Open video
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                print(f"Could not open video: {video_path}")
+                return []
+            
+            # Get video properties
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            duration = frame_count / fps if fps > 0 else 0
+            
+            print(f"Processing video: {duration:.1f}s, {fps:.1f} FPS, {frame_count} frames")
+            
+            # Extract frames using content-aware algorithm
+            extracted_frames = self._extract_content_frames(cap, fps)
+            
+            cap.release()
+            
+            print(f"Extracted {len(extracted_frames)} significant frames from video")
+            return extracted_frames
+            
+        except Exception as e:
+            print(f"Error extracting frames: {e}")
+            return []
+    
+    def _extract_content_frames(self, cap: cv2.VideoCapture, fps: float) -> List[Dict]:
+        """Extract frames based on content similarity analysis"""
+        extracted_frames = []
+        prev_frame = None
+        prev_frame_time = -self.min_time_between_frames
+        frame_number = 0
+        
+        # Calculate frame skip for efficiency (process every Nth frame initially)
+        skip_frames = max(1, int(fps / 2))  # Process 2 frames per second initially
+        
+        while len(extracted_frames) < self.max_frames:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            current_time = frame_number / fps
+            
+            # Skip frames for performance
+            if frame_number % skip_frames != 0:
+                frame_number += 1
+                continue
+            
+            # Ensure minimum time between extractions
+            if current_time - prev_frame_time < self.min_time_between_frames:
+                frame_number += 1
+                continue
+            
+            # Process frame
+            try:
+                is_significant = self._is_significant_change(frame, prev_frame)
+                
+                if is_significant or prev_frame is None:
+                    # Save frame
+                    saved_frame = self._save_frame(frame, current_time, frame_number)
+                    if saved_frame:
+                        extracted_frames.append(saved_frame)
+                        prev_frame_time = current_time
+                        
+                        # Update previous frame for comparison
+                        prev_frame = self._preprocess_frame(frame)
+                        print(f"Extracted frame at {current_time:.1f}s")
+                
+            except Exception as e:
+                print(f"Error processing frame {frame_number}: {e}")
+            
+            frame_number += 1
+        
+        return extracted_frames
+    
+    def _is_significant_change(self, current_frame: np.ndarray, prev_frame: Optional[np.ndarray]) -> bool:
+        """Determine if current frame represents a significant change from previous frame"""
+        if prev_frame is None:
+            return True
+        
+        try:
+            # Preprocess both frames
+            curr_processed = self._preprocess_frame(current_frame)
+            
+            # Calculate multiple similarity metrics
+            structural_sim = self._calculate_structural_similarity(curr_processed, prev_frame)
+            histogram_sim = self._calculate_histogram_similarity(curr_processed, prev_frame)
+            edge_sim = self._calculate_edge_similarity(curr_processed, prev_frame)
+            
+            # Combine metrics (weighted average)
+            combined_similarity = (
+                0.4 * structural_sim +
+                0.3 * histogram_sim +
+                0.3 * edge_sim
+            )
+            
+            # Frame is significant if similarity is below threshold
+            is_significant = combined_similarity < self.similarity_threshold
+            
+            return is_significant
+            
+        except Exception as e:
+            print(f"Error calculating frame similarity: {e}")
+            return False
+    
+    def _preprocess_frame(self, frame: np.ndarray) -> np.ndarray:
+        """Preprocess frame for comparison (resize, blur to ignore minor changes)"""
+        try:
+            # Resize to standard size for comparison
+            resized = cv2.resize(frame, (320, 240))
+            
+            # Convert to grayscale
+            gray = cv2.cvtColor(resized, cv2.COLOR_BGR2GRAY)
+            
+            # Apply slight blur to ignore minor pixel changes (like cursor movement)
+            blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+            
+            return blurred
+            
+        except Exception as e:
+            print(f"Error preprocessing frame: {e}")
+            return frame
+    
+    def _calculate_structural_similarity(self, frame1: np.ndarray, frame2: np.ndarray) -> float:
+        """Calculate structural similarity between frames"""
+        try:
+            # Use template matching for structural similarity
+            result = cv2.matchTemplate(frame1, frame2, cv2.TM_CCOEFF_NORMED)
+            return float(np.max(result))
+        except:
+            # Fallback: simple correlation
+            correlation = cv2.correlateNormalized(frame1.flatten(), frame2.flatten())
+            return float(correlation) if not np.isnan(correlation) else 0.0
+    
+    def _calculate_histogram_similarity(self, frame1: np.ndarray, frame2: np.ndarray) -> float:
+        """Calculate histogram similarity between frames"""
+        try:
+            # Calculate histograms
+            hist1 = cv2.calcHist([frame1], [0], None, [256], [0, 256])
+            hist2 = cv2.calcHist([frame2], [0], None, [256], [0, 256])
+            
+            # Compare histograms using correlation method
+            correlation = cv2.compareHist(hist1, hist2, cv2.HISTCMP_CORREL)
+            return float(correlation) if not np.isnan(correlation) else 0.0
+            
+        except Exception as e:
+            return 0.0
+    
+    def _calculate_edge_similarity(self, frame1: np.ndarray, frame2: np.ndarray) -> float:
+        """Calculate edge similarity between frames"""
+        try:
+            # Apply Canny edge detection
+            edges1 = cv2.Canny(frame1, 50, 150)
+            edges2 = cv2.Canny(frame2, 50, 150)
+            
+            # Calculate similarity of edge maps
+            diff = cv2.absdiff(edges1, edges2)
+            similarity = 1.0 - (np.sum(diff) / (diff.shape[0] * diff.shape[1] * 255))
+            
+            return float(similarity)
+            
+        except Exception as e:
+            return 0.0
+    
+    def _save_frame(self, frame: np.ndarray, timestamp: float, frame_number: int) -> Optional[Dict]:
+        """Save extracted frame to temporary file"""
+        try:
+            # Generate unique filename
+            frame_id = str(uuid.uuid4())
+            filename = f"frame_{frame_id}_{int(timestamp)}s.jpg"
+            filepath = os.path.join(self.temp_dir, filename)
+            
+            # Save frame as JPEG
+            success = cv2.imwrite(filepath, frame, [cv2.IMWRITE_JPEG_QUALITY, 85])
+            
+            if success and os.path.exists(filepath):
+                # Get file size
+                file_size = os.path.getsize(filepath)
+                
+                return {
+                    'filename': filename,
+                    'path': filepath,
+                    'timestamp': timestamp,
+                    'frame_number': frame_number,
+                    'file_size': file_size,
+                    'created_at': datetime.now().isoformat()
+                }
+            else:
+                print(f"Failed to save frame at {timestamp}s")
+                return None
+                
+        except Exception as e:
+            print(f"Error saving frame: {e}")
+            return None
+    
+    def extract_frames_at_intervals(self, video_path: str, interval_seconds: float = 30.0) -> List[Dict]:
+        """Extract frames at regular intervals (fallback method)"""
+        try:
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                return []
+            
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            duration = frame_count / fps if fps > 0 else 0
+            
+            extracted_frames = []
+            current_time = 0.0
+            
+            while current_time < duration and len(extracted_frames) < self.max_frames:
+                # Seek to specific time
+                frame_number = int(current_time * fps)
+                cap.set(cv2.CAP_PROP_POS_FRAMES, frame_number)
+                
+                ret, frame = cap.read()
+                if ret:
+                    saved_frame = self._save_frame(frame, current_time, frame_number)
+                    if saved_frame:
+                        extracted_frames.append(saved_frame)
+                
+                current_time += interval_seconds
+            
+            cap.release()
+            return extracted_frames
+            
+        except Exception as e:
+            print(f"Error extracting frames at intervals: {e}")
+            return []
+    
+    def extract_key_frames_opencv(self, video_path: str) -> List[Dict]:
+        """Alternative method using OpenCV's built-in keyframe detection"""
+        try:
+            # This would require more advanced OpenCV features
+            # For now, implement a simple scene change detection
+            
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                return []
+            
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            extracted_frames = []
+            prev_frame = None
+            frame_number = 0
+            
+            while len(extracted_frames) < self.max_frames:
+                ret, frame = cap.read()
+                if not ret:
+                    break
+                
+                current_time = frame_number / fps
+                
+                # Simple scene change detection using frame difference
+                if prev_frame is not None:
+                    # Calculate frame difference
+                    gray_curr = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+                    gray_prev = cv2.cvtColor(prev_frame, cv2.COLOR_BGR2GRAY)
+                    
+                    diff = cv2.absdiff(gray_curr, gray_prev)
+                    mean_diff = np.mean(diff)
+                    
+                    # Threshold for scene change
+                    if mean_diff > 30:  # Adjustable threshold
+                        saved_frame = self._save_frame(frame, current_time, frame_number)
+                        if saved_frame:
+                            extracted_frames.append(saved_frame)
+                
+                prev_frame = frame.copy()
+                frame_number += 1
+            
+            cap.release()
+            return extracted_frames
+            
+        except Exception as e:
+            print(f"Error in OpenCV key frame extraction: {e}")
+            return []
+    
+    def get_frame_hash(self, frame: np.ndarray) -> str:
+        """Generate hash for frame comparison"""
+        try:
+            # Resize and convert to grayscale for consistent hashing
+            small_frame = cv2.resize(frame, (16, 16))
+            gray_frame = cv2.cvtColor(small_frame, cv2.COLOR_BGR2GRAY)
+            
+            # Create hash from pixel values
+            frame_hash = hashlib.md5(gray_frame.tobytes()).hexdigest()
+            return frame_hash
+            
+        except Exception as e:
+            print(f"Error generating frame hash: {e}")
+            return ""
+    
+    def cleanup_temp_files(self, frame_list: List[Dict]):
+        """Clean up temporary frame files"""
+        for frame_info in frame_list:
+            try:
+                if 'path' in frame_info and os.path.exists(frame_info['path']):
+                    os.remove(frame_info['path'])
+            except Exception as e:
+                print(f"Error cleaning up frame file: {e}")
+    
+    def get_video_info(self, video_path: str) -> Dict:
+        """Get basic video information"""
+        try:
+            cap = cv2.VideoCapture(video_path)
+            if not cap.isOpened():
+                return {'error': 'Could not open video'}
+            
+            fps = cap.get(cv2.CAP_PROP_FPS)
+            frame_count = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+            width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+            height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+            duration = frame_count / fps if fps > 0 else 0
+            
+            cap.release()
+            
+            return {
+                'duration': duration,
+                'fps': fps,
+                'frame_count': frame_count,
+                'resolution': f"{width}x{height}",
+                'width': width,
+                'height': height,
+                'file_size': os.path.getsize(video_path) if os.path.exists(video_path) else 0
+            }
+            
+        except Exception as e:
+            return {'error': str(e)}
+
+class ImageAnalyzer:
+    """Additional image analysis utilities"""
+    
+    def __init__(self):
+        pass
+    
+    def detect_slide_content(self, image_path: str) -> Dict:
+        """Detect if image contains slide-like content"""
+        try:
+            image = cv2.imread(image_path)
+            if image is None:
+                return {'error': 'Could not load image'}
+            
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+            
+            # Detect text regions
+            text_regions = self._detect_text_regions(gray)
+            
+            # Detect geometric shapes (common in slides)
+            shapes = self._detect_shapes(gray)
+            
+            # Calculate text density
+            text_density = len(text_regions) / (gray.shape[0] * gray.shape[1]) * 1000
+            
+            return {
+                'text_regions': len(text_regions),
+                'shapes_detected': len(shapes),
+                'text_density': text_density,
+                'likely_slide': text_density > 0.5 or len(shapes) > 3
+            }
+            
+        except Exception as e:
+            return {'error': str(e)}
+    
+    def _detect_text_regions(self, gray_image: np.ndarray) -> List:
+        """Simple text region detection"""
+        try:
+            # Use MSER (Maximally Stable Extremal Regions) for text detection
+            mser = cv2.MSER_create()
+            regions, _ = mser.detectRegions(gray_image)
+            return regions
+        except:
+            return []
+    
+    def _detect_shapes(self, gray_image: np.ndarray) -> List:
+        """Detect geometric shapes in image"""
+        try:
+            # Find contours
+            edges = cv2.Canny(gray_image, 50, 150)
+            contours, _ = cv2.findContours(edges, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            
+            shapes = []
+            for contour in contours:
+                area = cv2.contourArea(contour)
+                if area > 100:  # Filter small contours
+                    shapes.append(contour)
+            
+            return shapes
+        except:
+            return []

implementation_guide.txt

@@ -0,0 +1,300 @@
+# AI Conference Summarization System - Implementation Guide
+
+## Overview
+
+This enhanced system transforms your basic transcription service into a comprehensive AI-powered conference analysis platform that combines:
+
+- **Speech transcription** with speaker identification
+- **Computer vision** for slide/document analysis  
+- **Multi-format file processing** (PDF, Word, Excel, PowerPoint, etc.)
+- **Intelligent frame extraction** from videos
+- **Advanced AI summarization** using Azure AI Agents
+
+## 📁 New File Structure
+
+```
+your-project/
+├── app.py                    # ✅ Updated main Gradio interface
+├── app_core.py              # ✅ Extended backend with AI features  
+├── backend.py               # ⚠️  Keep existing (imported by app_core.py)
+├── ai_summary.py            # 🆕 AI summarization core logic
+├── file_processors.py       # 🆕 Multi-format file processing
+├── image_extraction.py      # 🆕 Video frame extraction with CV
+├── requirements.txt         # ✅ Updated with new dependencies
+├── .env.example             # ✅ Updated environment template
+├── README.md               # ⚠️  Update with new features
+├── temp/                   # 📁 Temporary files (auto-created)
+├── uploads/                # 📁 File uploads (existing)
+├── database/               # 📁 SQLite database (existing)
+└── logs/                   # 📁 Application logs (optional)
+```
+
+## 🔧 Setup Instructions
+
+### 1. Install Dependencies
+
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Configure Azure Services
+
+You need to set up these Azure services:
+
+#### A. Existing Services (keep current configuration)
+- **Azure Speech Services** - For transcription
+- **Azure Blob Storage** - For file storage
+
+#### B. New Services Required
+
+**Computer Vision API:**
+- Location/Region: eastus
+- Endpoint: `https://image-process-256808.cognitiveservices.azure.com/`
+- Get API key from Azure portal
+
+**AI Agents Service:**
+- Project endpoint: `https://aiservicetesting001.services.ai.azure.com/api/projects/aiagentdeplyomentproject`
+- Agent ID: `asst_8isTjrGPs8M0d1RhkNONDtHK`
+- Get API key from Azure AI Studio
+
+### 3. Update Environment Configuration
+
+Copy `.env.example` to `.env` and fill in your actual values:
+
+```bash
+cp .env.example .env
+```
+
+**Critical new environment variables:**
+```bash
+# Computer Vision
+COMPUTER_VISION_ENDPOINT=https://your-cv-endpoint.cognitiveservices.azure.com/
+COMPUTER_VISION_KEY=your_computer_vision_key
+COMPUTER_VISION_REGION=eastus
+
+# AI Agents  
+AI_PROJECT_ENDPOINT=https://your-ai-project.services.ai.azure.com/api/projects/your-project
+AI_PROJECT_KEY=your_ai_project_key
+AI_AGENT_ID=your_agent_id
+```
+
+### 4. Database Migration
+
+The system will automatically create new tables for AI summary jobs when started. The extended database includes:
+
+- `summary_jobs` table for AI summarization requests
+- Additional indexes for performance
+- Extended user statistics
+
+### 5. File Permissions
+
+Ensure the application can write to:
+```bash
+chmod 755 temp/
+chmod 755 uploads/  
+chmod 755 database/
+```
+
+## 🚀 New Features Overview
+
+### 1. AI Summary Conference Tab
+
+**Three Processing Modes:**
+- **Batch Transcript:** Use existing transcripts from your history
+- **Upload New Media:** Process new videos, audio, documents, images
+- **Mixed Mode:** Combine both approaches
+
+**Supported File Types:**
+- **Video:** MP4, MOV, AVI, MKV, WebM, FLV (with frame extraction)
+- **Audio:** WAV, MP3, OGG, OPUS, FLAC, M4A, AAC
+- **Documents:** PDF, Word (.docx/.doc), PowerPoint (.pptx/.ppt)
+- **Data:** Excel (.xlsx/.xls), CSV, JSON, TXT  
+- **Images:** JPG, PNG, BMP, GIF (with OCR)
+
+### 2. Intelligent Video Processing
+
+**Smart Frame Extraction:**
+- Detects significant content changes (slide transitions)
+- Ignores minor movements (cursor, mouse)
+- Uses computer vision similarity analysis
+- Configurable similarity threshold (default: 85%)
+- Maximum frame limit for performance (default: 50)
+
+**Frame Analysis Pipeline:**
+1. Structural similarity comparison
+2. Histogram analysis for color changes  
+3. Edge detection for layout changes
+4. Combined weighted scoring
+
+### 3. Computer Vision Integration
+
+**OCR Text Extraction:**
+- Reads text from slides, documents, images
+- Handles multiple languages
+- Preserves text positioning and structure
+
+**Visual Content Analysis:**
+- Describes images and charts
+- Identifies visual elements
+- Extracts metadata and confidence scores
+
+### 4. Multi-Format Document Processing
+
+**Advanced Document Handlers:**
+- **PDF:** PyPDF2 + pdfplumber fallback
+- **Word:** python-docx with table extraction
+- **PowerPoint:** python-pptx with slide-by-slide processing
+- **Excel:** openpyxl + pandas with sheet separation
+- **CSV/JSON:** Smart parsing with encoding detection
+
+### 5. AI-Powered Summarization
+
+**Contextual Analysis:**
+- Combines transcripts, documents, and visual content
+- User prompt integration for corrections and focus
+- Configurable output formats
+- Action item extraction
+- Timestamp preservation
+
+## 🎯 User Experience Flow
+
+### For Conference Organizers:
+1. **Upload conference video** → System extracts key slides automatically
+2. **Add presentation PDFs** → Text content integrated with transcription
+3. **Provide context prompt** → "This is Q4 review, focus on budget decisions"  
+4. **Get comprehensive summary** → Executive summary with action items
+
+### For Meeting Participants:
+1. **Select existing transcripts** from previous sessions
+2. **Add supporting documents** shared during meetings
+3. **Specify focus areas** → "Extract technical decisions and timeline"
+4. **Download structured report** → Meeting minutes with timestamps
+
+### For Researchers:
+1. **Upload interview videos** → Automatic transcription + slide extraction
+2. **Include research documents** → Context integration
+3. **Custom analysis prompt** → "Identify key themes and participant insights"
+4. **Export detailed analysis** → Comprehensive research summary
+
+## 🔒 Security & Privacy Enhancements
+
+**User Data Separation:**
+- Each user's AI jobs stored in separate database partitions
+- Blob storage maintains user-specific folders
+- No cross-user data access possible
+
+**GDPR Compliance Extensions:**
+- AI summary jobs included in data exports
+- Complete deletion covers all AI-generated content
+- Audit trail for all AI processing activities
+
+**Enterprise Security:**
+- Azure Cognitive Services enterprise-grade security
+- All processing done within your Azure tenant
+- No data leaves your configured Azure region
+
+## 🚦 Performance Considerations
+
+**Resource Usage:**
+- Video processing: CPU-intensive for frame extraction
+- AI summarization: Network-intensive for API calls
+- Document processing: Memory-intensive for large files
+
+**Optimization Tips:**
+- Limit video duration to 2 hours for optimal performance
+- Use high-quality source videos for better frame extraction
+- Process large document batches during off-peak hours
+
+**Scaling Options:**
+- Increase `MAX_CONCURRENT_JOBS` for parallel processing
+- Add more Azure Cognitive Services units for higher throughput
+- Consider Azure Container Instances for horizontal scaling
+
+## 🛠️ Troubleshooting
+
+### Common Issues:
+
+**AI Features Not Available:**
+```python
+# Check this message in logs:
+"⚠️ AI Summary features not available: ImportError"
+```
+- Verify all dependencies installed: `pip install -r requirements.txt`
+- Check Azure service credentials in `.env`
+- Confirm network access to Azure endpoints
+
+**Frame Extraction Failing:**
+- Install OpenCV properly: `pip install opencv-python`
+- Check video file format compatibility
+- Verify sufficient disk space in `temp/` directory
+
+**Document Processing Errors:**
+- Install missing document processors: `pip install python-docx PyPDF2 openpyxl`
+- Check file permissions and encoding
+- Verify file formats are supported
+
+**AI Summarization Timeouts:**
+- Increase processing timeout in AI agent configuration
+- Check Azure AI service quotas and limits
+- Verify network connectivity to Azure AI endpoints
+
+### Debug Mode:
+
+Enable detailed logging:
+```bash
+export DEBUG=True
+export LOG_LEVEL=DEBUG
+```
+
+### Health Check Endpoints:
+
+The system includes built-in health checks for:
+- Database connectivity  
+- Azure services authentication
+- File processing pipeline
+- AI agent availability
+
+## 📈 Monitoring & Analytics
+
+**Built-in Metrics:**
+- Processing success/failure rates
+- Average processing times by file type  
+- User engagement with AI features
+- Resource usage patterns
+
+**Log Files:**
+- `app.log` - Application events
+- `ai_processing.log` - AI-specific operations
+- `error.log` - Error tracking
+
+## 🔄 Migration from Previous Version
+
+**Automatic Migration:**
+- Existing transcription data preserved
+- New database tables created automatically  
+- User accounts and permissions maintained
+- Previous API endpoints remain functional
+
+**Manual Steps Required:**
+1. Update environment variables with new API keys
+2. Install additional Python dependencies
+3. Restart application to initialize new services
+
+## 🎉 Testing the Enhanced Features
+
+**Quick Test Sequence:**
+1. **Login** with existing account
+2. **Upload a short video** (2-3 minutes) with slides
+3. **Add a PDF document** related to the video content
+4. **Provide AI instructions** like "Create executive summary focusing on key decisions"
+5. **Monitor processing** through status updates
+6. **Download results** in markdown format
+
+**Expected Results:**
+- Video automatically transcribed with speaker identification
+- Key slides extracted and analyzed with OCR
+- PDF content integrated into analysis
+- Comprehensive summary combining all sources
+- Timestamps and action items identified
+
+This enhanced system transforms basic transcription into comprehensive conference intelligence, making it suitable for enterprise meetings, academic research, and professional content analysis.

requirements.txt

@@ -0,0 +1,40 @@
+# Core application dependencies
+gradio>=4.0.0
+python-dotenv
+azure-storage-blob
+
+# AI and Azure Cognitive Services
+azure-ai-projects>=1.0.0b1
+azure-identity>=1.15.0
+azure-cognitiveservices-vision-computervision>=0.9.0
+msrest>=0.7.1
+
+# Token management for GPT models
+tiktoken>=0.5.0
+
+# File processing dependencies
+PyPDF2>=3.0.0
+python-docx>=1.1.0
+openpyxl>=3.1.0
+pandas>=2.0.0
+python-pptx>=0.6.0
+xlrd>=2.0.0
+striprtf>=0.0.26
+docx2txt>=0.8
+
+# Image and video processing
+opencv-python>=4.8.0
+Pillow>=10.0.0
+
+# Additional dependencies for robust file handling
+pdfplumber>=0.9.0
+python-magic-bin>=0.4.14  # For Windows file type detection
+chardet>=5.0.0  # For encoding detection
+
+# Optional but recommended for better performance
+numpy>=1.24.0
+scipy>=1.10.0
+
+# Development and debugging (optional)
+requests>=2.31.0
+urllib3>=1.26.0