Update services/streaming_voice_service.py

services/streaming_voice_service.py

@@ -15,13 +15,13 @@ from core.speechbrain_vad import SpeechBrainVAD
 from core.silero_vad import SileroVAD
 
 class StreamingVoiceService:
-    def __init__(self, groq_client: Groq, rag_system: EnhancedRAGSystem, tts_service: EnhancedTTSService):
+    def __init__(self, groq_client: Groq, rag_system, tts_service):
         self.client = groq_client
         self.rag_system = rag_system
         self.tts_service = tts_service
         
-        # Khởi tạo VAD tối ưu
-        self.vad_processor = SileroVAD()
+        # Khởi tạo VAD tối ưu với double buffer
+        self.vad_processor = OptimizedSileroVAD()
         self.is_listening = False
         self.speech_callback = None
         self.is_processing = False
@@ -31,25 +31,26 @@ class StreamingVoiceService:
         self.conversation_history = []
         self.current_transcription = ""
         
-        # Audio buffer
-        self.audio_buffer = []
-        self.buffer_lock = threading.Lock()
-        
-        # Response queue để quản lý thứ tự xử lý
+        # Multi-thread processing
         self.response_queue = queue.Queue()
-        self.current_task = None
-
-        #Latency
+        self.processing_threads = []
+        self.max_workers = 2  # Số lượng thread xử lý song song
+        
+        # Latency tracking
         self.latency_metrics = {
             'asr': [],
-            'rag' : [],
-            'llm' : [],
-            'tts' : [],
-            'total' : []
+            'rag': [],
+            'llm': [],
+            'tts': [],
+            'total': []
         }
+        
+        # Audio buffer management
+        self.pending_audio_segments = []
+        self.segment_lock = threading.Lock()
 
     def start_listening(self, speech_callback: Callable) -> bool:
-        """Bắt đầu lắng nghe với VAD tối ưu"""
+        """Bắt đầu lắng nghe với multi-thread processing"""
         if self.is_listening:
             return False
             
@@ -58,8 +59,18 @@ class StreamingVoiceService:
         if success:
             self.is_listening = True
             self.is_processing = False
-            threading.Thread(target=self._process_response_queue, daemon=True).start()
-            print("🎙️ Đã bắt đầu lắng nghe với VAD tối ưu")
+            
+            # Khởi động worker threads
+            for i in range(self.max_workers):
+                thread = threading.Thread(
+                    target=self._process_response_worker,
+                    daemon=True,
+                    name=f"ASR-Worker-{i}"
+                )
+                thread.start()
+                self.processing_threads.append(thread)
+            
+            print("🎙️ Đã bắt đầu lắng nghe với multi-thread processing")
         return success
 
     def stop_listening(self):
@@ -68,24 +79,33 @@ class StreamingVoiceService:
         self.is_listening = False
         self.is_processing = False
         self.speech_callback = None
-        with self.buffer_lock:
-            self.audio_buffer = []
+        
+        # Clear queue
+        while not self.response_queue.empty():
+            try:
+                self.response_queue.get_nowait()
+                self.response_queue.task_done()
+            except queue.Empty:
+                break
+                
         print("🛑 Đã dừng lắng nghe")
 
     def _on_speech_detected(self, speech_audio: np.ndarray, sample_rate: int):
-        """Callback khi VAD phát hiện speech - TỐI ƯU HÓA"""
-        print(f"🎯 VAD phát hiện speech: {len(speech_audio)/sample_rate:.2f}s")
+        """Callback khi VAD phát hiện speech - không blocking"""
+        audio_duration = len(speech_audio) / sample_rate
+        print(f"🎯 VAD phát hiện speech: {audio_duration:.2f}s - Đưa vào queue")
         
+        # Đưa vào queue mà không chờ đợi
         self.response_queue.put((speech_audio, sample_rate))
 
-    def _process_response_queue(self):
-        """Xử lý tuần tự các request từ queue"""
+    def _process_response_worker(self):
+        """Worker thread xử lý speech segments"""
         while self.is_listening:
             try:
                 # Chờ item từ queue với timeout
                 speech_audio, sample_rate = self.response_queue.get(timeout=1.0)
                 
-                # Xử lý speech
+                # Xử lý speech segment
                 self._process_speech_segment(speech_audio, sample_rate)
                 
                 # Đánh dấu task hoàn thành
@@ -94,25 +114,19 @@ class StreamingVoiceService:
             except queue.Empty:
                 continue
             except Exception as e:
