Refactor audio processing and chatbot services; enhance STT and TTS functionalities with base64 support and session management

config.py

@@ -17,8 +17,8 @@ PROJECT_ROOT = API_DIR.parent
 
 # ============ HUGGING FACE ============
 HUGGINGFACE_API_KEY = os.getenv("HUGGINGFACE_API_KEY", "")
-HUGGINGFACE_STANCE_MODEL_ID = os.getenv("HUGGINGFACE_STANCE_MODEL_ID", "NLP-Debater-Project/debertav3-stance-detection")
-HUGGINGFACE_LABEL_MODEL_ID = os.getenv("HUGGINGFACE_LABEL_MODEL_ID", "NLP-Debater-Project/distilBert-keypoint-matching")
+HUGGINGFACE_STANCE_MODEL_ID = os.getenv("HUGGINGFACE_STANCE_MODEL_ID")
+HUGGINGFACE_LABEL_MODEL_ID = os.getenv("HUGGINGFACE_LABEL_MODEL_ID")
 
 # ============ API CONFIGURATION ============
 API_TITLE = "NLP Debater - Voice Chatbot API"

main.py

@@ -58,7 +58,7 @@ from config import (
     HOST, PORT, RELOAD,
     CORS_ORIGINS, CORS_CREDENTIALS, CORS_METHODS, CORS_HEADERS,
     PRELOAD_MODELS_ON_STARTUP, LOAD_STANCE_MODEL, LOAD_KPA_MODEL,
-    LOAD_STT_MODEL, LOAD_CHATBOT_MODEL
+    LOAD_STT_MODEL, LOAD_CHATBOT_MODEL, STT_MODEL_ID, CHATBOT_MODEL_ID
 )
 
 @asynccontextmanager
@@ -92,9 +92,10 @@ async def lifespan(app: FastAPI):
         # Load STT Model (Speech-to-Text)
         if LOAD_STT_MODEL:
             try:
-                logger.info("Loading STT Model (Whisper)...")
-                from services.stt_service import load_stt_model
-                load_stt_model()
+                logger.info(f"Loading STT Model: {STT_MODEL_ID}")
+                from services.stt_service import STTService
+                stt_service = STTService()
+                await stt_service.initialize()
                 logger.info("✓ STT model loaded successfully")
             except Exception as e:
                 logger.error(f"✗ STT model loading failed: {str(e)}")
@@ -102,9 +103,10 @@ async def lifespan(app: FastAPI):
         # Load Chatbot Model
         if LOAD_CHATBOT_MODEL:
             try:
-                logger.info("Loading Chatbot Model (DialoGPT)...")
-                from services.chatbot_service import load_chatbot_model
-                load_chatbot_model()
+                logger.info(f"Loading Chatbot Model: {CHATBOT_MODEL_ID}")
+                from services.chatbot_service import ChatbotService
+                chatbot_service = ChatbotService()
+                await chatbot_service.initialize()
                 logger.info("✓ Chatbot model loaded successfully")
             except Exception as e:
                 logger.error(f"✗ Chatbot model loading failed: {str(e)}")
@@ -139,9 +141,16 @@ app.add_middleware(
 )
 
 # Include routers
+try:
+    from routes.audio import router as chatbot_router
+    app.include_router(chatbot_router, prefix="/api/v1", tags=["Voice Chatbot"])
+    logger.info("✓ Chatbot routes registered")
+except Exception as e:
+    logger.warning(f"⚠️ Chatbot routes failed to load: {e}")
+
 try:
     from routes.audio import router as audio_router
-    app.include_router(audio_router, prefix="/audio", tags=["Audio - Voice Chatbot"])
+    app.include_router(audio_router, prefix="/audio", tags=["Audio Processing"])
     logger.info("✓ Audio routes registered")
 except Exception as e:
     logger.warning(f"⚠️ Audio routes failed to load: {e}")
@@ -163,7 +172,8 @@ async def root():
         "version": API_VERSION,
         "docs": "/docs",
         "endpoints": {
-            "audio": "/docs#/Audio%20-%20Voice%20Chatbot",
+            "voice_chatbot": "/api/v1/chat/message",
+            "audio_processing": "/docs#/Audio%20Processing",
             "health": "/health",
             "models-status": "/models-status"
         }
