Deploy backend to HF Spaces

Dockerfile

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copy requirements file to the working directory
+COPY --chown=user ./requirements.txt requirements.txt
+
+# Install the Python dependencies
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the application code to the working directory
+COPY --chown=user . .
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

Dockerfile.hf

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# Copy requirements file to the working directory
+COPY --chown=user ./requirements.txt requirements.txt
+
+# Install the Python dependencies
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+# Copy the application code to the working directory
+COPY --chown=user . .
+
+# Expose port 7860 (Hugging Face Spaces default)
+EXPOSE 7860
+
+# Command to run the application
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,22 @@
+---
+title: Tibetan TTS Backend
+emoji: 🏔️
+colorFrom: blue
+colorTo: yellow
+sdk: docker
+app_port: 7860
+pinned: false
+license: mit
+---
+
+# Tibetan Learning Platform - Backend API
+
+This is the FastAPI backend for the Tibetan Learning Platform, capable of Text-to-Speech (MMS-TTS), Translation, and Learning modules.
+
+## Features
+- **TTS**: Meta MMS bindings for Tibetan
+- **Translation**: Dictionary and Fallback API
+- **Learning**: SRS Flashcard backend
+
+## Deployment
+Running on Docker with User 1000 at Port 7860.

app/__init__.py

@@ -0,0 +1 @@
+# Tibetan Learning Platform Backend

app/main.py

@@ -0,0 +1,77 @@
+"""
+Tibetan Learning Platform - FastAPI Backend
+Main application entry point
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from contextlib import asynccontextmanager
+
+from app.routers import tts, translate, learn
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Application lifespan events"""
+    # Startup: Load TTS model
+    from app.services.tts_service import tts_service
+    print("🔄 Loading TTS model...")
+    await tts_service.load_model()
+    print("✅ TTS model loaded successfully!")
+    
+    yield
+    
+    # Shutdown: Cleanup
+    print("👋 Shutting down...")
+
+
+app = FastAPI(
+    title="Tibetan Learning Platform API",
+    description="API for Tibetan TTS, Translation, and Learning features",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+# CORS middleware for frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=[
+        "http://localhost:3000",
+        "http://127.0.0.1:3000",
+        "*",  # Allow all origins for HF Spaces deployment
+    ],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(tts.router, prefix="/api/tts", tags=["TTS"])
+app.include_router(translate.router, prefix="/api/translate", tags=["Translation"])
+app.include_router(learn.router, prefix="/api/learn", tags=["Learning"])
+
+
+@app.get("/")
+async def root():
+    """Health check endpoint"""
+    return {
+        "status": "ok",
+        "message": "Tibetan Learning Platform API",
+        "version": "1.0.0"
+    }
+
+
+@app.get("/api/health")
+async def health_check():
+    """Detailed health check"""
+    from app.services.tts_service import tts_service
+    return {
+        "status": "healthy",
+        "tts_model_loaded": tts_service.is_loaded(),
+        "device": tts_service.get_device()
+    }
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)

app/models/__init__.py

@@ -0,0 +1 @@
+# Data Models

app/models/schemas.py

@@ -0,0 +1,103 @@
+"""
+Pydantic schemas for API request/response models
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional, List, Literal
+
+
+# ===================
+# TTS Schemas
+# ===================
+
+class TTSRequest(BaseModel):
+    """Request model for TTS generation"""
+    text: str = Field(..., min_length=1, max_length=1000, description="Tibetan text to convert to speech")
+    speed: float = Field(default=1.0, ge=0.5, le=2.0, description="Speech speed (0.5x to 2.0x)")
+
+
+class TTSResponse(BaseModel):
+    """Response model for TTS metadata"""
+    success: bool
+    message: str
+    sample_rate: Optional[int] = None
+    duration_seconds: Optional[float] = None
+
+
+# ===================
+# Translation Schemas
+# ===================
+
+LanguageCode = Literal["bo", "zh", "en"]
+
+class TranslateRequest(BaseModel):
+    """Request model for translation"""
+    text: str = Field(..., min_length=1, max_length=5000, description="Text to translate")
+    source: LanguageCode = Field(..., description="Source language code (bo=Tibetan, zh=Chinese, en=English)")
+    target: LanguageCode = Field(..., description="Target language code")
+
+
+class TranslateResponse(BaseModel):
+    """Response model for translation"""
+    success: bool
+    translation: Optional[str] = None
+    pronunciation: Optional[str] = None  # Romanization for Tibetan
+    source_language: str
+    target_language: str
+    error: Optional[str] = None
+
+
+# ===================
+# Learning Schemas
+# ===================
+
+class VocabularyItem(BaseModel):
+    """Single vocabulary item"""
+    id: str
+    tibetan: str
+    chinese: str
+    english: str
+    pronunciation: str  # Wylie or phonetic
+    category: str
+    example_sentence: Optional[str] = None
+
+
+class VocabularyCategory(BaseModel):
+    """Vocabulary category with items"""
+    category_id: str
+    category_name_zh: str
+    category_name_en: str
+    items: List[VocabularyItem]
+
+
+class AlphabetLetter(BaseModel):
+    """Single Tibetan alphabet letter"""
+    id: str
+    letter: str  # The Tibetan letter
+    unicode: str  # Unicode codepoint
+    pronunciation: str  # IPA or phonetic
+    description_zh: str
+    description_en: str
+    example_word: Optional[str] = None
+    example_meaning: Optional[str] = None
+
+
+class AlphabetResponse(BaseModel):
+    """Response model for alphabet data"""
+    consonants: List[AlphabetLetter]
+    vowels: List[AlphabetLetter]
+
+
+class FlashcardProgress(BaseModel):
+    """User's flashcard progress (for SRS)"""
+    vocabulary_id: str
+    ease_factor: float = 2.5  # SM-2 algorithm
+    interval_days: int = 1
+    repetitions: int = 0
+    next_review: Optional[str] = None  # ISO datetime
+
+
+class FlashcardReview(BaseModel):
+    """Request model for flashcard review"""
+    vocabulary_id: str
+    quality: int = Field(..., ge=0, le=5, description="Review quality (0=complete blackout, 5=perfect)")

app/routers/__init__.py

@@ -0,0 +1 @@
+# API Routers