-                print(f"❌ Lỗi trong response queue: {e}")
+                print(f"❌ Lỗi trong worker thread: {e}")
                 continue
 
     def _process_speech_segment(self, speech_audio: np.ndarray, sample_rate: int):
-        """Xử lý speech segment - TỐI ƯU HÓA"""
-        # Kiểm tra nếu đang xử lý
-        if self.is_processing:
-            print("⚠️ Bỏ qua speech segment - đang xử lý request trước")
-            return
-            
-        with self.processing_lock:
-            self.is_processing = True
+        """Xử lý speech segment - optimized version"""
         total_start_time = time.time()
+        
         try:
-            # Chuyển đổi speech thành text
-            # 1. ASR 
+            # 1. ASR Transcription
             asr_start = time.time()
-            transcription = self._transcribe_audio(speech_audio, sample_rate)
+            transcription = self._transcribe_audio_optimized(speech_audio, sample_rate)
             asr_latency = time.time() - asr_start
+            
             if not transcription or len(transcription.strip()) < 2:
                 print("⚠️ Transcription quá ngắn hoặc trống")
                 return
@@ -120,15 +134,18 @@ class StreamingVoiceService:
             print(f"📝 Transcription: {transcription}")
             self.current_transcription = transcription
             
-            # Tạo phản hồi AI
+            # 2. AI Response Generation
             rag_start = time.time()
-            response = self._generate_ai_response(transcription)
+            response = self._generate_ai_response_optimized(transcription)
             rag_latency = time.time() - rag_start
-            # Tạo TTS
+            
+            # 3. TTS Conversion
             tts_start = time.time()
-            tts_audio_path = self._text_to_speech(response)
+            tts_audio_path = self._text_to_speech_optimized(response)
             tts_latency = time.time() - tts_start
+            
             total_latency = time.time() - total_start_time
+            
             # Log latency metrics
             self._log_latency_metrics({
                 'asr': asr_latency,
@@ -136,183 +153,41 @@ class StreamingVoiceService:
                 'tts': tts_latency,
                 'total': total_latency
             })
+            
             # Gửi kết quả đến callback
             if self.speech_callback:
-                self.speech_callback({
+                result = {
                     'transcription': transcription,
                     'response': response,
                     'tts_audio': tts_audio_path,
-                    'status': 'completed'
-                })
+                    'status': 'completed',
+                    'latency': total_latency
+                }
+                self.speech_callback(result)
                 
         except Exception as e:
             print(f"❌ Lỗi xử lý speech segment: {e}")
             traceback.print_exc()
-        finally:
-            with self.processing_lock:
-                self.is_processing = False
-
-    def process_streaming_audio(self, audio_data: tuple) -> Dict[str, Any]:
-        """Xử lý audio streaming (phương thức cũ cho compatibility với Gradio)"""
-        if not audio_data:
-            return {
-                'transcription': "❌ Không có dữ liệu âm thanh",
-                'response': "Vui lòng nói lại",
-                'tts_audio': None,
-                'status': 'error'
-            }
-        
-        # Nếu đang xử lý VAD, trả về trạng thái processing
-        if self.is_processing:
-            return {
-                'transcription': "Đang xử lý...",
-                'response': "",
-                'tts_audio': None,
-                'status': 'processing'
-            }
-        
-        try:
-            # Lấy dữ liệu audio từ Gradio
-            sample_rate, audio_array = audio_data
-            
-            print(f"🎯 Nhận audio manual: {len(audio_array)} samples, SR: {sample_rate}")
-            
-            # Kiểm tra kiểu dữ liệu và chuyển đổi nếu cần
-            if isinstance(audio_array, np.ndarray):
-                if audio_array.dtype == np.float32 or audio_array.dtype == np.float64:
-                    # Chuyển từ float sang int16
-                    audio_array = (audio_array * 32767).astype(np.int16)
-            
-            # Kiểm tra audio có dữ liệu không
-            if len(audio_array) == 0:
-                return {
-                    'transcription': "❌ Âm thanh trống",
-                    'response': "Vui lòng nói lại",
-                    'tts_audio': None,
-                    'status': 'error'
-                }
-            
-            # Tính toán âm lượng
-            audio_abs = np.abs(audio_array.astype(np.float32))
-            audio_rms = np.sqrt(np.mean(audio_abs**2)) / 32767.0
-            print(f"📊 Âm lượng RMS: {audio_rms:.4f}")
-            
-            if audio_rms < 0.005:
-                return {
-                    'transcription': "❌ Âm thanh quá yếu",
-                    'response': "Xin vui lòng nói to hơn",
-                    'tts_audio': None,
-                    'status': 'error'
-                }
             