@@ -180,18 +190,22 @@ async def models_status():
     status = {
         "stt_model": "unknown",
         "tts_engine": "gtts (free)",
-        "chatbot_model": "unknown"
+        "chatbot_model": "unknown",
+        "stance_model": "unknown",
+        "kpa_model": "unknown"
     }
     
     try:
-        from services.stt_service import stt_pipeline
-        status["stt_model"] = "loaded" if stt_pipeline is not None else "not loaded"
+        from services.stt_service import STTService
+        stt_service = STTService()
+        status["stt_model"] = "loaded" if hasattr(stt_service, 'initialized') and stt_service.initialized else "not loaded"
     except:
         status["stt_model"] = "error"
     
     try:
-        from services.chatbot_service import chatbot_pipeline
-        status["chatbot_model"] = "loaded" if chatbot_pipeline is not None else "not loaded"
+        from services.chatbot_service import ChatbotService
+        chatbot_service = ChatbotService()
+        status["chatbot_model"] = "loaded" if hasattr(chatbot_service, 'initialized') and chatbot_service.initialized else "not loaded"
     except:
         status["chatbot_model"] = "error"
     
@@ -220,4 +234,4 @@ if __name__ == "__main__":
         port=PORT,
         reload=RELOAD,
         log_level="info"
-    )
+    )

models/audio.py

@@ -1,44 +1,30 @@
 from pydantic import BaseModel, Field
-from typing import Optional
+from typing import Optional, List, Dict, Any
+from enum import Enum
+from datetime import datetime
 
-class STTResponse(BaseModel):
-    text: str = Field(..., description="Transcribed text")
-    model_name: str = Field(default="whisper-base", description="Model used")
-    language: Optional[str] = Field(default="en", description="Language detected")
-    duration_seconds: Optional[float] = Field(None, description="Audio duration")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "text": "hello how are you",
-                "model_name": "whisper-base",
-                "language": "en",
-                "duration_seconds": 3.2
-            }
-        }
+class MessageType(str, Enum):
+    TEXT = "text"
+    AUDIO = "audio"
 
-class TTSRequest(BaseModel):
-    text: str = Field(..., min_length=1, max_length=500, description="Text to convert")
-    
-    class Config:
-        json_schema_extra = {"example": {"text": "Hello world"}}
-
-class ChatbotRequest(BaseModel):
-    text: str = Field(..., min_length=1, max_length=500, description="User input")
-    
-    class Config:
-        json_schema_extra = {"example": {"text": "What is AI?"}}
+class UserMessage(BaseModel):
+    message_id: str = Field(..., description="Unique message ID")
+    content: str = Field(..., description="Text content or audio base64")
+    message_type: MessageType = Field(..., description="Message type")
+    session_id: str = Field(..., description="User session ID")
+    timestamp: datetime = Field(default_factory=datetime.now)
 
 class ChatbotResponse(BaseModel):
-    user_input: str
-    bot_response: str
-    model_name: str = Field(default="DialoGPT-medium")
-    
-    class Config:
-        json_schema_extra = {
-            "example": {
-                "user_input": "Hello",
-                "bot_response": "Hi there! How can I help?",
-                "model_name": "DialoGPT-medium"
-            }
-        }
+    response_id: str = Field(..., description="Unique response ID")
+    text_response: str = Field(..., description="Chatbot text response")
+    audio_response: Optional[str] = Field(None, description="Audio response in base64")
+    audio_url: Optional[str] = Field(None, description="Generated audio URL")
+    session_id: str = Field(..., description="User session ID")
+    timestamp: datetime = Field(default_factory=datetime.now)
+
+class ChatSession(BaseModel):
+    session_id: str = Field(..., description="Session ID")
+    user_id: Optional[str] = Field(None, description="User ID")
+    created_at: datetime = Field(default_factory=datetime.now)
+    last_activity: datetime = Field(default_factory=datetime.now)
+    conversation_history: List[Dict[str, Any]] = Field(default_factory=list)

requirements.txt

