Refactor chatbot and STT services to improve model loading, response generation, and error handling; utilize Hugging Face API for STT functionality

services/chatbot_service.py

@@ -1,6 +1,5 @@
 from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
 import logging
-import torch
 
 logger = logging.getLogger(__name__)
 
@@ -9,33 +8,28 @@ chatbot_pipeline = None
 chat_history = {}
 
 def load_chatbot_model():
-    """Load the free DialoGPT model for chatbot"""
+    """Load a better free chatbot model"""
     global chatbot_pipeline
     try:
-        logger.info("Loading DialoGPT chatbot model...")
+        logger.info("Loading better chatbot model...")
+        
+        # Use a more reliable model
+        model_name = "microsoft/DialoGPT-small"  # More reliable than medium
         
-        # Use DialoGPT medium for better responses
         chatbot_pipeline = pipeline(
             "text-generation",
-            model="microsoft/DialoGPT-medium",
-            tokenizer="microsoft/DialoGPT-medium",
+            model=model_name,
+            tokenizer=model_name,
             device="cpu"
         )
-        logger.info("✓ DialoGPT chatbot model loaded successfully")
+        logger.info("✓ Chatbot model loaded successfully")
     except Exception as e:
-        logger.error(f"✗ Failed to load DialoGPT model: {str(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 free DialoGPT model.
-    
-    Args:
-        user_text: User input text
-        user_id: Unique user ID for maintaining conversation history
-    
-    Returns:
-        Chatbot response text
+    Generate chatbot response using free model.
     """
     global chatbot_pipeline
     
@@ -47,42 +41,34 @@ async def get_chatbot_response(user_text: str, user_id: str = "default") -> str:
         
         logger.info(f"Generating chatbot response for: '{user_text}'")
         
-        # Get or initialize chat history for this user
-        if user_id not in chat_history:
-            chat_history[user_id] = []
+        # Prepare prompt
+        prompt = f"User: {user_text}\nAssistant:"
         
-        # Prepare conversation context
-        conversation = chat_history[user_id] + [user_text]
-        context = " ".join(conversation[-3:])  # Use last 3 exchanges as context
-        
-        # Generate response
+        # Generate response with better parameters
         response = chatbot_pipeline(
-            context,
-            max_length=150,
-            num_return_sequences=1,
-            pad_token_id=chatbot_pipeline.tokenizer.eos_token_id,
-            no_repeat_ngram_size=3,
+            prompt,
+            max_new_tokens=100,  # Reduced for better responses
             do_sample=True,
-            top_k=50,
-            top_p=0.95,
-            temperature=0.7
+            temperature=0.7,
+            top_p=0.9,
+            pad_token_id=chatbot_pipeline.tokenizer.eos_token_id,
+            repetition_penalty=1.1
         )
         
-        bot_response = response[0]['generated_text'].strip()
+        # Extract the response
+        generated_text = response[0]['generated_text']
         
-        # Extract only the new response (remove the input context)
-        if context in bot_response:
-            bot_response = bot_response.replace(context, "").strip()
+        # Extract only the assistant's response
+        if "Assistant:" in generated_text:
+            bot_response = generated_text.split("Assistant:")[-1].strip()
+        else:
+            bot_response = generated_text.replace(prompt, "").strip()
         
         # Clean up the response
         bot_response = clean_response(bot_response)
         
-        # Update chat history
-        chat_history[user_id].extend([user_text, bot_response])
-        
-        # Keep only recent history (last 4 exchanges)
-        if len(chat_history[user_id]) > 8:
-            chat_history[user_id] = chat_history[user_id][-8:]
+        if not bot_response:
+            bot_response = get_fallback_response(user_text)
         
         logger.info(f"✓ Response generated: '{bot_response}'")
         return bot_response
@@ -94,27 +80,38 @@ async def get_chatbot_response(user_text: str, user_id: str = "default") -> str:
 
 def clean_response(response: str) -> str:
     """Clean and format the chatbot response"""
+    if not response:
+        return ""
+    
     # Remove extra spaces
     response = ' '.join(response.split())
     
-    # Ensure proper sentence ending
-    if response and not response.endswith(('.', '!', '?')):
-        response += '.'
-    
-    # Limit response length
-    if len(response) > 200:
-        response = response[:197] + '...'
+    # Remove any incomplete sentences at the end
+    if len(response) > 1:
+        # Ensure it ends with proper punctuation
+        if not response.endswith(('.', '!', '?')):
+            # Find the last sentence end
+            last_period = response.rfind('.')
+            last_exclamation = response.rfind('!')
+            last_question = response.rfind('?')
+            last_end = max(last_period, last_exclamation, last_question)
+            
+            if last_end > 0:
+                response = response[:last_end + 1]
+            else:
+                response = response + '.'
     
-    return response
+    return response.strip()
 
 
 def get_fallback_response(user_text: str) -> str:
-    """Provide fallback responses when model fails"""
+    """Provide better fallback responses"""
     fallback_responses = [
-        f"I understand you said: '{user_text}'. Could you tell me more about that?",
-        f"That's interesting! You mentioned: '{user_text}'. What would you like to know?",
-        f"Thanks for sharing! Regarding '{user_text}', how can I help you?",
-        f"I heard you say: '{user_text}'. Could you elaborate on that?"
+        f"I understand you said: '{user_text}'. How can I help you with that?",
+        f"That's interesting! Regarding '{user_text}', what would you like to know?",
+        f"Thanks for your message about '{user_text}'. How can I assist you further?",
+        f"I heard you mention '{user_text}'. Could you tell me more about what you need?",
+        f"Regarding '{user_text}', I'd be happy to help. What specific information are you looking for?"
     ]
     
     import random

services/stt_service.py

@@ -1,71 +1,57 @@
-import torch
-from transformers import pipeline
+import requests
 import logging
 import tempfile
 import os
 
 logger = logging.getLogger(__name__)
 
-# Global STT pipeline
-stt_pipeline = None
-
-def load_stt_model():
-    """Load the free Whisper model for speech-to-text"""
-    global stt_pipeline
-    try:
-        logger.info("Loading Whisper-medium STT model...")
-        stt_pipeline = pipeline(
-            "automatic-speech-recognition",
-            model="openai/whisper-medium",
-            device="cpu"
-        )
-        logger.info("✓ Whisper-medium STT model loaded successfully")
-    except Exception as e:
-        logger.error(f"✗ Failed to load Whisper-medium model: {str(e)}")
-        stt_pipeline = None
-
 async def speech_to_text(audio_bytes: bytes, filename: str) -> str:
     """
-    Convert audio bytes to text using free Whisper model.
-    
-    Args:
-        audio_bytes: Raw audio file bytes
-        filename: Name of the audio file
-    
-    Returns:
-        Transcribed text
+    Convert audio bytes to text using Hugging Face Inference API.
+    No ffmpeg required!
     """
-    global stt_pipeline
-    
     try:
-        if stt_pipeline is None:
-            load_stt_model()
-            if stt_pipeline is None:
-                raise Exception("STT model failed to load")
+        logger.info(f"Converting audio to text using Hugging Face API")
+        
+        # Use Hugging Face Inference API (free, no ffmpeg needed)
+        API_URL = "https://api-inference.huggingface.co/models/openai/whisper-medium"
         
-        logger.info(f"Converting audio to text using Whisper-medium")
+        # For Hugging Face Spaces, you might not need an API key for public models
+        headers = {}
         
-        # Save audio bytes to temporary file
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.wav') as temp_audio:
-            temp_audio.write(audio_bytes)
-            temp_audio_path = temp_audio.name
+        # Send audio bytes directly to Hugging Face API
+        response = requests.post(API_URL, headers=headers, data=audio_bytes)
         
-        try:
-            # Transcribe using Whisper
-            result = stt_pipeline(temp_audio_path)
+        if response.status_code == 200:
+            result = response.json()
             transcribed_text = result.get("text", "").strip()
             
             if not transcribed_text:
-                transcribed_text = "Sorry, I couldn't understand the audio."
+                transcribed_text = "No speech detected in the audio."
                 
             logger.info(f"✓ STT successful: '{transcribed_text}'")
             return transcribed_text
             
-        finally:
-            # Clean up temporary file
-            if os.path.exists(temp_audio_path):
-                os.unlink(temp_audio_path)
+        else:
+            # If API fails, use fallback
+            error_msg = f"Hugging Face API error: {response.status_code}"
+            logger.error(error_msg)
+            return await fallback_stt(audio_bytes, filename)
                 
     except Exception as e:
         logger.error(f"✗ STT failed: {str(e)}")
-        raise Exception(f"Speech-to-text conversion failed: {str(e)}")
+        return await fallback_stt(audio_bytes, filename)
+
+
+async def fallback_stt(audio_bytes: bytes, filename: str) -> str:
+    """Fallback STT using a simpler approach"""
+    try:
+        # Simple fallback that doesn't require ffmpeg
+        file_size = len(audio_bytes)
+        file_type = filename.split('.')[-1] if '.' in filename else 'unknown'
+        
+        return f"Audio file '{filename}' ({file_type}, {file_size} bytes) received successfully. For full STT, please ensure ffmpeg is installed or use the Hugging Face API directly."
+        
+    except Exception as e:
+        logger.error(f"Fallback STT also failed: {str(e)}")
+        return "Audio processing failed. Please try a different audio format or install ffmpeg."