Add profanity detection feature with 150+ Indonesian/English words

.gitignore

@@ -0,0 +1,65 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# Environment variables
+.env
+
+# Uploads
+uploads/
+*.wav
+*.mp3
+*.m4a
+*.flac
+*.ogg
+
+# Models (uncomment if not needed in repo)
+# best_model/
+
+# Data
+*.csv
+*.xlsx
+
+# Logs
+*.log
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Docker
+.dockerignore
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb

Dockerfile

@@ -0,0 +1,70 @@
+# Hugging Face Spaces - Single Container Dockerfile
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies including Redis
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsndfile1 \
+    git \
+    redis-server \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create cache directory for models BEFORE copying code
+# This ensures model downloads are cached even when code changes
+RUN mkdir -p /.cache && chmod 777 /.cache
+ENV HF_HOME=/.cache
+ENV TORCH_HOME=/.cache
+ENV XDG_CACHE_HOME=/.cache
+
+# Pre-download models during build (HF Pro with persistent storage)
+# These layers will be CACHED and won't rebuild when only code changes
+
+# 1. Download Structure Model from HF Hub (~475MB)
+RUN python -c "from transformers import AutoTokenizer, AutoModelForSequenceClassification; \
+    print('📥 Downloading Structure Model from HF Hub...'); \
+    AutoTokenizer.from_pretrained('Cyberlace/swara-structure-model', cache_dir='/.cache'); \
+    AutoModelForSequenceClassification.from_pretrained('Cyberlace/swara-structure-model', cache_dir='/.cache'); \
+    print('✅ Structure Model cached!')"
+
+# 2. Download Whisper Base Model (~140MB) - lighter and faster
+RUN python -c "import whisper; \
+    print('📥 Downloading Whisper base model...'); \
+    whisper.load_model('base', download_root='/.cache'); \
+    print('✅ Whisper base cached!')"
+
+# 3. Download Sentence Transformer for Keywords (~420MB)
+RUN python -c "from sentence_transformers import SentenceTransformer; \
+    print('📥 Downloading Sentence Transformer...'); \
+    SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2', cache_folder='/.cache'); \
+    print('✅ Sentence Transformer cached!')"
+
+# 4. Download Silero VAD (~10MB)
+RUN python -c "import torch; \
+    print('📥 Downloading Silero VAD model...'); \
+    torch.hub.load(repo_or_dir='snakers4/silero-vad', model='silero_vad', force_reload=False); \
+    print('✅ Silero VAD cached!')"
+
+# Copy application code LAST (after model downloads)
+# This way, code changes don't invalidate model cache layers
+COPY . .
+
+# Create uploads directory with proper permissions
+RUN mkdir -p uploads && chmod 777 uploads
+
+# Make start script executable
+RUN chmod +x start.sh
+
+# Expose Hugging Face Spaces port
+EXPOSE 7860
+
+# Start script (Redis + Worker + API)
+CMD ["./start.sh"]

Dockerfile.hf

@@ -0,0 +1,37 @@
+# Hugging Face Spaces - Single Container Dockerfile
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies including Redis
+RUN apt-get update && apt-get install -y \
+    ffmpeg \
+    libsndfile1 \
+    git \
+    redis-server \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Download smaller Whisper model for HF Spaces
+RUN python -c "import whisper; whisper.load_model('base')"
+
+# Copy application code
+COPY . .
+
+# Create uploads directory
+RUN mkdir -p uploads
+
+# Make start script executable
+RUN chmod +x start.sh
+
+# Expose Hugging Face Spaces port
+EXPOSE 7860
+
+# Start script (Redis + Worker + API)
+CMD ["./start.sh"]

README.md

@@ -0,0 +1,41 @@
+---
+title: Swara API - Audio Analysis
+emoji: 🎙️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+---
+
+# Swara API - Audio Analysis Service 🎙️
+
+AI-powered audio analysis service untuk penilaian public speaking.
+
+## Features
+
+- 🎤 Speech-to-Text dengan Whisper
+- ⏱️ Tempo & Jeda Analysis
+- 🗣️ Articulation Assessment
+- 📊 Structure Detection
+- 🔍 Keyword Relevance Analysis
+
+## API Documentation
+
+Once deployed, visit:
+
+- `/docs` - Interactive Swagger UI
+- `/redoc` - ReDoc documentation
+- `/api/v1/health` - Health check
+
+## Usage
+
+```bash
+# Submit audio for analysis
+curl -X POST "https://YOUR_SPACE.hf.space/api/v1/analyze" \
+  -F "audio=@your_audio.wav" \
+  -F "analyze_tempo=true" \
+  -F "analyze_structure=true"
+```
+
+For detailed documentation, see the full README in the repository.

README_HF.md

@@ -0,0 +1,41 @@
+---
+title: Swara API - Audio Analysis
+emoji: 🎙️
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+---
+
+# Swara API - Audio Analysis Service 🎙️
+
+AI-powered audio analysis service untuk penilaian public speaking.
+
+## Features
+
+- 🎤 Speech-to-Text dengan Whisper
+- ⏱️ Tempo & Jeda Analysis
+- 🗣️ Articulation Assessment
+- 📊 Structure Detection
+- 🔍 Keyword Relevance Analysis
+
+## API Documentation
+
+Once deployed, visit:
+
+- `/docs` - Interactive Swagger UI
+- `/redoc` - ReDoc documentation
+- `/api/v1/health` - Health check
+
+## Usage
+
+```bash
+# Submit audio for analysis
+curl -X POST "https://YOUR_SPACE.hf.space/api/v1/analyze" \
+  -F "audio=@your_audio.wav" \
+  -F "analyze_tempo=true" \
+  -F "analyze_structure=true"
+```
+
+For detailed documentation, see the full README in the repository.

app/__init__.py

@@ -0,0 +1,6 @@
+"""
+Swara API - Audio Analysis Service
+Public Speaking Analysis with AI
+"""
+
+__version__ = "1.0.0"

app/api/__init__.py

@@ -0,0 +1,3 @@
+"""
+API module
+"""

app/api/routes.py

@@ -0,0 +1,190 @@
+"""
+API Routes
+"""
+
+from fastapi import APIRouter, UploadFile, File, Form, HTTPException
+from typing import Optional, List
+import uuid
+import os
+import json
+
+from app.models import TaskResponse, TaskStatusResponse, TaskStatus, AnalysisRequest
+from app.core.redis_client import get_queue
+from app.core.storage import save_uploaded_file
+from app.config import settings
+from app.tasks import process_audio_task
+
+router = APIRouter()
+
+
+@router.post("/analyze", response_model=TaskResponse)
+async def analyze_audio(
+    audio: UploadFile = File(...),
+    reference_text: Optional[str] = Form(None),
+    topic_id: Optional[str] = Form(None),
+    custom_topic: Optional[str] = Form(None),
+    custom_keywords: Optional[str] = Form(None),  # JSON string dari frontend
+    analyze_tempo: bool = Form(True),
+    analyze_articulation: bool = Form(True),
+    analyze_structure: bool = Form(True),
+    analyze_keywords: bool = Form(False),
+    analyze_profanity: bool = Form(False)
+):
+    """
+    Submit audio file untuk analisis
+    
+    Parameters:
+    - audio: File audio (.wav, .mp3, .m4a, .flac, .ogg)
+    - reference_text: Teks referensi untuk artikulasi (optional)
+    - topic_id: ID topik dari database untuk Level 1-2 (optional)
+    - custom_topic: Topik custom untuk Level 3 (optional)
+    - custom_keywords: JSON array kata kunci dari GPT, contoh: ["inovasi", "kreativitas", "perubahan"] (optional)
+    - analyze_tempo: Analisis tempo (default: true)
+    - analyze_articulation: Analisis artikulasi (default: true)
+    - analyze_structure: Analisis struktur (default: true)
+    - analyze_keywords: Analisis kata kunci (default: false)
+    - analyze_profanity: Deteksi kata tidak senonoh (default: false)
+    
+    Returns task_id yang bisa digunakan untuk check status
+    """
+    
+    # Validate file extension
+    file_ext = os.path.splitext(audio.filename)[1].lower()
+    if file_ext not in settings.ALLOWED_EXTENSIONS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File type {file_ext} not allowed. Allowed: {settings.ALLOWED_EXTENSIONS}"
+        )
+    
+    # Validate file size
+    content = await audio.read()
+    if len(content) > settings.MAX_UPLOAD_SIZE:
+        raise HTTPException(
+            status_code=400,
+            detail=f"File too large. Max size: {settings.MAX_UPLOAD_SIZE / 1024 / 1024}MB"
+        )
+    
+    # Parse custom_keywords dari JSON string
+    parsed_custom_keywords = None
+    if custom_keywords:
+        try:
+            parsed_custom_keywords = json.loads(custom_keywords)
+            if not isinstance(parsed_custom_keywords, list):
+                raise ValueError("custom_keywords harus berupa array")
+        except json.JSONDecodeError:
+            raise HTTPException(
+                status_code=400,
+                detail="custom_keywords harus berupa JSON array valid, contoh: [\"kata1\", \"kata2\"]"
+            )
+    
+    # Save file
+    task_id = str(uuid.uuid4())
+    filename = f"{task_id}{file_ext}"
+    file_path = save_uploaded_file(content, filename)
+    
+    # Submit task to queue
+    queue = get_queue()
+    job = queue.enqueue(
+        process_audio_task,
+        audio_path=file_path,
+        reference_text=reference_text,
+        topic_id=topic_id,
+        custom_topic=custom_topic,
+        custom_keywords=parsed_custom_keywords,
+        analyze_tempo=analyze_tempo,
+        analyze_articulation=analyze_articulation,
+        analyze_structure=analyze_structure,
+        analyze_keywords=analyze_keywords,
+        analyze_profanity=analyze_profanity,
+        job_id=task_id,
+        job_timeout=settings.JOB_TIMEOUT,
+        result_ttl=settings.RESULT_TTL
+    )
+    
+    return TaskResponse(
+        task_id=task_id,
+        status=TaskStatus.QUEUED,
+        message="Task submitted successfully"
+    )
+
+
+@router.get("/status/{task_id}", response_model=TaskStatusResponse)
+async def get_task_status(task_id: str):
+    """
+    Check status dari task
+    
+    Returns status dan result jika sudah selesai
+    """
+    from rq.job import Job
+    from app.core.redis_client import get_redis_connection
+    
+    try:
+        redis_conn = get_redis_connection()
+        job = Job.fetch(task_id, connection=redis_conn)
+        
+        # Map job status to our TaskStatus
+        if job.is_queued:
+            status = TaskStatus.QUEUED
+        elif job.is_started:
+            status = TaskStatus.PROCESSING
+        elif job.is_finished:
+            status = TaskStatus.COMPLETED
+        elif job.is_failed:
+            status = TaskStatus.FAILED
+        else:
+            status = TaskStatus.QUEUED
+        
+        # Get result if completed
+        result = None
+        error = None
+        
+        if job.is_finished:
+            job_result = job.result
+            if isinstance(job_result, dict):
+                if job_result.get('status') == 'completed':
+                    result = job_result.get('result')
+                elif job_result.get('status') == 'failed':
+                    error = job_result.get('error')
+                    status = TaskStatus.FAILED
+        
+        if job.is_failed:
+            error = str(job.exc_info)
+        
+        return TaskStatusResponse(
+            task_id=task_id,
+            status=status,
+            result=result,
+            error=error,
+            created_at=job.created_at.isoformat() if job.created_at else None,
+            updated_at=job.ended_at.isoformat() if job.ended_at else None
+        )
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=404,
+            detail=f"Task not found: {str(e)}"
+        )
+
+
+@router.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    from app.core.redis_client import check_redis_connection
+    from app.core.device import get_device_info
+    
+    is_connected, error_msg = check_redis_connection()
+    
+    if is_connected:
+        redis_status = "healthy"
+    else:
+        redis_status = f"unhealthy: {error_msg}"
+    
+    # Get device information
+    device_info = get_device_info()
+    
+    return {
+        "status": "healthy" if is_connected else "degraded",
+        "redis": redis_status,
+        "version": settings.VERSION,
+        "device": device_info
+    }

app/config.py

@@ -0,0 +1,47 @@
+"""
+Configuration file
+"""
+
+import os
+from pydantic_settings import BaseSettings
+
+
+class Settings(BaseSettings):
+    """Application settings"""
+    
+    # App Info
+    APP_NAME: str = "Swara API - Audio Analysis"
+    VERSION: str = "1.0.0"
+    DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
+    
+    # Redis Configuration
+    REDIS_HOST: str = os.getenv("REDIS_HOST", "localhost")
+    REDIS_PORT: int = int(os.getenv("REDIS_PORT", "6379"))
+    REDIS_DB: int = int(os.getenv("REDIS_DB", "0"))
+    REDIS_PASSWORD: str = os.getenv("REDIS_PASSWORD", "")
+    
+    # RQ Worker Configuration
+    QUEUE_NAME: str = "audio_analysis"
+    JOB_TIMEOUT: int = 3600  # 1 hour
+    RESULT_TTL: int = 86400  # 24 hours
+    
+    # File Upload
+    MAX_UPLOAD_SIZE: int = 100 * 1024 * 1024  # 100 MB
+    ALLOWED_EXTENSIONS: list = [".wav", ".mp3", ".m4a", ".flac", ".ogg"]
+    UPLOAD_DIR: str = os.getenv("UPLOAD_DIR", "./uploads")
+    
+    # Model Configuration
+    WHISPER_MODEL: str = os.getenv("WHISPER_MODEL", "base")
+    KATA_KUNCI_PATH: str = os.getenv("KATA_KUNCI_PATH", "./kata_kunci.json")
+    
+    # Device Configuration (CPU/GPU)
+    DEVICE: str = os.getenv("DEVICE", "auto")  # 'auto', 'cpu', or 'cuda'
+    
+    # CORS
+    CORS_ORIGINS: list = ["*"]
+    
+    class Config:
+        env_file = ".env"
+
+
+settings = Settings()