@@ -9,14 +9,14 @@ pydantic==2.5.0
 python-dotenv==1.0.0
 torch>=2.0.0
 transformers>=4.35.0
-accelerate>=0.24.0
 protobuf>=3.20.0
 huggingface_hub>=0.19.0
 python-multipart
 google-genai>=0.4.0
-gtts==2.5.1
 requests==2.31.0
-ffmpeg-python==0.2.0
-librosa==0.10.1
 soundfile==0.12.1
-librosa==0.10.0
+gtts==2.3.2
+SpeechRecognition==3.10.0
+pyttsx3==2.90
+accelerate>=0.20.0
+coqui-tts==0.21.0

routes/audio.py

@@ -1,170 +1,86 @@
-from fastapi import APIRouter, UploadFile, File, HTTPException
-from fastapi.responses import StreamingResponse
-import io
-import logging
-from config import ALLOWED_AUDIO_TYPES, MAX_AUDIO_SIZE
-from services.stt_service import speech_to_text, load_stt_model
-from services.tts_service import generate_tts
-from services.chatbot_service import get_chatbot_response, load_chatbot_model
-from models.audio import STTResponse, TTSRequest, ChatbotRequest, ChatbotResponse
+from fastapi import APIRouter, HTTPException, UploadFile, File, Form
+from fastapi.responses import JSONResponse
+import uuid
+import base64
+from models.audio import UserMessage, ChatbotResponse, MessageType
+from services.chatbot_service import ChatbotService
 
-logger = logging.getLogger(__name__)
-router = APIRouter(prefix="/audio", tags=["Audio"])
+router = APIRouter()
+chatbot_service = ChatbotService()
 
-@router.on_event("startup")
-async def startup_models():
-    """Load models on startup"""
-    logger.info("🚀 Loading models...")
+@router.post("/chat/message", response_model=ChatbotResponse)
+async def send_chat_message(
+    session_id: str = Form(...),
+    message_type: str = Form(...),
+    message: str = Form(None),
+    audio_file: UploadFile = File(None)
+):
     try:
-        load_stt_model()
-        load_chatbot_model()
-        logger.info("✓ All models loaded successfully")
-    except Exception as e:
-        logger.error(f"⚠️ Model loading issues: {str(e)}")
-
-@router.post("/tts")
-async def tts(request: TTSRequest):
-    """
-    Convert text to speech.
-    Returns MP3 audio file.
-    
-    Example:
-    ```
-    POST /audio/tts
-    {
-        "text": "Hello, welcome to voice chatbot"
-    }
-    ```
-    """
-    try:
-        logger.info(f"TTS Request: '{request.text}'")
-        audio_bytes = await generate_tts(request.text)
-        return StreamingResponse(
-            io.BytesIO(audio_bytes),
-            media_type="audio/mpeg",
-            headers={"Content-Disposition": "attachment; filename=output.mp3"}
-        )
-    except Exception as e:
-        logger.error(f"TTS Error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.post("/stt", response_model=STTResponse)
-async def stt(file: UploadFile = File(...)):
-    """
-    Convert audio file to text.
-    Supports: WAV, MP3, M4A
-    
-    Example:
-    ```
-    POST /audio/stt
-    File: audio.mp3
-    ```
-    """
-    if file.content_type not in ALLOWED_AUDIO_TYPES:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unsupported format. Allowed: {', '.join(ALLOWED_AUDIO_TYPES)}"
-        )
-    
-    try:
-        logger.info(f"STT Request: {file.filename}")
-        audio_bytes = await file.read()
+        # Validate input
+        if not message and not audio_file:
+            raise HTTPException(status_code=400, detail="Either message or audio file must be provided")
         
-        if len(audio_bytes) > MAX_AUDIO_SIZE:
-            raise HTTPException(
-                status_code=400,
-                detail=f"File too large. Max: {MAX_AUDIO_SIZE / 1024 / 1024}MB"
-            )
+        if message_type == "audio" and not audio_file:
+            raise HTTPException(status_code=400, detail="Audio file required for audio messages")
         
-        text = await speech_to_text(audio_bytes, file.filename)
+        # Process audio file if provided
+        content = ""
+        if audio_file:
+            audio_data = await audio_file.read()
+            content = base64.b64encode(audio_data).decode('utf-8')
+        else:
+            content = message
         
