v1.3

backend/main.py

@@ -9,7 +9,7 @@ import os
 from config import get_settings
 from database import connect_db, close_db
 
-from routers import auth, resume, profile, interview, reports, admin
+from routers import auth, resume, profile, interview, reports, admin, speech
 
 settings = get_settings()
 
@@ -48,6 +48,7 @@ app.include_router(profile.router, prefix="/profile", tags=["Profile"])
 app.include_router(interview.router, prefix="/interview", tags=["Interview"])
 app.include_router(reports.router, prefix="/reports", tags=["Reports"])
 app.include_router(admin.router, prefix="/admin", tags=["Admin"])
+app.include_router(speech.router, prefix="/speech", tags=["Speech"])
 
 
 @app.get("/health")

backend/routers/profile.py

@@ -24,6 +24,9 @@ async def get_profile(current_user: dict = Depends(get_current_user)):
         "name": current_user.get("name", ""),
         "email": current_user.get("email", ""),
         "role": current_user.get("role", "student"),
+        "speech_settings": {
+            "voice_gender": (user or {}).get("speech_settings", {}).get("voice_gender", "female"),
+        },
     }
 
     # Get resume info
@@ -45,6 +48,27 @@ async def get_profile(current_user: dict = Depends(get_current_user)):
 
     return profile
 
+
+@router.put("/speech-settings")
+async def update_speech_settings(
+    request_data: dict,
+    current_user: dict = Depends(get_current_user),
+):
+    """Update user's speech assistant preferences."""
+    db = get_db()
+    voice_gender = (request_data.get("voice_gender") or "female").strip().lower()
+    if voice_gender not in {"male", "female", "auto"}:
+        raise HTTPException(status_code=400, detail="voice_gender must be one of: male, female, auto")
+
+    await db[USERS].update_one(
+        {"_id": ObjectId(current_user["user_id"])},
+        {"$set": {"speech_settings.voice_gender": voice_gender}},
+    )
+    return {
+        "message": "Speech settings updated successfully",
+        "speech_settings": {"voice_gender": voice_gender},
+    }
+
 @router.put("/skills")
 async def update_user_skills(
     request_data: dict,  # Or use UpdateSkillsRequest if imported

backend/routers/speech.py

@@ -0,0 +1,36 @@
+from fastapi import APIRouter, Depends, HTTPException
+from fastapi.responses import Response
+from pydantic import BaseModel
+
+from auth.jwt import get_current_user
+from services.tts_service import synthesize_wav
+
+router = APIRouter()
+
+
+class SpeechSynthesisRequest(BaseModel):
+    text: str
+    voice_gender: str = "female"
+
+
+@router.get("/health")
+async def speech_health(current_user: dict = Depends(get_current_user)):
+    """Check whether speech route is available for authenticated users."""
+    return {"status": "ok", "service": "speech"}
+
+
+@router.post("/synthesize")
+async def synthesize_speech(
+    request: SpeechSynthesisRequest,
+    current_user: dict = Depends(get_current_user),
+):
+    """Synthesize text to WAV bytes using Coqui TTS models."""
+    try:
+        wav_bytes = await synthesize_wav(request.text, request.voice_gender)
+        return Response(content=wav_bytes, media_type="audio/wav")
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+    except RuntimeError as e:
+        raise HTTPException(status_code=503, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Speech synthesis failed: {str(e)}")

backend/services/auth_service.py

@@ -25,6 +25,9 @@ async def signup_user(name: str, email: str, password: str, role: str = None) ->
         "email": email,
         "password": hashed_password,
         "role": determined_role,
+        "speech_settings": {
+            "voice_gender": "female",
+        },
         "created_at": utc_now(),
     }
 

backend/services/tts_service.py

@@ -0,0 +1,65 @@
+import asyncio
+import os
+import tempfile
+from typing import Tuple
+
+_MODEL_CACHE = {}
+_MODEL_LOCK = asyncio.Lock()
+
+
+def _select_model(voice_gender: str) -> Tuple[str, str | None]:
+    gender = (voice_gender or "female").strip().lower()
+    if gender == "male":
+        # Multi-speaker model; use a male VCTK speaker token.
+        return "tts_models/en/vctk/vits", "p226"
+    # Default female-like English voice model.
+    return "tts_models/en/ljspeech/tacotron2-DDC", None
+
+
+async def _get_tts_model(model_name: str):
+    async with _MODEL_LOCK:
+        if model_name in _MODEL_CACHE:
+            return _MODEL_CACHE[model_name]
+
+        def _load_model():
+            try:
+                from TTS.api import TTS
+            except Exception as exc:
+                raise RuntimeError(
+                    "Coqui TTS is not installed in the active Python environment"
+                ) from exc
+
+            # Use CPU by default for compatibility.
+            return TTS(model_name=model_name, progress_bar=False, gpu=False)
+
+        model = await asyncio.to_thread(_load_model)
+        _MODEL_CACHE[model_name] = model
+        return model
+
+
+async def synthesize_wav(text: str, voice_gender: str = "female") -> bytes:
+    content = (text or "").strip()
+    if not content:
+        raise ValueError("text is required")
+
+    model_name, speaker = _select_model(voice_gender)
+    tts = await _get_tts_model(model_name)
+
+    fd, tmp_path = tempfile.mkstemp(suffix=".wav")
+    os.close(fd)
+    try:
+        def _synthesize():
+            kwargs = {
+                "text": content,
+                "file_path": tmp_path,
+            }
+            if speaker:
+                kwargs["speaker"] = speaker
+            tts.tts_to_file(**kwargs)
+
+        await asyncio.to_thread(_synthesize)
+        with open(tmp_path, "rb") as f:
+            return f.read()
+    finally:
+        if os.path.exists(tmp_path):
+            os.remove(tmp_path)