app/core/__init__.py

@@ -0,0 +1,3 @@
+"""
+Core module
+"""

app/core/device.py

@@ -0,0 +1,83 @@
+"""
+Device Detection Utility
+Auto-detect dan konfigurasi device (CPU/GPU) untuk model ML
+"""
+
+import torch
+import os
+
+
+def get_device() -> str:
+    """
+    Deteksi device yang tersedia (CPU atau CUDA GPU)
+    
+    Returns:
+        str: 'cuda' jika GPU tersedia, 'cpu' jika tidak
+    """
+    # Check environment variable override
+    device_override = os.getenv("DEVICE", "").lower()
+    if device_override in ["cpu", "cuda"]:
+        print(f"🔧 Device override from env: {device_override}")
+        return device_override
+    
+    # Auto-detect
+    if torch.cuda.is_available():
+        device = "cuda"
+        gpu_name = torch.cuda.get_device_name(0)
+        gpu_memory = torch.cuda.get_device_properties(0).total_memory / 1024**3
+        print(f"🎮 GPU detected: {gpu_name} ({gpu_memory:.1f}GB)")
+    else:
+        device = "cpu"
+        print("💻 No GPU detected, using CPU")
+    
+    return device
+
+
+def get_device_info() -> dict:
+    """
+    Get detailed device information
+    
+    Returns:
+        dict: Device information
+    """
+    device = get_device()
+    
+    info = {
+        "device": device,
+        "cuda_available": torch.cuda.is_available(),
+    }
+    
+    if device == "cuda":
+        info.update({
+            "gpu_name": torch.cuda.get_device_name(0),
+            "gpu_memory_gb": round(torch.cuda.get_device_properties(0).total_memory / 1024**3, 2),
+            "cuda_version": torch.version.cuda,
+            "gpu_count": torch.cuda.device_count()
+        })
+    else:
+        info.update({
+            "cpu_count": os.cpu_count(),
+            "torch_threads": torch.get_num_threads()
+        })
+    
+    return info
+
+
+def optimize_for_device(device: str):
+    """
+    Optimize PyTorch settings based on device
+    
+    Args:
+        device: 'cpu' or 'cuda'
+    """
+    if device == "cpu":
+        # Optimize CPU performance
+        cpu_count = os.cpu_count() or 1
+        torch.set_num_threads(min(cpu_count, 4))  # Limit threads to avoid overhead
+        print(f"⚙️  PyTorch threads: {torch.get_num_threads()}")
+    
+    elif device == "cuda":
+        # Optimize GPU performance
+        torch.backends.cudnn.benchmark = True  # Auto-tune kernels
+        torch.backends.cuda.matmul.allow_tf32 = True  # Allow TF32 for faster matmul
+        print("⚡ GPU optimizations enabled")

app/core/redis_client.py

@@ -0,0 +1,44 @@
+"""
+Redis client setup
+"""
+
+import redis
+from rq import Queue
+from app.config import settings
+
+
+def get_redis_connection():
+    """Get Redis connection for RQ (without decode_responses)"""
+    redis_kwargs = {
+        'host': settings.REDIS_HOST,
+        'port': settings.REDIS_PORT,
+        'db': settings.REDIS_DB,
+    }
+    
+    # Only add password if it's set
+    if settings.REDIS_PASSWORD:
+        redis_kwargs['password'] = settings.REDIS_PASSWORD
+    
+    # Don't use decode_responses for RQ compatibility
+    return redis.Redis(**redis_kwargs)
+
+
+def get_queue():
+    """Get RQ Queue"""
+    conn = get_redis_connection()
+    return Queue(settings.QUEUE_NAME, connection=conn)
+
+
+def check_redis_connection():
+    """
+    Check if Redis connection is working
+    Returns tuple: (is_connected: bool, error_message: str)
+    """
+    try:
+        conn = get_redis_connection()
+        conn.ping()
+        return True, None
+    except redis.ConnectionError as e:
+        return False, f"Redis connection error: {str(e)}"
+    except Exception as e:
+        return False, f"Redis error: {str(e)}"

app/core/storage.py

@@ -0,0 +1,60 @@
+"""
+File storage utilities
+"""
+
+import os
+import shutil
+from pathlib import Path
+from app.config import settings
+
+
+def ensure_upload_dir():
+    """Ensure upload directory exists"""
+    Path(settings.UPLOAD_DIR).mkdir(parents=True, exist_ok=True)
+
+
+def save_uploaded_file(file_content: bytes, filename: str) -> str:
+    """
+    Save uploaded file
+    
+    Returns:
+        str: Path to saved file
+    """
+    ensure_upload_dir()
+    
+    file_path = os.path.join(settings.UPLOAD_DIR, filename)
+    
+    with open(file_path, "wb") as f:
+        f.write(file_content)
+    
+    return file_path
+
+
+def delete_file(file_path: str):
+    """Delete file if exists"""
+    if os.path.exists(file_path):
+        os.remove(file_path)
+
+
+def cleanup_old_files(max_age_hours: int = 24):
+    """Cleanup old uploaded files"""
+    import time
+    
+    if not os.path.exists(settings.UPLOAD_DIR):
+        return
+    
+    current_time = time.time()
+    max_age_seconds = max_age_hours * 3600
+    
+    for filename in os.listdir(settings.UPLOAD_DIR):
+        file_path = os.path.join(settings.UPLOAD_DIR, filename)
+        
+        if os.path.isfile(file_path):
+            file_age = current_time - os.path.getmtime(file_path)
+            
+            if file_age > max_age_seconds:
+                try:
+                    delete_file(file_path)
+                    print(f"Deleted old file: {filename}")
+                except Exception as e:
+                    print(f"Error deleting {filename}: {e}")

app/main.py

@@ -0,0 +1,57 @@
+"""
+FastAPI Application
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.config import settings
+from app.api.routes import router
+from app.core.storage import ensure_upload_dir
+
+# Create FastAPI app
+app = FastAPI(
+    title=settings.APP_NAME,
+    version=settings.VERSION,
+    description="Audio Analysis API for Public Speaking Assessment"
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=settings.CORS_ORIGINS,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(router, prefix="/api/v1", tags=["audio-analysis"])
+
+# Startup event
+@app.on_event("startup")
+async def startup_event():
+    """Initialize on startup"""
+    print(f"🚀 Starting {settings.APP_NAME} v{settings.VERSION}")
+    ensure_upload_dir()
+    print(f"✅ Upload directory ready: {settings.UPLOAD_DIR}")
+
+# Root endpoint
+@app.get("/")
+async def root():
+    """Root endpoint"""
+    return {
+        "app": settings.APP_NAME,
+        "version": settings.VERSION,
+        "docs": "/docs",
+        "health": "/api/v1/health"
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(
+        "app.main:app",
+        host="0.0.0.0",
+        port=8000,
+        reload=settings.DEBUG
+    )

app/models.py

@@ -0,0 +1,60 @@
+"""
+Pydantic models untuk request/response
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional, Dict, Any, List
+from enum import Enum
+
+
+class TaskStatus(str, Enum):
+    """Task status enum"""
+    QUEUED = "queued"
+    PROCESSING = "processing"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+class AnalysisRequest(BaseModel):
+    """Request untuk analisis audio"""
+    reference_text: Optional[str] = Field(None, description="Teks referensi untuk perbandingan")
+    topic_id: Optional[str] = Field(None, description="ID topik untuk analisis kata kunci")
+    analyze_tempo: bool = Field(True, description="Analisis tempo dan jeda")
+    analyze_articulation: bool = Field(True, description="Analisis artikulasi/pronunciation")
+    analyze_structure: bool = Field(True, description="Analisis struktur berbicara")
+    analyze_keywords: bool = Field(False, description="Analisis kata kunci (perlu topic_id)")
+
+
+class TaskResponse(BaseModel):
+    """Response untuk submit task"""
+    task_id: str
+    status: TaskStatus
+    message: str
+
+
+class TaskStatusResponse(BaseModel):
+    """Response untuk check status task"""
+    task_id: str
+    status: TaskStatus
+    progress: Optional[float] = None
+    result: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+    created_at: Optional[str] = None
+    updated_at: Optional[str] = None
+
+
+class AnalysisResult(BaseModel):
+    """Full analysis result"""
+    task_id: str
+    status: str
+    transcript: str
+    
+    # Results dari masing-masing analisis
+    tempo: Optional[Dict[str, Any]] = None
+    articulation: Optional[Dict[str, Any]] = None
+    structure: Optional[Dict[str, Any]] = None
+    keywords: Optional[Dict[str, Any]] = None
+    
+    # Summary
+    overall_score: Optional[float] = None
+    processing_time: Optional[float] = None

app/services/__init__.py

@@ -0,0 +1,19 @@
+"""
+Services module
+"""
+
+from app.services.speech_to_text import SpeechToTextService
+from app.services.tempo import TempoService
+from app.services.articulation import ArticulationService
+from app.services.structure import StructureService
+from app.services.keywords import KeywordService
+from app.services.audio_processor import AudioProcessor
+
+__all__ = [
+    'SpeechToTextService',
+    'TempoService',
+    'ArticulationService',
+    'StructureService',
+    'KeywordService',
+    'AudioProcessor'
+]

app/services/articulation.py