-        return STTResponse(
-            text=text,
-            model_name="whisper-base",
-            language="en"
-        )
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"STT Error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-@router.post("/chatbot")
-async def chatbot_voice(file: UploadFile = File(...)):
-    """
-    Full voice chatbot flow: Audio → Text → Response → Audio
-    
-    Example:
-    ```
-    POST /audio/chatbot
-    File: user_voice.mp3
-    Returns: Response MP3 audio
-    ```
-    """
-    if file.content_type not in ALLOWED_AUDIO_TYPES:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Unsupported format. Allowed: {', '.join(ALLOWED_AUDIO_TYPES)}"
+        # Create user message
+        user_message = UserMessage(
+            message_id=str(uuid.uuid4()),
+            content=content,
+            message_type=MessageType(message_type),
+            session_id=session_id
         )
-    
-    try:
-        logger.info(f"Voice Chatbot: Processing {file.filename}")
-        
-        audio_bytes = await file.read()
-        if len(audio_bytes) > MAX_AUDIO_SIZE:
-            raise HTTPException(
-                status_code=400,
-                detail=f"File too large. Max: {MAX_AUDIO_SIZE / 1024 / 1024}MB"
-            )
-        
-        # Step 1: STT
-        logger.info("Step 1/3: Converting speech to text...")
-        user_text = await speech_to_text(audio_bytes, file.filename)
-        
-        # Step 2: Chatbot response
-        logger.info("Step 2/3: Generating response...")
-        response_text = await get_chatbot_response(user_text)
-        
-        # Step 3: TTS
-        logger.info("Step 3/3: Converting response to speech...")
-        audio_response = await generate_tts(response_text)
         
-        logger.info("✓ Voice chatbot complete")
+        # Process through chatbot service
+        response = await chatbot_service.process_user_message(user_message)
         
-        return StreamingResponse(
-            io.BytesIO(audio_response),
-            media_type="audio/mpeg",
-            headers={"Content-Disposition": "attachment; filename=response.mp3"}
-        )
+        return response
         
-    except HTTPException:
-        raise
     except Exception as e:
-        logger.error(f"Voice Chatbot Error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error processing message: {str(e)}")
 
-@router.post("/chatbot-text", response_model=ChatbotResponse)
-async def chatbot_text(request: ChatbotRequest):
-    """
-    Text-only chatbot (no audio).
-    
-    Example:
-    ```
-    POST /audio/chatbot-text
-    {
-        "text": "What is artificial intelligence?"
-    }
-    ```
-    """
+@router.post("/chat/audio")
+async def send_audio_message(
+    session_id: str = Form(...),
+    audio_file: UploadFile = File(...)
+):
+    """Endpoint specifically for audio messages"""
     try:
-        logger.info(f"Text Chatbot: '{request.text}'")
-        bot_response = await get_chatbot_response(request.text)
+        audio_data = await audio_file.read()
+        audio_base64 = base64.b64encode(audio_data).decode('utf-8')
         
