Update app.py

app.py

@@ -1,69 +1,864 @@
+"""
+📞 Reem — Real-Time Streaming Voice RAG Bot
+Gradio on Hugging Face Spaces
+STT: Deepgram WebSocket  |  LLM: Groq  |  TTS: edge-tts
+"""
+
+import os, base64, asyncio, sqlite3, re, json, tempfile, threading, time
+from pathlib import Path
+from collections import deque
+from dataclasses import dataclass, field
+from typing import Optional, Generator
+import numpy as np
+import faiss
 import gradio as gr
-from huggingface_hub import InferenceClient
-
-
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-    hf_token: gr.OAuthToken,
-):
+import edge_tts
+from groq import Groq
+from sentence_transformers import SentenceTransformer
+from deepgram import DeepgramClient, LiveTranscriptionEvents, LiveOptions
+from pydub import AudioSegment
+import httpx
+
+# ── Env / Constants ────────────────────────────────────────────────────────
+GROQ_API_KEY     = os.environ.get("GROQ_API_KEY", "")
+DEEPGRAM_API_KEY = os.environ.get("DEEPGRAM_API_KEY", "")
+
+EMBED_MODEL      = "all-MiniLM-L6-v2"
+TOP_K            = 5
+MEMORY_TURNS     = 10
+FAISS_INDEX_PATH = "faiss.index"
+CHUNKS_PATH      = "chunks.npy"
+MIN_AUDIO_BYTES  = 8000
+DB_PATH          = "saudi_orders_database.db"
+
+DB_SCHEMA = """
+Table: orders
+Columns:
+  order_id         INTEGER (primary key)
+  order_date       TEXT
+  customer_name    TEXT
+  customer_city    TEXT
+  customer_address TEXT
+  status           TEXT  (e.g. 'Delivered', 'In Transit', 'Pending')
+  delivery_date    TEXT
+  comments         TEXT
+"""
+
+VOICES = {
+    "en": "en-US-AriaNeural",
+    "ar": "ar-SA-ZariyahNeural",
+    "ur": "ur-PK-UzmaNeural",
+}
+
+WELCOME_MESSAGES = {
+    "en": "Welcome to our virtual call centre. For English say English.",
+    "ar": "مرحباً بكم في مركز الاتصال الافتراضي. للعربية قل العربية.",
+    "ur": "ہمارے ورچوئل کال سینٹر میں خوش آمدید۔ اردو کے لیے اردو کہیں۔",
+}
+
+LANGUAGE_CONFIRMATION = {
+    "en": "Thank you for choosing English. How can I help you today?",
+    "ar": "شكراً لاختياركم العربية. كيف يمكنني مساعدتكم اليوم؟",
+    "ur": "اردو منتخب کرنے کا شکریہ۔ میں آپ کی کیسے مدد کر سکتی ہوں؟",
+}
+
+LANG_KEYWORDS = {
+    "en": ["english", "انگلش"],
+    "ar": ["arabic", "عربي", "عربية", "العربية"],
+    "ur": ["urdu", "اردو"],
+}
+
+ORDER_KEYWORDS = [
+    "order","track","status","delivery","deliver","shipment","shipped",
+    "parcel","package","where is my","when will",
+    "طلب","تتبع","حالة","توصيل","شحن",
+    "آرڈر","ٹریک","ڈیلیوری","اسٹیٹس",
+]
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  MEMORY
+# ══════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class Turn:
+    role: str
+    content: str
+    entities: dict = field(default_factory=dict)
+    route: str = ""
+
+
+class ConversationMemory:
+    def __init__(self, max_turns: int = MEMORY_TURNS):
+        self.turns: deque[Turn] = deque(maxlen=max_turns)
+        self.entity_cache: dict = {
+            "order_ids": [], "customer_name": None,
+            "last_topic": None, "city": None,
+        }
+
+    def extract_entities(self, text: str) -> dict:
+        entities = {}
+        ids = re.findall(r"\b(\d{3,})\b", text)
+        if ids:
+            entities["order_ids"] = [int(i) for i in ids]
+        name_match = re.search(
+            r"(?:my name is|i am|customer|اسمي|نام)\s+([A-Za-z\u0600-\u06FF]{2,})",
+            text, re.IGNORECASE)
+        if name_match:
+            entities["customer_name"] = name_match.group(1)
+        return entities
+
+    def update_cache(self, entities: dict):
+        if "order_ids" in entities:
+            for oid in entities["order_ids"]:
+                if oid not in self.entity_cache["order_ids"]:
+                    self.entity_cache["order_ids"].append(oid)
+        if "customer_name" in entities:
+            self.entity_cache["customer_name"] = entities["customer_name"]
+
+    def add_turn(self, role: str, content: str, route: str = ""):
+        entities = self.extract_entities(content) if role == "user" else {}
+        self.update_cache(entities)
+        self.turns.append(Turn(role=role, content=content,
+                               entities=entities, route=route))
+
+    def history_text(self, max_chars: int = 1200) -> str:
+        lines = []
+        for t in self.turns:
+            prefix = "Customer" if t.role == "user" else "Reem"
+            lines.append(f"{prefix}: {t.content}")
+        text = "\n".join(lines)
+        return text[-max_chars:] if len(text) > max_chars else text
+
+    def resolve_order_id(self, query: str) -> Optional[int]:
+        ids_in_query = re.findall(r"\b(\d{3,})\b", query)
+        if ids_in_query:
+            return int(ids_in_query[-1])
+        implicit = ["it","that order","same order","my order","the order",
+                    "طلبي","آرڈر","وہ"]
+        if any(t in query.lower() for t in implicit):
+            if self.entity_cache["order_ids"]:
+                return self.entity_cache["order_ids"][-1]
+        return None
+
+    def memory_keywords(self) -> list[str]:
+        keywords = []
+        for t in list(self.turns)[-3:]:
+            if t.role == "user":
+                keywords += re.findall(r"\b\w{4,}\b", t.content.lower())
+        return list(set(keywords))
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  SINGLETONS
+# ══════════════════════════════════════════════════════════════════════════
+
+_groq_client: Optional[Groq] = None
+_embedder = None
+_faiss_index = None
+_chunks = None
+
+def get_groq() -> Groq:
+    global _groq_client
+    if _groq_client is None:
+        _groq_client = Groq(api_key=GROQ_API_KEY)
+    return _groq_client
+
+def get_embedder():
+    global _embedder
+    if _embedder is None:
+        _embedder = SentenceTransformer(EMBED_MODEL)
+    return _embedder
+
+def get_index():
+    global _faiss_index, _chunks
+    if _faiss_index is None:
+        if Path(FAISS_INDEX_PATH).exists() and Path(CHUNKS_PATH).exists():
+            _faiss_index = faiss.read_index(FAISS_INDEX_PATH)
+            _chunks = np.load(CHUNKS_PATH, allow_pickle=True)
+    return _faiss_index, _chunks
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  DEEPGRAM STT  (streaming WebSocket)
+# ══════════════════════════════════════════════════════════════════════════
+
+def transcribe_audio_bytes(audio_bytes: bytes) -> str:
+    """
+    Send raw audio bytes to Deepgram's REST pre-recorded API.
+    Used for push-to-talk mic chunks from Gradio.
+    """
+    if len(audio_bytes) < MIN_AUDIO_BYTES:
+        return ""
+    try:
+        headers = {
+            "Authorization": f"Token {DEEPGRAM_API_KEY}",
+            "Content-Type": "audio/wav",
+        }
+        params = {
+            "model": "nova-2",
+            "language": "multi",      # auto-detect Arabic / English / Urdu
+            "smart_format": "true",
+            "punctuate": "true",
+        }
+        resp = httpx.post(
+            "https://api.deepgram.com/v1/listen",
+            headers=headers,
+            params=params,
+            content=audio_bytes,
+            timeout=20,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        return (data["results"]["channels"][0]
+                    ["alternatives"][0]["transcript"].strip())
+    except Exception as e:
+        print(f"[Deepgram STT error] {e}")
+        return ""
+
+
+class DeepgramStreamingSTT:
     """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
+    WebSocket-based streaming STT for real-time barge-in detection.
+    Runs in a background thread; emits final transcripts via callback.
     """
-    client = InferenceClient(token=hf_token.token, model="openai/gpt-oss-20b")
+    def __init__(self, on_transcript):
+        self.on_transcript = on_transcript
+        self._conn = None
+        self._loop = None
+        self._thread = None
+        self.running = False
+
+    def start(self):
+        self.running = True
+        self._thread = threading.Thread(target=self._run_loop, daemon=True)
+        self._thread.start()
+
+    def _run_loop(self):
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+        self._loop.run_until_complete(self._connect())
+
+    async def _connect(self):
+        dg = DeepgramClient(DEEPGRAM_API_KEY)
+        self._conn = dg.listen.asyncwebsocket.v("1")
+
+        self._conn.on(LiveTranscriptionEvents.Transcript, self._on_msg)
+
+        opts = LiveOptions(
+            model="nova-2",
+            language="multi",
+            smart_format=True,
+            interim_results=True,
+            endpointing=400,
+        )
+        await self._conn.start(opts)
+
+        while self.running:
+            await asyncio.sleep(0.05)
+
+        await self._conn.finish()
+
+    async def _on_msg(self, _self, result, **kwargs):
+        try:
+            alt = result.channel.alternatives[0]
+            if result.is_final and alt.transcript.strip():
+                self.on_transcript(alt.transcript.strip())
+        except Exception:
+            pass
+
+    def send_audio(self, chunk: bytes):
+        if self._conn and self._loop and self.running:
+            asyncio.run_coroutine_threadsafe(
+                self._conn.send(chunk), self._loop)
+
+    def stop(self):
+        self.running = False
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  TTS
+# ══════════════════════════════════════════════════════════════════════════
+
+async def _tts_async(text: str, voice: str, out_path: str):
+    communicate = edge_tts.Communicate(text, voice)
+    await communicate.save(out_path)
+
+
+def tts_to_file(text: str, lang_code: str) -> str:
+    """Returns path to generated mp3 file."""
+    voice = VOICES.get(lang_code, VOICES["en"])
+    tmp = tempfile.mktemp(suffix=".mp3")
+    asyncio.run(_tts_async(text, voice, tmp))
+    return tmp
+
+
+def tts_bytes(text: str, lang_code: str) -> bytes:
+    path = tts_to_file(text, lang_code)
+    try:
+        return Path(path).read_bytes()
+    finally:
+        Path(path).unlink(missing_ok=True)
+
+
+def welcome_audio_b64() -> str:
+    combined = AudioSegment.empty()
+    for lang_code, text in WELCOME_MESSAGES.items():
+        data = tts_bytes(text, lang_code)
+        tmp = tempfile.mktemp(suffix=".mp3")
+        Path(tmp).write_bytes(data)
+        combined += AudioSegment.from_mp3(tmp) + AudioSegment.silent(700)
+        Path(tmp).unlink(missing_ok=True)
+    out = tempfile.mktemp(suffix=".mp3")
+    combined.export(out, format="mp3")
+    b64 = base64.b64encode(Path(out).read_bytes()).decode()
+    Path(out).unlink(missing_ok=True)
+    return b64
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  ROUTING
+# ══════════════════════════════════════════════════════════════════════════
+
+def is_order_query(text: str) -> bool:
+    t = text.lower()
+    return any(kw in t for kw in ORDER_KEYWORDS)
+
+
+def route_query(query: str, memory: ConversationMemory) -> str:
+    if is_order_query(query) or re.search(r"\b\d{3,}\b", query):
+        return "sql"
+    recent_routes = [t.route for t in list(memory.turns)[-3:] if t.role == "user"]
+    if recent_routes and recent_routes[-1] == "sql":
+        if any(sig in query.lower() for sig in
+               ["when","why","how long","address","city","متى","کب"]):
+            return "sql"
+    prompt = (
+        "You are an intent router. Return ONLY 'sql' or 'rag'.\n"
+        f"Context:\n{memory.history_text(400)}\nQuery: {query}"
+    )
+    r = get_groq().chat.completions.create(
+        model="llama-3.3-70b-versatile", temperature=0, max_tokens=5,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    route = r.choices[0].message.content.strip().lower()
+    return route if route in ("sql", "rag") else "rag"
+
 
-    messages = [{"role": "system", "content": system_message}]
+# ══════════════════════════════════════════════════════════════════════════
+#  RAG
+# ══════════════════════════════════════════════════════════════════════════
 
-    messages.extend(history)
+def chunk_text(text, size=300, overlap=50):
+    words = text.split()
+    chunks, i = [], 0
+    while i < len(words):
+        chunks.append(" ".join(words[i:i+size]))
+        i += size - overlap
+    return chunks
 
-    messages.append({"role": "user", "content": message})
 
-    response = ""
+def build_index(texts: list[str]):
+    global _faiss_index, _chunks
+    embedder = get_embedder()
+    all_chunks = []
+    for t in texts:
+        all_chunks.extend(chunk_text(t))
+    if not all_chunks:
+        raise ValueError("No text found.")
+    vecs = embedder.encode(all_chunks, show_progress_bar=False,
+                           convert_to_numpy=True).astype(np.float32)
+    faiss.normalize_L2(vecs)
+    idx = faiss.IndexFlatIP(vecs.shape[1])
+    idx.add(vecs)
+    faiss.write_index(idx, FAISS_INDEX_PATH)
+    np.save(CHUNKS_PATH, np.array(all_chunks, dtype=object))
+    _faiss_index = idx
+    _chunks = np.array(all_chunks, dtype=object)
+    return idx, _chunks
 
-    for message in client.chat_completion(
-        messages,
-        max_tokens=max_tokens,
+
+def retrieve(query: str, index, chunks,
+             memory: ConversationMemory) -> list[str]:
+    embedder = get_embedder()
+    history_snippet = memory.history_text(300)
+    enriched = f"{history_snippet}\n\nQuestion: {query}" if history_snippet else query
+    q = embedder.encode([enriched], convert_to_numpy=True).astype(np.float32)
+    faiss.normalize_L2(q)
+    _, ids = index.search(q, TOP_K)
+    candidates = [chunks[i] for i in ids[0] if i >= 0]
+    keywords = memory.memory_keywords()
+    if keywords:
+        candidates.sort(key=lambda c: sum(1 for kw in keywords if kw in c.lower()),
+                        reverse=True)
+    return candidates[:3]
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  SQL PATH
+# ══════════════════════════════════════════════════════════════════════════
+
+def generate_sql(query: str, memory: ConversationMemory) -> str:
+    entity_hint = ""
+    if memory.entity_cache["customer_name"]:
+        entity_hint += f"\nKnown customer: {memory.entity_cache['customer_name']}"
+    if memory.entity_cache["order_ids"]:
+        entity_hint += f"\nPrior order IDs: {memory.entity_cache['order_ids']}"
+    prompt = (
+        f"You are a SQL expert.\nSchema:\n{DB_SCHEMA}{entity_hint}\n"
+        f"History:\n{memory.history_text(400)}\n"
+        f"Write a safe SELECT query for: {query}\n"
+        "Return ONLY raw SQL, no markdown."
+    )
+    r = get_groq().chat.completions.create(
+        model="llama-3.3-70b-versatile", temperature=0, max_tokens=200,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    sql = r.choices[0].message.content.strip()
+    return re.sub(r"```sql|```", "", sql).strip()
+
+
+def run_sql(sql: str):
+    if not Path(DB_PATH).exists():
+        return None, "Database not found."
+    if not sql.strip().upper().startswith("SELECT"):
+        return None, "Only SELECT allowed."
+    try:
+        conn = sqlite3.connect(DB_PATH)
+        cur = conn.cursor()
+        cur.execute(sql)
+        rows = cur.fetchall()
+        cols = [d[0] for d in cur.description]
+        conn.close()
+        return (cols, rows), None
+    except Exception as e:
+        return None, str(e)
+
+
+def answer_from_db(query, cols, rows, lang_code, memory) -> str:
+    lang_instr = {"en": "English only.", "ar": "Arabic only.", "ur": "Urdu only."}.get(lang_code, "English only.")
+    if not rows:
+        return {"en": "I couldn't find any matching order. Please check your order ID.",
+                "ar": "لم أجد أي طلب مطابق. يرجى التحقق من رقم الطلب.",
+                "ur": "کوئی ملتا جلتا آرڈر نہیں ملا۔ آرڈر نمبر چیک کریں۔"}.get(lang_code, "")
+    prompt = (
+        f"You are Reem, a professional call centre agent. {lang_instr}\n"
+        f"History:\n{memory.history_text(500)}\n"
+        f"Customer asked: \"{query}\"\n"
+        f"DB result — Columns: {cols}, Rows: {rows}\n"
+        "Give a friendly 2-3 sentence answer. No SQL mention."
+    )
+    r = get_groq().chat.completions.create(
+        model="llama-3.3-70b-versatile", temperature=0.1, max_tokens=250,
+        messages=[{"role": "user", "content": prompt}]
+    )
+    return r.choices[0].message.content.strip()
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  LLM (RAG) — STREAMING
+# ══════════════════════════════════════════════════════════════════════════
+
+def ask_llm_stream(query: str, ctx_chunks: list[str],
+                   lang_code: str, memory: ConversationMemory) -> Generator[str, None, None]:
+    """Yields token-by-token streamed response from Groq."""
+    context = "\n\n".join(ctx_chunks[:3])[:2800]
+    lang_instr = {"en": "Respond in English only.",
+                  "ar": "أجب باللغة العربية فقط.",
+                  "ur": "صرف اردو میں جواب دیں۔"}.get(lang_code, "Respond in English only.")
+    system = (
+        f"You are Reem, a professional female call centre agent. {lang_instr} "
+        "Use conversation history for context-aware answers. "
+        "If a follow-up, refer naturally to prior answers. Max 3 sentences."
+    )
+    user_msg = (
+        f"History:\n{memory.history_text(600)}\n\n"
+        f"Knowledge base:\n{context}\n\n"
+        f"Customer question: {query}"
+    )
+    stream = get_groq().chat.completions.create(
+        model="llama-3.3-70b-versatile",
+        temperature=0.1,
+        max_tokens=250,
         stream=True,
-        temperature=temperature,
-        top_p=top_p,
-    ):
-        choices = message.choices
-        token = ""
-        if len(choices) and choices[0].delta.content:
-            token = choices[0].delta.content
+        messages=[{"role": "system", "content": system},
+                  {"role": "user",   "content": user_msg}]
+    )
+    for chunk in stream:
+        delta = chunk.choices[0].delta.content
+        if delta:
+            yield delta
+
+
+def ask_llm(query, ctx_chunks, lang_code, memory) -> str:
+    return "".join(ask_llm_stream(query, ctx_chunks, lang_code, memory))
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  CORE PROCESSING
+# ══════════════════════════════════════════════════════════════════════════
 
-        response += token
-        yield response
+def process_query(query: str, memory: ConversationMemory,
+                  lang_code: str, chat_history: list) -> tuple[str, list, str]:
+    """
+    Returns (answer_text, updated_chat_history, tts_audio_path).
+    """
+    if not query or not query.strip():
+        return "", chat_history, None
+
+    route = route_query(query, memory)
+
+    # ── SQL ──────────────────────────────────────────────────────────
+    if route == "sql":
+        order_id = memory.resolve_order_id(query)
+        if not order_id and not re.search(r"\b\d{3,}\b", query):
+            ans = {"en": "I can help track your order. Please provide your order ID.",
+                   "ar": "يمكنني مساعدتك بتتبع طلبك. يرجى تزويدي برقم الطلب.",
+                   "ur": "براہ کرم آرڈر نمبر دیں۔"}.get(lang_code)
+        else:
+            sql = generate_sql(query, memory)
+            result, error = run_sql(sql)
+            if error:
+                ans = {"en": "Sorry, I couldn't retrieve that order.",
+                       "ar": "عذراً، لم أتمكن من استرداد الطلب.",
+                       "ur": "معذرت، آرڈر نہیں ملا۔"}.get(lang_code)
+            else:
+                cols, rows = result
+                ans = answer_from_db(query, cols, rows, lang_code, memory)
+
+    # ── RAG ──────────────────────────────────────────────────────────
+    else:
+        index, chunks = get_index()
+        if index is None:
+            ans = "No knowledge base loaded yet. Please upload TXT files first."
+        else:
+            ctx = retrieve(query, index, chunks, memory)
+            ans = ask_llm(query, ctx, lang_code, memory)
+
+    memory.add_turn("user", query, route=route)
+    memory.add_turn("assistant", ans, route=route)
+
+    chat_history = chat_history + [
+        {"role": "user", "content": query},
+        {"role": "assistant", "content": ans},
+    ]
+
+    # TTS
+    audio_path = tts_to_file(ans, lang_code)
+    return ans, chat_history, audio_path
 
 
+def detect_lang(text: str) -> Optional[str]:
+    t = text.lower().strip()
+    for code, keywords in LANG_KEYWORDS.items():
+        if any(kw in t for kw in keywords):
+            return code
+    return None
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  GRADIO UI
+# ══════════════════════════════════════════════════════════════════════════
+
+CSS = """
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
+body, .gradio-container { background: linear-gradient(145deg,#0a0f1a 0%,#131b2e 60%,#0d1526 100%) !important; font-family: 'Inter', sans-serif; }
+.hero { text-align:center; padding:1.5rem 2rem 1.25rem; margin-bottom:1rem;
+    background:linear-gradient(135deg,rgba(16,185,129,0.1),rgba(245,158,11,0.06));
+    border:1px solid rgba(255,255,255,0.08); border-radius:20px; }
+.hero h1 { font-size:1.8rem; font-weight:700; color:#f1f5f9; margin:0; }
+.hero p  { color:#94a3b8; margin:0.35rem 0 0; font-size:0.95rem; }
+.badge { display:inline-block; margin-top:0.6rem; padding:0.3rem 0.85rem;
+    background:rgba(16,185,129,0.15); border:1px solid rgba(16,185,129,0.35);
+    border-radius:999px; color:#34d399; font-size:0.78rem; font-weight:500; }
+.panel { background:rgba(17,24,39,0.75); border:1px solid rgba(255,255,255,0.08);
+    border-radius:16px; padding:1.2rem; margin-bottom:0.75rem; }
+#chatbot { background:rgba(17,24,39,0.7) !important; border-radius:14px !important; }
+.message.user   { background:rgba(16,185,129,0.12) !important; border:1px solid rgba(16,185,129,0.25) !important; color:#f1f5f9 !important; border-radius:12px !important; }
+.message.bot    { background:rgba(245,158,11,0.1) !important; border:1px solid rgba(245,158,11,0.2) !important; color:#f1f5f9 !important; border-radius:12px !important; }
+.gr-button-primary { background:linear-gradient(135deg,#10b981,#059669) !important; border:none !important; font-weight:600 !important; }
+footer { display:none !important; }
 """
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
+
+AVATAR_HTML = """
+<div style="background:linear-gradient(160deg,#0f172a,#1e293b);border-radius:20px;padding:24px;text-align:center;border:1px solid rgba(255,255,255,0.08);">
+  <div style="position:relative;width:160px;height:160px;margin:0 auto 16px;border-radius:50%;background:linear-gradient(135deg,#1e3a5f,#0f766e);display:flex;align-items:center;justify-content:center;font-size:72px;box-shadow:0 8px 32px rgba(16,185,129,0.2);">
+    👩‍💼
+    <div style="position:absolute;top:8px;right:8px;width:14px;height:14px;background:#10b981;border:2px solid #0f172a;border-radius:50%;box-shadow:0 0 8px rgba(16,185,129,0.8);"></div>
+  </div>
+  <p style="font-size:1.1rem;font-weight:600;color:#f8fafc;margin:0 0 4px;">Reem</p>
+  <p style="font-size:0.8rem;color:#94a3b8;margin:0 0 12px;">Virtual Call Centre Agent</p>
+  <span style="background:rgba(16,185,129,0.12);border:1px solid rgba(16,185,129,0.35);border-radius:999px;color:#34d399;padding:5px 14px;font-size:0.78rem;">🟢 Online</span>
+</div>
 """
-chatbot = gr.ChatInterface(
-    respond,
-    additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
-        gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
-    ],
-)
-
-with gr.Blocks() as demo:
-    with gr.Sidebar():
-        gr.LoginButton()
-    chatbot.render()
 
+def build_app():
+    # Pre-load welcome audio once
+    print("⏳ Generating welcome audio…")
+    welcome_b64 = welcome_audio_b64()
+    print("✅ Welcome audio ready.")
+
+    with gr.Blocks(css=CSS, title="Reem — Virtual Call Centre") as demo:
+
+        # ── State ──────────────────────────────────────────────────────
+        memory_state   = gr.State(ConversationMemory())
+        lang_state     = gr.State("")          # "" = not selected yet
+        chat_history   = gr.State([])
+
+        # ── Hero ───────────────────────────────────────────────────────
+        gr.HTML("""
+        <div class="hero">
+          <h1>📞 Virtual Call Centre</h1>
+          <p>XYZ Holdings — powered by AI agent <strong>Reem</strong></p>
+          <span class="badge">🟢 Online · Voice &amp; Text · English / العربية / اردو</span>
+        </div>
+        """)
+
+        with gr.Row():
+            # ── Left: Avatar + Admin ───────────────────────────────────
+            with gr.Column(scale=1, min_width=260):
+                gr.HTML(AVATAR_HTML)
+
+                with gr.Accordion("⚙️ Admin Panel", open=False):
+                    gr.Markdown("**📚 Knowledge Base**")
+                    kb_files  = gr.File(label="Upload TXT files",
+                                        file_types=[".txt"],
+                                        file_count="multiple")
+                    build_btn = gr.Button("Build KB", variant="primary", size="sm")
+                    kb_status = gr.Textbox(label="KB Status", interactive=False,
+                                           lines=1, value="No KB loaded")
+
+                    gr.Markdown("**🗄️ Orders Database**")
+                    db_file   = gr.File(label="Upload .db file",
+                                        file_types=[".db"])
+                    db_status = gr.Textbox(label="DB Status", interactive=False,
+                                           lines=1,
+                                           value="✅ Connected" if Path(DB_PATH).exists() else "❌ Not found")
+
+                    gr.Markdown("**🧠 Memory**")
+                    mem_info  = gr.Textbox(label="Entity cache", interactive=False, lines=2)
+                    clear_btn = gr.Button("🗑️ Clear memory", variant="secondary", size="sm")
+
+            # ── Right: Chat ────────────────────────────────────────────
+            with gr.Column(scale=2):
+
+                # ── Language selection (shown until lang chosen) ───────
+                with gr.Group(visible=True) as lang_group:
+                    gr.Markdown("### 🌐 Choose your language")
+                    gr.Markdown("Speak below or tap a button.")
+                    lang_mic = gr.Audio(
+                        sources=["microphone"],
+                        type="numpy",
+                        label="🎙️ Say your language",
+                        streaming=False,
+                    )
+                    with gr.Row():
+                        btn_en = gr.Button("🇬🇧 English",  variant="primary")
+                        btn_ar = gr.Button("🇸🇦 العربية", variant="primary")
+                        btn_ur = gr.Button("🇵🇰 اردو",    variant="primary")
+                    lang_audio_out = gr.Audio(
+                        label="Agent", autoplay=True,
+                        visible=False, interactive=False)
+
+                # ── Main chat interface (hidden until lang chosen) ─────
+                with gr.Group(visible=False) as chat_group:
+                    lang_badge    = gr.Markdown("🗣️ Language: **English**")
+                    chatbot       = gr.Chatbot(
+                        elem_id="chatbot",
+                        label="Reem",
+                        height=400,
+                        type="messages",
+                    )
+                    with gr.Row():
+                        voice_input = gr.Audio(
+                            sources=["microphone"],
+                            type="numpy",
+                            label="🎙️ Speak",
+                            streaming=False,
+                        )
+                    txt_input     = gr.Textbox(
+                        placeholder="Type your message or order number…",
+                        label="",
+                        lines=1,
+                    )
+                    with gr.Row():
+                        send_btn    = gr.Button("Send ➤", variant="primary")
+                        change_btn  = gr.Button("🔄 Change language", variant="secondary")
+                    audio_out     = gr.Audio(
+                        label="Reem speaks",
+                        autoplay=True,
+                        interactive=False,
+                    )
+
+                    # Welcome audio hidden autoplay on load
+                    welcome_audio_html = gr.HTML(
+                        f'<audio autoplay style="display:none" src="data:audio/mp3;base64,{welcome_b64}"></audio>'
+                    )
+
+        # ══════════════════════════════════════════════════════════════
+        #  HANDLERS
+        # ══════════════════════════════════════════════════════════════
+
+        # ── Build KB ──────────────────────────────────────────────────
+        def handle_build_kb(files):
+            if not files:
+                return "❌ No files uploaded."
+            texts = []
+            for f in files:
+                texts.append(Path(f.name).read_text(encoding="utf-8", errors="ignore"))
+            try:
+                _, chunks = build_index(texts)
+                return f"✅ {len(chunks)} chunks indexed."
+            except Exception as e:
+                return f"❌ {e}"
+
+        build_btn.click(handle_build_kb, inputs=kb_files, outputs=kb_status)
+
+        # ── Upload DB ─────────────────────────────────────────────────
+        def handle_db_upload(file):
+            if file is None:
+                return "❌ No file."
+            import shutil
+            shutil.copy(file.name, DB_PATH)
+            return "✅ Database connected."
+
+        db_file.change(handle_db_upload, inputs=db_file, outputs=db_status)
+
+        # ── Clear memory ──────────────────────────────────────────────
+        def handle_clear(memory):
+            return ConversationMemory(), [], "Memory cleared."
+
+        clear_btn.click(
+            handle_clear,
+            inputs=[memory_state],
+            outputs=[memory_state, chat_history, mem_info],
+        )
+
+        # ── Language selection helpers ─────────────────────────────────
+        def _set_language(code, memory):
+            confirm_text = LANGUAGE_CONFIRMATION[code]
+            audio_path = tts_to_file(confirm_text, code)
+            badge = f"🗣️ Language: **{{'en':'English','ar':'العربية','ur':'اردو'}.get(code,code)}**"
+            # Return: lang_state, hide lang_group, show chat_group, badge, audio, memory
+            return (
+                code,
+                gr.update(visible=False),   # lang_group
+                gr.update(visible=True),    # chat_group
+                badge,
+                audio_path,
+                memory,
+            )
+
+        def handle_lang_mic(audio, memory):
+            if audio is None:
+                return ("", gr.update(), gr.update(), "", None, memory)
+            sr, data = audio
+            import io, soundfile as sf
+            buf = io.BytesIO()
+            sf.write(buf, data, sr, format="WAV")
+            transcript = transcribe_audio_bytes(buf.getvalue())
+            if not transcript:
+                return ("", gr.update(), gr.update(), "", None, memory)
+            detected = detect_lang(transcript)
+            if not detected:
+                return ("", gr.update(), gr.update(), "", None, memory)
+            return _set_language(detected, memory)
+
+        lang_mic.stop_recording(
+            handle_lang_mic,
+            inputs=[lang_mic, memory_state],
+            outputs=[lang_state, lang_group, chat_group,
+                     lang_badge, lang_audio_out, memory_state],
+        )
+
+        for btn, code in [(btn_en, "en"), (btn_ar, "ar"), (btn_ur, "ur")]:
+            btn.click(
+                lambda mem, c=code: _set_language(c, mem),
+                inputs=[memory_state],
+                outputs=[lang_state, lang_group, chat_group,
+                         lang_badge, lang_audio_out, memory_state],
+            )
+
+        # ── Change language ────────────────────────────────────────────
+        def handle_change():
+            return "", gr.update(visible=True), gr.update(visible=False)
+
+        change_btn.click(
+            handle_change,
+            outputs=[lang_state, lang_group, chat_group],
+        )
+
+        # ── Voice input ────────────────────────────────────────────────
+        def handle_voice(audio, lang_code, memory, history):
+            if audio is None:
+                return history, None, memory, ""
+            sr, data = audio
+            import io, soundfile as sf
+            buf = io.BytesIO()
+            sf.write(buf, data, sr, format="WAV")
+            raw = buf.getvalue()
+            if len(raw) < MIN_AUDIO_BYTES:
+                return history, None, memory, ""
+            transcript = transcribe_audio_bytes(raw)
+            if not transcript or len(transcript.strip()) < 3:
+                return history, None, memory, "⚠️ No clear speech detected."
+            _, new_history, audio_path = process_query(
+                transcript, memory, lang_code, history)
+            mem_info_txt = _mem_info(memory)
+            return new_history, audio_path, memory, mem_info_txt
+
+        voice_input.stop_recording(
+            handle_voice,
+            inputs=[voice_input, lang_state, memory_state, chat_history],
+            outputs=[chatbot, audio_out, memory_state, mem_info],
+        )
+
+        # ── Text input ────────────────────────────────────────────────
+        def handle_text(text, lang_code, memory, history):
+            if not text or not text.strip():
+                return history, None, memory, "", ""
+            _, new_history, audio_path = process_query(
+                text, memory, lang_code, history)
+            mem_info_txt = _mem_info(memory)
+            return new_history, audio_path, memory, mem_info_txt, ""
+
+        def _mem_info(memory: ConversationMemory) -> str:
+            ec = memory.entity_cache
+            parts = [f"Turns: {len(memory.turns)}"]
+            if ec["order_ids"]:
+                parts.append(f"Orders: {ec['order_ids']}")
+            if ec["customer_name"]:
+                parts.append(f"Name: {ec['customer_name']}")
+            return " | ".join(parts)
+
+        send_btn.click(
+            handle_text,
+            inputs=[txt_input, lang_state, memory_state, chat_history],
+            outputs=[chatbot, audio_out, memory_state, mem_info, txt_input],
+        )
+        txt_input.submit(
+            handle_text,
+            inputs=[txt_input, lang_state, memory_state, chat_history],
+            outputs=[chatbot, audio_out, memory_state, mem_info, txt_input],
+        )
+
+    return demo
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  ENTRY POINT
+# ══════════════════════════════════════════════════════════════════════════
 
 if __name__ == "__main__":
-    demo.launch()
+    # Pre-warm models
+    print("⏳ Loading embedder…")
+    get_embedder()
+    print("⏳ Pre-loading FAISS index if available…")
+    get_index()
+
+    demo = build_app()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+    )