@@ -0,0 +1,332 @@
+"""
+Articulation Analysis Service
+Analisis artikulasi/pronunciation dengan BERT-based alignment
+"""
+
+import torch
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+from dataclasses import dataclass, asdict
+import re
+import warnings
+from difflib import SequenceMatcher
+warnings.filterwarnings('ignore')
+
+
+@dataclass
+class WordScore:
+    """Score untuk satu kata"""
+    index: int
+    expected: str
+    detected: str
+    is_correct: bool
+    similarity: float
+    is_filler: bool = False
+    match_type: str = "match"
+
+
+class FillerWordsDetector:
+    """Deteksi kata pengisi dalam Bahasa Indonesia"""
+    
+    FILLER_WORDS = {
+        'um', 'umm', 'ummm', 'em', 'emm', 'emmm',
+        'eh', 'ehh', 'ehhh', 'ehm', 'ehmm', 'ehmmm',
+        'ah', 'ahh', 'ahhh', 'ahm', 'ahmm', 'ahmmm',
+        'hmm', 'hmmm', 'hmmmm',
+        'uh', 'uhh', 'uhhh', 'uhm', 'uhmm',
+        'anu', 'ano', 'gitu', 'gituloh', 'gitu loh',
+        'kayak', 'kayaknya', 'kayak gini', 'kayak gitu',
+        'apa', 'apa ya', 'apa namanya',
+        'maksudnya', 'maksud saya', 'jadi', 'jadinya',
+        'nah', 'terus', 'lalu', 'kemudian',
+        'gini', 'begini', 'begitu',
+        'semacam', 'semisal', 'ibaratnya',
+        'ya kan', 'kan', 'ya', 'yah',
+        'sepertinya', 'mungkin',
+        'toh', 'sih', 'deh', 'dong', 'lah',
+    }
+    
+    @classmethod
+    def is_filler(cls, word: str) -> bool:
+        """Check if word is a filler"""
+        return word.lower() in cls.FILLER_WORDS
+    
+    @classmethod
+    def count_fillers(cls, words: List[str]) -> int:
+        """Count filler words in list"""
+        return sum(1 for word in words if cls.is_filler(word))
+
+
+class ProfanityDetector:
+    """Deteksi kata tidak senonoh dalam Bahasa Indonesia dan Inggris"""
+    
+    PROFANITY_WORDS = {
+        'anjir', 'anjay', 'njir', 'njay', 'anjrit', 'njrit', 'shit', 'fuck', 
+        'tolol', 'oon', 'bego', 'gak ada otak', 'goblok', 'bodoh', 'anjim', 
+        'anjing', 'anjrot', 'asu', 'babi', 'bacot', 'bajingan', 'banci', 
+        'bangke', 'bangor', 'bangsat', 'bejad', 'bencong', 'bodat', 'bugil', 
+        'bundir', 'bunuh', 'burik', 'burit', 'cawek', 'cemen', 'cipok', 'cium', 
+        'colai', 'coli', 'colmek', 'cukimai', 'cukimay', 'culun', 'cumbu', 
+        'dancuk', 'dewasa', 'dick', 'dildo', 'encuk', 'gay', 'gei', 'gembel', 
+        'gey', 'gigolo', 'gila', 'goblog', 'haram', 'hencet', 'hentai', 'idiot', 
+        'jablai', 'jablay', 'jancok', 'jancuk', 'jangkik', 'jembut', 'jilat', 
+        'jingan', 'kampang', 'keparat', 'kimak', 'kirik', 'klentit', 'klitoris', 
+        'konthol', 'kontol', 'koplok', 'kunyuk', 'kutang', 'kutis', 'kwontol', 
+        'lonte', 'maho', 'masturbasi', 'matane', 'mati', 'memek', 'mesum', 
+        'modar', 'modyar', 'mokad', 'najis', 'nazi', 'ndhasmu', 'nenen', 
+        'ngentot', 'ngolom', 'ngulum', 'nigga', 'nigger', 'onani', 'orgasme', 
+        'paksa', 'pantat', 'pantek', 'pecun', 'peli', 'penis', 'pentil', 'pepek', 
+        'perek', 'perkosa', 'piatu', 'porno', 'pukimak', 'qontol', 'selangkang', 
+        'sempak', 'senggama', 'setan', 'setubuh', 'silet', 'silit', 'sinting', 
+        'sodomi', 'stres', 'telanjang', 'telaso', 'tete', 'tewas', 'titit', 
+        'togel', 'toket', 'tusbol', 'urin', 'vagina'
+    }
+    
+    @classmethod
+    def detect_profanity(cls, text: str) -> Dict:
+        """
+        Deteksi kata tidak senonoh dalam teks
+        
+        Returns:
+            Dict dengan keys:
+            - has_profanity: bool
+            - profanity_count: int
+            - profanity_words: List[str] (kata yang terdeteksi)
+        """
+        # Normalisasi text
+        text_lower = text.lower()
+        words = re.findall(r'\b\w+\b', text_lower)
+        
+        # Cari kata tidak senonoh
+        found_profanity = []
+        for word in words:
+            if word in cls.PROFANITY_WORDS:
+                found_profanity.append(word)
+        
+        # Cari phrase (2-3 kata)
+        phrases_2 = [f"{words[i]} {words[i+1]}" for i in range(len(words)-1)]
+        phrases_3 = [f"{words[i]} {words[i+1]} {words[i+2]}" for i in range(len(words)-2)]
+        
+        for phrase in phrases_2 + phrases_3:
+            if phrase in cls.PROFANITY_WORDS:
+                found_profanity.append(phrase)
+        
+        return {
+            'has_profanity': len(found_profanity) > 0,
+            'profanity_count': len(found_profanity),
+            'profanity_words': list(set(found_profanity))  # Remove duplicates
+        }
+        import string
+        word_clean = word.lower().strip().rstrip(string.punctuation)
+        
+        if word_clean in cls.FILLER_WORDS:
+            return True
+        
+        if re.match(r'^(um+|em+|eh+m*|ah+m*|uh+m*|hmm+)$', word_clean):
+            return True
+        
+        return False
+    
+    @classmethod
+    def count_fillers(cls, text: str) -> Tuple[int, List[str]]:
+        """Count filler words in text"""
+        words = text.lower().split()
+        fillers = [w for w in words if cls.is_filler(w)]
+        return len(fillers), fillers
+
+
+class SequenceAligner:
+    """Sequence alignment untuk word matching"""
+    
+    @staticmethod
+    def calculate_similarity(word1: str, word2: str) -> float:
+        """Calculate similarity between two words"""
+        return SequenceMatcher(None, word1.lower(), word2.lower()).ratio()
+    
+    @staticmethod
+    def align_sequences(
+        reference: List[str],
+        detected: List[str],
+        match_threshold: float = 0.7
+    ) -> List[Tuple[Optional[str], Optional[str], str]]:
+        """Align two sequences dengan dynamic programming"""
+        m, n = len(reference), len(detected)
+        
+        dp = [[None for _ in range(n + 1)] for _ in range(m + 1)]
+        
+        MATCH_SCORE = 2
+        MISMATCH_PENALTY = -1
+        GAP_PENALTY = -1
+        
+        for i in range(m + 1):
+            dp[i][0] = (i * GAP_PENALTY, 'up')
+        for j in range(n + 1):
+            dp[0][j] = (j * GAP_PENALTY, 'left')
+        dp[0][0] = (0, 'done')
+        
+        for i in range(1, m + 1):
+            for j in range(1, n + 1):
+                ref_word = reference[i-1]
+                det_word = detected[j-1]
+                
+                similarity = SequenceAligner.calculate_similarity(ref_word, det_word)
+                
+                if similarity >= match_threshold:
+                    match_score = MATCH_SCORE
+                else:
+                    match_score = MISMATCH_PENALTY
+                
+                diagonal = dp[i-1][j-1][0] + match_score
+                up = dp[i-1][j][0] + GAP_PENALTY
+                left = dp[i][j-1][0] + GAP_PENALTY
+                
+                max_score = max(diagonal, up, left)
+                
+                if max_score == diagonal:
+                    dp[i][j] = (max_score, 'diagonal')
+                elif max_score == up:
+                    dp[i][j] = (max_score, 'up')
+                else:
+                    dp[i][j] = (max_score, 'left')
+        
+        alignment = []
+        i, j = m, n
+        
+        while i > 0 or j > 0:
+            if dp[i][j][1] == 'diagonal':
+                ref_word = reference[i-1]
+                det_word = detected[j-1]
+                similarity = SequenceAligner.calculate_similarity(ref_word, det_word)
+                
+                if similarity >= match_threshold:
+                    match_type = "match"
+                else:
+                    match_type = "substitution"
+                
+                alignment.append((ref_word, det_word, match_type))
+                i -= 1
+                j -= 1
+            elif dp[i][j][1] == 'up':
+                alignment.append((reference[i-1], None, "deletion"))
+                i -= 1
+            else:
+                alignment.append((None, detected[j-1], "insertion"))
+                j -= 1
+        
+        alignment.reverse()
+        return alignment
+
+
+class ArticulationService:
+    """Articulation assessment service"""
+    
+    def __init__(self):
+        """Initialize service"""
+        print("🗣️ Initializing Articulation Service")
+        self.filler_detector = FillerWordsDetector()
+        self.aligner = SequenceAligner()
+        print("✅ Articulation Service ready!\n")
+    
+    def normalize_text(self, text: str) -> str:
+        """Normalize text for comparison"""
+        text = text.lower()
+        text = re.sub(r'[,\.!?;:]+', ' ', text)
+        text = re.sub(r'\s+', ' ', text)
+        return text.strip()
+    
+    def tokenize_words(self, text: str) -> List[str]:
+        """Split text into words"""
+        text = self.normalize_text(text)
+        words = [w for w in text.split() if w]
+        return words
+    
+    def analyze(self, transcribed_text: str, reference_text: str) -> Dict:
+        """
+        Analisis artikulasi
+        
+        Args:
+            transcribed_text: Teks hasil transcription
+            reference_text: Teks referensi
+            
+        Returns:
+            Dict berisi hasil analisis
+        """
+        print(f"🗣️ Analyzing articulation...")
+        
+        # Tokenize
+        reference_words = self.tokenize_words(reference_text)
+        detected_words = self.tokenize_words(transcribed_text)
+        
+        # Detect fillers
+        filler_count, filler_list = self.filler_detector.count_fillers(transcribed_text)
+        
+        # Alignment
+        alignment = self.aligner.align_sequences(
+            reference_words,
+            detected_words,
+            match_threshold=0.7
+        )
+        
+        # Convert to word scores
+        word_scores = []
+        correct_words = 0
+        
+        for idx, (ref_word, det_word, match_type) in enumerate(alignment):
+            is_filler = False
+            if det_word and self.filler_detector.is_filler(det_word):
+                is_filler = True
+            
+            if match_type == "match":
+                is_correct = True
+                similarity = self.aligner.calculate_similarity(ref_word or "", det_word or "")
+                if not is_filler:
+                    correct_words += 1
+            else:
+                is_correct = False
+                similarity = self.aligner.calculate_similarity(ref_word or "", det_word or "") if ref_word and det_word else 0.0
+            
+            word_score = WordScore(
+                index=idx,
+                expected=ref_word or "[INSERTION]",
+                detected=det_word or "[DELETION]",
+                is_correct=is_correct,
+                similarity=similarity,
+                is_filler=is_filler,
+                match_type=match_type
+            )
+            
+            word_scores.append(word_score)
+        
+        # Calculate metrics
+        total_words = len(reference_words)
+        accuracy_percentage = (correct_words / total_words * 100) if total_words > 0 else 0
+        
+        # Determine category
+        if accuracy_percentage >= 81:
+            category = "Sangat Baik"
+            points = 5
+        elif accuracy_percentage >= 61:
+            category = "Baik"
+            points = 4
+        elif accuracy_percentage >= 41:
+            category = "Cukup"
+            points = 3
+        elif accuracy_percentage >= 21:
+            category = "Buruk"
+            points = 2
+        else:
+            category = "Perlu Ditingkatkan"
+            points = 1
+        
+        print(f"✅ Articulation analysis complete!\n")
+        
+        return {
+            'score': points,
+            'category': category,
+            'accuracy_percentage': round(accuracy_percentage, 1),
+            'correct_words': correct_words,
+            'total_words': total_words,
+            'filler_count': filler_count,
+            'filler_words': list(set(filler_list))[:10],
+            # 'word_scores': [asdict(ws) for ws in word_scores[:50]]  # Limit to first 50 words
+        }

app/services/audio_processor.py

@@ -0,0 +1,207 @@
+"""
+Audio Processor - Main Orchestrator
+Koordinasi semua analisis audio
+"""
+
+import time
+from typing import Dict, Optional, List
+from app.config import settings
+from app.services.speech_to_text import SpeechToTextService
+from app.services.tempo import TempoService
+from app.services.articulation import ArticulationService, ProfanityDetector
+from app.services.structure import StructureService
+from app.services.keywords import KeywordService
+
+
+class AudioProcessor:
+    """Main orchestrator untuk audio analysis"""
+    
+    def __init__(self):
+        """Initialize all services"""
+        print("🚀 Initializing Audio Processor...")
+        
+        # Initialize services (lazy loading)
+        self._stt_service = None
+        self._tempo_service = None
+        self._articulation_service = None
+        self._structure_service = None
+        self._keyword_service = None
+        
+        print("✅ Audio Processor ready!\n")
+    
+    @property
+    def stt_service(self):
+        """Lazy load STT service"""
+        if self._stt_service is None:
+            self._stt_service = SpeechToTextService(
+                model_name=settings.WHISPER_MODEL,
+                device="auto",  # Auto-detect GPU/CPU
+                language="id"
+            )
+        return self._stt_service
+    
+    @property
+    def tempo_service(self):
+        """Lazy load Tempo service"""
+        if self._tempo_service is None:
+            self._tempo_service = TempoService()
+        return self._tempo_service
+    
+    @property
+    def articulation_service(self):
+        """Lazy load Articulation service"""
+        if self._articulation_service is None:
+            self._articulation_service = ArticulationService()
+        return self._articulation_service
+    
+    @property
+    def structure_service(self):
+        """Lazy load Structure service"""
+        if self._structure_service is None:
+            # Uses default 'Cyberlace/swara-structure-model' from HF Hub
+            self._structure_service = StructureService()
+        return self._structure_service
+    
+    @property
+    def keyword_service(self):
+        """Lazy load Keyword service"""
+        if self._keyword_service is None:
+            self._keyword_service = KeywordService(
+                dataset_path=settings.KATA_KUNCI_PATH
+            )
+        return self._keyword_service
+    
+    def process_audio(
+        self,
+        audio_path: str,
+        reference_text: Optional[str] = None,
+        topic_id: Optional[str] = None,
+        custom_topic: Optional[str] = None,
+        custom_keywords: Optional[List[str]] = None,
+        analyze_tempo: bool = True,
+        analyze_articulation: bool = True,
+        analyze_structure: bool = True,
+        analyze_keywords: bool = False,
+        analyze_profanity: bool = False
+    ) -> Dict:
+        """
+        Process audio file dengan semua analisis yang diminta
+        
+        Args:
+            audio_path: Path ke file audio
+            reference_text: Teks referensi (untuk artikulasi)
+            topic_id: ID topik dari database (untuk Level 1-2)
+            custom_topic: Topik custom dari user (untuk Level 3)
+            custom_keywords: List kata kunci dari GPT (untuk Level 3)
+            analyze_tempo: Flag untuk analisis tempo
+            analyze_articulation: Flag untuk analisis artikulasi
+            analyze_structure: Flag untuk analisis struktur
+            analyze_keywords: Flag untuk analisis kata kunci
+            analyze_profanity: Flag untuk deteksi kata tidak senonoh
+            
+        Returns:
+            Dict berisi semua hasil analisis
+        """
+        start_time = time.time()
+        
+        print("="*70)
+        print("🎯 STARTING AUDIO ANALYSIS")
+        print("="*70)
+        print(f"📁 Audio file: {audio_path}")
+        print(f"⚙️  Tempo: {analyze_tempo}")
+        print(f"⚙️  Articulation: {analyze_articulation}")
+        print(f"⚙️  Structure: {analyze_structure}")
+        print(f"⚙️  Keywords: {analyze_keywords}")
+        print(f"⚙️  Profanity: {analyze_profanity}")
+        print("="*70 + "\n")
+        
+        results = {}
+        
+        # 1. Speech to Text (always required)
+        print("📝 Step 1/6: Transcribing audio...")
+        transcript_result = self.stt_service.transcribe(audio_path)
+        transcript = transcript_result['text']
+        results['transcript'] = transcript
+        print(f"✅ Transcript: {transcript[:100]}...\n")
+        
+        # 2. Tempo Analysis
+        if analyze_tempo:
+            print("🎵 Step 2/6: Analyzing tempo...")
+            results['tempo'] = self.tempo_service.analyze(audio_path, transcript)
+            print(f"✅ Tempo score: {results['tempo']['score']}/5\n")
+        
+        # 3. Articulation Analysis
+        if analyze_articulation and reference_text:
+            print("🗣️  Step 3/6: Analyzing articulation...")
+            results['articulation'] = self.articulation_service.analyze(
+                transcribed_text=transcript,
+                reference_text=reference_text
+            )
+            print(f"✅ Articulation score: {results['articulation']['score']}/5\n")
+        elif analyze_articulation:
+            print("⚠️  Step 3/6: Skipping articulation (no reference text)\n")
+        
+        # 4. Structure Analysis
+        if analyze_structure:
+            print("📊 Step 4/6: Analyzing structure...")
+            results['structure'] = self.structure_service.analyze(transcript)
+            print(f"✅ Structure score: {results['structure']['score']}/5\n")
+        
+        # 5. Keyword Analysis
+        if analyze_keywords:
+            print("🔍 Step 5/6: Analyzing keywords...")
+            
+            # Custom keywords (Level 3 - dari GPT)
+            if custom_topic and custom_keywords:
+                results['keywords'] = self.keyword_service.analyze(
+                    speech_text=transcript,
+                    custom_topic=custom_topic,
+                    custom_keywords=custom_keywords
+                )
+            # Predefined topic (Level 1-2 - dari database)
+            elif topic_id:
+                results['keywords'] = self.keyword_service.analyze(
+                    speech_text=transcript,
+                    topic_id=topic_id
+                )
+            else:
+                print("⚠️  Step 5/6: Skipping keywords (no topic_id or custom_keywords)\n")
+            
+            if 'keywords' in results:
+                print(f"✅ Keyword score: {results['keywords']['score']}/5\n")
+        elif analyze_keywords:
+            print("⚠️  Step 5/6: Keywords analysis disabled\n")
+        
+        # 6. Profanity Detection
+        if analyze_profanity:
+            print("🚫 Step 6/6: Detecting profanity...")
+            results['profanity'] = ProfanityDetector.detect_profanity(transcript)
+            status = "DETECTED" if results['profanity']['has_profanity'] else "CLEAN"
+            print(f"✅ Profanity check: {status} ({results['profanity']['profanity_count']} words)\n")
+        
+        # Calculate overall score
+        scores = []
+        if 'tempo' in results:
+            scores.append(results['tempo']['score'])
+        if 'articulation' in results:
+            scores.append(results['articulation']['score'])
+        if 'structure' in results:
+            scores.append(results['structure']['score'])
+        if 'keywords' in results:
+            scores.append(results['keywords']['score'])
+        
+        if scores:
+            results['overall_score'] = round(sum(scores) / len(scores), 2)
+        else:
+            results['overall_score'] = 0
+        
+        processing_time = time.time() - start_time
+        results['processing_time'] = round(processing_time, 2)
+        
+        print("="*70)
+        print(f"✅ ANALYSIS COMPLETE")
+        print(f"⏱️  Processing time: {processing_time:.2f}s")
+        print(f"📊 Overall score: {results['overall_score']}/5")
+        print("="*70 + "\n")
+        
+        return results