-        return ChatbotResponse(
-            user_input=request.text,
-            bot_response=bot_response,
-            model_name="DialoGPT-medium"
+        user_message = UserMessage(
+            message_id=str(uuid.uuid4()),
+            content=audio_base64,
+            message_type=MessageType.AUDIO,
+            session_id=session_id
         )
+        
+        response = await chatbot_service.process_user_message(user_message)
+        return response
+        
     except Exception as e:
-        logger.error(f"Text Chatbot Error: {str(e)}")
-        raise HTTPException(status_code=500, detail=str(e))
+        raise HTTPException(status_code=500, detail=f"Error processing audio: {str(e)}")
+
+@router.get("/session/{session_id}/history")
+async def get_session_history(session_id: str):
+    """Get conversation history for a session"""
+    history = chatbot_service.get_session_history(session_id)
+    if not history:
+        raise HTTPException(status_code=404, detail="Session not found")
+    return history
+
+@router.post("/session/new")
+async def create_new_session():
+    """Create a new chat session"""
+    session_id = str(uuid.uuid4())
+    chatbot_service._get_or_create_session(session_id)
+    return {"session_id": session_id, "message": "New session created"}

services/chatbot_service.py

@@ -1,69 +1,99 @@
-import logging
-from transformers import pipeline, Conversation
-import random
+import base64
+import uuid
+from typing import Optional, Dict, Any
+from datetime import datetime
+from models.audio import ChatbotResponse, UserMessage
+from services.tts_service import SimpleTTSService  # Use simple version
+from services.stt_service import STTService  # Use basic version
 
-logger = logging.getLogger(__name__)
-chatbot_pipeline = None
-conversation_history = {}
-
-def load_chatbot_model():
-    global chatbot_pipeline
-    try:
-        logger.info("Loading DialoGPT chatbot model...")
-        chatbot_pipeline = pipeline(
-            "conversational",
-            model="microsoft/DialoGPT-medium",
-            device="cpu"  # Use "cuda" if GPU available
-        )
-        logger.info("✓ Chatbot model loaded successfully")
-    except Exception as e:
-        logger.error(f"✗ Failed to load chatbot model: {str(e)}")
-        chatbot_pipeline = None
-
-async def get_chatbot_response(user_text: str, user_id: str = "default") -> str:
-    """
-    Generate chatbot response using DialoGPT.
-    Maintains conversation history per user.
-    """
-    global chatbot_pipeline, conversation_history
+class ChatbotService:
+    def __init__(self):
+        self.tts_service = SimpleTTSService()  # Use simple TTS
+        self.stt_service = STTService()        # Use basic STT
+        self.sessions: Dict[str, Dict[str, Any]] = {}
+        self.initialized = False
     
-    try:
-        if chatbot_pipeline is None:
-            load_chatbot_model()
-            if chatbot_pipeline is None:
-                return get_fallback_response(user_text)
+    async def initialize(self):
+        """Initialize the chatbot service"""
+        await self.stt_service.initialize()
+        self.initialized = True
+        print("✓ Chatbot Service initialized")
+    
+    async def process_user_message(self, user_message: UserMessage) -> ChatbotResponse:
+        # Update session
+        session = self._get_or_create_session(user_message.session_id)
         
-        logger.info(f"Chatbot: Processing '{user_text}'")
+        # Process message based on type
+        if user_message.message_type == "audio":
+            # STT: Convert audio to text
+            text_input = await self.stt_service.transcribe_audio_base64(
+                user_message.content
+            )
+        else:
+            text_input = user_message.content
         
-        # Initialize conversation for this user if needed
-        if user_id not in conversation_history:
-            conversation_history[user_id] = Conversation()
+        # Add to conversation history
+        session["conversation_history"].append({
+            "role": "user",
+            "content": text_input,
+            "timestamp": user_message.timestamp
+        })
         
-        # Add user input to conversation
-        conversation = conversation_history[user_id]
-        conversation.add_user_input(user_text)
+        # Generate chatbot response
+        chatbot_text = await self._generate_chatbot_response(text_input, session)
         
-        # Generate response
-        response = chatbot_pipeline(conversation)
-        bot_response = response.generated_responses[-1].strip()
+        # TTS: Convert response to audio
+        try:
+            audio_base64 = await self.tts_service.text_to_speech_base64(chatbot_text)
+        except Exception as e:
+            print(f"TTS error: {e}")
+            audio_base64 = None
         
-        if not bot_response:
-            bot_response = get_fallback_response(user_text)
+        # Create response
+        response = ChatbotResponse(
+            response_id=str(uuid.uuid4()),
+            text_response=chatbot_text,
+            audio_response=audio_base64,
+            session_id=user_message.session_id
+        )
         
-        logger.info(f"✓ Chatbot Response: '{bot_response}'")
-        return bot_response
+        # Add response to history
+        session["conversation_history"].append({
+            "role": "assistant",
+            "content": chatbot_text,
+            "audio_response": audio_base64,
+            "timestamp": response.timestamp
+        })
         
-    except Exception as e:
-        logger.error(f"✗ Chatbot Error: {str(e)}")
-        return get_fallback_response(user_text)
-
-def get_fallback_response(user_text: str) -> str:
-    """Fallback responses when model fails"""
-    responses = [
-        f"I understand: '{user_text}'. How can I assist?",
-        f"Interesting point about '{user_text}'. Tell me more?",
-        f"Regarding '{user_text}', what would you like to know?",
-        "I'm listening. Please continue.",
-        f"That's a great question about '{user_text}'!"
-    ]
-    return random.choice(responses)
+        return response
+    
+    async def _generate_chatbot_response(self, user_input: str, session: Dict[str, Any]) -> str:
+        """Chatbot response generation logic"""
+        # Simple response logic - replace with your actual chatbot model
+        user_input_lower = user_input.lower()
+        
+        if "hello" in user_input_lower or "hi" in user_input_lower:
+            return "Hello! How can I assist you today?"
+        elif "time" in user_input_lower:
+            return f"The current time is {datetime.now().strftime('%H:%M')}"
+        elif "help" in user_input_lower:
+            return "I'm here to help you. You can ask me questions or request assistance."
+        elif "audio" in user_input_lower or "voice" in user_input_lower:
+            return "I can process both text and voice messages. Try sending me a voice message!"
+        else:
+            return f"I received your message: '{user_input}'. How can I assist you further?"
+    
+    def _get_or_create_session(self, session_id: str) -> Dict[str, Any]:
+        if session_id not in self.sessions:
+            self.sessions[session_id] = {
+                "conversation_history": [],
+                "created_at": datetime.now(),
+                "last_activity": datetime.now()
+            }
+        else:
+            self.sessions[session_id]["last_activity"] = datetime.now()
+        
+        return self.sessions[session_id]
+    
+    def get_session_history(self, session_id: str) -> Optional[Dict[str, Any]]:
+        return self.sessions.get(session_id)

services/stt_service.py

@@ -1,66 +1,94 @@
-import logging
+import base64
+import io
 import tempfile
 import os
-from transformers import pipeline
-import librosa
-import numpy as np
+import wave
+import audioop
 
-logger = logging.getLogger(__name__)
-stt_pipeline = None
-
-def load_stt_model():
-    global stt_pipeline
-    try:
-        logger.info("Loading Whisper-base STT model...")
-        stt_pipeline = pipeline(
-            "automatic-speech-recognition",
-            model="openai/whisper-base",
-            device="cpu",  # Use "cuda" if GPU available
-            chunk_length_s=30,
-        )
-        logger.info("✓ Whisper STT model loaded successfully")
-    except Exception as e:
-        logger.error(f"✗ Failed to load STT model: {str(e)}")
-        stt_pipeline = None
-
-async def speech_to_text(audio_bytes: bytes, filename: str) -> str:
-    """
-    Convert audio bytes to text using Whisper.
-    Handles WAV, MP3, M4A formats automatically.
-    """
-    global stt_pipeline
+class STTService:
+    def __init__(self):
+        self.initialized = False
     
-    try:
-        if stt_pipeline is None:
-            load_stt_model()
-            if stt_pipeline is None:
-                raise Exception("STT model not loaded")
-        
-        logger.info(f"STT: Converting audio file '{filename}'")
+    async def initialize(self):
+        """Initialize STT service"""
+        # For now, we'll use a simple approach without external dependencies
+        self.initialized = True
+        print("✓ STT Service initialized (basic mode)")
+    
+    async def transcribe_audio_base64(self, audio_base64: str, language: str = "en-US") -> str:
+        """Transcribe base64 audio to text - SIMPLIFIED VERSION"""
+        try:
+            # Decode audio
+            audio_data = base64.b64decode(audio_base64)
+            
+            # For now, return a placeholder since we don't have STT models configured
+            # In a real implementation, you would use Whisper, Vosk, or other STT models here
+            
+            audio_info = await self._get_audio_info(audio_data)
+            return f"[Audio received: {audio_info}. STT service needs model configuration.]"
+            
+        except Exception as e:
+            print(f"Transcription error: {e}")
+            return "Sorry, I couldn't process the audio message."
+    
+    async def _get_audio_info(self, audio_data: bytes) -> str:
+        """Get basic information about the audio file"""
+        try:
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+                temp_path = temp_file.name
+                temp_file.write(audio_data)
+            
+            try:
+                with wave.open(temp_path, 'rb') as wav_file:
+                    frames = wav_file.getnframes()
+                    rate = wav_file.getframerate()
+                    duration = frames / float(rate)
+                    return f"Duration: {duration:.2f}s, Sample Rate: {rate}Hz"
+            except:
+                return f"Size: {len(audio_data)} bytes"
         
-        # Save to temporary file
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as tmp:
-            tmp.write(audio_bytes)
-            tmp_path = tmp.name
+        finally:
+            if os.path.exists(temp_path):
+                os.unlink(temp_path)
+
+# Alternative STT service using Whisper if available
+class WhisperSTTService:
+    def __init__(self):
+        self.model = None
+        self.initialized = False
+    
+    async def initialize(self):
+        """Initialize Whisper STT service"""
+        try:
+            import whisper
+            self.model = whisper.load_model("medium")
+            self.initialized = True
+            print("✓ Whisper STT Service initialized")
+        except ImportError:
+            print("⚠️ Whisper not available. Install with: pip install openai-whisper")
+            self.initialized = False
+        except Exception as e:
+            print(f"⚠️ Whisper initialization failed: {e}")
+            self.initialized = False
+    
+    async def transcribe_audio_base64(self, audio_base64: str, language: str = "en") -> str:
+        """Transcribe using Whisper"""
+        if not self.initialized:
+            return "STT service not available. Please install Whisper."
         
         try:
-            # Load and resample audio to 16kHz
-            audio, sr = librosa.load(tmp_path, sr=16000)
+            audio_data = base64.b64decode(audio_base64)
             
-            # Transcribe
-            result = stt_pipeline(audio, generate_kwargs={"language": "english"})
-            text = result["text"].strip()
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+                temp_path = temp_file.name
+                temp_file.write(audio_data)
             
-            if not text:
-                text = "[Silent audio or unrecognizable speech]"
+            result = self.model.transcribe(temp_path, language=language)
+            transcription = result["text"]
             
-            logger.info(f"✓ STT Success: '{text}'")
-            return text
+            os.unlink(temp_path)
+            return transcription
             
-        finally:
-            if os.path.exists(tmp_path):
-                os.unlink(tmp_path)
-                
-    except Exception as e:
-        logger.error(f"✗ STT Error: {str(e)}")
-        raise Exception(f"STT failed: {str(e)}")
+        except Exception as e:
+            print(f"Whisper transcription error: {e}")
+            return "Sorry, I couldn't transcribe the audio."

services/tts_service.py

@@ -1,49 +1,121 @@
-import logging
+import base64
 import io
+import tempfile
+import os
 from gtts import gTTS
-import numpy as np
-import wave
+import pyttsx3
 
-logger = logging.getLogger(__name__)
-
-async def generate_tts(text: str) -> bytes:
-    """
-    Convert text to speech using Google Text-to-Speech (gTTS).
-    Returns MP3 audio bytes.
-    """
-    try:
-        if not text or len(text) > 500:
-            raise ValueError("Text must be between 1-500 characters")
+class TTSService:
+    def __init__(self):
+        self.models = {}
+        self._initialize_models()
+    
+    def _initialize_models(self):
+        """Initialize TTS models"""
+        # gTTS is our primary method (always available)
+        self.models["gtts"] = True
         
-        logger.info(f"TTS: Generating audio for '{text[:50]}...'")
+        # Try to initialize pyttsx3 as fallback
+        try:
+            self.models["pyttsx3"] = pyttsx3.init()
+            print("✓ pyttsx3 TTS initialized")
+        except:
+            print("⚠️ pyttsx3 not available")
+            self.models["pyttsx3"] = None
         
-        # Generate audio using gTTS
-        tts = gTTS(text=text, lang='en', slow=False)
+        # Coqui TTS is optional
+        self.models["coqui"] = self._initialize_coqui_tts()
+    
+    def _initialize_coqui_tts(self):
+        """Initialize Coqui TTS if available"""
+        try:
+            from TTS.api import TTS
+            tts_model = TTS(model_name="tts_models/en/ljspeech/tacotron2-DDC", progress_bar=False)
+            print("✓ Coqui TTS initialized")
+            return tts_model
+        except ImportError:
+            print("⚠️ Coqui TTS not available. Install with: pip install TTS")
+            return None
+        except Exception as e:
+            print(f"⚠️ Coqui TTS initialization failed: {e}")
+            return None
+    
+    async def text_to_speech_base64(self, text: str, language: str = "en") -> str:
+        """Convert text to base64 audio"""
+        # Try gTTS first (most reliable and free)
+        try:
+            return await self._gtts_to_base64(text, language)
+        except Exception as e:
+            print(f"gTTS error: {e}")
         
-        # Save to bytes buffer
+        # Fallback to pyttsx3
+        try:
+            if self.models.get("pyttsx3"):
+                return await self._pyttsx3_to_base64(text)
+        except Exception as e:
+            print(f"pyttsx3 error: {e}")
+        
+        # Final fallback to Coqui TTS
+        try:
+            if self.models.get("coqui"):
+                return await self._coqui_to_base64(text)
+        except Exception as e:
+            print(f"Coqui TTS error: {e}")
+        
+        raise Exception("All TTS services failed")
+    
+    async def _gtts_to_base64(self, text: str, language: str) -> str:
+        """Convert using gTTS"""
+        tts = gTTS(text=text, lang=language, slow=False)
         audio_buffer = io.BytesIO()
         tts.write_to_fp(audio_buffer)
-        audio_bytes = audio_buffer.getvalue()
+        audio_buffer.seek(0)
+        return base64.b64encode(audio_buffer.getvalue()).decode('utf-8')
+    
+    async def _pyttsx3_to_base64(self, text: str) -> str:
+        """Convert using pyttsx3"""
+        engine = self.models["pyttsx3"]
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+            temp_path = temp_file.name
         
-        logger.info(f"✓ TTS Success: {len(audio_bytes)} bytes generated")
-        return audio_bytes
+        engine.save_to_file(text, temp_path)
+        engine.runAndWait()
         
-    except Exception as e:
-        logger.error(f"✗ TTS Error: {str(e)}")
-        # Return fallback silent audio
-        return generate_silent_wav()
-
-def generate_silent_wav() -> bytes:
-    """Generate 1-second silent WAV file as fallback"""
-    sample_rate = 22050
-    duration = 1.0
-    silence = np.zeros(int(sample_rate * duration), dtype=np.int16)
+        with open(temp_path, 'rb') as audio_file:
+            audio_base64 = base64.b64encode(audio_file.read()).decode('utf-8')
+        
+        # Cleanup
+        os.unlink(temp_path)
+        return audio_base64
     
-    buffer = io.BytesIO()
-    with wave.open(buffer, 'wb') as wav:
-        wav.setnchannels(1)
-        wav.setsampwidth(2)
-        wav.setframerate(sample_rate)
-        wav.writeframes(silence.tobytes())
+    async def _coqui_to_base64(self, text: str) -> str:
+        """Convert using Coqui TTS"""
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as temp_file:
+            temp_path = temp_file.name
+        
+        self.models["coqui"].tts_to_file(text=text, file_path=temp_path)
+        
+        with open(temp_path, 'rb') as audio_file:
+            audio_base64 = base64.b64encode(audio_file.read()).decode('utf-8')
+        
+        # Cleanup
+        os.unlink(temp_path)
+        return audio_base64
+
+# Simple TTS service that only uses gTTS (minimal dependencies)
+class SimpleTTSService:
+    def __init__(self):
+        pass
     
-    return buffer.getvalue()
+    async def text_to_speech_base64(self, text: str, language: str = "en") -> str:
+        """Convert text to base64 audio using only gTTS"""
+        try:
+            tts = gTTS(text=text, lang=language, slow=False)
+            audio_buffer = io.BytesIO()
+            tts.write_to_fp(audio_buffer)
+            audio_buffer.seek(0)
+            return base64.b64encode(audio_buffer.getvalue()).decode('utf-8')
+        except Exception as e:
+            print(f"gTTS error: {e}")
+            # Return a placeholder audio or error message
+            return "TTS_ERROR_PLACEHOLDER"