-            # Sử dụng VAD để kiểm tra speech
-            if not self.vad_processor.is_speech(audio_array, sample_rate):
-                return {
-                    'transcription': "❌ Không phát hiện giọng nói",
-                    'response': "Vui lòng nói rõ hơn",
-                    'tts_audio': None,
-                    'status': 'error'
-                }
-            
-            # Chuyển đổi thành văn bản
-            transcription = self._transcribe_audio(audio_array, sample_rate)
-            
-            if not transcription or len(transcription.strip()) == 0:
-                return {
-                    'transcription': "❌ Không nghe rõ",
-                    'response': "Xin vui lòng nói lại rõ hơn",
-                    'tts_audio': None,
-                    'status': 'error'
-                }
-            
-            # Kiểm tra nếu transcription quá ngắn
-            if len(transcription.strip()) < 2:
-                return {
-                    'transcription': "❌ Câu nói quá ngắn",
-                    'response': "Xin vui lòng nói câu dài hơn",
+            if self.speech_callback:
+                self.speech_callback({
+                    'transcription': f"Lỗi: {str(e)}",
+                    'response': "Xin lỗi, có lỗi xảy ra",
                     'tts_audio': None,
                     'status': 'error'
-                }
-            
-            print(f"📝 Đã chuyển đổi: {transcription}")
-            
-            # Cập nhật transcription hiện tại
-            self.current_transcription = transcription
-            
-            # Tạo phản hồi AI
-            response = self._generate_ai_response(transcription)
-            
-            # Tạo TTS
-            tts_audio_path = self._text_to_speech(response)
-            
-            return {
-                'transcription': transcription,
-                'response': response,
-                'tts_audio': tts_audio_path,
-                'status': 'completed'
-            }
-            
-        except Exception as e:
-            print(f"❌ Lỗi xử lý streaming audio: {e}")
-            print(f"Chi tiết lỗi: {traceback.format_exc()}")
-            return {
-                'transcription': f"❌ Lỗi: {str(e)}",
-                'response': "Xin lỗi, có lỗi xảy ra trong quá trình xử lý",
-                'tts_audio': None,
-                'status': 'error'
-            }
-    def process_audio_chunk(self, audio_data: tuple) -> Dict[str, Any]:
-        """Xử lý audio chunk với VAD"""
-        if not audio_data or not self.is_listening:
-            return {
-                'transcription': "Đang lắng nghe...",
-                'response': "",
-                'tts_audio': None,
-                'status': 'listening'
-            }
-        
-        try:
-            sample_rate, audio_array = audio_data
-            
-            # Thêm vào buffer và xử lý với VAD
-            with self.buffer_lock:
-                self.audio_buffer.extend(audio_array)
-                # Giới hạn buffer
-                max_buffer_samples = sample_rate * 15  # 15 giây
-                if len(self.audio_buffer) > max_buffer_samples:
-                    self.audio_buffer = self.audio_buffer[-max_buffer_samples:]
-            
-            # Xử lý với VAD
-            self.vad_processor.process_stream(audio_array, sample_rate)
-            
-            return {
-                'transcription': "Đang lắng nghe...",
-                'response': "",
-                'tts_audio': None,
-                'status': 'listening'
-            }
-            
-        except Exception as e:
-            print(f"❌ Lỗi xử lý audio chunk: {e}")
-            return {
-                'transcription': "",
-                'response': "",
-                'tts_audio': None,
-                'status': 'error'
-            }
+                })
 
-    def _transcribe_audio(self, audio_data: np.ndarray, sample_rate: int) -> Optional[str]:
-        """Chuyển audio -> text với xử lý cải tiến"""
+    def _transcribe_audio_optimized(self, audio_data: np.ndarray, sample_rate: int) -> Optional[str]:
+        """Chuyển audio -> text với tối ưu hiệu suất"""
         asr_start = time.time()
         try:
-            # Đảm bảo kiểu dữ liệu và chuẩn hóa
+            # Chuẩn hóa audio data
             if audio_data.dtype != np.int16:
                 if audio_data.dtype in [np.float32, np.float64]:
                     audio_data = (audio_data * 32767).astype(np.int16)
                 else:
                     audio_data = audio_data.astype(np.int16)
             