app/services/keywords.py

@@ -0,0 +1,397 @@
+"""
+Keyword Relevance Service
+Analisis relevansi kata kunci dengan topik menggunakan BERT embeddings
+"""
+
+import json
+import re
+import numpy as np
+from typing import Dict, List, Tuple
+from collections import defaultdict
+
+try:
+    from sentence_transformers import SentenceTransformer
+    from sklearn.metrics.pairwise import cosine_similarity
+    from app.core.device import get_device
+    EMBEDDINGS_AVAILABLE = True
+except ImportError:
+    EMBEDDINGS_AVAILABLE = False
+    print("⚠️  Warning: sentence-transformers not installed. Using fallback mode.")
+
+
+class KeywordService:
+    """Analisis relevansi kata kunci"""
+    
+    def __init__(self, dataset_path: str, model_name: str = 'paraphrase-multilingual-MiniLM-L12-v2'):
+        """
+        Initialize analyzer
+        
+        Args:
+            dataset_path: Path ke file JSON dataset kata kunci
+            model_name: Nama model Sentence Transformer
+        """
+        print("🔍 Initializing Keyword Service...")
+        
+        self.dataset_path = dataset_path
+        self.topics = {}
+        
+        # Load dataset
+        self.load_dataset(dataset_path)
+        
+        # Load BERT model
+        if EMBEDDINGS_AVAILABLE:
+            print(f"📦 Loading BERT model: {model_name}...")
+            device = get_device()
+            self.model = SentenceTransformer(model_name, device=device)
+            print("✅ Model loaded!")
+        else:
+            self.model = None
+            print("⚠️  Running in fallback mode (no embeddings)")
+        
+        # Precompute embeddings
+        self.keyword_embeddings = {}
+        if self.model:
+            self._precompute_embeddings()
+        
+        print("✅ Keyword Service ready!\n")
+    
+    def load_dataset(self, json_path: str):
+        """Load dataset dari file JSON"""
+        try:
+            with open(json_path, 'r', encoding='utf-8') as f:
+                self.topics = json.load(f)
+            print(f"✅ Dataset loaded: {len(self.topics)} topics")
+        except FileNotFoundError:
+            raise FileNotFoundError(f"❌ Dataset file not found: {json_path}")
+        except json.JSONDecodeError as e:
+            raise ValueError(f"❌ Invalid JSON format: {e}")
+    
+    def _precompute_embeddings(self):
+        """Precompute embeddings untuk semua keywords"""
+        print("🔄 Precomputing embeddings...")
+        
+        for topic_id, topic_data in self.topics.items():
+            self.keyword_embeddings[topic_id] = {}
+            
+            # Embed keywords
+            keywords = topic_data['keywords']
+            self.keyword_embeddings[topic_id]['keywords'] = self.model.encode(keywords)
+            
+            # Embed variants
+            all_variants = []
+            variant_mapping = []
+            for keyword in keywords:
+                variants = topic_data['variants'].get(keyword, [])
+                for variant in variants:
+                    all_variants.append(variant)
+                    variant_mapping.append(keyword)
+            
+            if all_variants:
+                self.keyword_embeddings[topic_id]['variants'] = {
+                    'embeddings': self.model.encode(all_variants),
+                    'mapping': variant_mapping,
+                    'texts': all_variants
+                }
+        
+        print("✅ Embeddings ready!")
+    
+    def extract_sentences(self, text: str) -> List[str]:
+        """Extract sentences dari text"""
+        sentences = re.split(r'[.!?]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        return sentences
+    
+    def semantic_keyword_detection(self, text: str, topic_id: str, threshold: float = 0.5) -> Dict:
+        """Deteksi keyword menggunakan semantic similarity"""
+        if not self.model or topic_id not in self.keyword_embeddings:
+            return self._fallback_detection(text, topic_id)
+        
+        sentences = self.extract_sentences(text)
+        sentence_embeddings = self.model.encode(sentences)
+        
+        topic_data = self.topics[topic_id]
+        keyword_embs = self.keyword_embeddings[topic_id]
+        
+        detected_keywords = defaultdict(list)
+        
+        # Direct keyword matching
+        keyword_similarities = cosine_similarity(
+            sentence_embeddings,
+            keyword_embs['keywords']
+        )
+        
+        for sent_idx, sentence in enumerate(sentences):
+            for kw_idx, keyword in enumerate(topic_data['keywords']):
+                similarity = keyword_similarities[sent_idx][kw_idx]
+                
+                if similarity >= threshold:
+                    detected_keywords[keyword].append({
+                        'type': 'semantic',
+                        'sentence': sentence,
+                        'similarity': float(similarity)
+                    })
+        
+        # Variant matching
+        if 'variants' in keyword_embs:
+            variant_similarities = cosine_similarity(
+                sentence_embeddings,
+                keyword_embs['variants']['embeddings']
+            )
+            
+            for sent_idx, sentence in enumerate(sentences):
+                for var_idx, (variant, mapped_kw) in enumerate(
+                    zip(keyword_embs['variants']['texts'],
+                        keyword_embs['variants']['mapping'])
+                ):
+                    similarity = variant_similarities[sent_idx][var_idx]
+                    
+                    if similarity >= threshold:
+                        if not any(d['type'] == 'variant' and d.get('variant') == variant
+                                 for d in detected_keywords[mapped_kw]):
+                            detected_keywords[mapped_kw].append({
+                                'type': 'variant',
+                                'variant': variant,
+                                'sentence': sentence,
+                                'similarity': float(similarity)
+                            })
+        
+        # Exact string matching
+        text_lower = text.lower()
+        for keyword in topic_data['keywords']:
+            if keyword in text_lower:
+                if not any(d['type'] == 'exact' for d in detected_keywords[keyword]):
+                    detected_keywords[keyword].insert(0, {
+                        'type': 'exact',
+                        'keyword': keyword,
+                        'similarity': 1.0
+                    })
+            
+            # Check variants
+            for variant in topic_data['variants'].get(keyword, []):
+                if variant.lower() in text_lower:
+                    if not any(d['type'] == 'exact_variant' and d.get('variant') == variant
+                             for d in detected_keywords[keyword]):
+                        detected_keywords[keyword].insert(0, {
+                            'type': 'exact_variant',
+                            'variant': variant,
+                            'similarity': 1.0
+                        })
+        
+        return dict(detected_keywords)
+    
+    def _fallback_detection(self, text: str, topic_id: str) -> Dict:
+        """Fallback method tanpa embeddings"""
+        text_lower = text.lower()
+        topic_data = self.topics[topic_id]
+        detected_keywords = {}
+        
+        for keyword in topic_data['keywords']:
+            detections = []
+            
+            if keyword in text_lower:
+                detections.append({
+                    'type': 'exact',
+                    'keyword': keyword,
+                    'similarity': 1.0
+                })
+            
+            for variant in topic_data['variants'].get(keyword, []):
+                if variant.lower() in text_lower:
+                    detections.append({
+                        'type': 'variant',
+                        'variant': variant,
+                        'similarity': 0.9
+                    })
+            
+            if detections:
+                detected_keywords[keyword] = detections
+        
+        return detected_keywords
+    
+    def calculate_score(self, detected_count: int) -> Dict:
+        """Calculate skor berdasarkan jumlah keyword terdeteksi"""
+        if detected_count >= 9:
+            return {
+                'score': 5,
+                'category': 'Sangat Baik',
+                'description': 'Coverage keyword sangat lengkap'
+            }
+        elif detected_count >= 7:
+            return {
+                'score': 4,
+                'category': 'Baik',
+                'description': 'Coverage keyword baik'
+            }
+        elif detected_count >= 5:
+            return {
+                'score': 3,
+                'category': 'Cukup',
+                'description': 'Coverage keyword cukup'
+            }
+        elif detected_count >= 3:
+            return {
+                'score': 2,
+                'category': 'Buruk',
+                'description': 'Coverage keyword kurang'
+            }
+        else:
+            return {
+                'score': 1,
+                'category': 'Perlu Ditingkatkan',
+                'description': 'Coverage keyword sangat rendah'
+            }
+    
+    def analyze(
+        self, 
+        speech_text: str, 
+        topic_id: str = None,
+        custom_topic: str = None,
+        custom_keywords: List[str] = None,
+        threshold: float = 0.5
+    ) -> Dict:
+        """
+        Analisis relevansi speech dengan topik
+        
+        Args:
+            speech_text: Teks speech hasil transcription
+            topic_id: ID topik dari database (untuk level 1-2)
+            custom_topic: Topik custom dari user (untuk level 3)
+            custom_keywords: List kata kunci dari GPT (untuk level 3)
+            threshold: Similarity threshold
+            
+        Returns:
+            Dict berisi hasil analisis
+        """
+        # Mode 1: Custom topic & keywords (Level 3 - dari GPT)
+        if custom_topic and custom_keywords:
+            print(f"🔍 Analyzing custom keywords for topic: {custom_topic}...")
+            return self._analyze_custom_keywords(
+                speech_text, 
+                custom_topic, 
+                custom_keywords,
+                threshold
+            )
+        
+        # Mode 2: Predefined topic (Level 1-2 - dari database)
+        if topic_id:
+            print(f"🔍 Analyzing keywords for topic {topic_id}...")
+            
+            if topic_id not in self.topics:
+                return {"error": f"Topik '{topic_id}' tidak ditemukan"}
+            
+            topic_data = self.topics[topic_id]
+            
+            # Deteksi keywords
+            detected_keywords = self.semantic_keyword_detection(
+                speech_text, topic_id, threshold
+            )
+            
+            missing_keywords = [
+                kw for kw in topic_data['keywords']
+                if kw not in detected_keywords
+            ]
+            
+            # Calculate scores
+            total_keywords = len(topic_data['keywords'])
+            detected_count = len(detected_keywords)
+            coverage_percentage = (detected_count / total_keywords) * 100
+            
+            score_result = self.calculate_score(detected_count)
+            
+            print(f"✅ Keyword analysis complete!\n")
+            
+            return {
+                'score': score_result['score'],
+                'category': score_result['category'],
+                'description': score_result['description'],
+                'topic_id': topic_id,
+                'topic_title': topic_data['title'],
+                'detected_count': detected_count,
+                'total_keywords': total_keywords,
+                'coverage_percentage': round(coverage_percentage, 1),
+                'detected_keywords': list(detected_keywords.keys()),
+                'missing_keywords': missing_keywords
+            }
+        
+        # Mode 3: Error - tidak ada input
+        return {"error": "Harus menyediakan topic_id ATAU (custom_topic + custom_keywords)"}
+    
+    def _analyze_custom_keywords(
+        self,
+        speech_text: str,
+        custom_topic: str,
+        custom_keywords: List[str],
+        threshold: float = 0.5
+    ) -> Dict:
+        """
+        Analisis dengan custom keywords dari GPT (untuk Level 3)
+        
+        Menghitung berapa kali setiap keyword disebutkan dalam speech
+        """
+        speech_lower = speech_text.lower()
+        
+        # Hitung kemunculan setiap keyword
+        keyword_mentions = {}
+        total_mentions = 0
+        
+        for keyword in custom_keywords:
+            keyword_lower = keyword.lower()
+            
+            # Count exact matches (case-insensitive)
+            count = speech_lower.count(keyword_lower)
+            
+            if count > 0:
+                keyword_mentions[keyword] = {
+                    'count': count,
+                    'mentioned': True
+                }
+                total_mentions += count
+            else:
+                keyword_mentions[keyword] = {
+                    'count': 0,
+                    'mentioned': False
+                }
+        
+        # Hitung statistik
+        total_keywords = len(custom_keywords)
+        mentioned_count = sum(1 for kw in keyword_mentions.values() if kw['mentioned'])
+        not_mentioned = [kw for kw, data in keyword_mentions.items() if not data['mentioned']]
+        coverage_percentage = (mentioned_count / total_keywords) * 100 if total_keywords > 0 else 0
+        
+        # Calculate score berdasarkan coverage
+        score_result = self.calculate_score(mentioned_count)
+        
+        # Semantic analysis (optional - jika ada model)
+        semantic_relevance = None
+        if self.model:
+            try:
+                # Encode speech dan keywords
+                speech_embedding = self.model.encode([speech_text])
+                keywords_text = " ".join(custom_keywords)
+                keywords_embedding = self.model.encode([keywords_text])
+                
+                # Calculate cosine similarity
+                similarity = cosine_similarity(speech_embedding, keywords_embedding)[0][0]
+                semantic_relevance = {
+                    'similarity_score': round(float(similarity), 3),
+                    'percentage': round(float(similarity) * 100, 1)
+                }
+            except Exception as e:
+                print(f"⚠️  Semantic analysis failed: {e}")
+        
+        print(f"✅ Custom keyword analysis complete!\n")
+        
+        return {
+            'score': score_result['score'],
+            'category': score_result['category'],
+            'description': score_result['description'],
+            'mode': 'custom',
+            'custom_topic': custom_topic,
+            'total_keywords': total_keywords,
+            'mentioned_count': mentioned_count,
+            'total_mentions': total_mentions,
+            'coverage_percentage': round(coverage_percentage, 1),
+            'keyword_details': keyword_mentions,
+            'not_mentioned': not_mentioned,
+            'semantic_relevance': semantic_relevance
+        }

app/services/speech_to_text.py

@@ -0,0 +1,109 @@
+"""
+Speech to Text Service
+Wrapper untuk Whisper STT
+"""
+
+import whisper
+import torch
+import warnings
+import os
+from typing import Dict
+from app.core.device import get_device, optimize_for_device
+warnings.filterwarnings('ignore')
+
+
+class SpeechToTextService:
+    """Speech-to-Text service using Whisper"""
+    
+    def __init__(self, model_name: str = "medium", device: str = None, language: str = "id"):
+        """Initialize Whisper model"""
+        print(f"🎙️ Initializing Speech-to-Text service")
+        print(f"📦 Loading Whisper model: {model_name}")
+        
+        # Auto-detect device if not specified
+        if device is None or device == "auto":
+            self.device = get_device()
+            optimize_for_device(self.device)
+        else:
+            self.device = device
+            print(f"💻 Using device: {self.device}")
+        
+        # Check if model is already cached
+        cache_dir = os.environ.get('XDG_CACHE_HOME', '/.cache')
+        model_cache_path = os.path.join(cache_dir, f'{model_name}.pt')
+        
+        # Load Whisper model
+        try:
+            if os.path.exists(model_cache_path):
+                print(f"✅ Loading from cache (pre-downloaded during build)")
+            else:
+                print(f"📥 Model not in cache, downloading '{model_name}'...")
+                print(f"   This may take 1-2 minutes...")
+            
+            self.model = whisper.load_model(model_name, device=self.device, download_root=cache_dir)
+            print("✅ Whisper model ready!\n")
+        except Exception as e:
+            print(f"❌ Failed to load model '{model_name}': {e}")
+            print("⚙️ Falling back to 'base' model...")
+            
+            base_cache_path = os.path.join(cache_dir, 'base.pt')
+            if os.path.exists(base_cache_path):
+                print(f"✅ Loading base model from cache")
+            else:
+                print(f"📥 Downloading base model...")
+            
+            self.model = whisper.load_model("base", device=self.device, download_root=cache_dir)
+            print("✅ Base model ready!\n")
+        
+        self.language = language
+    
+    def transcribe(self, audio_path: str, **kwargs) -> Dict:
+        """
+        Transcribe audio file to text
+        
+        Args:
+            audio_path: Path ke file audio
+            **kwargs: Additional Whisper parameters
+            
+        Returns:
+            Dict: {'text': str, 'segments': list, 'language': str}
+        """
+        print(f"🎧 Transcribing: {audio_path}")
+        
+        try:
+            # Try with word_timestamps first
+            # Use FP16 for GPU to reduce memory and improve speed
+            fp16 = self.device == "cuda"
+            
+            result = self.model.transcribe(
+                audio_path,
+                language=self.language,
+                task="transcribe",
+                word_timestamps=True,
+                condition_on_previous_text=False,
+                fp16=fp16,
+                **kwargs
+            )
+        except Exception as e:
+            print(f"⚠️ Transcription with word_timestamps failed: {e}")
+            print(f"🔄 Retrying without word_timestamps...")
+            
+            # Fallback: transcribe without word_timestamps
+            fp16 = self.device == "cuda"
+            
+            result = self.model.transcribe(
+                audio_path,
+                language=self.language,
+                task="transcribe",
+                condition_on_previous_text=False,
+                fp16=fp16,
+                **kwargs
+            )
+        
+        print("✅ Transcription complete!\n")
+        
+        return {
+            'text': result['text'],
+            'segments': result.get('segments', []),
+            'language': result.get('language', self.language)
+        }

app/services/structure.py

@@ -0,0 +1,221 @@
+"""
+Structure Analysis Service
+Analisis struktur berbicara (opening, content, closing)
+"""
+
+import pandas as pd
+import torch
+import re
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from typing import List, Dict
+from app.core.device import get_device
+
+
+class StructureService:
+    """Analisis struktur public speaking"""
+    
+    def __init__(self, model_path: str = 'Cyberlace/swara-structure-model'):
+        """
+        Initialize model from Hugging Face Hub
+        
+        Args:
+            model_path: HF Hub model name or local path
+        """
+        print("📊 Initializing Structure Service...")
+        print(f"📦 Loading model from: {model_path}")
+        
+        # Auto-detect device
+        self.device = get_device()
+        
+        # Load from Hugging Face Hub (with caching)
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            model_path,
+            cache_dir="/.cache"
+        )
+        self.model = AutoModelForSequenceClassification.from_pretrained(
+            model_path,
+            cache_dir="/.cache"
+        )
+        self.model.to(self.device)  # Move model to device
+        self.model.eval()
+        
+        self.label_map = {0: 'opening', 1: 'content', 2: 'closing'}
+        
+        print("✅ Structure Service ready!\n")
+    
+    def split_into_sentences(self, text: str) -> List[str]:
+        """Split text menjadi kalimat-kalimat"""
+        sentences = re.split(r'[.!?,;\n]+', text)
+        sentences = [s.strip() for s in sentences if s.strip()]
+        return sentences
+    
+    def predict_sentences(self, sentences: List[str], confidence_threshold: float = 0.7) -> List[Dict]:
+        """Prediksi label untuk list kalimat"""
+        results = []
+        
+        for idx, sentence in enumerate(sentences):
+            inputs = self.tokenizer(
+                sentence,
+                add_special_tokens=True,
+                max_length=128,
+                padding='max_length',
+                truncation=True,
+                return_tensors='pt'
+            )
+            
+            # Move inputs to device
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+                predicted_class = torch.argmax(probs, dim=-1).item()
+                confidence = probs[0][predicted_class].item()
+            
+            predicted_label = self.label_map[predicted_class]
+            
+            # Jika opening/closing tapi confidence rendah → ubah jadi content
+            if predicted_label in ['opening', 'closing'] and confidence < confidence_threshold:
+                predicted_label = 'content'
+            
+            results.append({
+                'sentence_idx': idx,
+                'text': sentence,
+                'predicted_label': predicted_label,
+                'confidence': confidence
+            })
+        
+        return results
+    
+    def apply_structure_rules(self, predictions: List[Dict]) -> List[Dict]:
+        """Terapkan rules untuk memperbaiki struktur"""
+        if not predictions:
+            return predictions
+        
+        n = len(predictions)
+        
+        # Rule 1: 2 kalimat pertama cenderung opening
+        for i in range(min(2, n)):
+            if predictions[i]['confidence'] > 0.5:
+                probs_opening = predictions[i].get('confidence', 0)
+                if probs_opening > 0.8:
+                    predictions[i]['predicted_label'] = 'opening'
+        
+        # Rule 2: 2 kalimat terakhir cenderung closing
+        for i in range(max(0, n-2), n):
+            if predictions[i]['confidence'] > 0.5:
+                probs_closing = predictions[i].get('confidence', 0)
+                if probs_closing > 0.8:
+                    predictions[i]['predicted_label'] = 'closing'
+        
+        # Rule 3: Detect keywords
+        closing_keywords = ['demikian', 'terima kasih', 'sekian', 'akhir kata',
+                           'wassalam', 'selamat pagi dan', 'sampai jumpa']
+        opening_keywords = ['selamat pagi', 'selamat siang', 'assalamualaikum',
+                           'hadirin', 'pertama-tama', 'izinkan saya']
+        
+        for pred in predictions:
+            text_lower = pred['text'].lower()
+            
+            if any(kw in text_lower for kw in closing_keywords):
+                pred['predicted_label'] = 'closing'
+            elif any(kw in text_lower for kw in opening_keywords):
+                pred['predicted_label'] = 'opening'
+        
+        return predictions
+    
+    def segment_speech_structure(self, predictions: List[Dict]) -> Dict:
+        """Grouping kalimat berdasarkan struktur"""
+        structure = {
+            'opening': [],
+            'content': [],
+            'closing': []
+        }
+        
+        for pred in predictions:
+            label = pred['predicted_label']
+            structure[label].append(pred)
+        
+        return structure
+    
+    def calculate_score(self, structure: Dict) -> Dict:
+        """Hitung skor berdasarkan struktur"""
+        has_opening = len(structure['opening']) > 0
+        has_content = len(structure['content']) > 0
+        has_closing = len(structure['closing']) > 0
+        
+        if has_opening and has_content and has_closing:
+            score = 5
+            description = "Sempurna! Struktur lengkap (Pembuka, Isi, Penutup)"
+        elif has_opening and has_content and not has_closing:
+            score = 4
+            description = "Baik. Ada pembuka dan isi, tapi kurang penutup"
+        elif has_opening and not has_content and has_closing:
+            score = 3
+            description = "Cukup. Ada pembuka dan penutup, tapi isi kurang jelas"
+        elif not has_opening and has_content and has_closing:
+            score = 2
+            description = "Perlu perbaikan. Kurang pembuka yang jelas"
+        elif has_opening and not has_content and not has_closing:
+            score = 1
+            description = "Kurang lengkap. Hanya ada pembuka"
+        else:
+            score = 0
+            description = "Struktur tidak terdeteksi dengan baik"
+        
+        return {
+            'score': score,
+            'max_score': 5,
+            'description': description,
+            'category': description.split('.')[0] if '.' in description else description,
+            'has_opening': has_opening,
+            'has_content': has_content,
+            'has_closing': has_closing,
+            'opening_count': len(structure['opening']),
+            'content_count': len(structure['content']),
+            'closing_count': len(structure['closing'])
+        }
+    
+    def analyze(self, transcript: str, apply_rules: bool = True) -> Dict:
+        """
+        Analisis struktur speech
+        
+        Args:
+            transcript: Teks lengkap dari speech
+            apply_rules: Gunakan heuristic rules
+            
+        Returns:
+            Dict berisi hasil analisis
+        """
+        print(f"📊 Analyzing structure...")
+        
+        # Split into sentences
+        sentences = self.split_into_sentences(transcript)
+        
+        # Predict
+        predictions = self.predict_sentences(sentences)
+        
+        # Apply rules
+        if apply_rules:
+            predictions = self.apply_structure_rules(predictions)
+        
+        # Segment structure
+        structure = self.segment_speech_structure(predictions)
+        
+        # Calculate score
+        score_result = self.calculate_score(structure)
+        
+        print("✅ Structure analysis complete!\n")
+        
+        return {
+            'score': score_result['score'],
+            'category': score_result['category'],
+            'description': score_result['description'],
+            'has_opening': score_result['has_opening'],
+            'has_content': score_result['has_content'],
+            'has_closing': score_result['has_closing'],
+            'opening_count': score_result['opening_count'],
+            'content_count': score_result['content_count'],
+            'closing_count': score_result['closing_count'],
+            'total_sentences': len(sentences)
+        }