app/routers/learn.py

@@ -0,0 +1,113 @@
+"""
+Learning API Router - Vocabulary, Alphabet, Flashcards
+"""
+
+from fastapi import APIRouter, HTTPException, Query
+from typing import Optional
+from app.models.schemas import FlashcardReview, FlashcardProgress
+from app.services.learning_service import learning_service
+
+
+router = APIRouter()
+
+
+@router.get("/vocabulary")
+async def get_vocabulary(
+    category: Optional[str] = Query(None, description="Filter by category")
+):
+    """
+    Get vocabulary items
+    
+    - **category**: Optional category filter (greetings, numbers, colors, daily)
+    """
+    try:
+        return learning_service.get_vocabulary_by_category(category)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/vocabulary/categories")
+async def get_vocabulary_categories():
+    """
+    Get list of vocabulary categories
+    """
+    categories = learning_service.get_vocabulary_categories()
+    return {"categories": categories}
+
+
+@router.get("/alphabet")
+async def get_alphabet():
+    """
+    Get Tibetan alphabet data (consonants and vowels)
+    """
+    try:
+        return learning_service.get_alphabet()
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/flashcards")
+async def get_flashcards(
+    category: Optional[str] = Query(None, description="Filter by category"),
+    limit: int = Query(10, ge=1, le=50, description="Number of flashcards to return")
+):
+    """
+    Get flashcards for practice session
+    
+    - **category**: Optional category filter
+    - **limit**: Maximum number of cards (1-50)
+    """
+    try:
+        cards = learning_service.get_flashcards(category, limit)
+        return {
+            "flashcards": cards,
+            "count": len(cards)
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/flashcards/review", response_model=FlashcardProgress)
+async def review_flashcard(review: FlashcardReview):
+    """
+    Submit a flashcard review and update SRS progress
+    
+    - **vocabulary_id**: ID of the vocabulary item
+    - **quality**: Review quality (0=complete blackout, 5=perfect)
+    
+    Uses SM-2 spaced repetition algorithm
+    """
+    try:
+        progress = learning_service.update_progress(
+            vocabulary_id=review.vocabulary_id,
+            quality=review.quality
+        )
+        return FlashcardProgress(
+            vocabulary_id=review.vocabulary_id,
+            ease_factor=progress["ease_factor"],
+            interval_days=progress["interval_days"],
+            repetitions=progress["repetitions"],
+            next_review=progress["next_review"]
+        )
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/stats")
+async def get_learning_stats():
+    """
+    Get learning statistics
+    """
+    vocab_data = learning_service.get_vocabulary_by_category()
+    categories = vocab_data.get("categories", [])
+    
+    total_items = sum(len(cat.get("items", [])) for cat in categories)
+    
+    return {
+        "total_vocabulary": total_items,
+        "categories_count": len(categories),
+        "alphabet": {
+            "consonants": 30,
+            "vowels": 4
+        }
+    }

app/routers/translate.py

@@ -0,0 +1,61 @@
+"""
+Translation API Router
+"""
+
+from fastapi import APIRouter, HTTPException
+from app.models.schemas import TranslateRequest, TranslateResponse
+from app.services.translate_service import translate_service
+
+
+router = APIRouter()
+
+
+@router.post("/", response_model=TranslateResponse)
+async def translate_text(request: TranslateRequest):
+    """
+    Translate text between Tibetan, Chinese, and English
+    
+    - **text**: Text to translate
+    - **source**: Source language code (bo=Tibetan, zh=Chinese, en=English)
+    - **target**: Target language code
+    """
+    try:
+        result = await translate_service.translate(
+            text=request.text,
+            source=request.source,
+            target=request.target
+        )
+        
+        return TranslateResponse(
+            success=result.get("success", False),
+            translation=result.get("translation"),
+            pronunciation=result.get("pronunciation"),
+            source_language=result.get("source_language", request.source),
+            target_language=result.get("target_language", request.target),
+            error=result.get("error")
+        )
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Translation error: {str(e)}")
+
+
+@router.get("/languages")
+async def get_supported_languages():
+    """
+    Get list of supported languages
+    """
+    return {
+        "languages": [
+            {"code": "bo", "name_zh": "藏语", "name_en": "Tibetan", "name_native": "བོད་སྐད།"},
+            {"code": "zh", "name_zh": "中文", "name_en": "Chinese", "name_native": "中文"},
+            {"code": "en", "name_zh": "英语", "name_en": "English", "name_native": "English"}
+        ],
+        "pairs": [
+            {"source": "bo", "target": "zh"},
+            {"source": "bo", "target": "en"},
+            {"source": "zh", "target": "bo"},
+            {"source": "zh", "target": "en"},
+            {"source": "en", "target": "bo"},
+            {"source": "en", "target": "zh"}
+        ]
+    }

app/routers/tts.py

@@ -0,0 +1,91 @@
+"""
+TTS API Router - Text-to-Speech endpoints
+"""
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+from app.models.schemas import TTSRequest, TTSResponse
+from app.services.tts_service import tts_service
+
+
+router = APIRouter()
+
+
+@router.post("/generate", response_class=StreamingResponse)
+async def generate_speech(request: TTSRequest):
+    """
+    Generate speech audio from Tibetan text
+    
+    - **text**: Tibetan text to convert (1-1000 characters)
+    - **speed**: Speech speed multiplier (0.5x to 2.0x)
+    
+    Returns: WAV audio file
+    """
+    try:
+        # Generate audio
+        audio, sample_rate = await tts_service.generate_audio(
+            text=request.text,
+            speed=request.speed
+        )
+        
+        # Convert to WAV bytes
+        audio_bytes = tts_service.audio_to_wav_bytes(audio, sample_rate)
+        
+        # Return as streaming response
+        return StreamingResponse(
+            audio_bytes,
+            media_type="audio/wav",
+            headers={
+                "Content-Disposition": "attachment; filename=tibetan_tts.wav",
+                "X-Audio-Duration": str(tts_service.get_audio_duration(audio, sample_rate)),
+                "X-Sample-Rate": str(sample_rate)
+            }
+        )
+        
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except RuntimeError as e:
+        raise HTTPException(status_code=500, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal error: {str(e)}")
+
+
+@router.post("/metadata", response_model=TTSResponse)
+async def get_tts_metadata(request: TTSRequest):
+    """
+    Get metadata about TTS generation without generating audio
+    Useful for estimating duration or validating input
+    """
+    try:
+        # Validate text
+        text = tts_service.preprocess_text(request.text)
+        
+        return TTSResponse(
+            success=True,
+            message=f"Text validated: {len(text)} characters",
+            sample_rate=tts_service.sample_rate,
+            duration_seconds=None  # Would need to generate to get actual duration
+        )
+        
+    except ValueError as e:
+        return TTSResponse(
+            success=False,
+            message=str(e),
+            sample_rate=None,
+            duration_seconds=None
+        )
+
+
+@router.get("/status")
+async def get_tts_status():
+    """
+    Get TTS service status
+    """
+    return {
+        "model_loaded": tts_service.is_loaded(),
+        "model_name": tts_service.model_name,
+        "device": tts_service.get_device(),
+        "sample_rate": tts_service.sample_rate,
+        "max_text_length": 1000,
+        "speed_range": {"min": 0.5, "max": 2.0, "default": 1.0}
+    }

app/services/__init__.py

@@ -0,0 +1 @@
+# Services

app/services/learning_service.py

@@ -0,0 +1,264 @@
+"""
+Learning Service - Vocabulary, Alphabet, and SRS (Spaced Repetition System)
+"""
+
+import json
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from datetime import datetime, timedelta
+
+
+class LearningService:
+    """Service for vocabulary and learning features"""
+    
+    def __init__(self):
+        self.data_dir = Path(__file__).parent.parent / "data"
+        self._vocabulary: Dict[str, Any] = {}
+        self._alphabet: Dict[str, Any] = {}
+        self._progress: Dict[str, Any] = {}  # In-memory progress (for now)
+        self._load_data()
+    
+    def _load_data(self):
+        """Load vocabulary and alphabet data"""
+        try:
+            vocab_path = self.data_dir / "vocabulary.json"
+            if vocab_path.exists():
+                with open(vocab_path, "r", encoding="utf-8") as f:
+                    self._vocabulary = json.load(f)
+            else:
+                self._vocabulary = self._get_default_vocabulary()
+                
+            alphabet_path = self.data_dir / "alphabet.json"
+            if alphabet_path.exists():
+                with open(alphabet_path, "r", encoding="utf-8") as f:
+                    self._alphabet = json.load(f)
+            else:
+                self._alphabet = self._get_default_alphabet()
+                
+        except Exception as e:
+            print(f"Error loading data: {e}")
+            self._vocabulary = self._get_default_vocabulary()
+            self._alphabet = self._get_default_alphabet()
+    
+    def get_vocabulary_categories(self) -> List[str]:
+        """Get list of vocabulary categories"""
+        return list(self._vocabulary.get("categories", {}).keys())
+    
+    def get_vocabulary_by_category(self, category: Optional[str] = None) -> Dict[str, Any]:
+        """Get vocabulary items, optionally filtered by category"""
+        categories = self._vocabulary.get("categories", {})
+        
+        if category and category in categories:
+            return {
+                "category_id": category,
+                "category_name_zh": categories[category].get("name_zh", category),
+                "category_name_en": categories[category].get("name_en", category),
+                "items": categories[category].get("items", [])
+            }
+        
+        # Return all categories
+        result = []
+        for cat_id, cat_data in categories.items():
+            result.append({
+                "category_id": cat_id,
+                "category_name_zh": cat_data.get("name_zh", cat_id),
+                "category_name_en": cat_data.get("name_en", cat_id),
+                "items": cat_data.get("items", [])
+            })
+        return {"categories": result}
+    
+    def get_alphabet(self) -> Dict[str, Any]:
+        """Get Tibetan alphabet data"""
+        return self._alphabet
+    
+    def get_flashcards(self, category: Optional[str] = None, limit: int = 10) -> List[Dict[str, Any]]:
+        """Get flashcards for practice"""
+        all_items = []
+        categories = self._vocabulary.get("categories", {})
+        
+        if category and category in categories:
+            all_items = categories[category].get("items", [])
+        else:
+            for cat_data in categories.values():
+                all_items.extend(cat_data.get("items", []))
+        
+        # Apply SRS ordering (items due for review first)
+        # For now, just return items in order
+        return all_items[:limit]
+    
+    def update_progress(self, vocabulary_id: str, quality: int) -> Dict[str, Any]:
+        """
+        Update learning progress using SM-2 algorithm
+        
+        quality: 0-5 (0=complete blackout, 5=perfect response)
+        """
+        progress = self._progress.get(vocabulary_id, {
+            "ease_factor": 2.5,
+            "interval_days": 1,
+            "repetitions": 0,
+            "next_review": None
+        })
+        
+        # SM-2 Algorithm
+        if quality >= 3:
+            # Correct response
+            if progress["repetitions"] == 0:
+                progress["interval_days"] = 1
+            elif progress["repetitions"] == 1:
+                progress["interval_days"] = 6
+            else:
+                progress["interval_days"] = round(
+                    progress["interval_days"] * progress["ease_factor"]
+                )
+            progress["repetitions"] += 1
+        else:
+            # Incorrect response
+            progress["repetitions"] = 0
+            progress["interval_days"] = 1
+        
+        # Update ease factor
+        progress["ease_factor"] = max(
+            1.3,
+            progress["ease_factor"] + (0.1 - (5 - quality) * (0.08 + (5 - quality) * 0.02))
+        )
+        
+        # Calculate next review date
+        next_review = datetime.now() + timedelta(days=progress["interval_days"])
+        progress["next_review"] = next_review.isoformat()
+        
+        self._progress[vocabulary_id] = progress
+        return progress
+    
+    def _get_default_vocabulary(self) -> Dict[str, Any]:
+        """Default vocabulary data"""
+        return {
+            "categories": {
+                "greetings": {
+                    "name_zh": "问候语",
+                    "name_en": "Greetings",
+                    "items": [
+                        {
+                            "id": "greet_001",
+                            "tibetan": "བཀྲ་ཤིས་བདེ་ལེགས།",
+                            "chinese": "扎西德勒（吉祥如意/你好）",
+                            "english": "Tashi Delek (Hello/Blessings)",
+                            "pronunciation": "tashi delek",
+                            "category": "greetings"
+                        },
+                        {
+                            "id": "greet_002",
+                            "tibetan": "ཐུགས་རྗེ་ཆེ།",
+                            "chinese": "谢谢",
+                            "english": "Thank you",
+                            "pronunciation": "thuk je che",
+                            "category": "greetings"
+                        },
+                        {
+                            "id": "greet_003",
+                            "tibetan": "མཇལ་བར་དགའ་པོ་བྱུང་།",
+                            "chinese": "很高兴见到你",
+                            "english": "Nice to meet you",
+                            "pronunciation": "jal war ga po chung",
+                            "category": "greetings"
+                        },
+                        {
+                            "id": "greet_004",
+                            "tibetan": "བདེ་མོ།",
+                            "chinese": "再见",
+                            "english": "Goodbye",
+                            "pronunciation": "de mo",
+                            "category": "greetings"
+                        }
+                    ]
+                },
+                "numbers": {
+                    "name_zh": "数字",
+                    "name_en": "Numbers",
+                    "items": [
+                        {"id": "num_001", "tibetan": "གཅིག", "chinese": "一", "english": "One", "pronunciation": "chik", "category": "numbers"},
+                        {"id": "num_002", "tibetan": "གཉིས", "chinese": "二", "english": "Two", "pronunciation": "nyi", "category": "numbers"},
+                        {"id": "num_003", "tibetan": "གསུམ", "chinese": "三", "english": "Three", "pronunciation": "sum", "category": "numbers"},
+                        {"id": "num_004", "tibetan": "བཞི", "chinese": "四", "english": "Four", "pronunciation": "shi", "category": "numbers"},
+                        {"id": "num_005", "tibetan": "ལྔ", "chinese": "五", "english": "Five", "pronunciation": "nga", "category": "numbers"},
+                        {"id": "num_006", "tibetan": "དྲུག", "chinese": "六", "english": "Six", "pronunciation": "druk", "category": "numbers"},
+                        {"id": "num_007", "tibetan": "བདུན", "chinese": "七", "english": "Seven", "pronunciation": "dün", "category": "numbers"},
+                        {"id": "num_008", "tibetan": "བརྒྱད", "chinese": "八", "english": "Eight", "pronunciation": "gyé", "category": "numbers"},
+                        {"id": "num_009", "tibetan": "དགུ", "chinese": "九", "english": "Nine", "pronunciation": "gu", "category": "numbers"},
+                        {"id": "num_010", "tibetan": "བཅུ", "chinese": "十", "english": "Ten", "pronunciation": "chu", "category": "numbers"}
+                    ]
+                },
+                "colors": {
+                    "name_zh": "颜色",
+                    "name_en": "Colors",
+                    "items": [
+                        {"id": "color_001", "tibetan": "དཀར་པོ", "chinese": "白色", "english": "White", "pronunciation": "kar po", "category": "colors"},
+                        {"id": "color_002", "tibetan": "ནག་པོ", "chinese": "黑色", "english": "Black", "pronunciation": "nak po", "category": "colors"},
+                        {"id": "color_003", "tibetan": "དམར་པོ", "chinese": "红色", "english": "Red", "pronunciation": "mar po", "category": "colors"},
+                        {"id": "color_004", "tibetan": "སྔོན་པོ", "chinese": "蓝色", "english": "Blue", "pronunciation": "ngön po", "category": "colors"},
+                        {"id": "color_005", "tibetan": "སེར་པོ", "chinese": "黄色", "english": "Yellow", "pronunciation": "ser po", "category": "colors"},
+                        {"id": "color_006", "tibetan": "ལྗང་ཁུ", "chinese": "绿色", "english": "Green", "pronunciation": "jang khu", "category": "colors"}
+                    ]
+                },
+                "daily": {
+                    "name_zh": "日常用语",
+                    "name_en": "Daily Phrases",
+                    "items": [
+                        {"id": "daily_001", "tibetan": "ང", "chinese": "我", "english": "I/Me", "pronunciation": "nga", "category": "daily"},
+                        {"id": "daily_002", "tibetan": "ཁྱོད", "chinese": "你", "english": "You", "pronunciation": "khyö", "category": "daily"},
+                        {"id": "daily_003", "tibetan": "ཁོ", "chinese": "他", "english": "He", "pronunciation": "kho", "category": "daily"},
+                        {"id": "daily_004", "tibetan": "མོ", "chinese": "她", "english": "She", "pronunciation": "mo", "category": "daily"},
+                        {"id": "daily_005", "tibetan": "ཡིན།", "chinese": "是", "english": "Yes/Is", "pronunciation": "yin", "category": "daily"},
+                        {"id": "daily_006", "tibetan": "མིན།", "chinese": "不是", "english": "No/Is not", "pronunciation": "min", "category": "daily"},
+                        {"id": "daily_007", "tibetan": "དགོས།", "chinese": "需要", "english": "Need", "pronunciation": "gö", "category": "daily"},
+                        {"id": "daily_008", "tibetan": "ཆུ", "chinese": "水", "english": "Water", "pronunciation": "chu", "category": "daily"}
+                    ]
+                }
+            }
+        }
+    
+    def _get_default_alphabet(self) -> Dict[str, Any]:
+        """Default Tibetan alphabet data"""
+        return {
+            "consonants": [
+                {"id": "con_01", "letter": "ཀ", "unicode": "U+0F40", "pronunciation": "ka", "description_zh": "清辅音，类似汉语拼音'k'", "description_en": "Voiceless velar stop, like 'k' in 'kite'"},
+                {"id": "con_02", "letter": "ཁ", "unicode": "U+0F41", "pronunciation": "kha", "description_zh": "送气音，类似'k'但带强气流", "description_en": "Aspirated 'k', like 'k' in 'king' with more breath"},
+                {"id": "con_03", "letter": "ག", "unicode": "U+0F42", "pronunciation": "ga", "description_zh": "浊辅音，类似汉语拼音'g'", "description_en": "Voiced velar stop, like 'g' in 'go'"},
+                {"id": "con_04", "letter": "ང", "unicode": "U+0F44", "pronunciation": "nga", "description_zh": "鼻音，类似汉语拼音'ng'", "description_en": "Velar nasal, like 'ng' in 'sing'"},
+                {"id": "con_05", "letter": "ཅ", "unicode": "U+0F45", "pronunciation": "ca", "description_zh": "塞擦音，类似汉语拼音'j'", "description_en": "Voiceless palatal affricate, like 'ch' in 'church'"},
+                {"id": "con_06", "letter": "ཆ", "unicode": "U+0F46", "pronunciation": "cha", "description_zh": "送气塞擦音", "description_en": "Aspirated 'ch'"},
+                {"id": "con_07", "letter": "ཇ", "unicode": "U+0F47", "pronunciation": "ja", "description_zh": "浊塞擦音，类似汉语拼音'zh'", "description_en": "Voiced palatal affricate, like 'j' in 'judge'"},
+                {"id": "con_08", "letter": "ཉ", "unicode": "U+0F49", "pronunciation": "nya", "description_zh": "鼻音，类似西班牙语'ñ'", "description_en": "Palatal nasal, like 'ny' in 'canyon'"},
+                {"id": "con_09", "letter": "ཏ", "unicode": "U+0F4F", "pronunciation": "ta", "description_zh": "清塞音，类似汉语拼音't'", "description_en": "Voiceless dental stop, like 't' in 'top'"},
+                {"id": "con_10", "letter": "ཐ", "unicode": "U+0F50", "pronunciation": "tha", "description_zh": "送气塞音", "description_en": "Aspirated 't'"},
+                {"id": "con_11", "letter": "ད", "unicode": "U+0F51", "pronunciation": "da", "description_zh": "浊塞音，类似汉语拼音'd'", "description_en": "Voiced dental stop, like 'd' in 'dog'"},
+                {"id": "con_12", "letter": "ན", "unicode": "U+0F53", "pronunciation": "na", "description_zh": "鼻音，类似汉语拼音'n'", "description_en": "Dental nasal, like 'n' in 'no'"},
+                {"id": "con_13", "letter": "པ", "unicode": "U+0F54", "pronunciation": "pa", "description_zh": "清塞音，类似汉语拼音'p'", "description_en": "Voiceless bilabial stop, like 'p' in 'pot'"},
+                {"id": "con_14", "letter": "ཕ", "unicode": "U+0F55", "pronunciation": "pha", "description_zh": "送气塞音", "description_en": "Aspirated 'p'"},
+                {"id": "con_15", "letter": "བ", "unicode": "U+0F56", "pronunciation": "ba", "description_zh": "浊塞音，类似汉语拼音'b'", "description_en": "Voiced bilabial stop, like 'b' in 'boy'"},
+                {"id": "con_16", "letter": "མ", "unicode": "U+0F58", "pronunciation": "ma", "description_zh": "鼻音，类似汉语拼音'm'", "description_en": "Bilabial nasal, like 'm' in 'mom'"},
+                {"id": "con_17", "letter": "ཙ", "unicode": "U+0F59", "pronunciation": "tsa", "description_zh": "塞擦音，类似汉语拼音'c'", "description_en": "Voiceless alveolar affricate, like 'ts' in 'cats'"},
+                {"id": "con_18", "letter": "ཚ", "unicode": "U+0F5A", "pronunciation": "tsha", "description_zh": "送气塞擦音", "description_en": "Aspirated 'ts'"},
+                {"id": "con_19", "letter": "ཛ", "unicode": "U+0F5B", "pronunciation": "dza", "description_zh": "浊塞擦音，类似汉语拼音'z'", "description_en": "Voiced alveolar affricate, like 'dz' in 'adze'"},
+                {"id": "con_20", "letter": "ཝ", "unicode": "U+0F5D", "pronunciation": "wa", "description_zh": "半元音，类似汉语拼音'w'", "description_en": "Labial approximant, like 'w' in 'water'"},
+                {"id": "con_21", "letter": "ཞ", "unicode": "U+0F5E", "pronunciation": "zha", "description_zh": "浊擦音，类似汉语拼音'r'", "description_en": "Voiced retroflex fricative, like 'zh' in 'measure'"},
+                {"id": "con_22", "letter": "ཟ", "unicode": "U+0F5F", "pronunciation": "za", "description_zh": "浊擦音，类似汉语拼音'z'", "description_en": "Voiced alveolar fricative, like 'z' in 'zoo'"},
+                {"id": "con_23", "letter": "འ", "unicode": "U+0F60", "pronunciation": "'a", "description_zh": "声门塞音，表示元音开始", "description_en": "Glottal stop, used as a vowel carrier"},
+                {"id": "con_24", "letter": "ཡ", "unicode": "U+0F61", "pronunciation": "ya", "description_zh": "半元音，类似汉语拼音'y'", "description_en": "Palatal approximant, like 'y' in 'yes'"},
+                {"id": "con_25", "letter": "ར", "unicode": "U+0F62", "pronunciation": "ra", "description_zh": "颤音，类似西班牙语'r'", "description_en": "Alveolar trill, like rolled 'r'"},
+                {"id": "con_26", "letter": "ལ", "unicode": "U+0F63", "pronunciation": "la", "description_zh": "边音，类似汉语拼音'l'", "description_en": "Alveolar lateral, like 'l' in 'love'"},
+                {"id": "con_27", "letter": "ཤ", "unicode": "U+0F64", "pronunciation": "sha", "description_zh": "清擦音，类似汉语拼音'sh'", "description_en": "Voiceless palatal fricative, like 'sh' in 'ship'"},
+                {"id": "con_28", "letter": "ས", "unicode": "U+0F66", "pronunciation": "sa", "description_zh": "清擦音，类似汉语拼音's'", "description_en": "Voiceless alveolar fricative, like 's' in 'sun'"},
+                {"id": "con_29", "letter": "ཧ", "unicode": "U+0F67", "pronunciation": "ha", "description_zh": "清擦音，类似汉语拼音'h'", "description_en": "Voiceless glottal fricative, like 'h' in 'hat'"},
+                {"id": "con_30", "letter": "ཨ", "unicode": "U+0F68", "pronunciation": "a", "description_zh": "元音字母", "description_en": "Vowel letter 'a'"}
+            ],
+            "vowels": [
+                {"id": "vow_01", "letter": "ི", "unicode": "U+0F72", "pronunciation": "i", "description_zh": "元音符号 i，加在辅音上方", "description_en": "Vowel sign 'i', placed above the consonant"},
+                {"id": "vow_02", "letter": "ུ", "unicode": "U+0F74", "pronunciation": "u", "description_zh": "元音符号 u，加在辅音下方", "description_en": "Vowel sign 'u', placed below the consonant"},
+                {"id": "vow_03", "letter": "ེ", "unicode": "U+0F7A", "pronunciation": "e", "description_zh": "元音符号 e，加在辅音上方", "description_en": "Vowel sign 'e', placed above the consonant"},
+                {"id": "vow_04", "letter": "ོ", "unicode": "U+0F7C", "pronunciation": "o", "description_zh": "元音符号 o，加在辅音上方", "description_en": "Vowel sign 'o', placed above the consonant"}
+            ]
+        }
+
+
+# Singleton instance
+learning_service = LearningService()

app/services/translate_service.py

@@ -0,0 +1,327 @@
+"""
+Translation Service for Tibetan ↔ Chinese ↔ English
+Uses Google Translate with improved parsing and local dictionary
+"""
+
+import httpx
+from typing import Optional, Dict, Any, List
+import re
+
+class TranslationService:
+    """Translation service supporting multiple backends"""
+    
+    # Language code mapping
+    LANGUAGE_NAMES = {
+        "bo": {"zh": "藏语", "en": "Tibetan"},
+        "zh": {"zh": "中文", "en": "Chinese"},
+        "en": {"zh": "英语", "en": "English"}
+    }
+    
+    # Extended dictionary for common phrases
+    DICTIONARY = {
+        # Tibetan -> Chinese
+        ("bo", "zh"): {
+            "བཀྲ་ཤིས་བདེ་ལེགས།": "扎西德勒（吉祥如意/你好）",
+            "ཐུགས་རྗེ་ཆེ།": "谢谢",
+            "བདེ་མོ།": "再见",
+            "མཇལ་བར་དགའ་པོ་བྱུང་།": "很高兴见到你",
+            "ཡིན།": "是",
+            "མིན།": "不是",
+            "གཅིག": "一",
+            "གཉིས": "二",
+            "གསུམ": "三",
+            "བཞི": "四",
+            "ལྔ": "五",
+            "དྲུག": "六",
+            "བདུན": "七",
+            "བརྒྱད": "八",
+            "དགུ": "九",
+            "བཅུ": "十",
+            "དཀར་པོ": "白色",
+            "ནག་པོ": "黑色",
+            "དམར་པོ": "红色",
+            "སྔོན་པོ": "蓝色",
+            "སེར་པོ": "黄色",
+            "ལྗང་ཁུ": "绿色",
+            "ང": "我",
+            "ཁྱོད": "你",
+            "ཁོ": "他",
+            "མོ": "她",
+            "ཆུ": "水",
+            "དགོས།": "需要",
+        },
+        # Tibetan -> English
+        ("bo", "en"): {
+            "བཀྲ་ཤིས་བདེ་ལེགས།": "Tashi Delek (Hello/Blessings)",
+            "ཐུགས་རྗེ་ཆེ།": "Thank you",
+            "བདེ་མོ།": "Goodbye",
+            "མཇལ་བར་དགའ་པོ་བྱུང་།": "Nice to meet you",
+            "ཡིན།": "Yes / Is",
+            "མིན།": "No / Is not",
+            "གཅིག": "One",
+            "གཉིས": "Two",
+            "གསུམ": "Three",
+            "བཞི": "Four",
+            "ལྔ": "Five",
+            "དཀར་པོ": "White",
+            "ནག་པོ": "Black",
+            "དམར་པོ": "Red",
+            "སྔོན་པོ": "Blue",
+            "ང": "I / Me",
+            "ཁྱོད": "You",
+            "ཆུ": "Water",
+        },
+        # Chinese -> Tibetan
+        ("zh", "bo"): {
+            "你好": "བཀྲ་ཤིས་བདེ་ལེགས།",
+            "谢谢": "ཐུགས་རྗེ་ཆེ།",
+            "再见": "བདེ་མོ།",
+            "很高兴见到你": "མཇལ་བར་དགའ་པོ་བྱུང་།",
+            "是": "ཡིན།",
+            "不是": "མིན།",
+            "一": "གཅིག",
+            "二": "གཉིས",
+            "三": "གསུམ",
+            "四": "བཞི",
+            "五": "ལྔ",
+            "六": "དྲུག",
+            "七": "བདུན",
+            "八": "བརྒྱད",
+            "九": "དགུ",
+            "十": "བཅུ",
+            "白色": "དཀར་པོ",
+            "黑色": "ནག་པོ",
+            "红色": "དམར་པོ",
+            "蓝色": "སྔོན་པོ",
+            "黄色": "སེར་པོ",
+            "绿色": "ལྗང་ཁུ",
+            "我": "ང",
+            "你": "ཁྱོད",
+            "他": "ཁོ",
+            "她": "མོ",
+            "水": "ཆུ",
+            "需要": "དགོས།",
+        },
+        # English -> Tibetan
+        ("en", "bo"): {
+            "hello": "བཀྲ་ཤིས་བདེ་ལེགས།",
+            "thank you": "ཐུགས་རྗེ་ཆེ།",
+            "thanks": "ཐུགས་རྗེ་ཆེ།",
+            "goodbye": "བདེ་མོ།",
+            "bye": "བདེ་མོ།",
+            "yes": "ཡིན།",
+            "no": "མིན།",
+            "one": "གཅིག",
+            "two": "གཉིས",
+            "three": "གསུམ",
+            "four": "བཞི",
+            "five": "ལྔ",
+            "white": "དཀར་པོ",
+            "black": "ནག་པོ",
+            "red": "དམར་པོ",
+            "blue": "སྔོན་པོ",
+            "yellow": "སེར་པོ",
+            "green": "ལྗང་ཁུ",
+            "i": "ང",
+            "you": "ཁྱོད",
+            "water": "ཆུ",
+        },
+    }
+    
+    # Pronunciation mappings for Tibetan words
+    PRONUNCIATION = {
+        "བཀྲ་ཤིས་བདེ་ལེགས།": "tashi delek",
+        "ཐུགས་རྗེ་ཆེ།": "thuk je che",
+        "བདེ་མོ།": "de mo",
+        "མཇལ་བར་དགའ་པོ་བྱུང་།": "jal war ga po chung",
+        "ཡིན།": "yin",
+        "མིན།": "min",
+        "གཅིག": "chik",
+        "གཉིས": "nyi",
+        "གསུམ": "sum",
+        "བཞི": "shi",
+        "ལྔ": "nga",
+        "དྲུག": "druk",
+        "བདུན": "dün",
+        "བརྒྱད": "gyé",
+        "དགུ": "gu",
+        "བཅུ": "chu",
+        "དཀར་པོ": "kar po",
+        "ནག་པོ": "nak po",
+        "དམར་པོ": "mar po",
+        "སྔོན་པོ": "ngön po",
+        "སེར་པོ": "ser po",
+        "ལྗང་ཁུ": "jang khu",
+        "ང": "nga",
+        "ཁྱོད": "khyö",
+        "ཁོ": "kho",
+        "མོ": "mo",
+        "ཆུ": "chu",
+        "དགོས།": "gö",
+    }
+
+    def __init__(self):
+        self.client = httpx.AsyncClient(timeout=30.0)
+    
+    async def translate(
+        self, 
+        text: str, 
+        source: str, 
+        target: str
+    ) -> Dict[str, Any]:
+        """
+        Translate text between languages
+        """
+        text = text.strip()
+        
+        if not text:
+            return {
+                "success": False,
+                "translation": None,
+                "pronunciation": None,
+                "source_language": self.LANGUAGE_NAMES.get(source, {}).get("en", source),
+                "target_language": self.LANGUAGE_NAMES.get(target, {}).get("en", target),
+                "error": "Empty text"
+            }
+        
+        if source == target:
+            return {
+                "success": True,
+                "translation": text,
+                "pronunciation": self.PRONUNCIATION.get(text) if source == "bo" else None,
+                "source_language": self.LANGUAGE_NAMES[source]["en"],
+                "target_language": self.LANGUAGE_NAMES[target]["en"]
+            }
+        
+        # Try dictionary first
+        result = self._translate_dictionary(text, source, target)
+        if result.get("success"):
+            return result
+        
+        # Try Google Translate as fallback
+        result = await self._translate_google(text, source, target)
+        if result and result.get("success"):
+            return result
+        
+        # Return error if nothing works
+        return {
+            "success": False,
+            "translation": None,
+            "pronunciation": None,
+            "source_language": self.LANGUAGE_NAMES.get(source, {}).get("en", source),
+            "target_language": self.LANGUAGE_NAMES.get(target, {}).get("en", target),
+            "error": f"无法翻译此文本。"
+        }
+    
+    def _translate_dictionary(
+        self, 
+        text: str, 
+        source: str, 
+        target: str
+    ) -> Dict[str, Any]:
+        """Dictionary-based translation"""
+        key = (source, target)
+        lookup = self.DICTIONARY.get(key, {})
+        
+        # Normalize text: strip punctuation like '?' or '！' for lookup
+        clean_text = text.strip().rstrip("?.!！。")
+        lookup_text_lower = clean_text.lower()
+        
+        translation = lookup.get(lookup_text_lower) or lookup.get(clean_text) or lookup.get(text.strip())
+        
+        if translation:
+            pronunciation = None
+            if target == "bo":
+                pronunciation = self.PRONUNCIATION.get(translation)
+            elif source == "bo":
+                pronunciation = self.PRONUNCIATION.get(text.strip())
+            
+            return {
+                "success": True,
+                "translation": translation,
+                "pronunciation": pronunciation,
+                "source_language": self.LANGUAGE_NAMES[source]["en"],
+                "target_language": self.LANGUAGE_NAMES[target]["en"]
+            }
+        
+        return {"success": False}
+    
+    async def _translate_google(
+        self, 
+        text: str, 
+        source: str, 
+        target: str
+    ) -> Optional[Dict[str, Any]]:
+        """Translate using Google Translate API"""
+        try:
+            # Map language codes
+            lang_map = {"bo": "bo", "zh": "zh-CN", "en": "en"}
+            src = lang_map.get(source, source)
+            tgt = lang_map.get(target, target)
+            
+            url = "https://translate.googleapis.com/translate_a/single"
+            params = [
+                ("client", "gtx"),
+                ("sl", src),
+                ("tl", tgt),
+                ("dt", "t"),
+                ("dt", "rm"),
+                ("q", text)
+            ]
+            
+            response = await self.client.get(url, params=params)
+            
+            if response.status_code == 200:
+                data = response.json()
+                
+                # Parse response
+                translation = ""
+                pronunciation = None
+                
+                if data and isinstance(data, list) and len(data) > 0:
+                    # Extract translation
+                    if data[0] and isinstance(data[0], list):
+                        for part in data[0]:
+                            if isinstance(part, list) and len(part) > 0 and part[0]:
+                                translation += str(part[0])
+                    
+                    # Pronunciation extraction
+                    # IMPORTANT: For target=bo (Tibetan), Google often returns corrupt or Source-language pronunciation (like Pinyin)
+                    # We MUST DISABLE pronunciation for Tibetan target unless we are sure it's valid.
+                    
+                    if target != "bo":
+                        # Only try to extract pronunciation if target is NOT Tibetan
+                        # Because for Tibetan target, Google returns garbage or Pinyin
+                        for item in data[0]:
+                            if isinstance(item, list) and len(item) > 2 and isinstance(item[2], str) and item[2]:
+                                pronunciation = item[2]
+                                break
+                                
+                    # If we accidentally got pinyin for Tibetan, clear it
+                    # Pinyin usually has tone marks, Tibetan romanization usually doesn't (or looks different)
+                    # But safest is just to never trust Google's pronunciation for Tibetan target
+                    if target == "bo":
+                        pronunciation = None
+
+                if translation:
+                    return {
+                        "success": True,
+                        "translation": translation,
+                        "pronunciation": pronunciation,
+                        "source_language": self.LANGUAGE_NAMES[source]["en"],
+                        "target_language": self.LANGUAGE_NAMES[target]["en"]
+                    }
+            
+            return None
+            
+        except Exception as e:
+            print(f"Google Translate error: {e}")
+            return None
+
+    async def close(self):
+        """Close the HTTP client"""
+        await self.client.aclose()
+
+
+# Singleton instance
+translate_service = TranslationService()

app/services/tts_service.py

@@ -0,0 +1,165 @@
+"""
+Tibetan Text-to-Speech Service
+Migrated from original Streamlit app, using Meta's MMS (facebook/mms-tts-bod) model
+"""
+
+import torch
+import numpy as np
+import scipy.signal
+import scipy.io.wavfile
+from io import BytesIO
+from typing import Tuple, Optional
+import asyncio
+from functools import lru_cache
+import warnings
+
+warnings.filterwarnings('ignore')
+
+
+class TibetanTTSService:
+    """Backend service for Tibetan Text-to-Speech using Meta's MMS model"""
+
+    def __init__(self, model_name: str = "facebook/mms-tts-bod"):
+        """Initialize the TTS service"""
+        self.model_name = model_name
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model = None
+        self.tokenizer = None
+        self.sample_rate = 16000  # Default sample rate for MMS-TTS
+        self._loaded = False
+
+    async def load_model(self) -> bool:
+        """Load the model and tokenizer (async wrapper)"""
+        # Run in executor to avoid blocking
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._load_model_sync)
+
+    def _load_model_sync(self) -> bool:
+        """Synchronous model loading"""
+        try:
+            from transformers import VitsModel, AutoTokenizer
+            
+            print(f"Loading model {self.model_name} on {self.device}...")
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = VitsModel.from_pretrained(self.model_name)
+            self.model.to(self.device)
+            self.model.eval()
+            self._loaded = True
+            print(f"✅ Model loaded successfully on {self.device}")
+            return True
+        except Exception as e:
+            print(f"❌ Error loading model: {str(e)}")
+            return False
+
+    def is_loaded(self) -> bool:
+        """Check if model is loaded"""
+        return self._loaded
+
+    def get_device(self) -> str:
+        """Get current device"""
+        return self.device
+
+    def preprocess_text(self, text: str) -> str:
+        """Normalize and prepare text for the model"""
+        # Basic preprocessing: strip whitespace
+        text = text.strip()
+
+        # Check if text is empty
+        if not text:
+            raise ValueError("Input text cannot be empty")
+
+        # Check text length (MMS models typically have a max length)
+        if len(text) > 1000:
+            raise ValueError("Input text is too long. Please limit to 1000 characters.")
+
+        return text
+
+    def adjust_speed(self, audio: np.ndarray, original_rate: int, speed_factor: float) -> Tuple[np.ndarray, int]:
+        """
+        Adjust audio speed without changing pitch using resampling
+
+        Args:
+            audio: numpy array of audio samples
+            original_rate: original sample rate
+            speed_factor: speed multiplier (0.5 = slower, 2.0 = faster)
+
+        Returns:
+            Modified audio array and sample rate
+        """
+        if speed_factor == 1.0:
+            return audio, original_rate
+
+        # Calculate the number of samples in the output
+        num_samples = int(len(audio) / speed_factor)
+
+        # Use scipy's resample for high-quality speed adjustment
+        resampled_audio = scipy.signal.resample(audio, num_samples)
+
+        return resampled_audio, original_rate
+
+    async def generate_audio(self, text: str, speed: float = 1.0) -> Tuple[np.ndarray, int]:
+        """
+        Generate audio from text with optional speed adjustment (async)
+
+        Args:
+            text: Input Tibetan text
+            speed: Speed factor (0.5 to 2.0)
+
+        Returns:
+            tuple: (audio_array, sample_rate)
+        """
+        # Run in executor to avoid blocking
+        loop = asyncio.get_event_loop()
+        return await loop.run_in_executor(None, self._generate_audio_sync, text, speed)
+
+    def _generate_audio_sync(self, text: str, speed: float = 1.0) -> Tuple[np.ndarray, int]:
+        """Synchronous audio generation"""
+        if not self._loaded:
+            raise RuntimeError("TTS model not loaded. Call load_model() first.")
+
+        try:
+            # Preprocess text
+            text = self.preprocess_text(text)
+
+            # Tokenize input
+            inputs = self.tokenizer(text, return_tensors="pt")
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+
+            # Generate audio
+            with torch.no_grad():
+                output = self.model(**inputs)
+                audio = output.waveform
+
+            # Convert to numpy array
+            audio_np = audio.squeeze().cpu().numpy()
+
+            # Normalize audio to prevent clipping
+            audio_np = audio_np / np.max(np.abs(audio_np)) * 0.95
+
+            # Apply speed adjustment
+            if speed != 1.0:
+                audio_np, sample_rate = self.adjust_speed(audio_np, self.sample_rate, speed)
+            else:
+                sample_rate = self.sample_rate
+
+            return audio_np, sample_rate
+
+        except Exception as e:
+            raise RuntimeError(f"Error generating audio: {str(e)}")
+
+    def audio_to_wav_bytes(self, audio: np.ndarray, sample_rate: int) -> BytesIO:
+        """Convert audio array to WAV bytes for response"""
+        byte_io = BytesIO()
+        # Convert to 16-bit PCM
+        audio_int16 = (audio * 32767).astype(np.int16)
+        scipy.io.wavfile.write(byte_io, sample_rate, audio_int16)
+        byte_io.seek(0)
+        return byte_io
+
+    def get_audio_duration(self, audio: np.ndarray, sample_rate: int) -> float:
+        """Get audio duration in seconds"""
+        return len(audio) / sample_rate
+
+
+# Singleton instance
+tts_service = TibetanTTSService()

requirements.txt

@@ -0,0 +1,23 @@
+# FastAPI Backend Dependencies
+fastapi>=0.104.0
+uvicorn[standard]>=0.24.0
+python-multipart>=0.0.6
+
+# TTS Dependencies (from original app)
+torch>=2.0.0
+transformers>=4.30.0
+scipy>=1.10.0
+numpy>=1.24.0
+soundfile>=0.12.1
+
+# Translation & HTTP
+httpx>=0.25.0
+aiohttp>=3.9.0
+
+# Database
+sqlalchemy>=2.0.0
+aiosqlite>=0.19.0
+
+# Utilities
+pydantic>=2.5.0
+python-dotenv>=1.0.0