-            # Chuẩn hóa audio data
             if audio_data.ndim > 1:
                 audio_data = np.mean(audio_data, axis=1).astype(np.int16)
             
@@ -323,18 +198,11 @@ class StreamingVoiceService:
                 sample_rate = target_sample_rate
             
             # Giới hạn độ dài audio
-            max_duration = 30  # giây
+            max_duration = 30
             max_samples = sample_rate * max_duration
             if len(audio_data) > max_samples:
                 audio_data = audio_data[:max_samples]
             
-            # Đảm bảo audio đủ dài
-            min_duration = 2  # giây
-            min_samples = int(sample_rate * min_duration)
-            if len(audio_data) < min_samples:
-                padding = np.zeros(min_samples - len(audio_data), dtype=np.int16)
-                audio_data = np.concatenate([audio_data, padding])
-            
             print(f"🔊 Gửi audio đến Whisper: {len(audio_data)} samples, {sample_rate}Hz")
             
             # Tạo temporary file trong memory
@@ -342,8 +210,7 @@ class StreamingVoiceService:
             sf.write(buffer, audio_data, sample_rate, format='wav', subtype='PCM_16')
             buffer.seek(0)
 
-            
-            # Gọi API Whisper
+            # Gọi API Whisper với timeout
             api_start = time.time()
             try:
                 transcription = self.client.audio.transcriptions.create(
@@ -356,7 +223,9 @@ class StreamingVoiceService:
             except Exception as e:
                 print(f"❌ Lỗi Whisper API: {e}")
                 return None
+                
             api_latency = time.time() - api_start
+            
             # Xử lý response
             if hasattr(transcription, 'text'):
                 result = transcription.text.strip()
@@ -364,49 +233,59 @@ class StreamingVoiceService:
                 result = transcription.strip()
             else:
                 result = str(transcription).strip()
-            short_responses = {
-                'ừ', 'um', 'à', 'ờ', 'ê', 'ô', 
-                'có', 'không', 'đúng', 'sai', 'ok', 'okay', 'ừm',
-                'vâng', 'dạ', 'ạ', 'được', 'tốt', 'hay', 'ừ ừ',
-                'yes', 'no', 'yeah', 'yep', 'nope'
-            }
             
             total_asr_latency = time.time() - asr_start
             print(f"✅ ASR Latency: {total_asr_latency:.2f}s (API: {api_latency:.2f}s)")
-                # Chuẩn hóa text để so sánh
-            normalized_text = result.lower().strip()
             
-            # Loại bỏ dấu câu và khoảng trắng thừa
-            import re
-            normalized_text = re.sub(r'[^\w\s]', '', normalized_text)
-            
-            # Nếu là từ ngắn thông dụng, vẫn chấp nhận
-            if normalized_text in short_responses:
-                print(f"✅ Nhận diện phản hồi ngắn: '{result}'")
+            # Kiểm tra chất lượng transcription
+            if self._is_valid_transcription(result):
                 return result
-            # Kiểm tra độ dài tối thiểu cho các từ khác
-            min_length = 2  # Ít nhất 2 ký tự cho các từ không trong danh sách ngắn
-            if len(normalized_text) < min_length and normalized_text not in short_responses:
-                print(f"⚠️ Bỏ qua transcription quá ngắn: '{result}'")
+            else:
                 return None
-            print(f"✅ Transcription: '{result}'")
-            return result
                 
         except Exception as e:
             print(f"❌ Lỗi transcription: {e}")
             return None
 
-    def _generate_ai_response(self, user_input: str) -> str:
-        """Sinh phản hồi AI với xử lý lỗi"""
+    def _is_valid_transcription(self, text: str) -> bool:
+        """Kiểm tra tính hợp lệ của transcription"""
+        if not text or len(text.strip()) == 0:
+            return False
+            
+        # Danh sách từ ngắn được chấp nhận
+        short_responses = {
+            'ừ', 'um', 'à', 'ờ', 'ê', 'ô', 
+            'có', 'không', 'đúng', 'sai', 'ok', 'okay', 'ừm',
+            'vâng', 'dạ', 'ạ', 'được', 'tốt', 'hay', 'ừ ừ',
+            'yes', 'no', 'yeah', 'yep', 'nope'
+        }
+        
+        normalized_text = text.lower().strip()
+        
+        # Loại bỏ dấu câu và khoảng trắng thừa
+        import re
+        normalized_text = re.sub(r'[^\w\s]', '', normalized_text)
+        
+        # Nếu là từ ngắn thông dụng, chấp nhận
+        if normalized_text in short_responses:
+            return True
+            
+        # Kiểm tra độ dài tối thiểu cho các từ khác
+        min_length = 2
+        return len(normalized_text) >= min_length
+
+    def _generate_ai_response_optimized(self, user_input: str) -> str:
+        """Sinh phản hồi AI với tối ưu hiệu suất"""
         llm_start = time.time()
         try:
             # Thêm vào lịch sử
             self.conversation_history.append({"role": "user", "content": user_input})
 
-            # Tìm kiếm RAG
+            # Tìm kiếm RAG (có thể bỏ qua nếu cần tốc độ)
             rag_start = time.time()
-            rag_results = self.rag_system.semantic_search(user_input, top_k=2)
+            rag_results = self.rag_system.semantic_search(user_input, top_k=2) if self.rag_system else []
             rag_latency = time.time() - rag_start
+            
             context_text = "\n".join([f"- {result.get('text', str(result))}" for result in rag_results]) if rag_results else ""
 
             system_prompt = f"""Bạn là trợ lý AI thông minh chuyên về tiếng Việt. 
@@ -419,30 +298,36 @@ Thông tin tham khảo:
             # Giữ lại 6 tin nhắn gần nhất
             messages.extend(self.conversation_history[-6:])
 
+            llm_inference_start = time.time()
             completion = self.client.chat.completions.create(
                 model=settings.MULTILINGUAL_LLM_MODEL,
                 messages=messages,
                 max_tokens=300,
                 temperature=0.7
             )
-            ttft = time.time() - llm_inference_start  # Time To First Token
+            ttft = time.time() - llm_inference_start
+            
             response = completion.choices[0].message.content
             self.conversation_history.append({"role": "assistant", "content": response})
+            
             total_llm_latency = time.time() - llm_start
+            
             # Giới hạn lịch sử
             if len(self.conversation_history) > 12:
                 self.conversation_history = self.conversation_history[-12:]
+                
             print(f"✅ RAG Latency: {rag_latency:.2f}s")
             print(f"✅ LLM TTFT: {ttft:.2f}s")
             print(f"✅ Total LLM Latency: {total_llm_latency:.2f}s")
+            
             return response
 
         except Exception as e:
             print(f"❌ Lỗi tạo AI response: {e}")
             return "Xin lỗi, tôi gặp lỗi khi tạo phản hồi. Vui lòng thử lại."
 
-    def _text_to_speech(self, text: str) -> Optional[str]:
-        """Chuyển văn bản thành giọng nói với latency tracking"""
+    def _text_to_speech_optimized(self, text: str) -> Optional[str]:
+        """Chuyển văn bản thành giọng nói với tối ưu"""
         tts_start = time.time()
         try:
             if not text or text.startswith("❌") or text.startswith("Xin lỗi"):
@@ -454,12 +339,75 @@ Thông tin tham khảo:
             if tts_bytes:
                 audio_path = self.tts_service.save_audio_to_file(tts_bytes)
                 print(f"✅ TTS Latency: {tts_latency:.2f}s")
-                print(f"✅ Đã tạo TTS: {audio_path}")
                 return audio_path
         except Exception as e:
             print(f"❌ Lỗi TTS: {e}")
         return None
 
+    def process_streaming_audio(self, audio_data: tuple) -> Dict[str, Any]:
+        """Xử lý audio streaming manual mode"""
+        if not audio_data:
+            return self._create_error_response("❌ Không có dữ liệu âm thanh")
+        
+        try:
+            sample_rate, audio_array = audio_data
+            
+            print(f"🎯 Nhận audio manual: {len(audio_array)} samples, SR: {sample_rate}")
+            
+            # Kiểm tra và chuyển đổi kiểu dữ liệu
+            if isinstance(audio_array, np.ndarray):
+                if audio_array.dtype == np.float32 or audio_array.dtype == np.float64:
+                    audio_array = (audio_array * 32767).astype(np.int16)
+            
+            if len(audio_array) == 0:
+                return self._create_error_response("❌ Âm thanh trống")
+            
+            # Kiểm tra âm lượng
+            audio_abs = np.abs(audio_array.astype(np.float32))
+            audio_rms = np.sqrt(np.mean(audio_abs**2)) / 32767.0
+            
+            if audio_rms < 0.005:
+                return self._create_error_response("❌ Âm thanh quá yếu")
+            
+            # Sử dụng VAD để kiểm tra speech
+            if not self.vad_processor.is_speech(audio_array, sample_rate):
+                return self._create_error_response("❌ Không phát hiện giọng nói")
+            
+            # Chuyển đổi thành văn bản
+            transcription = self._transcribe_audio_optimized(audio_array, sample_rate)
+            
+            if not transcription:
+                return self._create_error_response("❌ Không nghe rõ")
+            
+            print(f"📝 Đã chuyển đổi: {transcription}")
+            self.current_transcription = transcription
+            
+            # Tạo phản hồi AI
+            response = self._generate_ai_response_optimized(transcription)
+            
+            # Tạo TTS
+            tts_audio_path = self._text_to_speech_optimized(response)
+            
+            return {
+                'transcription': transcription,
+                'response': response,
+                'tts_audio': tts_audio_path,
+                'status': 'completed'
+            }
+            
+        except Exception as e:
+            print(f"❌ Lỗi xử lý streaming audio: {e}")
+            return self._create_error_response(f"❌ Lỗi: {str(e)}")
+
+    def _create_error_response(self, message: str) -> Dict[str, Any]:
+        """Tạo response lỗi chuẩn"""
+        return {
+            'transcription': message,
+            'response': "Vui lòng thử lại",
+            'tts_audio': None,
+            'status': 'error'
+        }
+
     def _resample_audio(self, audio_data: np.ndarray, orig_sr: int, target_sr: int) -> np.ndarray:
         """Resample audio"""
         try:
@@ -471,11 +419,6 @@ Thông tin tham khảo:
         except Exception:
             return audio_data
 
-    def clear_conversation(self):
-        """Xóa lịch sử hội thoại"""
-        self.conversation_history = []
-        self.current_transcription = ""
-        print("🗑️ Đã xóa lịch sử hội thoại")
     def _log_latency_metrics(self, latencies: dict):
         """Log và theo dõi latency metrics"""
         for key, value in latencies.items():
@@ -486,25 +429,9 @@ Thông tin tham khảo:
                 if len(self.latency_metrics[key]) > 100:
                     self.latency_metrics[key] = self.latency_metrics[key][-100:]
         
-        # Log tổng hợp
         print("📊 LATENCY REPORT:")
-        print(f"   ASR: {latencies['asr']:.2f}s")
-        print(f"   RAG: {latencies['rag']:.2f}s") 
-        print(f"   TTS: {latencies['tts']:.2f}s")
-        print(f"   TOTAL: {latencies['total']:.2f}s")
-        
-        # Tính toán và hiển thị latency trung bình
-        self._print_average_latencies()
-
-    def _print_average_latencies(self):
-        """In ra latency trung bình"""
-        if len(self.latency_metrics['total']) > 0:
-            print("📈 AVERAGE LATENCIES (last 10 requests):")
-            for component in ['asr', 'rag', 'tts', 'total']:
-                recent_latencies = self.latency_metrics[component][-10:]
-                if recent_latencies:
-                    avg = sum(recent_latencies) / len(recent_latencies)
-                    print(f"   {component.upper()}: {avg:.2f}s")
+        for component, latency in latencies.items():
+            print(f"   {component.upper()}: {latency:.2f}s")
 
     def get_latency_stats(self) -> dict:
         """Lấy thống kê latency"""
@@ -516,11 +443,12 @@ Thông tin tham khảo:
                     'min': min(latencies),
                     'max': max(latencies),
                     'count': len(latencies),
-                    'recent_avg': sum(latencies[-10:]) / min(10, len(latencies)) if latencies else 0
+                    'recent_avg': sum(latencies[-10:]) / min(10, len(latencies))
                 }
             else:
                 stats[component] = {'avg': 0, 'min': 0, 'max': 0, 'count': 0, 'recent_avg': 0}
         return stats
+
     def get_conversation_state(self) -> dict:
         """Lấy trạng thái hội thoại"""
         return {
@@ -529,5 +457,12 @@ Thông tin tham khảo:
             'history_length': len(self.conversation_history),
             'current_transcription': self.current_transcription,
             'queue_size': self.response_queue.qsize(),
+            'worker_threads': len(self.processing_threads),
             'last_update': time.strftime("%H:%M:%S")
-        }
+        }
+
+    def clear_conversation(self):
+        """Xóa lịch sử hội thoại"""
+        self.conversation_history = []
+        self.current_transcription = ""
+        print("🗑️ Đã xóa lịch sử hội thoại")