app/services/tempo.py

@@ -0,0 +1,143 @@
+"""
+Tempo Analysis Service
+Analisis tempo dan jeda bicara menggunakan Silero VAD
+"""
+
+import torch
+from typing import Dict, List
+import warnings
+warnings.filterwarnings('ignore')
+
+
+class TempoService:
+    """Analisis tempo dan jeda bicara"""
+    
+    def __init__(self):
+        """Initialize Silero VAD model"""
+        print("🔄 Loading Silero VAD model...")
+        torch.set_num_threads(1)
+        self.model, utils = torch.hub.load(
+            repo_or_dir='snakers4/silero-vad', 
+            model='silero_vad', 
+            force_reload=False
+        )
+        (self.get_speech_timestamps, 
+         self.save_audio, 
+         self.read_audio, 
+         self.VADIterator, 
+         self.collect_chunks) = utils
+        print("✅ Silero VAD model loaded!\n")
+    
+    def analyze(self, audio_path: str, transcription: str, sampling_rate: int = 16000) -> Dict:
+        """
+        Analisis tempo berdasarkan jumlah kata per menit dan deteksi jeda panjang
+        
+        Kriteria penilaian:
+        - Poin 5 (Sangat Baik): 140-150 kata dalam 48-60 detik, tidak ada jeda >3 detik
+        - Poin 4 (Baik): 110-139 kata dalam 36-60 detik, tidak ada jeda >3 detik
+        - Poin 3 (Cukup): 60-109 kata dalam 60 detik, tidak ada jeda >3 detik
+        - Poin 2 (Buruk): <60 kata dalam 60 detik, tidak ada jeda >3 detik
+        - Poin 1 (Perlu Ditingkatkan): Berhenti sebelum 60 detik ATAU ada jeda >3 detik
+        
+        Args:
+            audio_path: Path ke file audio
+            transcription: Teks hasil transcription untuk hitung jumlah kata
+            sampling_rate: Sample rate audio (default: 16000)
+            
+        Returns:
+            Dict berisi hasil analisis lengkap
+        """
+        print(f"🎧 Analyzing tempo: {audio_path}")
+        
+        # Load audio
+        wav = self.read_audio(audio_path)
+        
+        # Deteksi segmen bicara
+        speech_timestamps = self.get_speech_timestamps(
+            wav, self.model, sampling_rate=sampling_rate
+        )
+        
+        # Hitung total durasi audio
+        total_duration_sec = len(wav) / sampling_rate
+        
+        # Hitung jumlah kata dari transcription
+        word_count = len(transcription.split())
+        
+        # Hitung kata per menit (normalize ke 60 detik)
+        words_per_minute = (word_count / total_duration_sec) * 60 if total_duration_sec > 0 else 0
+        
+        # Deteksi jeda panjang (>3 detik)
+        long_pauses = []
+        has_long_pause = False
+        
+        data = []
+        for i, seg in enumerate(speech_timestamps):
+            start_time = seg['start'] / sampling_rate
+            end_time = seg['end'] / sampling_rate
+            duration = end_time - start_time
+            
+            if i == 0:
+                pause_before = start_time
+            else:
+                pause_before = start_time - (speech_timestamps[i - 1]['end'] / sampling_rate)
+            
+            # Check jeda panjang
+            if pause_before > 3.0:
+                has_long_pause = True
+                long_pauses.append({
+                    'after_segment': i,
+                    'pause_duration': round(pause_before, 2)
+                })
+            
+            data.append({
+                'segment': i + 1,
+                'start_sec': round(start_time, 2),
+                'end_sec': round(end_time, 2),
+                'duration_sec': round(duration, 2),
+                'pause_before_sec': round(pause_before, 2)
+            })
+        
+        # Tentukan skor berdasarkan kriteria
+        if total_duration_sec < 60 or has_long_pause:
+            # Poin 1: Berhenti sebelum 60 detik ATAU ada jeda >3 detik
+            poin = 1
+            kategori = "Perlu Ditingkatkan"
+            if total_duration_sec < 60:
+                alasan = f"Durasi bicara hanya {round(total_duration_sec, 1)} detik (kurang dari 60 detik)"
+            else:
+                alasan = f"Terdapat {len(long_pauses)} jeda lebih dari 3 detik"
+        elif words_per_minute >= 140 and words_per_minute <= 150 and total_duration_sec >= 48:
+            # Poin 5: 140-150 kata dalam 48-60 detik
+            poin = 5
+            kategori = "Sangat Baik"
+            alasan = f"Tempo ideal: {round(words_per_minute, 1)} kata/menit dalam {round(total_duration_sec, 1)} detik"
+        elif words_per_minute >= 110 and words_per_minute <= 139 and total_duration_sec >= 36:
+            # Poin 4: 110-139 kata dalam 36-60 detik
+            poin = 4
+            kategori = "Baik"
+            alasan = f"Tempo baik: {round(words_per_minute, 1)} kata/menit dalam {round(total_duration_sec, 1)} detik"
+        elif words_per_minute >= 60 and words_per_minute <= 109:
+            # Poin 3: 60-109 kata dalam 60 detik
+            poin = 3
+            kategori = "Cukup"
+            alasan = f"Tempo cukup: {round(words_per_minute, 1)} kata/menit"
+        else:
+            # Poin 2: <60 kata dalam 60 detik
+            poin = 2
+            kategori = "Buruk"
+            alasan = f"Tempo lambat: hanya {round(words_per_minute, 1)} kata/menit"
+        
+        print("✅ Tempo analysis complete!\n")
+        
+        return {
+            'score': poin,
+            'category': kategori,
+            'reason': alasan,
+            'total_duration_sec': round(total_duration_sec, 2),
+            'word_count': word_count,
+            'words_per_minute': round(words_per_minute, 1),
+            'has_long_pause': has_long_pause,
+            'long_pauses': long_pauses,
+            'total_segments': len(speech_timestamps),
+            # 'segments': data
+        }

