voicebot offical

app.py

@@ -1,1211 +0,0 @@
-import gradio as gr
-import groq
-import os
-import io
-import numpy as np
-import soundfile as sf
-from PIL import Image
-from dotenv import load_dotenv
-import pandas as pd
-import json
-from typing import List, Dict
-from sentence_transformers import SentenceTransformer
-import faiss
-import time
-import re
-from gtts import gTTS
-import edge_tts
-import asyncio
-
-# //load_dotenv()
-api_key = os.getenv("GROQ_API_KEY")
-# Get the GROQ_API_KEY from environment variables
-# api_key = os.environ.get("GROQ_API_KEY")
-if not api_key:
-    raise ValueError("Please set the GROQ_API_KEY environment variable.")
-
-# Initialize the Groq client
-client = groq.Client(api_key=api_key)
-
-# Initialize Vietnamese embedding model
-print("🔄 Đang tải mô hình embedding tiếng Việt...")
-try:
-    vietnamese_embedder = SentenceTransformer('keepitreal/vietnamese-sbert')
-    print("✅ Đã tải mô hình embedding tiếng Việt")
-except Exception as e:
-    print(f"❌ Lỗi tải mô hình embedding: {e}")
-    vietnamese_embedder = None
-
-# Enhanced RAG system with Vietnamese embeddings
-class EnhancedRAGSystem:
-    def __init__(self):
-        self.documents = []
-        self.metadatas = []
-        self.embeddings = None
-        self.index = None
-        self.dimension = 384  # Dimension for Vietnamese SBERT
-        
-        print("✅ Đã khởi tạo Enhanced RAG system với embedding tiếng Việt")
-        
-        # Initialize sample nutrition data in Vietnamese
-        self._initialize_sample_data()
-    
-    def _initialize_sample_data(self):
-        """Khởi tạo dữ liệu dinh dưỡng mẫu bằng tiếng Việt"""
-        nutrition_data = [
-            "Chế độ ăn Địa Trung Hải giàu rau củ, trái cây, ngũ cốc nguyên hạt và dầu olive tốt cho tim mạch",
-            "Protein từ thịt gà, cá hồi và đậu phụ giúp xây dựng cơ bắp và duy trì sức khỏe",
-            "Trái cây họ cam quýt như cam, bưởi cung cấp vitamin C tăng cường hệ miễn dịch",
-            "Rau xanh như cải bó xôi, bông cải xanh chứa nhiều chất xơ và vitamin K",
-            "Cá hồi giàu omega-3 tốt cho não bộ và sức khỏe tim mạch",
-            "Các loại hạt như hạnh nhân, óc chó cung cấp chất béo lành mạnh và protein",
-            "Sữa chua Hy Lạp chứa probiotic tốt cho hệ tiêu hóa và giàu protein",
-            "Gạo lứt và yến mạch là nguồn carbohydrate phức tạp cung cấp năng lượng lâu dài"
-        ]
-        
-        self.add_documents(nutrition_data, [{"type": "nutrition", "source": "sample", "language": "vi"}] * len(nutrition_data))
-    
-    def add_documents(self, documents: List[str], metadatas: List[Dict] = None):
-        """Thêm documents vào database với embedding"""
-        if not documents:
-            return
-        
-        # Generate embeddings for new documents
-        if vietnamese_embedder is not None:
-            try:
-                new_embeddings = vietnamese_embedder.encode(documents)
-                
-                if self.embeddings is None:
-                    self.embeddings = new_embeddings
-                else:
-                    self.embeddings = np.vstack([self.embeddings, new_embeddings])
-                
-                # Update FAISS index
-                self._update_faiss_index()
-                
-            except Exception as e:
-                print(f"❌ Lỗi tạo embedding: {e}")
-        
-        self.documents.extend(documents)
-        self.metadatas.extend(metadatas or [{}] * len(documents))
-        print(f"✅ Đã thêm {len(documents)} documents vào RAG database với embedding")
-    
-    def _update_faiss_index(self):
-        """Cập nhật FAISS index với embeddings hiện tại"""
-        if self.embeddings is None or len(self.embeddings) == 0:
-            return
-            
-        try:
-            dimension = self.embeddings.shape[1]
-            self.index = faiss.IndexFlatIP(dimension)  # Inner product for cosine similarity
-            self.index.add(self.embeddings.astype(np.float32))
-        except Exception as e:
-            print(f"❌ Lỗi cập nhật FAISS index: {e}")
-    
-    def semantic_search(self, query: str, top_k: int = 3) -> List[Dict]:
-        """Tìm kiếm ngữ nghĩa sử dụng embedding tiếng Việt"""
-        if not self.documents or self.index is None:
-            return self._fallback_keyword_search(query, top_k)
-            
-        try:
-            # Encode query using Vietnamese embedder
-            query_embedding = vietnamese_embedder.encode([query])
-            
-            # Search in FAISS index
-            similarities, indices = self.index.search(query_embedding.astype(np.float32), min(top_k, len(self.documents)))
-            
-            results = []
-            for i, (similarity, idx) in enumerate(zip(similarities[0], indices[0])):
-                if idx < len(self.documents):
-                    results.append({
-                        'id': str(idx),
-                        'text': self.documents[idx],
-                        'similarity': float(similarity),
-                        'metadata': self.metadatas[idx] if idx < len(self.metadatas) else {}
-                    })
-            
-            return results
-            
-        except Exception as e:
-            print(f"❌ Lỗi tìm kiếm ngữ nghĩa: {e}")
-            return self._fallback_keyword_search(query, top_k)
-    
-    def _fallback_keyword_search(self, query: str, top_k: int = 3) -> List[Dict]:
-        """Tìm kiếm dự phòng dựa trên từ khóa"""
-        query_lower = query.lower()
-        results = []
-        
-        for i, doc in enumerate(self.documents):
-            score = 0
-            for word in query_lower.split():
-                if word in doc.lower():
-                    score += 1
-            
-            if score > 0:
-                results.append({
-                    'id': str(i),
-                    'text': doc,
-                    'similarity': min(score / 5, 1.0),
-                    'metadata': self.metadatas[i] if i < len(self.metadatas) else {}
-                })
-        
-        results.sort(key=lambda x: x['similarity'], reverse=True)
-        return results[:top_k]
-    
-    def get_collection_stats(self) -> Dict:
-        """Lấy thống kê collection"""
-        return {
-            'count': len(self.documents),
-            'embedding_count': len(self.embeddings) if self.embeddings is not None else 0,
-            'name': 'enhanced_rag_vi',
-            'status': 'active',
-            'has_embeddings': self.embeddings is not None
-        }
-
-class WikipediaProcessor:
-    def __init__(self):
-        self.supported_formats = ['.txt', '.csv', '.json']
-    
-    def process_uploaded_file(self, file_path: str) -> List[str]:
-        """Xử lý file Wikipedia uploaded"""
-        file_ext = os.path.splitext(file_path)[1].lower()
-        
-        try:
-            if file_ext == '.txt':
-                return self._process_txt_file(file_path)
-            elif file_ext == '.csv':
-                return self._process_csv_file(file_path)
-            elif file_ext == '.json':
-                return self._process_json_file(file_path)
-            else:
-                raise ValueError(f"Định dạng file không được hỗ trợ: {file_ext}")
-        except Exception as e:
-            raise Exception(f"Lỗi xử lý file: {str(e)}")
-    
-    def _process_txt_file(self, file_path: str) -> List[str]:
-        """Xử lý file text"""
-        with open(file_path, 'r', encoding='utf-8') as f:
-            content = f.read()
-        
-        paragraphs = [p.strip() for p in content.split('\n\n') if p.strip() and len(p.strip()) > 20]
-        return paragraphs
-    
-    def _process_csv_file(self, file_path: str) -> List[str]:
-        """Xử lý file CSV"""
-        try:
-            df = pd.read_csv(file_path)
-            documents = []
-            
-            for _, row in df.iterrows():
-                doc_parts = []
-                for col in df.columns:
-                    if pd.notna(row[col]) and str(row[col]).strip():
-                        doc_parts.append(f"{col}: {row[col]}")
-                if doc_parts:
-                    documents.append(" | ".join(doc_parts))
-            
-            return documents
-        except Exception as e:
-            raise Exception(f"Lỗi đọc CSV: {str(e)}")
-    
-    def _process_json_file(self, file_path: str) -> List[str]:
-        """Xử lý file JSON"""
-        try:
-            with open(file_path, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-            
-            documents = []
-            
-            def extract_text(obj, current_path=""):
-                if isinstance(obj, dict):
-                    for key, value in obj.items():
-                        extract_text(value, f"{current_path}.{key}" if current_path else key)
-                elif isinstance(obj, list):
-                    for item in obj:
-                        extract_text(item, current_path)
-                elif isinstance(obj, str) and len(obj.strip()) > 10:
-                    documents.append(f"{current_path}: {obj.strip()}")
-            
-            extract_text(data)
-            return documents
-        except Exception as e:
-            raise Exception(f"Lỗi đọc JSON: {str(e)}")
-
-# Enhanced TTS Service with multiple providers and chunking
-class EnhancedTTSService:
-    def __init__(self):
-        self.supported_languages = {
-            'vi': 'vi',  # Vietnamese
-            'en': 'en',  # English
-            'fr': 'fr',  # French
-            'es': 'es',  # Spanish
-            'de': 'de',  # German
-            'ja': 'ja',  # Japanese
-            'ko': 'ko',  # Korean
-            'zh': 'zh'   # Chinese
-        }
-        self.max_chunk_length = 200  # Maximum characters per TTS request
-    
-    def detect_language(self, text: str) -> str:
-        """Đơn giản phát hiện ngôn ngữ dựa trên ký tự"""
-        vietnamese_chars = set('àáâãèéêìíòóôõùúýăđĩũơưạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹ')
-        if any(char in vietnamese_chars for char in text.lower()):
-            return 'vi'
-        # Simple detection for other languages
-        elif any(char in text for char in 'あいうえお'):  # Japanese
-            return 'ja'
-        elif any(char in text for char in '你好'):  # Chinese
-            return 'zh'
-        elif any(char in text for char in '안녕'):  # Korean
-            return 'ko'
-        else:
-            return 'en'  # Default to English
-    
-    def split_text_into_chunks(self, text: str, max_length: int = None) -> List[str]:
-        """Chia văn bản thành các đoạn nhỏ cho TTS"""
-        if max_length is None:
-            max_length = self.max_chunk_length
-        
-        # Split by sentences first
-        sentences = re.split(r'[.!?]+', text)
-        chunks = []
-        current_chunk = ""
-        
-        for sentence in sentences:
-            sentence = sentence.strip()
-            if not sentence:
-                continue
-                
-            # If sentence is too long, split by commas
-            if len(sentence) > max_length:
-                parts = re.split(r'[,;:]', sentence)
-                for part in parts:
-                    part = part.strip()
-                    if not part:
-                        continue
-                    if len(current_chunk) + len(part) + 2 <= max_length:
-                        if current_chunk:
-                            current_chunk += ". " + part
-                        else:
-                            current_chunk = part
-                    else:
-                        if current_chunk:
-                            chunks.append(current_chunk)
-                        current_chunk = part
-            else:
-                if len(current_chunk) + len(sentence) + 2 <= max_length:
-                    if current_chunk:
-                        current_chunk += ". " + sentence
-                    else:
-                        current_chunk = sentence
-                else:
-                    if current_chunk:
-                        chunks.append(current_chunk)
-                    current_chunk = sentence
-        
-        if current_chunk:
-            chunks.append(current_chunk)
-        
-        return chunks
-    
-    def text_to_speech_gtts(self, text: str, language: str = 'vi') -> bytes:
-        """Sử dụng gTTS (Google Text-to-Speech) library"""
-        try:
-            # Split long text into chunks
-            chunks = self.split_text_into_chunks(text)
-            audio_chunks = []
-            
-            for chunk in chunks:
-                if not chunk.strip():
-                    continue
-                    
-                tts = gTTS(text=chunk, lang=language, slow=False)
-                audio_buffer = io.BytesIO()
-                tts.write_to_fp(audio_buffer)
-                audio_buffer.seek(0)
-                audio_chunks.append(audio_buffer.read())
-                
-                # Small delay between requests
-                time.sleep(0.1)
-            
-            # Combine all audio chunks
-            if audio_chunks:
-                return b''.join(audio_chunks)
-            return None
-            
-        except Exception as e:
-            print(f"❌ Lỗi gTTS: {e}")
-            return None
-    
-    async def text_to_speech_edgetts(self, text: str, voice: str = 'vi-VN-NamMinhNeural') -> bytes:
-        """Sử dụng Edge-TTS (Microsoft Edge) - async version"""
-        try:
-            communicate = edge_tts.Communicate(text, voice)
-            audio_buffer = io.BytesIO()
-            
-            async for chunk in communicate.stream():
-                if chunk["type"] == "audio":
-                    audio_buffer.write(chunk["data"])
-            
-            audio_buffer.seek(0)
-            return audio_buffer.read()
-            
-        except Exception as e:
-            print(f"❌ Lỗi Edge-TTS: {e}")
-            return None
-    
-    def text_to_speech_edgetts_sync(self, text: str, voice: str = 'vi-VN-NamMinhNeural') -> bytes:
-        """Sync wrapper for Edge-TTS"""
-        try:
-            return asyncio.run(self.text_to_speech_edgetts(text, voice))
-        except Exception as e:
-            print(f"❌ Lỗi Edge-TTS sync: {e}")
-            return None
-    
-    def text_to_speech_fallback(self, text: str, language: str = 'vi') -> bytes:
-        """Fallback TTS using simple method"""
-        try:
-            # Use gTTS as fallback
-            return self.text_to_speech_gtts(text, language)
-        except Exception as e:
-            print(f"❌ Lỗi fallback TTS: {e}")
-            return None
-    
-    def text_to_speech(self, text: str, language: str = None, provider: str = "auto") -> bytes:
-        """Chuyển văn b���n thành giọng nói với nhiều nhà cung cấp"""
-        if not text or len(text.strip()) == 0:
-            return None
-        
-        if language is None:
-            language = self.detect_language(text)
-        
-        # Clean and prepare text
-        text = self.clean_text(text)
-        
-        try:
-            if provider == "auto" or provider == "gtts":
-                print(f"🔊 Đang sử dụng gTTS cho văn bản {len(text)} ký tự...")
-                audio_bytes = self.text_to_speech_gtts(text, language)
-                if audio_bytes:
-                    return audio_bytes
-            
-            if provider == "auto" or provider == "edgetts":
-                print(f"🔊 Đang thử Edge-TTS cho văn bản {len(text)} ký tự...")
-                voice_map = {
-                    'vi': 'vi-VN-NamMinhNeural',
-                    'en': 'en-US-AriaNeural',
-                    'fr': 'fr-FR-DeniseNeural',
-                    'es': 'es-ES-ElviraNeural',
-                    'de': 'de-DE-KatjaNeural',
-                    'ja': 'ja-JP-NanamiNeural',
-                    'ko': 'ko-KR-SunHiNeural',
-                    'zh': 'zh-CN-XiaoxiaoNeural'
-                }
-                voice = voice_map.get(language, 'vi-VN-NamMinhNeural')
-                audio_bytes = self.text_to_speech_edgetts_sync(text, voice)
-                if audio_bytes:
-                    return audio_bytes
-            
-            # Final fallback
-            print(f"🔊 Đang sử dụng fallback TTS...")
-            return self.text_to_speech_fallback(text, language)
-            
-        except Exception as e:
-            print(f"❌ Lỗi TTS tổng hợp: {e}")
-            return None
-    
-    def clean_text(self, text: str) -> str:
-        """Làm sạch văn bản trước khi chuyển thành giọng nói"""
-        # Remove URLs
-        text = re.sub(r'http\S+', '', text)
-        # Remove special characters but keep Vietnamese diacritics
-        text = re.sub(r'[^\w\sàáâãèéêìíòóôõùúýăđĩũơưạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹ.,!?;:()-]', '', text)
-        # Replace multiple spaces with single space
-        text = re.sub(r'\s+', ' ', text)
-        # Remove extra whitespace
-        text = text.strip()
-        return text
-    
-    def save_audio_to_file(self, audio_bytes: bytes, filename: str = None) -> str:
-        """Lưu audio bytes thành file tạm thời"""
-        if audio_bytes is None:
-            return None
-            
-        if filename is None:
-            filename = f"tts_output_{int(time.time())}.mp3"
-            
-        temp_dir = "temp_audio"
-        os.makedirs(temp_dir, exist_ok=True)
-        
-        filepath = os.path.join(temp_dir, filename)
-        with open(filepath, 'wb') as f:
-            f.write(audio_bytes)
-            
-        return filepath
-
-# Initialize systems
-rag_system = EnhancedRAGSystem()
-wikipedia_processor = WikipediaProcessor()
-tts_service = EnhancedTTSService()
-
-# Audio utility functions
-def numpy_to_mp3(audio_array: np.ndarray, sampling_rate: int = 24000) -> bytes:
-    """Convert numpy array to MP3 bytes"""
-    buffer = io.BytesIO()
-    sf.write(buffer, audio_array, sampling_rate, format='mp3')
-    buffer.seek(0)
-    return buffer.read()
-
-def transcribe_audio(audio):
-    """Chuyển đổi audio thành văn bản và tạo phản hồi với TTS"""
-    if audio is None:
-        return "No audio provided.", "", None
-    
-    sr, y = audio
-
-    # Convert to mono if stereo
-    if y.ndim > 1:
-        y = y.mean(axis=1)
-
-    # Normalize audio
-    y = y.astype(np.float32)
-    y /= np.max(np.abs(y))
-
-    # Write audio to buffer
-    buffer = io.BytesIO()
-    sf.write(buffer, y, sr, format='wav')
-    buffer.seek(0)
-
-    try:
-        # Use Whisper model for transcription
-        completion = client.audio.transcriptions.create(
-            model="whisper-large-v3-turbo",
-            file=("audio.wav", buffer),
-            response_format="text"
-        )
-        transcription = completion
-    except Exception as e:
-        transcription = f"Error in transcription: {str(e)}"
-
-    response = generate_response_with_rag(transcription)
-    
-    # Generate TTS audio for response
-    tts_audio = None
-    if response and not response.startswith("Error"):
-        tts_bytes = tts_service.text_to_speech(response, 'vi')
-        if tts_bytes:
-            tts_audio_path = tts_service.save_audio_to_file(tts_bytes)
-            tts_audio = tts_audio_path
-    
-    return transcription, response, tts_audio
-
-def generate_response_with_rag(user_input):
-    """Tạo phản hồi sử dụng RAG với embedding tiếng Việt"""
-    if not user_input or user_input.startswith("Error"):
-        return "No valid input available. Please try again."
-
-    try:
-        # Tìm kiếm thông tin liên quan từ RAG với embedding tiếng Việt
-        rag_results = rag_system.semantic_search(user_input, top_k=3)
-        
-        # Tạo context từ RAG results
-        context_text = ""
-        if rag_results:
-            context_text = "\n".join([f"- {doc['text']}" for doc in rag_results])
-        
-        # System prompt với RAG context
-        system_prompt = """Bạn là trợ lý AI thông minh chuyên về tiếng Việt. Hãy sử dụng thông tin từ cơ sở kiến thức được cung cấp để trả lời câu hỏi một cách chính xác và hữu ích bằng tiếng Việt.
-        
-Thông tin tham khảo từ cơ sở kiến thức:
-{context}
-
-Nếu thông tin từ cơ sở kiến thức không đủ để trả lời, hãy dựa vào kiến thức chung của bạn. Luôn trả lời bằng tiếng Việt tự nhiên và dễ hiểu."""
-        
-        messages = [
-            {"role": "system", "content": system_prompt.format(context=context_text)},
-            {"role": "user", "content": user_input}
-        ]
-
-        # Use Llama 3.3 70B model for text generation với RAG context
-        completion = client.chat.completions.create(
-            model="llama-3.3-70b-versatile",
-            messages=messages,
-        )
-        return completion.choices[0].message.content
-    except Exception as e:
-        return f"Error in response generation: {str(e)}"
-
-def analyze_image_with_description(image, user_description):
-    """Phân tích hình ảnh kết hợp với mô tả từ người dùng"""
-    if image is None:
-        return "No image uploaded."
-
-    try:
-        if user_description:
-            prompt = f"""Người dùng tải lên một hình ảnh và mô tả: "{user_description}"
-
-Dựa trên mô tả này, hãy phân tích chi tiết bằng tiếng Việt:
-1. Mô tả những gì có trong hình ảnh
-2. Nếu là thức ăn: ước tính dinh dưỡng (calo, protein, carbs, chất béo, chất xơ)
-3. Nếu là cảnh quan/con người: mô tả chi tiết và ý nghĩa
-4. Đưa ra nhận xét hoặc lời khuyên liên quan"""
-        else:
-            prompt = """Hãy mô tả chi tiết bằng tiếng Việt những gì bạn nghĩ có thể có trong hình ảnh này. Nếu là thức ăn, hãy ước tính giá trị dinh dưỡng. Nếu là cảnh quan hoặc con người, hãy mô tả chi tiết."""
-
-        chat_completion = client.chat.completions.create(
-            messages=[
-                {
-                    "role": "user",
-                    "content": prompt
-                }
-            ],
-            model="llama-3.3-70b-versatile",
-        )
-        description = chat_completion.choices[0].message.content
-    except Exception as e:
-        description = f"Error in image analysis: {str(e)}"
-
-    return description
-
-def respond(message, chat_history):
-    """Xử lý chat với TTS output"""
-    if chat_history is None:
-        chat_history = []
-
-    # Prepare the message history for the API
-    messages = []
-    for user_msg, assistant_msg in chat_history:
-        messages.append({"role": "user", "content": user_msg})
-        messages.append({"role": "assistant", "content": assistant_msg})
-
-    messages.append({"role": "user", "content": message})
-
-    try:
-        # Sử dụng RAG để tìm kiếm thông tin liên quan
-        rag_results = rag_system.semantic_search(message, top_k=2)
-        
-        # Thêm context từ RAG vào system prompt
-        context_text = ""
-        if rag_results:
-            context_text = "\nThông tin tham khảo:\n" + "\n".join([f"- {doc['text']}" for doc in rag_results])
-        
-        system_message = {
-            "role": "system", 
-            "content": f"Bạn là trợ lý AI hữu ích chuyên về tiếng Việt. Sử dụng thông tin từ cơ sở kiến thức khi có liên quan. Luôn trả lời bằng tiếng Việt tự nhiên.{context_text}"
-        }
-        
-        # Chèn system message vào đầu
-        messages_with_context = [system_message] + messages
-
-        # Use Llama 3.3 70B model for generating assistant response
-        completion = client.chat.completions.create(
-            model="llama-3.3-70b-versatile",
-            messages=messages_with_context,
-        )
-        assistant_message = completion.choices[0].message.content
-        chat_history.append((message, assistant_message))
-        
-        # Generate TTS audio for the response
-        tts_audio_path = None
-        if assistant_message and not assistant_message.startswith("Error"):
-            tts_bytes = tts_service.text_to_speech(assistant_message, 'vi')
-            if tts_bytes:
-                tts_audio_path = tts_service.save_audio_to_file(tts_bytes)
-        
-    except Exception as e:
-        assistant_message = f"Error: {str(e)}"
-        chat_history.append((message, assistant_message))
-        tts_audio_path = None
-
-    return "", chat_history, chat_history, tts_audio_path
-
-def upload_wikipedia_file(file):
-    """Xử lý upload file Wikipedia"""
-    if file is None:
-        return "Vui lòng chọn file để upload"
-    
-    try:
-        documents = wikipedia_processor.process_uploaded_file(file.name)
-        
-        if not documents:
-            return "Không tìm thấy dữ liệu nào trong file."
-        
-        # Thêm metadata
-        metadatas = [{"source": "wikipedia", "type": "knowledge", "file": os.path.basename(file.name), "language": "vi"} for _ in documents]
-        
-        rag_system.add_documents(documents, metadatas)
-        
-        stats = rag_system.get_collection_stats()
-        return f"✅ Đã thêm {len(documents)} documents Wikipedia vào RAG database. Tổng số documents: {stats['count']}, Embeddings: {stats['embedding_count']}"
-        
-    except Exception as e:
-        return f"❌ Lỗi xử lý file Wikipedia: {str(e)}"
-
-def get_rag_stats():
-    """Lấy thống kê RAG database"""
-    stats = rag_system.get_collection_stats()
-    return f"📊 Thống kê RAG Database:\n- Tổng documents: {stats['count']}\n- Embeddings: {stats['embedding_count']}\n- Trạng thái: {stats['status']}\n- Hỗ trợ embedding: {stats['has_embeddings']}"
-
-def search_rag_database(query):
-    """Tìm kiếm trong RAG database để debug"""
-    if not query.strip():
-        return []
-    
-    results = rag_system.semantic_search(query, top_k=5)
-    return results
-
-def clear_chat_history(chat_history):
-    """Xóa lịch sử chat"""
-    return [], []
-
-# Enhanced Streaming Voice AI Functions with TTS
-def generate_streaming_response(audio_file):
-    """Generate response for streaming voice AI với TTS"""
-    if audio_file is None:
-        return None, "No audio provided", None
-    
-    try:
-        # Transcribe audio using Whisper
-        with open(audio_file, "rb") as f:
-            transcription = client.audio.transcriptions.create(
-                model="whisper-large-v3-turbo",
-                file=f,
-                response_format="text"
-            )
-        
-        # Generate response using RAG với embedding tiếng Việt
-        rag_results = rag_system.semantic_search(transcription, top_k=2)
-        context_text = ""
-        if rag_results:
-            context_text = "\nThông tin tham khảo:\n" + "\n".join([f"- {doc['text']}" for doc in rag_results])
-        
-        system_prompt = f"""Bạn là trợ lý AI thông minh và thân thiện chuyên về tiếng Việt. Hãy trả lời câu hỏi một cách tự nhiên và hữu ích bằng tiếng Việt. Sử dụng thông tin từ cơ sở kiến thức khi có liên quan.{context_text}"""
-        
-        messages = [
-            {"role": "system", "content": system_prompt},
-            {"role": "user", "content": transcription}
-        ]
-        
-        completion = client.chat.completions.create(
-            model="llama-3.3-70b-versatile",
-            messages=messages,
-            max_tokens=150
-        )
-        
-        response = completion.choices[0].message.content
-        
-        # Generate TTS audio
-        tts_audio_bytes = tts_service.text_to_speech(response, 'vi')
-        if tts_audio_bytes:
-            # Save to temporary file for audio output
-            temp_audio_file = tts_service.save_audio_to_file(tts_audio_bytes)
-            return response, response, temp_audio_file
-        
-        return response, response, None
-        
-    except Exception as e:
-        error_msg = f"Error in streaming response: {str(e)}"
-        return None, error_msg, None
-
-def read_streaming_response(answer):
-    """Read response aloud using TTS"""
-    if not answer:
-        return answer, None
-    
-    try:
-        tts_audio_bytes = tts_service.text_to_speech(answer, 'vi')
-        if tts_audio_bytes:
-            temp_audio_file = tts_service.save_audio_to_file(tts_audio_bytes)
-            return answer, temp_audio_file
-    except Exception as e:
-        print(f"❌ Lỗi TTS: {e}")
-    
-    return answer, None
-
-# Enhanced Magic 8 Ball Functions with Vietnamese responses
-def generate_magic_8_ball_response(audio_file):
-    """Generate Magic 8 Ball response for audio input với tiếng Việt"""
-    if audio_file is None:
-        return None, "No audio provided", None
-    
-    try:
-        # Transcribe audio using Whisper
-        with open(audio_file, "rb") as f:
-            transcription = client.audio.transcriptions.create(
-                model="whisper-large-v3-turbo",
-                file=f,
-                response_format="text"
-            )
-        
-        # Magic 8 Ball system prompt in Vietnamese
-        messages = [
-            {
-                "role": "system", 
-                "content": (
-                )
-            },
-            {
-                "role": "user", 
-                "content": f"Quả cầu pha lê xin hãy trả lời câu hỏi này - {transcription}"
-            }
-        ]
-        
-        completion = client.chat.completions.create(
-            model="llama-3.3-70b-versatile",
-            messages=messages,
-            max_tokens=64,
-            temperature=0.8
-        )
-        
-        response = completion.choices[0].message.content
-        # Clean up response
-        response = response.replace("Magic 8 Ball", "").replace("Quả cầu pha lê", "").replace(":", "").strip()
-        
-        # Generate TTS audio
-        tts_audio_bytes = tts_service.text_to_speech(response, 'vi')
-        if tts_audio_bytes:
-            temp_audio_file = tts_service.save_audio_to_file(tts_audio_bytes)
-            return response, response, temp_audio_file
-        
-        return response, response, None
-        
-    except Exception as e:
-        error_msg = f"Error in Magic 8 Ball response: {str(e)}"
-        return None, error_msg, None
-
-def read_magic_8_ball_response(answer):
-    """Read Magic 8 Ball response aloud using TTS"""
-    if not answer:
-        return answer, None
-    
-    try:
-        tts_audio_bytes = tts_service.text_to_speech(answer, 'vi')
-        if tts_audio_bytes:
-            temp_audio_file = tts_service.save_audio_to_file(tts_audio_bytes)
-            return answer, temp_audio_file
-    except Exception as e:
-        print(f"❌ Lỗi TTS: {e}")
-    
-    return answer, None
-
-# Text-to-Speech standalone function
-def text_to_speech_standalone(text, language, tts_provider):
-    """Chức năng TTS độc lập"""
-    if not text:
-        return None
-    
-    try:
-        tts_audio_bytes = tts_service.text_to_speech(text, language, tts_provider)
-        if tts_audio_bytes:
-            temp_audio_file = tts_service.save_audio_to_file(tts_audio_bytes)
-            return temp_audio_file
-    except Exception as e:
-        print(f"❌ Lỗi TTS: {e}")
-    
-    return None
-
-# Custom CSS (giữ nguyên)
-custom_css = """
-.gradio-container {
-    background-color: #1f1f1f;
-}
-
-.gr-markdown, .gr-markdown * {
-    color: #ffffff !important;
-}
-
-.gr-textbox, .gr-textbox * {
-    color: #ffffff !important;
-}
-
-.gr-label, .gr-label * {
-    color: #ffffff !important;
-}
-
-.gr-chatbot, .gr-chatbot * {
-    color: #ffffff !important;
-}
-
-.gr-json, .gr-json * {
-    color: #ffffff !important;
-}
-
-.gr-box, .gr-block, .panel, .tab-item {
-    background-color: #2d2d2d !important;
-    border-color: #444444 !important;
-}
-
-input, textarea, select {
-    color: #ffffff !important;
-    background-color: #2d2d2d !important;
-    border-color: #444444 !important;
-}
-
-::placeholder {
-    color: #aaaaaa !important;
-}
-
-.message {
-    color: #ffffff !important;
-}
-
-.user-message, .bot-message {
-    color: #ffffff !important;
-}
-
-h1, h2, h3, h4, h5, h6 {
-    color: #ffffff !important;
-}
-
-.tab-nav {
-    color: #ffffff !important;
-}
-
-.tab-item {
-    color: #ffffff !important;
-}
-
-.gr-button {
-    color: #ffffff !important;
-    background-color: #f55036 !important;
-    border-color: #f55036 !important;
-}
-
-.gr-button-secondary {
-    color: #ffffff !important;
-    background-color: #666666 !important;
-    border-color: #666666 !important;
-}
-
-.gr-file, .gr-file * {
-    color: #ffffff !important;
-}
-
-.gr-json {
-    background-color: #2d2d2d !important;
-}
-
-.gr-audio, .gr-audio * {
-    color: #ffffff !important;
-}
-
-.gr-image, .gr-image * {
-    color: #ffffff !important;
-}
-
-.form, .form * {
-    color: #ffffff !important;
-}
-
-.block, .block * {
-    color: #ffffff !important;
-}
-
-div[data-testid="block"] {
-    background-color: #2d2d2d !important;
-    color: #ffffff !important;
-}
-
-.gr-component, .gr-component * {
-    color: #ffffff !important;
-}
-
-#groq-badge {
-    position: fixed;
-    bottom: 20px;
-    right: 20px;
-    z-index: 1000;
-    color: #ffffff !important;
-}
-
-.streaming-voice-container {
-    background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-    padding: 20px;
-    border-radius: 10px;
-    margin: 10px 0;
-}
-
-.magic-8-ball-container {
-    background: linear-gradient(135deg, #1a2a6c 0%, #b21f1f 50%, #fdbb2d 100%);
-    padding: 20px;
-    border-radius: 15px;
-    margin: 10px 0;
-    text-align: center;
-    border: 3px solid #ffffff;
-}
-
-.magic-8-ball-title {
-    font-size: 2.5em !important;
-    font-weight: bold !important;
-    text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
-    margin-bottom: 10px !important;
-}
-
-.magic-8-ball-subtitle {
-    font-size: 1.2em !important;
-    opacity: 0.9;
-    margin-bottom: 20px !important;
-}
-
-.tts-container {
-    background: linear-gradient(135deg, #00b09b 0%, #96c93d 100%);
-    padding: 20px;
-    border-radius: 10px;
-    margin: 10px 0;
-}
-"""
-
-with gr.Blocks(css=custom_css, theme=gr.themes.Soft(primary_hue="orange", neutral_hue="slate")) as demo:
-    gr.Markdown("# 🎙️ Groq x Gradio Multi-Modal với RAG Wikipedia & TTS Tiếng Việt")
-    gr.Markdown("**Ứng dụng đa chức năng với Llama 3.3, Whisper, RAG embedding tiếng Việt**")
-
-    with gr.Tab("🎙️ Audio"):
-        gr.Markdown("## Nói chuyện với AI (có TTS)")
-        with gr.Row():
-            audio_input = gr.Audio(type="numpy", label="Nói hoặc tải lên file âm thanh")
-        with gr.Row():
-            transcription_output = gr.Textbox(
-                label="Bản ghi âm",
-                lines=5,
-                interactive=True,
-                placeholder="Bản ghi âm sẽ hiển thị ở đây..."
-            )
-            response_output = gr.Textbox(
-                label="Phản hồi AI",
-                lines=5,
-                interactive=True,
-                placeholder="Phản hồi của AI sẽ hiển thị ở đây..."
-            )
-        with gr.Row():
-            tts_audio_output = gr.Audio(
-                label="Phản hồi bằng giọng nói",
-                interactive=False
-            )
-        process_button = gr.Button("Xử lý", variant="primary")
-        process_button.click(
-            transcribe_audio,
-            inputs=audio_input,
-            outputs=[transcription_output, response_output, tts_audio_output]
-        )
-    
-    with gr.Tab("🔊 Streaming Voice"):
-        gr.Markdown("## 🎤 Trò chuyện giọng nói thời gian thực với TTS")
-        gr.Markdown("Nói chuyện tự nhiên với AI - Câu hỏi của bạn sẽ được chuyển thành văn bản và AI sẽ trả lời bằng giọng nói tiếng Việt")
-        
-        with gr.Group():
-            with gr.Row():
-                audio_out = gr.Audio(
-                    label="Câu trả lời bằng giọng nói", 
-                    autoplay=True,
-                    format="mp3"
-                )
-                answer_text = gr.Textbox(
-                    label="Câu trả lời văn bản",
-                    lines=5,
-                    placeholder="Câu trả lời văn bản sẽ hiển thị ở đây..."
-                )
-                streaming_state = gr.State()
-            
-            with gr.Row():
-                audio_in = gr.Audio(
-                    label="Nói câu hỏi của bạn", 
-                    sources="microphone", 
-                    type="filepath",
-                    format="wav"
-                )
-        
-        audio_in.stop_recording(
-            generate_streaming_response, 
-            inputs=[audio_in], 
-            outputs=[streaming_state, answer_text, audio_out]
-        ).then(
-            fn=read_streaming_response, 
-            inputs=[streaming_state], 
-            outputs=[answer_text, audio_out]
-        )
-
-    with gr.Tab("🎱 Magic 8 Ball"):
-        gr.HTML(
-            """
-            <div class="magic-8-ball-container">
-                <h1 class="magic-8-ball-title">Magic 8 Ball 🎱</h1>
-                <h3 class="magic-8-ball-subtitle">Hỏi một câu hỏi và nhận trí tuệ từ quả cầu thần kỳ bằng tiếng Việt</h3>
-                <p class="magic-8-ball-subtitle">Powered by Groq & Whisper & TTS</p>
-            </div>
-            """
-        )
-        
-        with gr.Group():
-            with gr.Row():
-                magic_audio_out = gr.Audio(
-                    label="Câu trả lời bằng giọng nói", 
-                    autoplay=True,
-                    format="mp3"
-                )
-                magic_answer = gr.Textbox(
-                    label="Câu trả lời",
-                    lines=3,
-                    placeholder="Câu trả lời thần kỳ sẽ hiển thị ở đây..."
-                )
-                magic_state = gr.State()
-            
-            with gr.Row():
-                magic_audio_in = gr.Audio(
-                    label="Nói câu hỏi của bạn", 
-                    sources="microphone", 
-                    type="filepath",
-                    format="wav"
-                )
-
-        magic_audio_in.stop_recording(
-            generate_magic_8_ball_response, 
-            inputs=[magic_audio_in], 
-            outputs=[magic_state, magic_answer, magic_audio_out]
-        ).then(
-            fn=read_magic_8_ball_response, 
-            inputs=[magic_state], 
-            outputs=[magic_answer, magic_audio_out]
-        )
-    
-    with gr.Tab("🔊 Text-to-Speech"):
-        gr.Markdown("## 🎵 Chuyển văn bản thành giọng nói nâng cao")
-        gr.Markdown("Nhập văn bản và chọn ngôn ngữ để chuyển thành giọng nói")
-        
-        with gr.Group():
-            with gr.Row():
-                tts_text_input = gr.Textbox(
-                    label="Văn bản cần chuyển thành giọng nói",
-                    lines=4,
-                    placeholder="Nhập văn bản tại đây..."
-                )
-            with gr.Row():
-                tts_language = gr.Dropdown(
-                    choices=["vi", "en", "fr", "es", "de", "ja", "ko", "zh"],
-                    value="vi",
-                    label="Ngôn ngữ"
-                )
-                tts_provider = gr.Dropdown(
-                    choices=["auto", "gtts", "edgetts"],
-                    value="auto",
-                    label="Nhà cung cấp TTS"
-                )
-            with gr.Row():
-                tts_output_audio = gr.Audio(
-                    label="Kết quả giọng nói",
-                    interactive=False
-                )
-            tts_button = gr.Button("🔊 Chuyển thành giọng nói", variant="primary")
-        
-        tts_button.click(
-            text_to_speech_standalone,
-            inputs=[tts_text_input, tts_language, tts_provider],
-            outputs=[tts_output_audio]
-        )
-    
-    with gr.Tab("🖼️ Image"):
-        gr.Markdown("## Phân tích hình ảnh")
-        with gr.Row():
-            image_input = gr.Image(type="numpy", label="Tải lên hình ảnh")
-        with gr.Row():
-            image_description = gr.Textbox(
-                label="Mô tả hình ảnh của bạn (tùy chọn)",
-                placeholder="Mô tả ngắn về hình ảnh để AI phân tích chính xác hơn..."
-            )
-        with gr.Row():
-            image_output = gr.Textbox(label="Kết quả phân tích")
-        analyze_button = gr.Button("Phân tích hình ảnh", variant="primary")
-        analyze_button.click(
-            analyze_image_with_description,
-            inputs=[image_input, image_description],
-            outputs=[image_output]
-        )
-
-    with gr.Tab("💬 Chat"):
-        gr.Markdown("## Trò chuyện với AI Assistant (có TTS)")
-        chatbot = gr.Chatbot()
-        state = gr.State([])
-        with gr.Row():
-            user_input = gr.Textbox(
-                show_label=False, 
-                placeholder="Nhập tin nhắn của bạn ở đây...", 
-                container=False,
-                scale=4
-            )
-            send_button = gr.Button("Gửi", variant="primary", scale=1)
-            clear_button = gr.Button("Xóa Chat", variant="secondary", scale=1)
-        with gr.Row():
-            chat_tts_output = gr.Audio(
-                label="Phản hồi bằng giọng nói",
-                interactive=False
-            )
-        
-        send_button.click(
-            respond,
-            inputs=[user_input, state],
-            outputs=[user_input, chatbot, state, chat_tts_output],
-        )
-        clear_button.click(
-            clear_chat_history,
-            inputs=[state],
-            outputs=[chatbot, state]
-        )
-
-    with gr.Tab("📚 RAG Wikipedia"):
-        gr.Markdown("## Quản lý kiến thức với Wikipedia và Embedding Tiếng Việt")
-        
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📤 Upload dữ liệu Wikipedia")
-                file_upload = gr.File(
-                    label="Tải lên file Wikipedia",
-                    file_types=['.txt', '.csv', '.json'],
-                    file_count="single"
-                )
-                upload_btn = gr.Button("📤 Upload Data", variant="primary")
-                upload_status = gr.Textbox(label="Trạng thái Upload", interactive=False)
-                
-                gr.Markdown("### 📊 Thống kê Database")
-                stats_btn = gr.Button("📊 Database Stats", variant="secondary")
-                stats_display = gr.Textbox(label="Thống kê", interactive=False)
-                
-                gr.Markdown("### 🔍 Tìm kiếm Database")
-                search_query = gr.Textbox(
-                    label="Tìm kiếm trong database",
-                    placeholder="Nhập từ khóa để tìm kiếm..."
-                )
-                search_btn = gr.Button("🔍 Tìm kiếm", variant="secondary")
-            
-            with gr.Column(scale=2):
-                gr.Markdown("### 📋 Kết quả tìm kiếm RAG")
-                rag_results = gr.JSON(
-                    label="Tài liệu tham khảo tìm được"
-                )
-        
-        upload_btn.click(
-            upload_wikipedia_file,
-            inputs=[file_upload],
-            outputs=[upload_status]
-        )
-        
-        stats_btn.click(
-            get_rag_stats,
-            inputs=[],
-            outputs=[stats_display]
-        )
-        
-        search_btn.click(
-            search_rag_database,
-            inputs=[search_query],
-            outputs=[rag_results]
-        )
-
-    gr.HTML("""
-    <div id="groq-badge">
-        <div style="color: #ffffff !important; font-weight: bold; background-color: #f55036; padding: 8px 12px; border-radius: 5px;">
-            POWERED BY DAT | VIETNAMESE EMBEDDING & ENHANCED TTS
-        </div>
-    </div>
-    """)
-
-if __name__ == "__main__":
-    demo.launch(share=True)

config/settings.py

@@ -0,0 +1,45 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class Settings:
+    GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+    
+    # Multilingual Model Settings
+    VIETNAMESE_EMBEDDING_MODEL = 'dangvantuan/vietnamese-embedding'
+    VIETNAMESE_LLM_MODEL = "Vietnamese_LLaMA2_13B_8K_SFT_General_Domain_Knowledge"
+    
+    MULTILINGUAL_EMBEDDING_MODEL = 'Qwen/Qwen3-Embedding-4B'
+    MULTILINGUAL_LLM_MODEL = "meta-llama/Llama-3.1-8B-Instruct"
+    
+    # Fallback models in case primary models fail
+    FALLBACK_MULTILINGUAL_EMBEDDING_MODEL = 'sentence-transformers/all-MiniLM-L6-v2'
+    
+    # Default models (fallback)
+    DEFAULT_EMBEDDING_MODEL = 'dangvantuan/vietnamese-embedding'
+    DEFAULT_LLM_MODEL = "Vietnamese_LLaMA2_13B_8K_SFT_General_Domain_Knowledge"
+    
+    WHISPER_MODEL = "whisper-large-v3-turbo"
+    
+    # TTS Settings
+    MAX_CHUNK_LENGTH = 200
+    SUPPORTED_LANGUAGES = {
+        'vi': 'vi', 'en': 'en', 'fr': 'fr', 'es': 'es', 
+        'de': 'de', 'ja': 'ja', 'ko': 'ko', 'zh': 'zh'
+    }
+    
+    # RAG Settings
+    EMBEDDING_DIMENSION = 768  # For Vietnamese model
+    MULTILINGUAL_EMBEDDING_DIMENSION = 4096  # For Nemotron model
+    
+    TOP_K_RESULTS = 3
+    
+    # SpeechBrain VAD Settings
+    VAD_MODEL = "speechbrain/vad-crdnn-libriparty"
+    VAD_THRESHOLD = 0.5
+    VAD_MIN_SILENCE_DURATION = 0.5
+    VAD_SPEECH_PAD_DURATION = 0.1
+    SAMPLE_RATE = 16000
+
+settings = Settings()

core/multilingual_manager.py

@@ -0,0 +1,146 @@
+import re
+from typing import Dict, Tuple, Optional
+from sentence_transformers import SentenceTransformer
+from config.settings import settings
+
+class MultilingualManager:
+    def __init__(self):
+        self.vietnamese_model = None
+        self.multilingual_model = None
+        self.current_language = 'vi' 
+
+        # Phát hiện thuộc ngôn ngữ dựa trên các mẫu ký tự và từ phổ biến
+        self.language_patterns = {
+            'vi': {
+                'chars': set('àáâãèéêìíòóôõùúýăđĩũơưạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹ'),
+                'common_words': ['của', 'và', 'là', 'có', 'được', 'trong', 'cho', 'với', 'như', 'tôi']
+            },
+            'en': {
+                'chars': set('abcdefghijklmnopqrstuvwxyz'),
+                'common_words': ['the', 'and', 'is', 'are', 'for', 'with', 'this', 'that', 'you', 'they']
+            },
+            'fr': {
+                'chars': set('àâæçèéêëîïôœùûüÿ'),
+                'common_words': ['le', 'la', 'et', 'est', 'dans', 'pour', 'avec', 'vous', 'nous', 'ils']
+            },
+            'es': {
+                'chars': set('áéíóúñü'),
+                'common_words': ['el', 'la', 'y', 'es', 'en', 'por', 'con', 'los', 'las', 'del']
+            },
+            'de': {
+                'chars': set('äöüß'),
+                'common_words': ['der', 'die', 'das', 'und', 'ist', 'in', 'für', 'mit', 'sich', 'nicht']
+            },
+            'ja': {
+                'chars': set('ぁ-んァ-ン一-龯'),
+                'common_words': ['の', 'に', 'は', 'を', 'た', 'で', 'し', 'が', 'ます', 'です']
+            },
+            'ko': {
+                'chars': set('가-힣'),
+                'common_words': ['이', '그', '에', '를', '의', '에', '에서', '으로', '하다', '이다']
+            },
+            'zh': {
+                'chars': set('一-鿌'),
+                'common_words': ['的', '是', '在', '有', '和', '了', '人', '我', '他', '这']
+            }
+        }
+        self._initialize_models()
+    def _initialize_models(self):
+        """Khởi tạo các mô hình đa ngôn ngữ"""
+        try:
+            print("🔄 Đang tải mô hình embedding tiếng Việt...")
+            self.vietnamese_model = SentenceTransformer(settings.VIETNAMESE_EMBEDDING_MODEL)
+            print("✅ Đã tải mô hình embedding tiếng Việt")
+        except Exception as e:
+            print(f"❌ Lỗi tải mô hình embedding tiếng Việt: {e}")
+            self.vietnamese_model = None
+        
+        try:
+            print("🔄 Đang tải mô hình embedding đa ngôn ngữ...")
+            self.multilingual_model = SentenceTransformer(settings.MULTILINGUAL_EMBEDDING_MODEL,trust_remote_code=True )
+            print("✅ Đã tải mô hình embedding đa ngôn ngữ")
+        except Exception as e:
+            print(f"❌ Lỗi tải mô hình embedding đa ngôn ngữ: {e}")
+            self.multilingual_model = None
+    
+    def detect_language(self, text: str) -> str:
+        """Phát hiện ngôn ngữ với độ chính xác cao"""
+        if not text or len(text.strip()) == 0:
+            return 'vi'  # Default to Vietnamese
+        
+        text_lower = text.lower()
+        scores = {}
+        
+        for lang, patterns in self.language_patterns.items():
+            score = 0
+            
+            # Score based on special characters
+            char_score = sum(1 for char in text if char in patterns['chars'])
+            score += char_score * 2
+            
+            # Score based on common words
+            word_score = sum(1 for word in patterns['common_words'] if word in text_lower)
+            score += word_score
+            
+            scores[lang] = score
+        
+        # Return language with highest score
+        detected_lang = max(scores.items(), key=lambda x: x[1])[0]
+        
+        # If no strong detection, use character-based fallback
+        if max(scores.values()) < 3:
+            vietnamese_chars = set('àáâãèéêìíòóôõùúýăđĩũơưạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹ')
+            if any(char in vietnamese_chars for char in text):
+                return 'vi'
+            elif any(char in text for char in 'あいうえおぁ-んァ-ン'):
+                return 'ja'
+            elif any(char in text for char in '你好'):
+                return 'zh'
+            elif any(char in text for char in '안녕'):
+                return 'ko'
+            else:
+                return 'en'  # Default to English for other cases
+        
+        return detected_lang
+    def get_embedding_model(self, language: str = None) -> Optional[SentenceTransformer]:
+        """Lấy mô hình embedding dựa trên ngôn ngữ đã phát hiện"""
+        lang = language if language in settings.SUPPORTED_LANGUAGES else self.current_language
+        
+        if lang == 'vi':
+            return self.vietnamese_model
+        else:
+            return self.multilingual_model
+    
+    def get_llm_model_name(self, language: str = None) -> str:
+        """Lấy tên mô hình LLM dựa trên ngôn ngữ đã phát hiện"""
+        lang = language if language in settings.SUPPORTED_LANGUAGES else self.current_language
+        
+        if lang == 'vi':
+            return settings.VIETNAMESE_LLM_MODEL
+        else:
+            return settings.MULTILINGUAL_LLM_MODEL
+    
+    def get_language_info(self, language: str = None) -> Dict:
+        """Lấy thông tin ngôn ngữ bao gồm mã và tên đầy đủ"""
+        lang = language if language in settings.SUPPORTED_LANGUAGES else self.current_language
+        
+        model_info = {
+            'vi': {
+                'name': 'Tiếng Việt',
+                'embedding_model': settings.VIETNAMESE_EMBEDDING_MODEL,
+                'llm_model': settings.VIETNAMESE_LLM_MODEL,
+                'status': 'active' if self.vietnamese_model else 'inactive'
+            },
+            'other': {
+                'name': 'Multilingual',
+                'embedding_model': settings.MULTILINGUAL_EMBEDDING_MODEL,
+                'llm_model': settings.MULTILINGUAL_LLM_MODEL,
+                'status': 'active' if self.multilingual_model else 'inactive'
+            }
+        }
+        
+        if lang == 'vi':
+            return model_info['vi']
+        else:
+            return model_info['other']
+    

core/rag_system.py

@@ -0,0 +1,262 @@
+import numpy as np
+import faiss
+from typing import List, Dict, Optional
+from sentence_transformers import SentenceTransformer
+from models.schemas import RAGSearchResult
+from config.settings import settings
+from core.multilingual_manager import MultilingualManager
+
+class EnhancedRAGSystem:
+    def __init__(self):
+        self.documents: List[str] = []
+        self.metadatas: List[Dict] = []
+        self.embeddings: Optional[np.ndarray] = None
+        self.index: Optional[faiss.Index] = None
+        
+        # Multilingual support
+        self.multilingual_manager = MultilingualManager()
+        self.current_dimension = settings.EMBEDDING_DIMENSION
+        
+        self._initialize_sample_data()  # SỬA TÊN HÀM
+    
+    def _initialize_sample_data(self):  # SỬA TÊN HÀM
+        """Khởi tạo dữ liệu mẫu"""
+        # Vietnamese sample data
+        vietnamese_data = [
+            "Rau xanh cung cấp nhiều vitamin và chất xơ tốt cho sức khỏe",
+            "Trái cây tươi chứa nhiều vitamin C và chất chống oxy hóa",
+            "Cá hồi giàu omega-3 tốt cho tim mạch và trí não",
+            "Nước rất quan trọng cho cơ thể, nên uống ít nhất 2 lít mỗi ngày",
+            "Hà Nội là thủ đô của Việt Nam, nằm ở miền Bắc",
+            "Thành phố Hồ Chí Minh là thành phố lớn nhất Việt Nam",
+            "Việt Nam có khí hậu nhiệt đới gió mùa với 4 mùa rõ rệt"
+        ]
+        
+        # English sample data
+        english_data = [
+            "Green vegetables provide many vitamins and fiber that are good for health",
+            "Fresh fruits contain lots of vitamin C and antioxidants",
+            "Salmon is rich in omega-3 which is good for heart and brain",
+            "Water is very important for the body, should drink at least 2 liters per day",
+            "London is the capital of England and the United Kingdom",
+            "New York City is the most populous city in the United States",
+            "The United States has diverse climate zones from tropical to arctic"
+        ]
+        
+        # Vietnamese metadata - SỬA LỖI SYNTAX
+        vietnamese_metadatas = [
+            {"type": "nutrition", "source": "sample", "language": "vi"},
+            {"type": "nutrition", "source": "sample", "language": "vi"},
+            {"type": "nutrition", "source": "sample", "language": "vi"},
+            {"type": "health", "source": "sample", "language": "vi"},
+            {"type": "geography", "source": "sample", "language": "vi"},
+            {"type": "geography", "source": "sample", "language": "vi"},
+            {"type": "geography", "source": "sample", "language": "vi"}
+        ]
+        
+        # English metadata - SỬA LỖI SYNTAX
+        english_metadatas = [
+            {"type": "nutrition", "source": "sample", "language": "en"},
+            {"type": "nutrition", "source": "sample", "language": "en"},
+            {"type": "nutrition", "source": "sample", "language": "en"},
+            {"type": "health", "source": "sample", "language": "en"},
+            {"type": "geography", "source": "sample", "language": "en"},
+            {"type": "geography", "source": "sample", "language": "en"},
+            {"type": "geography", "source": "sample", "language": "en"}
+        ]
+        
+        # Add documents with language metadata
+        self.add_documents(vietnamese_data, vietnamese_metadatas)
+        self.add_documents(english_data, english_metadatas)
+    
+    def add_documents(self, documents: List[str], metadatas: List[Dict] = None):
+        """Thêm documents vào database với embedding phù hợp"""
+        if not documents:
+            return
+        
+        # Ensure metadatas has the same length as documents
+        if metadatas is None:
+            metadatas = [{} for _ in documents]
+        elif len(metadatas) != len(documents):
+            # Extend or truncate metadatas to match documents length
+            if len(metadatas) < len(documents):
+                metadatas = metadatas + [{} for _ in range(len(documents) - len(metadatas))]
+            else:
+                metadatas = metadatas[:len(documents)]
+        
+        # Detect language for each document and create embeddings accordingly
+        new_embeddings_list = []
+        valid_documents = []
+        valid_metadatas = []
+        
+        for i, doc in enumerate(documents):
+            if not doc or len(doc.strip()) == 0:
+                continue
+                
+            language = metadatas[i].get('language', 'vi')
+            embedding_model = self.multilingual_manager.get_embedding_model(language)
+            
+            if embedding_model is not None:
+                try:
+                    # Create embedding for this document
+                    doc_embedding = embedding_model.encode([doc])
+                    new_embeddings_list.append(doc_embedding[0])
+                    valid_documents.append(doc)
+                    valid_metadatas.append(metadatas[i])
+                    
+                except Exception as e:
+                    print(f"❌ Lỗi tạo embedding cho document {i}: {e}")
+        
+        if not valid_documents:
+            return
+        
+        # Convert list of embeddings to numpy array
+        new_embeddings = np.array(new_embeddings_list)
+        
+        # Handle dimension mismatch
+        if self.embeddings is not None and self.embeddings.shape[1] != new_embeddings.shape[1]:
+            print(f"⚠️ Phát hiện dimension mismatch ({self.embeddings.shape[1]} vs {new_embeddings.shape[1]}), tạo index mới...")
+            self.embeddings = None
+            self.index = None
+        
+        # Update embeddings
+        if self.embeddings is None:
+            self.embeddings = new_embeddings
+            self.current_dimension = new_embeddings.shape[1]
+        else:
+            self.embeddings = np.vstack([self.embeddings, new_embeddings])
+        
+        # Update FAISS index
+        self._update_faiss_index()
+        
+        self.documents.extend(valid_documents)
+        self.metadatas.extend(valid_metadatas)
+        print(f"✅ Đã thêm {len(valid_documents)} documents vào RAG database")
+    
+    def _update_faiss_index(self):
+        """Cập nhật FAISS index với embeddings hiện tại"""
+        if self.embeddings is None or len(self.embeddings) == 0:
+            return
+            
+        try:
+            dimension = self.embeddings.shape[1]
+            self.index = faiss.IndexFlatIP(dimension)
+            
+            # Normalize embeddings for cosine similarity
+            faiss.normalize_L2(self.embeddings)
+            self.index.add(self.embeddings.astype(np.float32))
+            
+            print(f"✅ Đã cập nhật FAISS index với dimension {dimension}")
+        except Exception as e:
+            print(f"❌ Lỗi cập nhật FAISS index: {e}")
+    
+    def semantic_search(self, query: str, top_k: int = None) -> List[RAGSearchResult]:
+        """Tìm kiếm ngữ nghĩa với model phù hợp theo ngôn ngữ"""
+        if top_k is None:
+            top_k = settings.TOP_K_RESULTS
+            
+        if not self.documents or self.index is None:
+            return self._fallback_keyword_search(query, top_k)
+        
+        # Detect query language and get appropriate model
+        query_language = self.multilingual_manager.detect_language(query)
+        embedding_model = self.multilingual_manager.get_embedding_model(query_language)
+        
+        if embedding_model is None:
+            return self._fallback_keyword_search(query, top_k)
+            
+        try:
+            # Encode query with appropriate model
+            query_embedding = embedding_model.encode([query])
+            
+            # Normalize query embedding for cosine similarity
+            faiss.normalize_L2(query_embedding)
+            
+            # Search in FAISS index
+            similarities, indices = self.index.search(
+                query_embedding.astype(np.float32), 
+                min(top_k, len(self.documents))
+            )
+            
+            results = []
+            for i, (similarity, idx) in enumerate(zip(similarities[0], indices[0])):
+                if idx < len(self.documents):
+                    results.append(RAGSearchResult(
+                        id=str(idx),
+                        text=self.documents[idx],
+                        similarity=float(similarity),
+                        metadata=self.metadatas[idx] if idx < len(self.metadatas) else {}
+                    ))
+            
+            # Filter results by language relevance
+            filtered_results = self._filter_by_language_relevance(results, query_language)
+            
+            print(f"🔍 Tìm kiếm '{query[:50]}...' (ngôn ngữ: {query_language}) - Tìm thấy {len(filtered_results)} kết quả")
+            return filtered_results
+            
+        except Exception as e:
+            print(f"❌ Lỗi tìm kiếm ngữ nghĩa: {e}")
+            return self._fallback_keyword_search(query, top_k)
+    
+    def _filter_by_language_relevance(self, results: List[RAGSearchResult], query_language: str) -> List[RAGSearchResult]:
+        """Lọc kết quả theo độ liên quan ngôn ngữ"""
+        if not results:
+            return results
+        
+        # Boost scores for documents in the same language
+        for result in results:
+            doc_language = result.metadata.get('language', 'vi')
+            if doc_language == query_language:
+                # Boost similarity score for same language documents
+                result.similarity = min(result.similarity * 1.2, 1.0)
+        
+        # Re-sort by updated similarity scores
+        results.sort(key=lambda x: x.similarity, reverse=True)
+        return results
+    
+    def _fallback_keyword_search(self, query: str, top_k: int) -> List[RAGSearchResult]:
+        """Tìm kiếm dự phòng dựa trên từ khóa"""
+        query_lower = query.lower()
+        results = []
+        
+        for i, doc in enumerate(self.documents):
+            score = 0
+            doc_language = self.metadatas[i].get('language', 'vi') if i < len(self.metadatas) else 'vi'
+            query_language = self.multilingual_manager.detect_language(query)
+            
+            # Language matching bonus
+            if doc_language == query_language:
+                score += 0.5
+            
+            # Keyword matching
+            for word in query_lower.split():
+                if len(word) > 2 and word in doc.lower():
+                    score += 1
+            
+            if score > 0:
+                results.append(RAGSearchResult(
+                    id=str(i),
+                    text=doc,
+                    similarity=min(score / 5, 1.0),
+                    metadata=self.metadatas[i] if i < len(self.metadatas) else {}
+                ))
+        
+        results.sort(key=lambda x: x.similarity, reverse=True)
+        return results[:top_k]
+    
+    def get_collection_stats(self) -> Dict:
+        """Lấy thống kê collection với thông tin đa ngôn ngữ"""
+        language_stats = {}
+        for metadata in self.metadatas:
+            lang = metadata.get('language', 'unknown')
+            language_stats[lang] = language_stats.get(lang, 0) + 1
+        
+        return {
+            'total_documents': len(self.documents),
+            'embedding_count': len(self.embeddings) if self.embeddings is not None else 0,
+            'embedding_dimension': self.current_dimension,
+            'language_distribution': language_stats,
+            'name': 'multilingual_rag_system',
+            'status': 'active',
+            'has_embeddings': self.embeddings is not None
+        }

core/speechbrain_vad.py

@@ -0,0 +1,154 @@
+import torch
+import torchaudio
+import numpy as np
+from speechbrain.inference import VAD
+from typing import List, Tuple, Optional
+import queue
+import threading
+import time
+from config.settings import settings
+
+class SpeechBrainVAD:
+    def __init__(self):
+        self.vad_model = None
+        self.sample_rate = settings.SAMPLE_RATE
+        self.threshold = settings.VAD_THRESHOLD
+        self.min_silence_duration = settings.VAD_MIN_SILENCE_DURATION
+        self.speech_pad_duration = settings.VAD_SPEECH_PAD_DURATION
+        self.is_running = False
+        self.audio_queue = queue.Queue()
+        self.speech_buffer = []
+        self.silence_start_time = None
+        self.callback = None
+        
+        self._initialize_model()
+    
+    def _initialize_model(self):
+        """Khởi tạo mô hình VAD từ SpeechBrain"""
+        try:
+            print("🔄 Đang tải mô hình SpeechBrain VAD...")
+            self.vad_model = VAD.from_hparams(
+                source=settings.VAD_MODEL,
+                savedir=f"pretrained_models/{settings.VAD_MODEL}"
+            )
+            print("✅ Đã tải mô hình VAD thành công")
+        except Exception as e:
+            print(f"❌ Lỗi tải mô hình VAD: {e}")
+            self.vad_model = None
+    
+    def preprocess_audio(self, audio_data: np.ndarray, original_sr: int) -> np.ndarray:
+        """Tiền xử lý audio cho VAD"""
+        if original_sr != self.sample_rate:
+            # Resample audio to VAD sample rate
+            audio_tensor = torch.from_numpy(audio_data).float()
+            if len(audio_tensor.shape) > 1:
+                audio_tensor = audio_tensor.mean(dim=0)  # Convert to mono
+            
+            resampler = torchaudio.transforms.Resample(
+                orig_freq=original_sr, 
+                new_freq=self.sample_rate
+            )
+            audio_tensor = resampler(audio_tensor)
+            audio_data = audio_tensor.numpy()
+        
+        # Normalize audio
+        if np.max(np.abs(audio_data)) > 0:
+            audio_data = audio_data / np.max(np.abs(audio_data))
+        
+        return audio_data
+    
+    def detect_voice_activity(self, audio_chunk: np.ndarray) -> bool:
+        """Phát hiện hoạt động giọng nói trong audio chunk"""
+        if self.vad_model is None:
+            # Fallback: simple energy-based VAD
+            return self._energy_based_vad(audio_chunk)
+        
+        try:
+            # Convert to tensor and add batch dimension
+            audio_tensor = torch.from_numpy(audio_chunk).float().unsqueeze(0)
+            
+            # Get VAD probabilities
+            with torch.no_grad():
+                prob = self.vad_model.get_speech_prob_chunk(audio_tensor)
+            
+            return prob.item() > self.threshold
+            
+        except Exception as e:
+            print(f"❌ Lỗi VAD detection: {e}")
+            return self._energy_based_vad(audio_chunk)
+    
+    def _energy_based_vad(self, audio_chunk: np.ndarray) -> bool:
+        """Fallback VAD dựa trên năng lượng âm thanh"""
+        energy = np.mean(audio_chunk ** 2)
+        return energy > 0.01  # Simple threshold
+    
+    def process_stream(self, audio_chunk: np.ndarray, original_sr: int):
+        """Xử lý audio stream real-time"""
+        if not self.is_running:
+            return
+        
+        # Preprocess audio
+        processed_audio = self.preprocess_audio(audio_chunk, original_sr)
+        
+        # Detect voice activity
+        is_speech = self.detect_voice_activity(processed_audio)
+        
+        if is_speech:
+            self.silence_start_time = None
+            self.speech_buffer.extend(processed_audio)
+            print("🎤 Đang nói...")
+        else:
+            # Silence detected
+            if self.silence_start_time is None:
+                self.silence_start_time = time.time()
+            elif len(self.speech_buffer) > 0:
+                silence_duration = time.time() - self.silence_start_time
+                if silence_duration >= self.min_silence_duration:
+                    # End of speech segment
+                    self._process_speech_segment()
+        
+        return is_speech
+    
+    def _process_speech_segment(self):
+        """Xử lý segment giọng nói khi kết thúc"""
+        if len(self.speech_buffer) == 0:
+            return
+        
+        # Convert buffer to numpy array
+        speech_audio = np.array(self.speech_buffer)
+        
+        # Call callback with speech segment
+        if self.callback and callable(self.callback):
+            self.callback(speech_audio, self.sample_rate)
+        
+        # Clear buffer
+        self.speech_buffer = []
+        self.silence_start_time = None
+        
+        print("✅ Đã xử lý segment giọng nói")
+    
+    def start_stream(self, callback: callable):
+        """Bắt đầu xử lý stream"""
+        self.is_running = True
+        self.callback = callback
+        self.speech_buffer = []
+        self.silence_start_time = None
+        print("🎙️ Bắt đầu stream VAD...")
+    
+    def stop_stream(self):
+        """Dừng xử lý stream"""
+        self.is_running = False
+        # Process any remaining speech
+        if len(self.speech_buffer) > 0:
+            self._process_speech_segment()
+        print("🛑 Đã dừng stream VAD")
+    
+    def get_audio_chunk_from_stream(self, stream, chunk_size: int = 1024):
+        """Lấy audio chunk từ stream (for microphone input)"""
+        try:
+            data = stream.read(chunk_size, exception_on_overflow=False)
+            audio_data = np.frombuffer(data, dtype=np.int16)
+            return audio_data.astype(np.float32) / 32768.0  # Normalize to [-1, 1]
+        except Exception as e:
+            print(f"❌ Lỗi đọc audio stream: {e}")
+            return None

core/tts_service.py

@@ -0,0 +1,189 @@
+import io
+import re
+import time
+import asyncio
+from typing import List, Optional
+from gtts import gTTS
+import edge_tts
+from config.settings import settings
+from models.schemas import TTSRequest
+
+class EnhancedTTSService:
+    def __init__(self):
+        self.supported_languages = settings.SUPPORTED_LANGUAGES
+        self.max_chunk_length = settings.MAX_CHUNK_LENGTH
+    
+    def detect_language(self, text: str) -> str:
+        """Đơn giản phát hiện ngôn ngữ dựa trên ký tự"""
+        vietnamese_chars = set('àáâãèéêìíòóôõùúýăđĩũơưạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹ')
+        if any(char in vietnamese_chars for char in text.lower()):
+            return 'vi'
+        elif any(char in text for char in 'あいうえお'):
+            return 'ja'
+        elif any(char in text for char in '你好'):
+            return 'zh'
+        elif any(char in text for char in '안녕'):
+            return 'ko'
+        else:
+            return 'en'
+    
+    def split_text_into_chunks(self, text: str, max_length: int = None) -> List[str]:
+        """Chia văn bản thành các đoạn nhỏ cho TTS"""
+        if max_length is None:
+            max_length = self.max_chunk_length
+        
+        sentences = re.split(r'[.!?]+', text)
+        chunks = []
+        current_chunk = ""
+        
+        for sentence in sentences:
+            sentence = sentence.strip()
+            if not sentence:
+                continue
+                
+            if len(sentence) > max_length:
+                parts = re.split(r'[,;:]', sentence)
+                for part in parts:
+                    part = part.strip()
+                    if not part:
+                        continue
+                    if len(current_chunk) + len(part) + 2 <= max_length:
+                        if current_chunk:
+                            current_chunk += ". " + part
+                        else:
+                            current_chunk = part
+                    else:
+                        if current_chunk:
+                            chunks.append(current_chunk)
+                        current_chunk = part
+            else:
+                if len(current_chunk) + len(sentence) + 2 <= max_length:
+                    if current_chunk:
+                        current_chunk += ". " + sentence
+                    else:
+                        current_chunk = sentence
+                else:
+                    if current_chunk:
+                        chunks.append(current_chunk)
+                    current_chunk = sentence
+        
+        if current_chunk:
+            chunks.append(current_chunk)
+        
+        return chunks
+    
+    def text_to_speech_gtts(self, text: str, language: str = 'vi') -> Optional[bytes]:
+        """Sử dụng gTTS (Google Text-to-Speech) library"""
+        try:
+            chunks = self.split_text_into_chunks(text)
+            audio_chunks = []
+            
+            for chunk in chunks:
+                if not chunk.strip():
+                    continue
+                    
+                tts = gTTS(text=chunk, lang=language, slow=False)
+                audio_buffer = io.BytesIO()
+                tts.write_to_fp(audio_buffer)
+                audio_buffer.seek(0)
+                audio_chunks.append(audio_buffer.read())
+                
+                time.sleep(0.1)
+            
+            if audio_chunks:
+                return b''.join(audio_chunks)
+            return None
+            
+        except Exception as e:
+            print(f"❌ Lỗi gTTS: {e}")
+            return None
+    
+    async def text_to_speech_edgetts(self, text: str, voice: str = 'vi-VN-NamMinhNeural') -> Optional[bytes]:
+        """Sử dụng Edge-TTS (Microsoft Edge) - async version"""
+        try:
+            communicate = edge_tts.Communicate(text, voice)
+            audio_buffer = io.BytesIO()
+            
+            async for chunk in communicate.stream():
+                if chunk["type"] == "audio":
+                    audio_buffer.write(chunk["data"])
+            
+            audio_buffer.seek(0)
+            return audio_buffer.read()
+            
+        except Exception as e:
+            print(f"❌ Lỗi Edge-TTS: {e}")
+            return None
+    
+    def text_to_speech_edgetts_sync(self, text: str, voice: str = 'vi-VN-NamMinhNeural') -> Optional[bytes]:
+        """Sync wrapper for Edge-TTS"""
+        try:
+            return asyncio.run(self.text_to_speech_edgetts(text, voice))
+        except Exception as e:
+            print(f"❌ Lỗi Edge-TTS sync: {e}")
+            return None
+    
+    def text_to_speech(self, text: str, language: str = None, provider: str = "auto") -> Optional[bytes]:
+        """Chuyển văn bản thành giọng nói với nhiều nhà cung cấp"""
+        if not text or len(text.strip()) == 0:
+            return None
+        
+        if language is None:
+            language = self.detect_language(text)
+        
+        text = self.clean_text(text)
+        
+        try:
+            if provider == "auto" or provider == "gtts":
+                print(f"🔊 Đang sử dụng gTTS cho văn bản {len(text)} ký tự...")
+                audio_bytes = self.text_to_speech_gtts(text, language)
+                if audio_bytes:
+                    return audio_bytes
+            
+            if provider == "auto" or provider == "edgetts":
+                print(f"🔊 Đang thử Edge-TTS cho văn bản {len(text)} ký tự...")
+                voice_map = {
+                    'vi': 'vi-VN-NamMinhNeural',
+                    'en': 'en-US-AriaNeural',
+                    'fr': 'fr-FR-DeniseNeural',
+                    'es': 'es-ES-ElviraNeural',
+                    'de': 'de-DE-KatjaNeural',
+                    'ja': 'ja-JP-NanamiNeural',
+                    'ko': 'ko-KR-SunHiNeural',
+                    'zh': 'zh-CN-XiaoxiaoNeural'
+                }
+                voice = voice_map.get(language, 'vi-VN-NamMinhNeural')
+                audio_bytes = self.text_to_speech_edgetts_sync(text, voice)
+                if audio_bytes:
+                    return audio_bytes
+            
+            return self.text_to_speech_gtts(text, language)
+            
+        except Exception as e:
+            print(f"❌ Lỗi TTS tổng hợp: {e}")
+            return None
+    
+    def clean_text(self, text: str) -> str:
+        """Làm sạch văn bản trước khi chuyển thành giọng nói"""
+        text = re.sub(r'http\S+', '', text)
+        text = re.sub(r'[^\w\sàáâãèéêìíòóôõùúýăđĩũơưạảấầẩẫậắằẳẵặẹẻẽếềểễệỉịọỏốồổỗộớờởỡợụủứừửữựỳỵỷỹ.,!?;:()-]', '', text)
+        text = re.sub(r'\s+', ' ', text)
+        return text.strip()
+    
+    def save_audio_to_file(self, audio_bytes: bytes, filename: str = None) -> str:
+        """Lưu audio bytes thành file tạm thời"""
+        if audio_bytes is None:
+            return None
+            
+        if filename is None:
+            filename = f"tts_output_{int(time.time())}.mp3"
+            
+        import os
+        temp_dir = "temp_audio"
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        filepath = os.path.join(temp_dir, filename)
+        with open(filepath, 'wb') as f:
+            f.write(audio_bytes)
+            
+        return filepath

core/wikipedia_processor.py

@@ -0,0 +1,74 @@
+import os
+import json
+import pandas as pd
+from typing import List
+from models.schemas import RAGDocument
+
+class WikipediaProcessor:
+    def __init__(self):
+        self.supported_formats = ['.txt', '.csv', '.json']
+    
+    def process_uploaded_file(self, file_path: str) -> List[str]:
+        """Xử lý file Wikipedia uploaded"""
+        file_ext = os.path.splitext(file_path)[1].lower()
+        
+        try:
+            if file_ext == '.txt':
+                return self._process_txt_file(file_path)
+            elif file_ext == '.csv':
+                return self._process_csv_file(file_path)
+            elif file_ext == '.json':
+                return self._process_json_file(file_path)
+            else:
+                raise ValueError(f"Định dạng file không được hỗ trợ: {file_ext}")
+        except Exception as e:
+            raise Exception(f"Lỗi xử lý file: {str(e)}")
+    
+    def _process_txt_file(self, file_path: str) -> List[str]:
+        """Xử lý file text"""
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        paragraphs = [p.strip() for p in content.split('\n\n') if p.strip() and len(p.strip()) > 20]
+        return paragraphs
+    
+    def _process_csv_file(self, file_path: str) -> List[str]:
+        """Xử lý file CSV"""
+        try:
+            df = pd.read_csv(file_path)
+            documents = []
+            
+            for _, row in df.iterrows():
+                doc_parts = []
+                for col in df.columns:
+                    if pd.notna(row[col]) and str(row[col]).strip():
+                        doc_parts.append(f"{col}: {row[col]}")
+                if doc_parts:
+                    documents.append(" | ".join(doc_parts))
+            
+            return documents
+        except Exception as e:
+            raise Exception(f"Lỗi đọc CSV: {str(e)}")
+    
+    def _process_json_file(self, file_path: str) -> List[str]:
+        """Xử lý file JSON"""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            documents = []
+            
+            def extract_text(obj, current_path=""):
+                if isinstance(obj, dict):
+                    for key, value in obj.items():
+                        extract_text(value, f"{current_path}.{key}" if current_path else key)
+                elif isinstance(obj, list):
+                    for item in obj:
+                        extract_text(item, current_path)
+                elif isinstance(obj, str) and len(obj.strip()) > 10:
+                    documents.append(f"{current_path}: {obj.strip()}")
+            
+            extract_text(data)
+            return documents
+        except Exception as e:
+            raise Exception(f"Lỗi đọc JSON: {str(e)}")

main.py

@@ -0,0 +1,50 @@
+import gradio as gr
+import groq
+from config.settings import settings
+from core.rag_system import EnhancedRAGSystem
+from core.tts_service import EnhancedTTSService
+from core.wikipedia_processor import WikipediaProcessor
+from services.audio_service import AudioService
+from services.chat_service import ChatService
+from services.image_service import ImageService
+from services.streaming_voice_service import StreamingVoiceService
+from ui.components import create_custom_css, create_header
+from ui.tabs import create_all_tabs
+
+def main():
+    # Initialize clients and services
+    if not settings.GROQ_API_KEY:
+        raise ValueError("Please set the GROQ_API_KEY environment variable.")
+
+    client = groq.Client(api_key=settings.GROQ_API_KEY)
+    
+    # Initialize core systems
+    rag_system = EnhancedRAGSystem()
+    tts_service = EnhancedTTSService()
+    wikipedia_processor = WikipediaProcessor()
+    
+    # Initialize services
+    audio_service = AudioService(client, rag_system, tts_service)
+    chat_service = ChatService(client, rag_system, tts_service)
+    image_service = ImageService(client)
+    streaming_voice_service = StreamingVoiceService(client, rag_system, tts_service)
+    
+    # Create Gradio interface
+    with gr.Blocks(css=create_custom_css(), theme=gr.themes.Soft(primary_hue="orange", neutral_hue="slate")) as demo:
+        create_header()
+        gr.Markdown("### 🌐 Hệ thống Đa ngôn ngữ - Tự động chuyển đổi model theo ngôn ngữ")
+        create_all_tabs(
+            audio_service=audio_service,
+            chat_service=chat_service,
+            image_service=image_service,
+            rag_system=rag_system,
+            tts_service=tts_service,
+            wikipedia_processor=wikipedia_processor,
+            streaming_voice_service=streaming_voice_service
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = main()
+    demo.launch(share=True)

models/schemas.py

@@ -0,0 +1,22 @@
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+
+class RAGDocument(BaseModel):
+    text: str
+    metadata: Dict[str, Any] = {}
+    similarity: Optional[float] = None
+
+class RAGSearchResult(BaseModel):
+    id: str
+    text: str
+    similarity: float
+    metadata: Dict[str, Any]
+
+class ChatMessage(BaseModel):
+    role: str
+    content: str
+
+class TTSRequest(BaseModel):
+    text: str
+    language: str = 'vi'
+    provider: str = 'auto'

requirements.txt

@@ -8,4 +8,4 @@ faiss-cpu
 edge-tts
 gtts
 groq
-
+speechbrain

services/audio_service.py

@@ -0,0 +1,91 @@
+import numpy as np
+import soundfile as sf
+import io
+from groq import Groq
+from config.settings import settings
+from core.rag_system import EnhancedRAGSystem
+from core.tts_service import EnhancedTTSService
+from core.multilingual_manager import MultilingualManager  # NEW
+
+class AudioService:
+
+    def __init__(self, groq_client: Groq, rag_system: EnhancedRAGSystem, tts_service: EnhancedTTSService):
+        self.groq_client = groq_client
+        self.rag_system = EnhancedRAGSystem()
+        self.tts_service = EnhancedTTSService()
+        self.multilingual_manager = MultilingualManager()  # NEW
+        
+
+    def transcribe_audio(self, audio: str) -> str:
+        """Chuyển đổi giọng nói thành văn bản sử dụng mô hình Whisper."""
+        if not audio:
+            raise ValueError("Audio input is empty.")
+        sr, y =audio
+
+        if y.ndim > 1:
+            y = np.mean(y, axis=1)  # Chuyển đổi sang mono nếu cần
+        y = y.astype(np.float32)
+        y /= np.max(np.abs(y))  # Chuẩn hóa âm thanh
+
+        buffer = io.BytesIO()
+        sf.write(buffer, y, sr, format='WAV')
+        buffer.seek(0)
+
+        try:
+            completion = self.groq_client.audio.transcribe(
+                model=settings.WHISPER_MODEL,
+                audio=buffer,
+                response_format="text"
+            )
+            transcription = completion
+        except Exception as e:
+            transcription = f"Error trong quá trình chuyển đổi giọng nói thành văn bản: {e}"
+
+        language = self.multilingual_manager.detect_language(transcription)
+        respone = self._generate_response_with_rag(transcription, language)
+
+        tts_audio = None
+        if respone and respone.startswith("Error") is False:
+            tts_bytes = self.tts_service.text_to_speech(respone, language)
+            if tts_bytes:
+                tts_audio_path = self.tts_service.save_tts_audio(tts_bytes)
+                tts_audio = tts_audio_path
+            return transcription, respone, tts_audio, language
+        
+    def _generate_response_with_rag(self, query: str, language: str) -> str:
+        """Tạo phản hồi sử dụng hệ thống RAG dựa trên truy vấn và ngôn ngữ."""
+        if not query or query.startswith("Error"):
+            return "Error: Truy vấn không hợp lệ để tạo phản hồi."
+        try:
+            rag_results = self.rag_system.semantic_search(query, top_k=3)
+            context_text = ""
+            if rag_results:
+                for result in rag_results:
+                    context_text += result.document + "\n"
+            llm_model = self.multilingual_manager.get_llm_model(language)
+            if language == "vi":
+                system_prompt = """Bạn là trợ lý AI thông minh chuyên về tiếng Việt. Hãy sử dụng thông tin từ cơ sở kiến thức được cung cấp để trả lời câu hỏi một cách chính xác và hữu ích bằng tiếng Việt.             
+                    Thông tin tham khảo từ cơ sở kiến thức:
+                    {context}
+                    Nếu thông tin từ cơ sở kiến thức không đủ để trả lời, hãy dựa vào kiến thức chung của bạn. Luôn trả lời bằng tiếng Việt tự nhiên và dễ hiểu."""
+            else:
+                system_prompt = """You are a smart AI assistant. Please use the information from the provided knowledge base to answer questions accurately and helpfully in the same language as the user's question.
+
+                    Reference information from knowledge base:
+                    {context}
+
+                    If the information from the knowledge base is not sufficient to answer, rely on your general knowledge. Always respond in natural and easy-to-understand language matching the user's language."""
+            message = [
+                {"role": "system", "content": system_prompt.format(context=context_text)},
+                {"role": "user", "content": query}
+            ]
+            completion = self.groq_client.chat.completions.create(
+                model=llm_model,
+                messages=message,
+                max_tokens=512,
+                temperature=0.7,
+            )
+            return completion.choices[0].message['content'].strip()
+        except Exception as e:
+            return f"Error trong quá trình tạo phản hồi với RAG: {e}"
+        

services/chat_service.py

@@ -0,0 +1,69 @@
+from typing import List, Tuple, Optional
+from groq import Groq
+from config.settings import settings
+from core.rag_system import EnhancedRAGSystem
+from core.tts_service import EnhancedTTSService
+from models.schemas import ChatMessage
+
+class ChatService:
+    def __init__(self, groq_client: Groq, rag_system: EnhancedRAGSystem, tts_service: EnhancedTTSService):
+        self.groq_client = groq_client
+        self.rag_system = rag_system
+        self.tts_service = tts_service
+        self.multilingual_manager = rag_system.multilingual_manager
+
+    def respond(self, message: str,chat_history: List[Tuple[str, str]]) -> tuple:
+        """Tạo phản hồi cho tin nhắn đầu vào dựa trên lịch sử trò chuyện và ngôn ngữ."""
+        if chat_history is None:
+            chat_history = []
+
+        language = self.multilingual_manager.detect_language(message)
+        llm_model = self.multilingual_manager.get_llm_model(language)
+
+        messages = []
+        for user_msg, assistant_msg in chat_history:
+            messages.append({"role": "user", "content": user_msg})
+            messages.append({"role": "assistant", "content": assistant_msg})
+        messages.append({"role": "user", "content": message})
+
+        try:
+            rag_results = self.rag_system.semantic_search(message, top_k=3)
+            context_text = ""
+            if rag_results:
+                context_text = "\n Thông tin tham khảo:\n +".join([result.document for result in rag_results])
+
+            if language == 'vi':
+                system_message = {
+                    "role": "system",
+                    "content": f"Bạn là trợ lý AI hữu ích chuyên về tiếng Việt. Sử dụng thông tin từ cơ sở kiến thức khi có liên quan. Luôn trả lời bằng tiếng Việt tự nhiên.{context_text}"
+                }
+            else:
+                system_message = {
+                    "role": "system",
+                    "content": f"You are a helpful AI assistant. Use information from the knowledge base when relevant. Always respond in natural language matching the user's language.{context_text}"
+                }
+            messages_with_context = [system_message] + messages
+
+            completion = self.groq_client.chat.completions.create(
+                model=llm_model,
+                messages=messages_with_context,
+                max_tokens=512,
+                temperature=0.7,
+            )
+            assistant_message  = completion.choices[0].message['content'].strip()
+
+            chat_history.append((message, assistant_message))
+
+            tts_audio_path = None
+            if assistant_message and not assistant_message.startswith("Error"):
+                tts_bytes = self.tts_service.text_to_speech(assistant_message, language)
+                if tts_bytes:
+                    tts_audio_path = self.tts_service.save_tts_audio(tts_bytes)
+        except Exception as e:
+            assistant_message = f"Error trong quá trình tạo phản hồi: {e}"
+            chat_history.append((message, assistant_message))
+            tts_audio_path = None
+        return  "", chat_history, tts_audio_path, language
+    def clear_chat_history(self, chat_history: List[Tuple[str,str]]) -> tuple:
+        """Xóa lịch sử trò chuyện (nếu lưu trữ lịch sử trong phiên làm việc)."""
+        return [],[]

services/image_service.py

@@ -0,0 +1,33 @@
+from groq import Groq
+from config.settings import settings
+
+class ImageService:
+    def __init__(self, groq_client: Groq):
+        self.client = groq_client
+    
+    def analyze_image_with_description(self, image, user_description: str) -> str:
+        """Phân tích hình ảnh kết hợp với mô tả từ người dùng"""
+        if image is None:
+            return "No image uploaded."
+
+        try:
+            if user_description:
+                prompt = f"""Người dùng tải lên một hình ảnh và mô tả: "{user_description}"
+
+Dựa trên mô tả này, hãy phân tích chi tiết bằng tiếng Việt:
+1. Mô tả chi tiết những gì có trong hình ảnh
+2. Phân tích các yếu tố liên quan đến mô tả của người dùng
+3. Đưa ra nhận xét và thông tin hữu ích"""
+            else:
+                prompt = """Hãy mô tả chi tiết bằng tiếng Việt những gì bạn nghĩ có thể có trong hình ảnh này. 
+                Mô tả các đối tượng, màu sắc, bố cục và ngữ cảnh có thể có của hình ảnh."""
+
+            chat_completion = self.client.chat.completions.create(
+                messages=[{"role": "user", "content": prompt}],
+                model=settings.LLM_MODEL,
+            )
+            description = chat_completion.choices[0].message.content
+        except Exception as e:
+            description = f"Error in image analysis: {str(e)}"
+
+        return description

services/streaming_voice_service.py

@@ -0,0 +1,205 @@
+import io
+import numpy as np
+import soundfile as sf
+import threading
+import time
+import pyaudio
+from groq import Groq
+from typing import Optional, Callable
+from config.settings import settings
+from core.speechbrain_vad import SpeechBrainVAD
+from core.rag_system import EnhancedRAGSystem
+from core.tts_service import EnhancedTTSService
+
+class StreamingVoiceService:
+    def __init__(self, groq_client: Groq, rag_system: EnhancedRAGSystem, tts_service: EnhancedTTSService):
+        self.client = groq_client
+        self.rag_system = rag_system
+        self.tts_service = tts_service
+        self.vad_processor = SpeechBrainVAD()
+        
+        # Streaming state
+        self.is_listening = False
+        self.audio_stream = None
+        self.pyaudio_instance = None
+        self.callback_handler = None
+        
+        # Conversation context
+        self.conversation_history = []
+        self.current_transcription = ""
+    
+    def start_listening(self, callback_handler: Callable):
+        """Bắt đầu lắng nghe với VAD"""
+        if self.is_listening:
+            return False
+        
+        try:
+            self.callback_handler = callback_handler
+            self.is_listening = True
+            self.conversation_history = []
+            
+            # Initialize PyAudio
+            self.pyaudio_instance = pyaudio.PyAudio()
+            
+            # Start audio stream
+            self.audio_stream = self.pyaudio_instance.open(
+                format=pyaudio.paInt16,
+                channels=1,
+                rate=settings.SAMPLE_RATE,
+                input=True,
+                frames_per_buffer=1024,
+                stream_callback=self._audio_callback
+            )
+            
+            # Start VAD processing
+            self.vad_processor.start_stream(self._process_speech_segment)
+            
+            print("🎙️ Bắt đầu lắng nghe...")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Lỗi khởi động stream: {e}")
+            self.stop_listening()
+            return False
+    
+    def stop_listening(self):
+        """Dừng lắng nghe"""
+        self.is_listening = False
+        
+        if self.audio_stream:
+            self.audio_stream.stop_stream()
+            self.audio_stream.close()
+        
+        if self.pyaudio_instance:
+            self.pyaudio_instance.terminate()
+        
+        self.vad_processor.stop_stream()
+        print("🛑 Đã dừng lắng nghe")
+    
+    def _audio_callback(self, in_data, frame_count, time_info, status):
+        """Callback xử lý audio input real-time"""
+        if status:
+            print(f"Audio stream status: {status}")
+        
+        if self.is_listening:
+            # Convert audio data to numpy array
+            audio_data = np.frombuffer(in_data, dtype=np.int16)
+            audio_float = audio_data.astype(np.float32) / 32768.0
+            
+            # Process with VAD
+            self.vad_processor.process_stream(audio_float, settings.SAMPLE_RATE)
+        
+        return (in_data, pyaudio.paContinue)
+    
+    def _process_speech_segment(self, speech_audio: np.ndarray, sample_rate: int):
+        """Xử lý segment giọng nói đã được VAD phát hiện"""
+        if not self.is_listening or len(speech_audio) == 0:
+            return
+        
+        print(f"🎯 Đang xử lý segment giọng nói ({len(speech_audio)} samples)...")
+        
+        # Transcribe speech segment
+        transcription = self._transcribe_audio(speech_audio, sample_rate)
+        if transcription and len(transcription.strip()) > 0:
+            self.current_transcription = transcription
+            print(f"📝 Transcription: {transcription}")
+            
+            # Generate AI response
+            response = self._generate_ai_response(transcription)
+            
+            # Convert response to speech
+            tts_audio = self._text_to_speech(response)
+            
+            # Call callback with results
+            if self.callback_handler:
+                self.callback_handler({
+                    'transcription': transcription,
+                    'response': response,
+                    'tts_audio': tts_audio,
+                    'speech_audio': speech_audio
+                })
+    
+    def _transcribe_audio(self, audio_data: np.ndarray, sample_rate: int) -> Optional[str]:
+        """Chuyển đổi audio thành văn bản sử dụng Whisper"""
+        try:
+            # Convert numpy array to bytes buffer
+            buffer = io.BytesIO()
+            sf.write(buffer, audio_data, sample_rate, format='wav')
+            buffer.seek(0)
+            
+            # Transcribe with Whisper
+            transcription = self.client.audio.transcriptions.create(
+                model=settings.WHISPER_MODEL,
+                file=("speech.wav", buffer.read()),
+                response_format="text",
+                language="vi"  # Focus on Vietnamese
+            )
+            
+            return transcription.strip()
+            
+        except Exception as e:
+            print(f"❌ Lỗi transcription: {e}")
+            return None
+    
+    def _generate_ai_response(self, user_input: str) -> str:
+        """Tạo phản hồi AI với RAG context"""
+        try:
+            # Add to conversation history
+            self.conversation_history.append({"role": "user", "content": user_input})
+            
+            # Semantic search với RAG
+            rag_results = self.rag_system.semantic_search(user_input, top_k=2)
+            context_text = "\n".join([f"- {doc.text}" for doc in rag_results]) if rag_results else ""
+            
+            # Prepare messages với conversation history
+            system_prompt = f"""Bạn là trợ lý AI thông minh chuyên về tiếng Việt. Hãy trả lời ngắn gọn, tự nhiên và hữu ích. Sử dụng thông tin từ cơ sở kiến thức khi có liên quan.
+
+Thông tin tham khảo:
+{context_text}
+
+Hãy giữ câu trả lời ngắn gọn và tự nhiên như đang trò chuyện."""
+            
+            messages = [{"role": "system", "content": system_prompt}]
+            
+            # Add last 3 exchanges for context (to keep it manageable)
+            recent_history = self.conversation_history[-6:]  # Last 3 user-assistant pairs
+            messages.extend(recent_history)
+            
+            # Generate response
+            completion = self.client.chat.completions.create(
+                model=settings.LLM_MODEL,
+                messages=messages,
+                max_tokens=150,  # Keep responses concise for streaming
+                temperature=0.7
+            )
+            
+            response = completion.choices[0].message.content
+            self.conversation_history.append({"role": "assistant", "content": response})
+            
+            # Keep conversation history manageable
+            if len(self.conversation_history) > 10:
+                self.conversation_history = self.conversation_history[-10:]
+            
+            return response
+            
+        except Exception as e:
+            return f"Xin lỗi, tôi gặp lỗi: {str(e)}"
+    
+    def _text_to_speech(self, text: str) -> Optional[str]:
+        """Chuyển văn bản thành giọng nói"""
+        try:
+            tts_bytes = self.tts_service.text_to_speech(text, 'vi')
+            if tts_bytes:
+                return self.tts_service.save_audio_to_file(tts_bytes)
+        except Exception as e:
+            print(f"❌ Lỗi TTS: {e}")
+        
+        return None
+    
+    def get_conversation_state(self) -> dict:
+        """Lấy trạng thái cuộc hội thoại hiện tại"""
+        return {
+            'is_listening': self.is_listening,
+            'history_length': len(self.conversation_history),
+            'current_transcription': self.current_transcription
+        }

ui/components.py

@@ -0,0 +1,174 @@
+import gradio as gr
+
+def create_custom_css() -> str:
+    return """
+    .gradio-container {
+        background-color: #1f1f1f;
+    }
+    .gr-markdown, .gr-markdown * {
+        color: #ffffff !important;
+    }
+    
+    .streaming-active {
+        border: 3px solid #00ff00 !important;
+        animation: pulse 2s infinite;
+    }
+    
+    .streaming-inactive {
+        border: 2px solid #ff4444 !important;
+    }
+    
+    @keyframes pulse {
+        0% { border-color: #00ff00; }
+        50% { border-color: #00cc00; }
+        100% { border-color: #00ff00; }
+    }
+    
+    .vad-visualizer {
+        background: linear-gradient(90deg, #00ff00, #ffff00, #ff0000);
+        height: 20px;
+        border-radius: 10px;
+        margin: 10px 0;
+        transition: all 0.1s ease;
+    }
+    
+    .conversation-bubble {
+        background: #2d2d2d;
+        border-radius: 15px;
+        padding: 10px 15px;
+        margin: 5px 0;
+        border-left: 4px solid #f55036;
+    }
+    
+    .user-bubble {
+        border-left-color: #36a2f5;
+    }
+    
+    .assistant-bubble {
+        border-left-color: #f55036;
+    }
+    """
+def create_header() -> gr.Markdown:
+    return gr.Markdown("# 🎙️ Groq x Gradio Multi-Modal với RAG Wikipedia")
+def create_audio_components() -> tuple:
+    with gr.Row():
+        audio_input = gr.Audio(type="numpy", label="Nói hoặc tải lên file âm thanh")
+    
+    with gr.Row():
+        transcription_output = gr.Textbox(
+            label="Bản ghi âm",
+            lines=5,
+            interactive=True,
+            placeholder="Bản ghi âm sẽ hiển thị ở đây..."
+        )
+        response_output = gr.Textbox(
+            label="Phản hồi AI",
+            lines=5,
+            interactive=True,
+            placeholder="Phản hồi của AI sẽ hiển thị ở đây..."
+        )
+    
+    with gr.Row():
+        tts_audio_output = gr.Audio(
+            label="Phản hồi bằng giọng nói",
+            interactive=False
+        )
+    
+    process_button = gr.Button("Xử lý", variant="primary")
+    
+    return audio_input, transcription_output, response_output, tts_audio_output, process_button
+
+def create_chat_components() -> tuple:
+    chatbot = gr.Chatbot()
+    state = gr.State([])
+    
+    with gr.Row():
+        user_input = gr.Textbox(
+            show_label=False, 
+            placeholder="Nhập tin nhắn của bạn ở đây...", 
+            container=False,
+            scale=4
+        )
+        send_button = gr.Button("Gửi", variant="primary", scale=1)
+        clear_button = gr.Button("Xóa Chat", variant="secondary", scale=1)
+    
+    with gr.Row():
+        chat_tts_output = gr.Audio(
+            label="Phản hồi bằng giọng nói",
+            interactive=False
+        )
+    
+    return chatbot, state, user_input, send_button, clear_button, chat_tts_output
+def create_streaming_voice_components() -> tuple:
+    """Tạo components cho streaming voice với VAD"""
+    with gr.Group():
+        gr.Markdown("## 🎤 Trò chuyện giọng nói thời gian thực với VAD")
+        gr.Markdown("Hệ thống sẽ tự động phát hiện khi bạn nói và dừng, tạo cuộc hội thoại tự nhiên")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Voice activity visualization
+                vad_visualizer = gr.HTML(
+                    value="<div class='vad-visualizer' style='width: 100%;'></div>",
+                    label="Voice Activity"
+                )
+                
+                # Controls
+                with gr.Row():
+                    start_listening_btn = gr.Button(
+                        "🎙️ Bắt đầu lắng nghe", 
+                        variant="primary",
+                        size="sm"
+                    )
+                    stop_listening_btn = gr.Button(
+                        "🛑 Dừng lắng nghe", 
+                        variant="secondary",
+                        size="sm"
+                    )
+                
+                # Status
+                status_display = gr.Textbox(
+                    label="Trạng thái",
+                    value="Chưa lắng nghe",
+                    interactive=False
+                )
+                
+                # Conversation state
+                state_display = gr.JSON(
+                    label="Thông tin hội thoại",
+                    value={}
+                )
+            
+            with gr.Column(scale=2):
+                # Real-time transcription
+                realtime_transcription = gr.Textbox(
+                    label="🎯 Đang nói...",
+                    lines=2,
+                    interactive=False,
+                    placeholder="Văn bản được chuyển đổi sẽ xuất hiện ở đây..."
+                )
+                
+                # AI Response
+                ai_response = gr.Textbox(
+                    label="🤖 Phản hồi AI",
+                    lines=3,
+                    interactive=False,
+                    placeholder="Phản hồi của AI sẽ xuất hiện ở đây..."
+                )
+                
+                # TTS Audio output
+                tts_output = gr.Audio(
+                    label="🔊 Phản hồi bằng giọng nói",
+                    interactive=False,
+                    autoplay=True
+                )
+        
+        # Hidden state components
+        streaming_state = gr.State(value=False)
+        conversation_history = gr.State(value=[])
+    
+    return (
+        start_listening_btn, stop_listening_btn, status_display, state_display,
+        realtime_transcription, ai_response, tts_output, streaming_state,
+        conversation_history, vad_visualizer
+    )

ui/tabs.py

@@ -0,0 +1,315 @@
+import gradio as gr
+import threading
+import time
+from services.audio_service import AudioService
+from services.chat_service import ChatService
+from services.image_service import ImageService
+from services.streaming_voice_service import StreamingVoiceService
+from core.rag_system import EnhancedRAGSystem
+from core.tts_service import EnhancedTTSService
+from core.wikipedia_processor import WikipediaProcessor
+from ui.components import create_audio_components, create_chat_components, create_streaming_voice_components
+
+def create_all_tabs(audio_service: AudioService, chat_service: ChatService, 
+                   image_service: ImageService, rag_system: EnhancedRAGSystem,
+                   tts_service: EnhancedTTSService, wikipedia_processor: WikipediaProcessor,
+                   streaming_voice_service: StreamingVoiceService):
+    
+    with gr.Tab("🎙️ Streaming Voice (VAD)"):
+        create_streaming_voice_tab(streaming_voice_service)
+    
+    with gr.Tab("🎙️ Audio"):
+        create_audio_tab(audio_service)
+    
+    with gr.Tab("💬 Chat"):
+        create_chat_tab(chat_service)
+    
+    with gr.Tab("🖼️ Image"):
+        create_image_tab(image_service)
+    
+    with gr.Tab("📚 RAG Wikipedia"):
+        create_rag_tab(rag_system, wikipedia_processor)
+    
+    with gr.Tab("🔊 Text-to-Speech"):
+        create_tts_tab(tts_service)
+    
+    with gr.Tab("🌐 Language Info"):  # NEW TAB
+        create_language_info_tab(rag_system.multilingual_manager)
+def create_rag_tab(rag_system: EnhancedRAGSystem, wikipedia_processor: WikipediaProcessor):
+    gr.Markdown("## Upload data có sẵn")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 📤 Upload dữ liệu")
+            file_upload = gr.File(
+                label="Tải lên file",
+                file_types=['.txt', '.csv', '.json'],
+                file_count="single"
+            )
+            upload_btn = gr.Button("📤 Upload Data", variant="primary")
+            upload_status = gr.Textbox(label="Trạng thái Upload", interactive=False)
+            
+            gr.Markdown("### 📊 Thống kê Database")
+            stats_btn = gr.Button("📊 Database Stats", variant="secondary")
+            stats_display = gr.Textbox(label="Thống kê", interactive=False)
+            
+            gr.Markdown("### 🔍 Tìm kiếm Database")
+            search_query = gr.Textbox(
+                label="Tìm kiếm trong database",
+                placeholder="Nhập từ khóa để tìm kiếm..."
+            )
+            search_btn = gr.Button("🔍 Tìm kiếm", variant="secondary")
+        
+        with gr.Column(scale=2):
+            gr.Markdown("### 📋 Kết quả tìm kiếm RAG")
+            rag_results = gr.JSON(label="Tài liệu tham khảo tìm được")
+    
+    def upload_wikipedia_file(file):
+        if file is None:
+            return "Vui lòng chọn file để upload"
+        
+        try:
+            documents = wikipedia_processor.process_uploaded_file(file.name)
+            
+            if not documents:
+                return "Không tìm thấy dữ liệu nào trong file."
+            
+            metadatas = [{"source": "wikipedia", "type": "knowledge", "file": file.name, "language": "vi"} for _ in documents]
+            rag_system.add_documents(documents, metadatas)
+            
+            stats = rag_system.get_collection_stats()
+            return f"✅ Đã thêm {len(documents)} documents Wikipedia vào RAG database. Tổng số documents: {stats['count']}"
+            
+        except Exception as e:
+            return f"❌ Lỗi xử lý file Wikipedia: {str(e)}"
+    
+    upload_btn.click(upload_wikipedia_file, inputs=[file_upload], outputs=[upload_status])
+    stats_btn.click(rag_system.get_collection_stats, inputs=[], outputs=[stats_display])
+    search_btn.click(rag_system.semantic_search, inputs=[search_query], outputs=[rag_results])
+def create_audio_tab(audio_service: AudioService):
+    gr.Markdown("## Nói chuyện với AI (Đa ngôn ngữ)")
+    audio_input, transcription_output, response_output, tts_audio_output, process_button = create_audio_components()
+    
+    # NEW: Language display
+    language_display = gr.Textbox(
+        label="🌐 Ngôn ngữ phát hiện",
+        interactive=False,
+        placeholder="Ngôn ngữ sẽ hiển thị ở đây..."
+    )
+    
+    process_button.click(
+        audio_service.transcribe_audio,
+        inputs=audio_input,
+        outputs=[transcription_output, response_output, tts_audio_output, language_display]  # UPDATED
+    )
+def create_image_tab(image_service: ImageService):
+    gr.Markdown("## Phân tích hình ảnh")
+    with gr.Row():
+        image_input = gr.Image(type="numpy", label="Tải lên hình ảnh")
+    with gr.Row():
+        image_description = gr.Textbox(
+            label="Mô tả hình ảnh của bạn (tùy chọn)",
+            placeholder="Mô tả ngắn về hình ảnh để AI phân tích chính xác hơn..."
+        )
+    with gr.Row():
+        image_output = gr.Textbox(label="Kết quả phân tích")
+    analyze_button = gr.Button("Phân tích hình ảnh", variant="primary")
+    analyze_button.click(
+        image_service.analyze_image_with_description,
+        inputs=[image_input, image_description],
+        outputs=[image_output]
+    )
+def create_chat_tab(chat_service: ChatService):
+    gr.Markdown("## Trò chuyện với AI Assistant (Đa ngôn ngữ)")
+    chatbot, state, user_input, send_button, clear_button, chat_tts_output = create_chat_components()
+    
+    # NEW: Language display
+    chat_language_display = gr.Textbox(
+        label="🌐 Ngôn ngữ phát hiện",
+        interactive=False,
+        placeholder="Ngôn ngữ sẽ hiển thị ở đây..."
+    )
+    
+    send_button.click(
+        chat_service.respond,
+        inputs=[user_input, state],
+        outputs=[user_input, chatbot, state, chat_tts_output, chat_language_display]  # UPDATED
+    )
+    clear_button.click(
+        chat_service.clear_chat_history,
+        inputs=[state],
+        outputs=[chatbot, state]
+    )
+
+def create_language_info_tab(multilingual_manager):  # NEW FUNCTION
+    """Tab hiển thị thông tin về hệ thống đa ngôn ngữ"""
+    gr.Markdown("## 🌐 Thông tin Hệ thống Đa ngôn ngữ")
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 🔧 Cấu hình Model")
+            
+            vietnamese_info = multilingual_manager.get_language_info('vi')
+            multilingual_info = multilingual_manager.get_language_info('en')
+            
+            gr.Markdown(f"""
+            **Tiếng Việt:**
+            - Embedding Model: `{vietnamese_info['embedding_model']}`
+            - LLM Model: `{vietnamese_info['llm_model']}`
+            - Trạng thái: {vietnamese_info['status']}
+            
+            **Đa ngôn ngữ:**
+            - Embedding Model: `{multilingual_info['embedding_model']}`
+            - LLM Model: `{multilingual_info['llm_model']}`
+            - Trạng thái: {multilingual_info['status']}
+            """)
+        
+        with gr.Column():
+            gr.Markdown("### 🎯 Ngôn ngữ được hỗ trợ")
+            
+            supported_languages = """
+            - 🇻🇳 **Tiếng Việt**: Sử dụng model chuyên biệt
+            - 🇺🇸 **English**: Sử dụng model đa ngôn ngữ
+            - 🇫🇷 **French**: Sử dụng model đa ngôn ngữ
+            - 🇪🇸 **Spanish**: Sử dụng model đa ngôn ngữ
+            - 🇩🇪 **German**: Sử dụng model đa ngôn ngữ
+            - 🇯🇵 **Japanese**: Sử dụng model đa ngôn ngữ
+            - 🇰🇷 **Korean**: Sử dụng model đa ngôn ngữ
+            - 🇨🇳 **Chinese**: Sử dụng model đa ngôn ngữ
+            """
+            gr.Markdown(supported_languages)
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 🔍 Kiểm tra Ngôn ngữ")
+            test_text = gr.Textbox(
+                label="Nhập văn bản để kiểm tra ngôn ngữ",
+                placeholder="Nhập văn bản bằng bất kỳ ngôn ngữ nào..."
+            )
+            test_button = gr.Button("🔍 Kiểm tra", variant="primary")
+            
+            test_result = gr.JSON(label="Kết quả phát hiện ngôn ngữ")
+        
+        test_button.click(
+            lambda text: {
+                'detected_language': multilingual_manager.detect_language(text),
+                'language_info': multilingual_manager.get_language_info(multilingual_manager.detect_language(text)),
+                'embedding_model': multilingual_manager.get_embedding_model(multilingual_manager.detect_language(text)) is not None,
+                'llm_model': multilingual_manager.get_llm_model(multilingual_manager.detect_language(text))
+            },
+            inputs=[test_text],
+            outputs=[test_result]
+        )
+def create_tts_tab(tts_service: EnhancedTTSService):
+        gr.Markdown("## 🎵 Chuyển văn bản thành giọng nói nâng cao")
+        gr.Markdown("Nhập văn bản và chọn ngôn ngữ để chuyển thành giọng nói")
+        
+        with gr.Group():
+            with gr.Row():
+                tts_text_input = gr.Textbox(
+                    label="Văn bản cần chuyển thành giọng nói",
+                    lines=4,
+                    placeholder="Nhập văn bản tại đây..."
+                )
+            with gr.Row():
+                tts_language = gr.Dropdown(
+                    choices=["vi", "en", "fr", "es", "de", "ja", "ko", "zh"],
+                    value="vi",
+                    label="Ngôn ngữ"
+                )
+                tts_provider = gr.Dropdown(
+                    choices=["auto", "gtts", "edgetts"],
+                    value="auto",
+                    label="Nhà cung cấp TTS"
+                )
+            with gr.Row():
+                tts_output_audio = gr.Audio(
+                    label="Kết quả giọng nói",
+                    interactive=False
+                )
+            tts_button = gr.Button("🔊 Chuyển thành giọng nói", variant="primary")
+        
+        def text_to_speech_standalone(text, language, tts_provider):
+            if not text:
+                return None
+            
+            try:
+                tts_audio_bytes = tts_service.text_to_speech(text, language, tts_provider)
+                if tts_audio_bytes:
+                    temp_audio_file = tts_service.save_audio_to_file(tts_audio_bytes)
+                    return temp_audio_file
+            except Exception as e:
+                print(f"❌ Lỗi TTS: {e}")
+            
+            return None
+        
+        tts_button.click(
+            text_to_speech_standalone,
+            inputs=[tts_text_input, tts_language, tts_provider],
+            outputs=[tts_output_audio]
+        )
+def create_streaming_voice_tab(streaming_service: StreamingVoiceService):
+    """Tạo tab streaming voice với VAD"""
+    
+    # Create components
+    (start_btn, stop_btn, status_display, state_display,
+    transcription, ai_response, tts_output, streaming_state,
+    conversation_history, vad_visualizer) = create_streaming_voice_components()
+    
+    def start_streaming():
+        """Bắt đầu streaming với VAD"""
+        def callback_handler(result):
+            """Xử lý kết quả real-time"""
+            # Cập nhật UI với kết quả mới
+            # Note: Trong thực tế, cần sử dụng gr.update() và queue
+            print(f"🎯 Kết quả: {result['transcription']}")
+            print(f"🤖 Phản hồi: {result['response']}")
+        
+        success = streaming_service.start_listening(callback_handler)
+        status = "✅ Đang lắng nghe..." if success else "❌ Lỗi khởi động"
+        
+        # Start background thread for UI updates
+        if success:
+            threading.Thread(target=update_ui_loop, daemon=True).start()
+        
+        return status, streaming_service.get_conversation_state()
+    
+    def stop_streaming():
+        """Dừng streaming"""
+        streaming_service.stop_listening()
+        return "🛑 Đã dừng lắng nghe", streaming_service.get_conversation_state()
+    
+    def update_ui_loop():
+        """Vòng lặp cập nhật UI real-time"""
+        while streaming_service.is_listening:
+            # Cập nhật trạng thái
+            state = streaming_service.get_conversation_state()
+            
+            # Ở đây cần sử dụng gr.update() và queue để cập nhật UI
+            # Đây là phiên bản đơn giản, trong thực tế cần tích hợp với Gradio Queue
+            
+            time.sleep(0.1)
+    
+    # Event handlers
+    start_btn.click(
+        start_streaming,
+        outputs=[status_display, state_display]
+    )
+    
+    stop_btn.click(
+        stop_streaming,
+        outputs=[status_display, state_display]
+    )
+    
+    # Demo real-time updates (simplified)
+    def demo_update():
+        """Demo cập nhật real-time"""
+        if streaming_service.is_listening:
+            state = streaming_service.get_conversation_state()
+            return (
+                state['current_transcription'] or "Đang lắng nghe...",
+                "Phản hồi sẽ xuất hiện ở đây...",
+                state
+            )
+        return "Chưa lắng nghe", "Chưa có phản hồi", {}
+    

utils/helpers.py

@@ -0,0 +1,14 @@
+import numpy as np
+import io
+import soundfile as sf
+
+def numpy_to_mp3(audio_array: np.ndarray, sampling_rate: int = 24000) -> bytes:
+    """Convert numpy array to MP3 bytes"""
+    buffer = io.BytesIO()
+    sf.write(buffer, audio_array, sampling_rate, format='mp3')
+    buffer.seek(0)
+    return buffer.read()
+
+def validate_api_key(api_key: str) -> bool:
+    """Validate Groq API key"""
+    return api_key is not None and len(api_key.strip()) > 0