app/tasks.py

@@ -0,0 +1,76 @@
+"""
+Background tasks untuk RQ worker
+"""
+
+from typing import List, Optional
+from app.services.audio_processor import AudioProcessor
+from app.core.storage import delete_file
+
+
+def process_audio_task(
+    audio_path: str,
+    reference_text: Optional[str] = None,
+    topic_id: Optional[str] = None,
+    custom_topic: Optional[str] = None,
+    custom_keywords: Optional[List[str]] = None,
+    analyze_tempo: bool = True,
+    analyze_articulation: bool = True,
+    analyze_structure: bool = True,
+    analyze_keywords: bool = False,
+    analyze_profanity: bool = False
+):
+    """
+    Background task untuk process audio
+    
+    This function will be executed by RQ worker
+    
+    Args:
+        audio_path: Path ke file audio
+        reference_text: Teks referensi untuk artikulasi
+        topic_id: ID topik dari database (Level 1-2)
+        custom_topic: Topik custom dari user (Level 3)
+        custom_keywords: List kata kunci dari GPT (Level 3)
+        analyze_tempo: Flag tempo analysis
+        analyze_articulation: Flag articulation analysis
+        analyze_structure: Flag structure analysis
+        analyze_keywords: Flag keyword analysis
+        analyze_profanity: Flag profanity detection
+    """
+    try:
+        processor = AudioProcessor()
+        
+        result = processor.process_audio(
+            audio_path=audio_path,
+            reference_text=reference_text,
+            topic_id=topic_id,
+            custom_topic=custom_topic,
+            custom_keywords=custom_keywords,
+            analyze_tempo=analyze_tempo,
+            analyze_articulation=analyze_articulation,
+            analyze_structure=analyze_structure,
+            analyze_keywords=analyze_keywords,
+            analyze_profanity=analyze_profanity
+        )
+        
+        # Cleanup file after processing
+        try:
+            delete_file(audio_path)
+        except Exception as e:
+            print(f"Warning: Could not delete file {audio_path}: {e}")
+        
+        return {
+            'status': 'completed',
+            'result': result
+        }
+        
+    except Exception as e:
+        # Cleanup file on error
+        try:
+            delete_file(audio_path)
+        except:
+            pass
+        
+        return {
+            'status': 'failed',
+            'error': str(e)
+        }

app/worker.py

@@ -0,0 +1,50 @@
+"""
+RQ Worker
+Run this to start the background worker
+"""
+
+import time
+import sys
+from rq import Worker
+from app.core.redis_client import get_redis_connection, get_queue, check_redis_connection
+from app.config import settings
+
+
+def run_worker():
+    """Run RQ worker with retry logic"""
+    
+    print(f"🔄 Starting RQ Worker...")
+    print(f"📊 Queue: {settings.QUEUE_NAME}")
+    print(f"🔗 Redis: {settings.REDIS_HOST}:{settings.REDIS_PORT}")
+    
+    # Wait for Redis to be ready
+    max_retries = 30
+    retry_interval = 2
+    
+    for attempt in range(1, max_retries + 1):
+        is_connected, error_msg = check_redis_connection()
+        
+        if is_connected:
+            print(f"✅ Redis connected!")
+            break
+        else:
+            if attempt < max_retries:
+                print(f"⏳ Waiting for Redis... (attempt {attempt}/{max_retries})")
+                time.sleep(retry_interval)
+            else:
+                print(f"❌ Failed to connect to Redis after {max_retries} attempts")
+                print(f"   Error: {error_msg}")
+                sys.exit(1)
+    
+    # Start worker
+    redis_conn = get_redis_connection()
+    queue = get_queue()
+    
+    print(f"🚀 Worker ready and listening for tasks!\n")
+    
+    worker = Worker([queue], connection=redis_conn)
+    worker.work()
+
+
+if __name__ == "__main__":
+    run_worker()

backup_old_files/REDIS_CONFIG_NOTES.md

@@ -0,0 +1,312 @@
+# 🔴 Redis Configuration - Technical Notes
+
+## ✅ Configuration Summary
+
+Konfigurasi Redis untuk Swara API sudah **BENAR** dan siap untuk deployment ke Hugging Face Spaces.
+
+---
+
+## 📋 Redis Settings
+
+### 1. **Configuration File** (`app/config.py`)
+
+```python
+REDIS_HOST: str = os.getenv("REDIS_HOST", "localhost")
+REDIS_PORT: int = int(os.getenv("REDIS_PORT", "6379"))
+REDIS_DB: int = int(os.getenv("REDIS_DB", "0"))
+REDIS_PASSWORD: str = os.getenv("REDIS_PASSWORD", "")
+```
+
+✅ **Correct**: Defaults ke `localhost:6379` untuk single-container deployment
+
+---
+
+### 2. **Redis Client** (`app/core/redis_client.py`)
+
+**FIXED Issues:**
+
+- ❌ **Before**: `decode_responses=True` → Caused RQ errors
+- ✅ **After**: Removed `decode_responses` → RQ compatible
+
+**Current Configuration:**
+
+```python
+def get_redis_connection():
+    redis_kwargs = {
+        'host': settings.REDIS_HOST,
+        'port': settings.REDIS_PORT,
+        'db': settings.REDIS_DB,
+    }
+
+    if settings.REDIS_PASSWORD:
+        redis_kwargs['password'] = settings.REDIS_PASSWORD
+
+    return redis.Redis(**redis_kwargs)  # No decode_responses!
+```
+
+✅ **Benefits:**
+
+- Compatible with RQ (Redis Queue)
+- Proper bytes handling
+- Password support (optional)
+- Clean connection management
+
+**New Functions:**
+
+```python
+def check_redis_connection():
+    """Health check function"""
+    try:
+        conn = get_redis_connection()
+        conn.ping()
+        return True, None
+    except Exception as e:
+        return False, str(e)
+```
+
+✅ **Use case**: Health checks & startup validation
+
+---
+
+### 3. **Startup Script** (`start.sh`)
+
+**Improvements Made:**
+
+**Before:**
+
+```bash
+redis-server --daemonize yes
+until redis-cli ping; do
+  echo "Waiting for Redis..."
+  sleep 1
+done
+```
+
+**After:**
+
+```bash
+# Set environment variables
+export REDIS_HOST=localhost
+export REDIS_PORT=6379
+export REDIS_DB=0
+
+# Start Redis with specific binding
+redis-server --daemonize yes --bind 127.0.0.1 --port 6379
+
+# Wait with timeout
+REDIS_TIMEOUT=30
+until redis-cli -h localhost -p 6379 ping 2>/dev/null | grep -q PONG; do
+  if [ $ELAPSED -ge $REDIS_TIMEOUT ]; then
+    echo "ERROR: Redis failed to start"
+    exit 1
+  fi
+  sleep 2
+done
+```
+
+✅ **Improvements:**
+
+- Environment variables explicitly set
+- Timeout protection (30s max)
+- Specific binding to localhost
+- Better error handling
+- Clearer logging
+
+---
+
+### 4. **Worker** (`app/worker.py`)
+
+**Added Retry Logic:**
+
+```python
+def run_worker():
+    # Wait for Redis with retries
+    max_retries = 30
+    for attempt in range(1, max_retries + 1):
+        is_connected, error_msg = check_redis_connection()
+        if is_connected:
+            break
+        time.sleep(2)
+
+    # Then start worker
+    worker = Worker([queue], connection=redis_conn)
+    worker.work()
+```
+
+✅ **Benefits:**
+
+- Graceful startup
+- Handles Redis not ready yet
+- Clear error messages
+- Auto-retry mechanism
+
+---
+
+### 5. **Health Check** (`app/api/routes.py`)
+
+**Improved Endpoint:**
+
+```python
+@router.get("/health")
+async def health_check():
+    is_connected, error_msg = check_redis_connection()
+
+    return {
+        "status": "healthy" if is_connected else "degraded",
+        "redis": "healthy" if is_connected else f"unhealthy: {error_msg}",
+        "version": settings.VERSION
+    }
+```
+
+✅ **Benefits:**
+
+- Real-time Redis status
+- Degraded state detection
+- Useful for monitoring
+
+---
+
+## 🏗️ Architecture for HF Spaces
+
+```
+┌─────────────────────────────────────────┐
+│   Hugging Face Space (Single Container) │
+│                                          │
+│  ┌──────────────────────────────────┐  │
+│  │  Redis Server (localhost:6379)    │  │
+│  │  - In-memory data store           │  │
+│  │  - Task queue                     │  │
+│  │  - Result storage (24h TTL)       │  │
+│  └─────────┬────────────────────────┘  │
+│            │                             │
+│  ┌─────────▼───────────┐                │
+│  │  RQ Worker          │                │
+│  │  - Process tasks    │                │
+│  │  - Run AI models    │                │
+│  └─────────┬───────────┘                │
+│            │                             │
+│  ┌─────────▼───────────┐                │
+│  │  FastAPI App        │                │
+│  │  - REST API         │                │
+│  │  - Port 7860        │                │
+│  └─────────────────────┘                │
+│                                          │
+└──────────────────────────────────────────┘
+         ▲
+         │ HTTP Requests
+         │
+    ┌────┴─────┐
+    │  Client  │
+    └──────────┘
+```
+
+---
+
+## 🔍 Configuration Validation
+
+### Check 1: Environment Variables
+
+```bash
+# In HF Spaces, these are auto-set by start.sh:
+REDIS_HOST=localhost
+REDIS_PORT=6379
+REDIS_DB=0
+```
+
+✅ **Status**: Configured in `start.sh`
+
+### Check 2: Redis Connection
+
+```python
+# Test connection
+from app.core.redis_client import check_redis_connection
+is_connected, error = check_redis_connection()
+print(f"Connected: {is_connected}")
+```
+
+✅ **Status**: Function available
+
+### Check 3: Queue Setup
+
+```python
+# Test queue
+from app.core.redis_client import get_queue
+queue = get_queue()
+print(f"Queue: {queue.name}")
+```
+
+✅ **Status**: Queue name: `audio_analysis`
+
+---
+
+## 🚨 Common Issues & Solutions
+
+### Issue 1: "Connection refused"
+
+**Cause**: Redis not started yet
+**Solution**: ✅ Fixed with retry logic in worker
+
+### Issue 2: "decode_responses error"
+
+**Cause**: RQ doesn't support `decode_responses=True`
+**Solution**: ✅ Fixed by removing from connection
+
+### Issue 3: Worker timeout
+
+**Cause**: Long-running tasks
+**Solution**: ✅ Set `JOB_TIMEOUT=3600` (1 hour)
+
+### Issue 4: Results disappear
+
+**Cause**: Default TTL too short
+**Solution**: ✅ Set `RESULT_TTL=86400` (24 hours)
+
+---
+
+## 📊 Redis Performance Settings
+
+### Current Settings:
+
+```python
+QUEUE_NAME: str = "audio_analysis"
+JOB_TIMEOUT: int = 3600        # 1 hour
+RESULT_TTL: int = 86400        # 24 hours
+```
+
+### Recommended for Production:
+
+```python
+# For high traffic:
+RESULT_TTL: int = 3600         # 1 hour (save memory)
+
+# For long audio:
+JOB_TIMEOUT: int = 7200        # 2 hours
+```
+
+---
+
+## ✅ Final Checklist
+
+- [x] Redis connection without `decode_responses`
+- [x] Environment variables in `start.sh`
+- [x] Retry logic in worker
+- [x] Health check endpoint
+- [x] Timeout protection
+- [x] Error handling
+- [x] Graceful startup sequence
+- [x] Proper binding to localhost
+- [x] TTL configuration
+
+---
+
+## 🎯 Status: READY FOR DEPLOYMENT
+
+Semua konfigurasi Redis sudah **BENAR** dan **OPTIMAL** untuk:
+
+- ✅ Hugging Face Spaces (single container)
+- ✅ Local development
+- ✅ Production deployment
+- ✅ High availability
+- ✅ Error recovery
+
+**No further Redis configuration needed!** 🚀

kata_kunci.json

@@ -0,0 +1,203 @@
+{
+            "1": {
+                "title": "Generasi Z Lebih Produktif di Dunia Digital daripada di Dunia Nyata",
+                "keywords": [
+                    "produktivitas", "media sosial", "digitalisasi", "multitasking",
+                    "kebiasaan online", "self-branding", "fokus", "distraksi",
+                    "keseimbangan", "realitas sosial"
+                ],
+                "variants": {
+                    "produktivitas": ["produktif", "efisiensi", "efektif", "hasil kerja"],
+                    "media sosial": ["medsos", "sosmed", "platform digital", "jejaring sosial"],
+                    "digitalisasi": ["digital", "teknologi digital", "dunia digital", "era digital"],
+                    "multitasking": ["multi tasking", "banyak tugas", "kerja simultan"],
+                    "kebiasaan online": ["kebiasaan daring", "aktivitas online", "perilaku digital"],
+                    "self-branding": ["personal branding", "citra diri", "branding diri"],
+                    "fokus": ["konsentrasi", "perhatian", "atensi"],
+                    "distraksi": ["gangguan", "pengalih perhatian", "distorsi fokus"],
+                    "keseimbangan": ["balance", "seimbang", "proporsi"],
+                    "realitas sosial": ["kehidupan sosial", "interaksi sosial", "dunia nyata"]
+                }
+            },
+            "2": {
+                "title": "Kebebasan Berpendapat di Media Sosial Justru Mengancam Etika Komunikasi",
+                "keywords": [
+                    "kebebasan berekspresi", "hate speech", "netizen", "literasi digital",
+                    "tanggung jawab", "komentar", "polarisasi", "etika",
+                    "cancel culture", "privasi"
+                ],
+                "variants": {
+                    "kebebasan berekspresi": ["kebebasan berpendapat", "freedom of speech", "bebas bicara"],
+                    "hate speech": ["ujaran kebencian", "ucapan kebencian", "konten negatif"],
+                    "netizen": ["warganet", "pengguna internet", "masyarakat digital"],
+                    "literasi digital": ["melek digital", "pemahaman digital", "edukasi digital"],
+                    "tanggung jawab": ["responsibility", "akuntabilitas", "pertanggungjawaban"],
+                    "komentar": ["comment", "respon", "feedback"],
+                    "polarisasi": ["perpecahan", "kubu-kubuan", "dikotomi"],
+                    "etika": ["moral", "norma", "sopan santun", "adab"],
+                    "cancel culture": ["budaya membatalkan", "boikot sosial"],
+                    "privasi": ["privacy", "data pribadi", "kerahasiaan"]
+                }
+            },
+            "3": {
+                "title": "Media Sosial Lebih Banyak Merusak Kesehatan Mental daripada Membantu Ekspresi Diri",
+                "keywords": [
+                    "self-esteem", "validasi sosial", "perbandingan", "overthinking",
+                    "toxic positivity", "citra diri", "dopamine", "burnout",
+                    "kesehatan mental", "eksposur publik"
+                ],
+                "variants": {
+                    "self-esteem": ["harga diri", "kepercayaan diri", "rasa percaya diri"],
+                    "validasi sosial": ["pengakuan sosial", "approval", "penerimaan sosial"],
+                    "perbandingan": ["comparison", "membandingkan", "komparasi"],
+                    "overthinking": ["berpikir berlebihan", "overthink", "cemas berlebihan"],
+                    "toxic positivity": ["positif berlebihan", "positifitas toksik"],
+                    "citra diri": ["body image", "self image", "penampilan diri"],
+                    "dopamine": ["hormon bahagia", "reward system"],
+                    "burnout": ["kelelahan mental", "jenuh", "exhausted"],
+                    "kesehatan mental": ["mental health", "kondisi mental", "psikologis"],
+                    "eksposur publik": ["paparan publik", "tampil di publik", "visibilitas"]
+                }
+            },
+            "4": {
+                "title": "Budaya Gotong Royong Mulai Luntur di Era Individualisme Digital",
+                "keywords": [
+                    "solidaritas", "empati", "komunitas", "kesibukan",
+                    "gaya hidup modern", "isolasi sosial", "partisipasi", "nilai budaya",
+                    "relasi sosial", "kebersamaan"
+                ],
+                "variants": {
+                    "solidaritas": ["kebersamaan", "kekompakan", "saling membantu"],
+                    "empati": ["simpati", "kepedulian", "rasa iba"],
+                    "komunitas": ["masyarakat", "kelompok", "perkumpulan"],
+                    "kesibukan": ["busy", "aktivitas padat", "rutinitas"],
+                    "gaya hidup modern": ["lifestyle modern", "kehidupan modern", "modernisasi"],
+                    "isolasi sosial": ["terisolasi", "menyendiri", "kesepian sosial"],
+                    "partisipasi": ["keterlibatan", "peran serta", "kontribusi"],
+                    "nilai budaya": ["budaya", "tradisi", "kearifan lokal"],
+                    "relasi sosial": ["hubungan sosial", "interaksi", "pertemanan"],
+                    "kebersamaan": ["togetherness", "kolektif", "gotong royong"]
+                }
+            },
+            "5": {
+                "title": "Produk Lokal Layak Jadi Kebanggaan Nasional di Tengah Gempuran Globalisasi",
+                "keywords": [
+                    "UMKM", "inovasi", "branding", "ekonomi kreatif",
+                    "ekspor", "identitas budaya", "daya saing", "kreativitas",
+                    "kemandirian", "nasionalisme"
+                ],
+                "variants": {
+                    "UMKM": ["usaha kecil", "UKM", "wirausaha", "pelaku usaha"],
+                    "inovasi": ["inovatif", "kreasi baru", "terobosan"],
+                    "branding": ["merek", "citra produk", "brand"],
+                    "ekonomi kreatif": ["industri kreatif", "creative economy"],
+                    "ekspor": ["export", "perdagangan luar negeri", "pasar global"],
+                    "identitas budaya": ["jati diri", "ciri khas", "karakteristik budaya"],
+                    "daya saing": ["kompetitif", "keunggulan", "competitiveness"],
+                    "kreativitas": ["kreatif", "daya cipta", "imajinatif"],
+                    "kemandirian": ["mandiri", "independen", "swasembada"],
+                    "nasionalisme": ["cinta tanah air", "patriotisme", "bangga Indonesia"]
+                }
+            },
+            "6": {
+                "title": "Uang Bukan Tolak Ukur Kebahagiaan",
+                "keywords": [
+                    "kesejahteraan", "mental health", "gaya hidup", "materialisme",
+                    "kesederhanaan", "prioritas", "hubungan sosial", "gratitude",
+                    "keseimbangan", "nilai hidup"
+                ],
+                "variants": {
+                    "kesejahteraan": ["well-being", "sejahtera", "kemakmuran"],
+                    "mental health": ["kesehatan mental", "psikologis", "kondisi jiwa"],
+                    "gaya hidup": ["lifestyle", "pola hidup", "cara hidup"],
+                    "materialisme": ["materialistik", "konsumtif", "hedonisme"],
+                    "kesederhanaan": ["sederhana", "simple", "minimalis"],
+                    "prioritas": ["hal penting", "yang utama", "fokus utama"],
+                    "hubungan sosial": ["relasi", "pertemanan", "keluarga"],
+                    "gratitude": ["syukur", "bersyukur", "rasa terima kasih"],
+                    "keseimbangan": ["balance", "seimbang", "harmoni"],
+                    "nilai hidup": ["makna hidup", "filosofi hidup", "prinsip"]
+                }
+            },
+            "7": {
+                "title": "Teknologi Membuat Manusia Semakin Malas Berpikir Kritis",
+                "keywords": [
+                    "AI", "otomatisasi", "kenyamanan", "ketergantungan",
+                    "literasi digital", "algoritma", "kecepatan informasi", "refleksi",
+                    "kreativitas", "kesadaran"
+                ],
+                "variants": {
+                    "AI": ["artificial intelligence", "kecerdasan buatan", "machine learning"],
+                    "otomatisasi": ["automasi", "serba otomatis", "automation"],
+                    "kenyamanan": ["kemudahan", "comfort", "efisiensi"],
+                    "ketergantungan": ["addiction", "kecanduan", "bergantung"],
+                    "literasi digital": ["melek digital", "pemahaman teknologi"],
+                    "algoritma": ["algorithm", "sistem", "pola"],
+                    "kecepatan informasi": ["informasi cepat", "instant information"],
+                    "refleksi": ["renungan", "introspeksi", "contemplation"],
+                    "kreativitas": ["kreatif", "inovasi", "imajinasi"],
+                    "kesadaran": ["awareness", "mindfulness", "sadar"]
+                }
+            },
+            "8": {
+                "title": "Literasi Membaca di Kalangan Anak Muda Indonesia Masih Rendah",
+                "keywords": [
+                    "minat baca", "gadget", "media sosial", "budaya literasi",
+                    "pendidikan", "akses buku", "kebiasaan", "digital reading",
+                    "perpustakaan", "edukasi"
+                ],
+                "variants": {
+                    "minat baca": ["reading interest", "gemar membaca", "hobi baca"],
+                    "gadget": ["gawai", "smartphone", "perangkat digital"],
+                    "media sosial": ["medsos", "sosmed", "platform digital"],
+                    "budaya literasi": ["literacy culture", "tradisi membaca"],
+                    "pendidikan": ["education", "pembelajaran", "sekolah"],
+                    "akses buku": ["ketersediaan buku", "availability", "jangkauan buku"],
+                    "kebiasaan": ["habit", "rutinitas", "pola"],
+                    "digital reading": ["membaca digital", "e-book", "bacaan online"],
+                    "perpustakaan": ["library", "taman bacaan", "pojok baca"],
+                    "edukasi": ["education", "pembelajaran", "pengajaran"]
+                }
+            },
+            "9": {
+                "title": "Standar Kecantikan di Media Sosial Menyebabkan Krisis Percaya Diri",
+                "keywords": [
+                    "body image", "filter", "influencer", "estetika",
+                    "kesehatan mental", "tren", "citra diri", "autentisitas",
+                    "tekanan sosial", "representasi"
+                ],
+                "variants": {
+                    "body image": ["citra tubuh", "penampilan fisik", "bentuk tubuh"],
+                    "filter": ["filter wajah", "edit foto", "beautify"],
+                    "influencer": ["content creator", "selebgram", "public figure"],
+                    "estetika": ["aesthetic", "keindahan", "penampilan"],
+                    "kesehatan mental": ["mental health", "psikologis", "kondisi jiwa"],
+                    "tren": ["trend", "mode", "viral"],
+                    "citra diri": ["self image", "harga diri", "kepercayaan diri"],
+                    "autentisitas": ["keaslian", "authentic", "natural"],
+                    "tekanan sosial": ["social pressure", "tuntutan sosial"],
+                    "representasi": ["representation", "gambaran", "potret"]
+                }
+            },
+            "10": {
+                "title": "Hukuman untuk Pelaku Korupsi di Indonesia Masih Terlalu Ringan",
+                "keywords": [
+                    "hukum", "integritas", "keadilan", "KPK",
+                    "sistem peradilan", "sanksi", "efek jera", "moralitas",
+                    "kepercayaan publik", "reformasi hukum"
+                ],
+                "variants": {
+                    "hukum": ["law", "peraturan", "regulasi", "legal"],
+                    "integritas": ["kejujuran", "accountability", "transparansi"],
+                    "keadilan": ["justice", "fairness", "adil"],
+                    "KPK": ["komisi pemberantasan korupsi", "lembaga antikorupsi"],
+                    "sistem peradilan": ["pengadilan", "judicial system", "proses hukum"],
+                    "sanksi": ["hukuman", "punishment", "vonis"],
+                    "efek jera": ["deterrent effect", "pembelajaran", "pencegahan"],
+                    "moralitas": ["moral", "etika", "nilai"],
+                    "kepercayaan publik": ["trust", "kredibilitas", "public trust"],
+                    "reformasi hukum": ["perbaikan hukum", "pembaruan sistem"]
+                }
+            }
+        }
+    

requirements.txt

@@ -0,0 +1,37 @@
+# Core dependencies
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+python-multipart==0.0.6
+pydantic==2.5.0
+pydantic-settings==2.1.0
+
+# Redis and task queue
+redis==5.0.1
+rq==1.15.1
+
+# AI/ML libraries
+torch==2.1.0
+torchaudio==2.1.0
+transformers==4.35.0
+whisper==1.1.10
+openai-whisper==20231117
+
+# NLP
+sentence-transformers==2.2.2
+scikit-learn==1.3.2
+
+# Audio processing
+librosa==0.10.1
+soundfile==0.12.1
+ffmpeg-python==0.2.0
+
+# Data processing
+pandas==2.1.3
+numpy==1.24.3
+
+# Utilities
+python-dotenv==1.0.0
+requests==2.31.0
+
+# Optional for production
+gunicorn==21.2.0

start.sh

@@ -0,0 +1,56 @@
+#!/bin/bash
+
+echo "=========================================="
+echo "Starting Swara API Services"
+echo "=========================================="
+
+# Fix OpenMP warning - set proper thread count
+export OMP_NUM_THREADS=4
+
+# Set environment variables for Redis (localhost since in same container)
+export REDIS_HOST=localhost
+export REDIS_PORT=6379
+export REDIS_DB=0
+
+# Start Redis in background with persistence DISABLED (in-memory only)
+echo "[1/4] Starting Redis server (in-memory mode)..."
+redis-server --daemonize yes --bind 127.0.0.1 --port 6379 \
+    --save "" \
+    --appendonly no \
+    --maxmemory 512mb \
+    --maxmemory-policy allkeys-lru
+
+# Wait for Redis to be ready with timeout
+echo "[2/4] Waiting for Redis to be ready..."
+REDIS_TIMEOUT=30
+ELAPSED=0
+until redis-cli -h localhost -p 6379 ping 2>/dev/null | grep -q PONG; do
+  if [ $ELAPSED -ge $REDIS_TIMEOUT ]; then
+    echo "ERROR: Redis failed to start within ${REDIS_TIMEOUT}s"
+    exit 1
+  fi
+  echo "   Waiting for Redis... (${ELAPSED}s)"
+  sleep 2
+  ELAPSED=$((ELAPSED + 2))
+done
+
+echo "   ✓ Redis is ready!"
+
+# Start RQ worker in background
+echo "[3/4] Starting RQ Worker..."
+python -m app.worker &
+WORKER_PID=$!
+echo "   ✓ Worker started (PID: $WORKER_PID)"
+
+# Give worker time to initialize
+sleep 2
+
+# Start FastAPI application
+echo "[4/4] Starting FastAPI application..."
+echo "=========================================="
+echo "API will be available at:"
+echo "  http://localhost:7860"
+echo "  http://localhost:7860/docs (API Documentation)"
+echo "=========================================="
+
+uvicorn app.main:app --host 0.0.0.0 --port 7860

tempo.py

@@ -0,0 +1,154 @@
+"""
+tempo.py
+Analisis Tempo dan Jeda Bicara menggunakan Silero VAD
+"""
+
+import torch
+import pandas as pd
+from typing import Dict, List
+import warnings
+warnings.filterwarnings('ignore')
+
+
+class TempoAnalyzer:
+    """Analisis tempo dan jeda bicara"""
+    
+    def __init__(self):
+        """Initialize Silero VAD model"""
+        print("🔄 Loading Silero VAD model...")
+        torch.set_num_threads(1)
+        self.model, utils = torch.hub.load(
+            repo_or_dir='snakers4/silero-vad', 
+            model='silero_vad', 
+            force_reload=False
+        )
+        (self.get_speech_timestamps, 
+         self.save_audio, 
+         self.read_audio, 
+         self.VADIterator, 
+         self.collect_chunks) = utils
+        print("✅ Silero VAD model loaded!\n")
+    
+    def analyze_tempo(self, audio_path: str, sampling_rate: int = 16000) -> Dict:
+        """
+        Analisis tempo dan jeda dari file audio
+        
+        Args:
+            audio_path: Path ke file audio
+            sampling_rate: Sample rate audio (default: 16000)
+            
+        Returns:
+            Dict berisi hasil analisis lengkap
+        """
+        print(f"🎧 Analyzing tempo: {audio_path}")
+        
+        # Load audio
+        wav = self.read_audio(audio_path)
+        
+        # Deteksi segmen bicara
+        speech_timestamps = self.get_speech_timestamps(
+            wav, self.model, sampling_rate=sampling_rate
+        )
+        
+        # Buat daftar data analisis
+        data = []
+        total_pause = 0
+        total_score = 0
+        num_pauses = 0
+        
+        for i, seg in enumerate(speech_timestamps):
+            start_time = seg['start'] / sampling_rate
+            end_time = seg['end'] / sampling_rate
+            duration = end_time - start_time
+            
+            if i == 0:
+                pause_before = start_time  # jeda awal sebelum bicara pertama
+            else:
+                pause_before = start_time - (speech_timestamps[i - 1]['end'] / sampling_rate)
+            
+            # Hitung skor jeda (0 atau 1)
+            # Jika jeda <= 3 detik → 1, jika > 3 detik → 0
+            skor = 1 if pause_before <= 3.0 else 0
+            
+            total_pause += pause_before
+            total_score += skor
+            num_pauses += 1
+            
+            data.append({
+                'Segmen': i + 1,
+                'Mulai (detik)': round(start_time, 2),
+                'Selesai (detik)': round(end_time, 2),
+                'Durasi Bicara (detik)': round(duration, 2),
+                'Jeda Sebelum (detik)': round(pause_before, 2),
+                'Skor Jeda': skor
+            })
+        
+        # Hitung rata-rata jeda dan skor
+        rata_jeda = total_pause / num_pauses if num_pauses > 0 else 0
+        rata_skor = total_score / num_pauses if num_pauses > 0 else 0
+        
+        # Tentukan kategori
+        if rata_skor >= 0.9:
+            kategori = "Sangat Baik"
+            poin = 5
+        elif rata_skor >= 0.7:
+            kategori = "Baik"
+            poin = 4
+        elif rata_skor >= 0.5:
+            kategori = "Cukup"
+            poin = 3
+        elif rata_skor >= 0.3:
+            kategori = "Buruk"
+            poin = 2
+        else:
+            kategori = "Perlu Ditingkatkan"
+            poin = 1
+        
+        print("✅ Tempo analysis complete!\n")
+        
+        return {
+            'segments': data,
+            'total_segments': len(speech_timestamps),
+            'rata_rata_jeda': round(rata_jeda, 2),
+            'rata_rata_skor': round(rata_skor, 2),
+            'kategori': kategori,
+            'poin': poin,
+            'summary': {
+                'score': poin,
+                'category': kategori,
+                'avg_pause': round(rata_jeda, 2),
+                'avg_score': round(rata_skor, 2),
+                'total_segments': len(speech_timestamps)
+            }
+        }
+    
+    def print_report(self, result: Dict):
+        """Print detailed report"""
+        df = pd.DataFrame(result['segments'])
+        
+        print("\n" + "="*70)
+        print("📊 ANALISIS TEMPO DAN JEDA BICARA")
+        print("="*70)
+        print(df.to_string(index=False))
+        print("\n" + "="*70)
+        print(f"Total Segmen Bicara      : {result['total_segments']}")
+        print(f"Rata-rata Jeda (detik)   : {result['rata_rata_jeda']}")
+        print(f"Rata-rata Skor Jeda      : {result['rata_rata_skor']}/1")
+        print(f"Kategori                 : {result['kategori']}")
+        print(f"Poin                     : {result['poin']}/5")
+        print("="*70 + "\n")
+
+
+# ========== DEMO ==========
+
+def demo():
+    """Demo function"""
+    analyzer = TempoAnalyzer()
+    
+    audio_path = "./bad.wav"
+    result = analyzer.analyze_tempo(audio_path)
+    analyzer.print_report(result)
+
+
+if __name__ == "__main__":
+    demo()

upload_model_to_hf.py

@@ -0,0 +1,175 @@
+"""
+Script untuk upload best_model ke Hugging Face Hub
+Run sekali saja untuk upload model
+"""
+
+from huggingface_hub import HfApi, create_repo, login
+import os
+
+# Konfigurasi
+MODEL_PATH = "./best_model"  # Path ke model lokal
+REPO_NAME = "Cyberlace/swara-structure-model"  # Nama repository di HF Hub
+
+def upload_model():
+    """Upload model ke Hugging Face Hub"""
+    
+    print("=" * 70)
+    print("📦 Uploading Structure Model to Hugging Face Hub")
+    print("=" * 70)
+    
+    # Step 1: Check if already logged in
+    print("\n🔐 Step 1: Checking Hugging Face authentication")
+    
+    from huggingface_hub import HfFolder
+    token = HfFolder.get_token()
+    
+    if token is None:
+        print("❌ Not logged in!")
+        print("\n💡 Please login first:")
+        print("   Run: huggingface-cli login")
+        return
+    
+    print("✅ Already logged in!")
+    
+    # Step 2: Buat repository (jika belum ada)
+    print(f"\n📁 Step 2: Creating repository: {REPO_NAME}")
+    try:
+        create_repo(
+            repo_id=REPO_NAME,
+            repo_type="model",
+            exist_ok=True  # Skip jika sudah ada
+        )
+        print("✅ Repository ready!")
+    except Exception as e:
+        print(f"⚠️  Repository might already exist: {e}")
+    
+    # Step 3: Upload semua files di best_model
+    print(f"\n📤 Step 3: Uploading model files from {MODEL_PATH}")
+    
+    api = HfApi()
+    
+    # List semua files di best_model
+    files_to_upload = []
+    for root, dirs, files in os.walk(MODEL_PATH):
+        for file in files:
+            file_path = os.path.join(root, file)
+            # Relative path untuk upload
+            path_in_repo = os.path.relpath(file_path, MODEL_PATH)
+            files_to_upload.append((file_path, path_in_repo))
+    
+    print(f"   Found {len(files_to_upload)} files to upload:")
+    for file_path, path_in_repo in files_to_upload:
+        file_size = os.path.getsize(file_path) / (1024 * 1024)  # MB
+        print(f"   - {path_in_repo} ({file_size:.2f} MB)")
+    
+    # Upload files
+    print("\n⏳ Uploading files...")
+    try:
+        for file_path, path_in_repo in files_to_upload:
+            print(f"   Uploading {path_in_repo}...", end=" ")
+            api.upload_file(
+                path_or_fileobj=file_path,
+                path_in_repo=path_in_repo,
+                repo_id=REPO_NAME,
+                repo_type="model"
+            )
+            print("✅")
+        
+        print("\n🎉 Upload complete!")
+        print(f"📍 Model URL: https://huggingface.co/{REPO_NAME}")
+        
+    except Exception as e:
+        print(f"\n❌ Upload failed: {e}")
+        return
+    
+    # Step 4: Create README
+    print("\n📝 Step 4: Creating README.md")
+    readme_content = f"""---
+language:
+- id
+license: apache-2.0
+tags:
+- text-classification
+- indonesian
+- speech-structure
+- bert
+datasets:
+- custom
+---
+
+# Swara Structure Analysis Model
+
+BERT model untuk analisis struktur berbicara (opening, content, closing) dalam Bahasa Indonesia.
+
+## Model Description
+
+Model ini dilatih untuk mengklasifikasikan kalimat dalam pidato/presentasi menjadi 3 kategori:
+- **Opening**: Pembukaan (salam, perkenalan, pengantar)
+- **Content**: Isi utama (poin-poin, argumen, penjelasan)
+- **Closing**: Penutup (kesimpulan, ucapan terima kasih)
+
+## Usage
+
+```python
+from transformers import BertTokenizer, BertForSequenceClassification
+import torch
+
+# Load model
+model_name = "{REPO_NAME}"
+tokenizer = BertTokenizer.from_pretrained(model_name)
+model = BertForSequenceClassification.from_pretrained(model_name)
+
+# Predict
+text = "Selamat pagi hadirin sekalian"
+inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=128)
+
+with torch.no_grad():
+    outputs = model(**inputs)
+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
+    predicted_class = torch.argmax(probs, dim=1).item()
+
+labels = {{0: "opening", 1: "content", 2: "closing"}}
+print(f"Predicted: {{labels[predicted_class]}}")
+```
+
+## Training Data
+
+Model dilatih dengan dataset pidato dan presentasi dalam Bahasa Indonesia.
+
+## Intended Use
+
+Model ini digunakan dalam sistem analisis public speaking untuk:
+- Evaluasi struktur presentasi
+- Feedback otomatis untuk pembicara
+- Training public speaking
+"""
+    
+    try:
+        api.upload_file(
+            path_or_fileobj=readme_content.encode('utf-8'),
+            path_in_repo="README.md",
+            repo_id=REPO_NAME,
+            repo_type="model"
+        )
+        print("✅ README created!")
+    except Exception as e:
+        print(f"⚠️  README creation failed: {e}")
+    
+    print("\n" + "=" * 70)
+    print("✅ ALL DONE!")
+    print("=" * 70)
+    print(f"\n📍 Model Repository: https://huggingface.co/{REPO_NAME}")
+    print("\n💡 Next steps:")
+    print("   1. Update app/services/structure.py to use this model")
+    print("   2. Remove best_model/ from your Space repository")
+    print("   3. Deploy and test")
+
+
+if __name__ == "__main__":
+    # Check if best_model exists
+    if not os.path.exists(MODEL_PATH):
+        print(f"❌ Error: Model path not found: {MODEL_PATH}")
+        print("   Please make sure best_model/ directory exists")
+        exit(1)
+    
+    upload_model()