Update app.py

app.py

@@ -1,14 +1,15 @@
 import os
 import re
 import glob
+import shutil
 import threading
-import hashlib
 import logging
 from typing import List, Tuple, Optional
 
-import gradio as gr
+import faiss
 import numpy as np
 import yaml
+import gradio as gr
 from sentence_transformers import SentenceTransformer
 
 # -----------------------------
@@ -18,24 +19,26 @@ logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(me
 logger = logging.getLogger(__name__)
 
 # -----------------------------
-# CONFIG — loaded from config.yaml, with safe defaults
+# CONFIG
 # -----------------------------
 _CONFIG_PATH = "./config.yaml"
 
 
 def load_config(path: str = _CONFIG_PATH) -> dict:
-    """Load configuration from YAML file with fallback defaults."""
     defaults = {
-        "kb": {"directory": "./kb"},
-        "models": {"embedding": "sentence-transformers/all-MiniLM-L6-v2"},
+        "kb": {"directory": "./kb", "index_directory": "./.cache/faiss"},
+        "models": {
+            "embedding": "sentence-transformers/all-MiniLM-L6-v2",
+            "qa": "google/flan-t5-small",
+        },
         "chunking": {"chunk_size": 500, "overlap": 100},
-        "retrieval": {"top_k": 3, "min_similarity": 0.3, "context_chars": 1500},
-        "llm": {"model": "TinyLlama/TinyLlama-1.1B-Chat-v1.0", "max_new_tokens": 256},
+        "retrieval": {"top_k": 5, "min_similarity": 0.25, "max_sentences": 6},
         "client": {"name": "Self-Service KB Assistant"},
         "messages": {
-            "welcome": "👋 Ask me anything you'd normally search for in a knowledge base.",
-            "no_answer": "❌ I couldn't find anything relevant in the knowledge base for this query.",
+            "welcome": "Ask me anything about the documents in the knowledge base!",
+            "no_answer": "I couldn't find anything relevant to your question in the knowledge base.",
         },
+        "quick_actions": [],
     }
     if os.path.exists(path):
         try:
@@ -50,351 +53,432 @@ def load_config(path: str = _CONFIG_PATH) -> dict:
         except Exception as e:
             logger.warning(f"Could not load {path}: {e}. Using defaults.")
     else:
-        logger.warning(f"{path} not found. Using default configuration.")
+        logger.warning(f"{path} not found — using defaults.")
     return defaults
 
 
 CONFIG = load_config()
 
 KB_DIR               = CONFIG["kb"]["directory"]
+INDEX_DIR            = CONFIG["kb"]["index_directory"]
 EMBEDDING_MODEL_NAME = CONFIG["models"]["embedding"]
+QA_MODEL_NAME        = CONFIG["models"]["qa"]
 CHUNK_SIZE           = CONFIG["chunking"]["chunk_size"]
 CHUNK_OVERLAP        = CONFIG["chunking"]["overlap"]
 TOP_K                = CONFIG["retrieval"]["top_k"]
 MIN_SIMILARITY       = CONFIG["retrieval"]["min_similarity"]
-CONTEXT_CHARS        = CONFIG["retrieval"]["context_chars"]
-LLM_MODEL_NAME       = CONFIG["llm"]["model"]
-MAX_NEW_TOKENS       = CONFIG["llm"]["max_new_tokens"]
-MAX_QUERY_CHARS      = 1000
+MAX_SENTENCES        = CONFIG["retrieval"]["max_sentences"]
+MAX_QUERY_CHARS      = 800
+
+ALLOWED_EXTENSIONS   = {".txt", ".md", ".pdf", ".docx", ".doc"}
+MAX_FILE_SIZE_MB     = 10
 
-# Paths for caching embeddings
-_CACHE_DIR  = "./.cache"
-_CACHE_FILE = os.path.join(_CACHE_DIR, "kb_embeddings.npz")
+# FAISS index paths
+_IDX_PATH  = os.path.join(INDEX_DIR, "kb.index")
+_META_PATH = os.path.join(INDEX_DIR, "kb_meta.npy")
 
 # -----------------------------
-# UTILITIES
+# FILE LOADING  (txt / md / pdf / docx)
+# -----------------------------
+
+def load_file_text(path: str) -> str:
+    """Extract plain text from .txt, .md, .pdf, or .docx files."""
+    ext = os.path.splitext(path)[1].lower()
+    try:
+        if ext == ".pdf":
+            from PyPDF2 import PdfReader
+            reader = PdfReader(path)
+            parts = []
+            for page in reader.pages:
+                t = page.extract_text()
+                if t:
+                    parts.append(t)
+            return "\n".join(parts)
+
+        elif ext in (".docx", ".doc"):
+            import docx as python_docx
+            doc = python_docx.Document(path)
+            return "\n".join(p.text for p in doc.paragraphs if p.text.strip())
+
+        else:  # .txt / .md
+            with open(path, "r", encoding="utf-8", errors="replace") as f:
+                return f.read()
+
+    except Exception as e:
+        logger.error(f"Could not read {path}: {e}")
+        raise
+
+
+def load_kb_documents(kb_dir: str) -> List[Tuple[str, str]]:
+    """Load all supported documents from kb_dir. Returns [(filename, text), ...]."""
+    docs: List[Tuple[str, str]] = []
+    if not os.path.isdir(kb_dir):
+        logger.warning(f"KB directory not found: {kb_dir}")
+        os.makedirs(kb_dir, exist_ok=True)
+        return docs
+
+    patterns = ["*.txt", "*.md", "*.pdf", "*.docx", "*.doc"]
+    paths: List[str] = []
+    for pat in patterns:
+        paths.extend(glob.glob(os.path.join(kb_dir, pat)))
+
+    if not paths:
+        logger.warning(f"No documents found in {kb_dir}")
+        return docs
+
+    for path in sorted(paths):
+        try:
+            text = load_file_text(path)
+            if text and text.strip():
+                docs.append((os.path.basename(path), text))
+                logger.info(f"Loaded: {os.path.basename(path)}")
+        except Exception as e:
+            logger.warning(f"Skipped {path}: {e}")
+
+    return docs
+
+# -----------------------------
+# CHUNKING
 # -----------------------------
 
 def chunk_text(text: str, chunk_size: int = CHUNK_SIZE, overlap: int = CHUNK_OVERLAP) -> List[str]:
-    """
-    Split text into overlapping chunks that break on sentence boundaries
-    where possible, preventing mid-word or mid-sentence splits.
-    """
+    """Sentence-boundary chunking with overlap. Clamps overlap to prevent infinite loops."""
     if not text:
         return []
-
-    # FIX: clamp overlap so chunk_size - overlap is always >= 1, preventing infinite loop
     overlap = min(overlap, chunk_size - 1)
+    sentence_re = re.compile(r'(?<=[.!?])\s+')
+    sentences = sentence_re.split(text.strip())
 
-    sentence_endings = re.compile(r'(?<=[.!?])\s+')
-    sentences = sentence_endings.split(text.strip())
-
-    chunks = []
-    current_chunk: List[str] = []
+    chunks: List[str] = []
+    current: List[str] = []
     current_len = 0
 
-    for sentence in sentences:
-        sentence = sentence.strip()
-        if not sentence:
+    for sent in sentences:
+        sent = sent.strip()
+        if not sent:
             continue
-        slen = len(sentence)
+        slen = len(sent)
 
-        # If a single sentence exceeds chunk_size, force-split it
         if slen > chunk_size:
-            if current_chunk:
-                chunks.append(" ".join(current_chunk))
-                current_chunk = []
-                current_len = 0
+            if current:
+                chunks.append(" ".join(current))
+                current, current_len = [], 0
             start = 0
             while start < slen:
-                end = min(start + chunk_size, slen)
-                chunks.append(sentence[start:end].strip())
+                chunks.append(sent[start:min(start + chunk_size, slen)].strip())
                 start += chunk_size - overlap
             continue
 
         if current_len + slen + 1 > chunk_size:
-            if current_chunk:
-                chunks.append(" ".join(current_chunk))
-            # Carry over last sentence(s) for overlap
-            overlap_words: List[str] = []
-            overlap_len = 0
-            for s in reversed(current_chunk):
-                if overlap_len + len(s) + 1 > overlap:
+            if current:
+                chunks.append(" ".join(current))
+            carry: List[str] = []
+            carry_len = 0
+            for s in reversed(current):
+                if carry_len + len(s) + 1 > overlap:
                     break
-                overlap_words.insert(0, s)
-                overlap_len += len(s) + 1
-            current_chunk = overlap_words
-            current_len = overlap_len
+                carry.insert(0, s)
+                carry_len += len(s) + 1
+            current, current_len = carry, carry_len
 
-        current_chunk.append(sentence)
+        current.append(sent)
         current_len += slen + 1
 
-    if current_chunk:
-        chunks.append(" ".join(current_chunk))
+    if current:
+        chunks.append(" ".join(current))
 
-    return [c for c in chunks if c.strip()]
+    return [c for c in chunks if len(c.strip()) > 20]
 
+# -----------------------------
+# CONTEXT CLEANING
+# -----------------------------
 
 def clean_context(text: str) -> str:
     """
-    Clean text for LLM context: remove only Markdown heading markers (leading #),
-    collapse whitespace, but preserve legitimate # characters mid-text.
-    """
-    text = re.sub(r'(?m)^#+\s*', '', text)
-    text = re.sub(r'\s+', ' ', text)
-    return text.strip()
-
-
-def kb_fingerprint(kb_dir: str) -> str:
-    """
-    Return an MD5 fingerprint of all KB filenames + modification times.
-    Returns a sentinel string when the directory is empty or missing,
-    so cache comparisons never falsely match a populated index.
-    """
-    paths = sorted(
-        glob.glob(os.path.join(kb_dir, "*.txt")) +
-        glob.glob(os.path.join(kb_dir, "*.md"))
-    )
-    # FIX: return distinct sentinel when no files found, not md5('') which
-    # would match any other empty-directory state from a different run.
-    if not paths:
-        return "NO_KB_FILES"
-    sig = "|".join(f"{p}:{os.path.getmtime(p)}" for p in paths)
-    return hashlib.md5(sig.encode()).hexdigest()
-
-
-def load_kb_texts(kb_dir: str = KB_DIR) -> List[Tuple[str, str]]:
-    """
-    Load all .txt and .md files from the KB directory.
-    Returns a list of (source_name, content).
-    Falls back to built-in demo content if directory is empty or missing.
+    Clean retrieved text before scoring:
+    - Strip Markdown headings, ordered/unordered list markers
+    - Remove duplicate lines and very short noise lines
+    - Skip title-like lines (mostly capitalised words)
     """
-    texts = []
-
-    if os.path.isdir(kb_dir):
-        paths = (
-            glob.glob(os.path.join(kb_dir, "*.txt")) +
-            glob.glob(os.path.join(kb_dir, "*.md"))
-        )
-        for path in sorted(paths):
-            try:
-                with open(path, "r", encoding="utf-8") as f:
-                    content = f.read()
-                if content.strip():
-                    texts.append((os.path.basename(path), content))
-            except Exception as e:
-                logger.warning(f"Could not read {path}: {e}")
-
-    if not texts:
-        logger.warning("No KB files found. Using built-in demo content.")
-        demo_text = """
-        Welcome to the Self-Service KB Assistant.
-
-        This assistant is meant to help you find information inside a knowledge base.
-        In a real setup, it would be connected to your own articles, procedures,
-        troubleshooting guides and FAQs.
-
-        Good knowledge base content is:
-        - Clear and structured with headings, steps and expected outcomes.
-        - Written in a customer-friendly tone.
-        - Easy to scan, with short paragraphs and bullet points.
-        - Maintained regularly to reflect product and process changes.
-
-        Example use cases for a KB assistant:
-        - Agents quickly searching for internal procedures.
-        - Customers asking "how do I..." style questions.
-        - Managers analyzing gaps in documentation based on repeated queries.
-        """
-        texts.append(("demo_content.txt", demo_text))
+    lines = text.splitlines()
+    cleaned: List[str] = []
+    seen: set = set()
 
-    return texts
+    for line in lines:
+        l = line.strip()
+        if not l or len(l) < 5:
+            continue
+        l = re.sub(r'^#+\s*', '', l)           # Markdown headings
+        l = re.sub(r'^\d+[\.\)]\s*', '', l)    # ordered list markers
+        l = re.sub(r'^[-*]\s*', '', l)          # bullet markers
+        if len(l) < 5:
+            continue
+        words = l.split()
+        cap = sum(1 for w in words if w[:1].isupper())
+        if words and len(words) <= 10 and cap >= len(words) - 1:
+            continue   # looks like a heading/title
+        if l in seen:
+            continue
+        seen.add(l)
+        cleaned.append(l)
 
+    return "\n".join(cleaned)
 
 # -----------------------------
-# KB INDEX
+# KB INDEX  (FAISS + sentence re-ranking)
 # -----------------------------
 
 class KBIndex:
-    def __init__(self, kb_dir: str = KB_DIR, model_name: str = EMBEDDING_MODEL_NAME):
-        self.kb_dir = kb_dir
-        self.model_name = model_name
-        # FIX: _lock removed from KBIndex — it was defined but never acquired.
-        # LLM concurrency is handled by the module-level _llm_lock instead.
-
-        logger.info("Loading embedding model...")
-        self.model = SentenceTransformer(model_name)
+    def __init__(self):
+        self.embedder: Optional[SentenceTransformer] = None
+        self.chunks:   List[str] = []
+        self.sources:  List[str] = []
+        self.index:    Optional[faiss.Index] = None
+        self._lock = threading.Lock()
+
+        logger.info("Loading embedding model…")
+        self.embedder = SentenceTransformer(EMBEDDING_MODEL_NAME)
         logger.info("Embedding model loaded.")
 
-        self.chunks: List[str] = []
-        self.chunk_sources: List[str] = []
-        self.embeddings: Optional[np.ndarray] = None
-        self._fingerprint: Optional[str] = None
-
-        self.build_index()
+        os.makedirs(INDEX_DIR, exist_ok=True)
+        self._load_or_build()
 
-    def build_index(self, force: bool = False):
-        """
-        Load KB texts, split into chunks, and build an embedding index.
-        Uses disk cache keyed on KB fingerprint to skip re-encoding on cold start.
-        Pass force=True to rebuild regardless of cache.
-        """
-        texts = load_kb_texts(self.kb_dir)
-        fingerprint = kb_fingerprint(self.kb_dir)
+    # ── Index persistence ──────────────────────────────────────────
 
-        # Try loading from cache if fingerprint matches
-        if not force and os.path.exists(_CACHE_FILE):
+    def _load_or_build(self) -> None:
+        """Load FAISS index from disk if available, otherwise build from KB docs."""
+        if os.path.exists(_IDX_PATH) and os.path.exists(_META_PATH):
             try:
-                cached = np.load(_CACHE_FILE, allow_pickle=True)
-                # FIX: NpzFile stores arrays; extract scalar string correctly
-                # using item() instead of str() which would produce "array('...')"
-                cached_fp = str(cached["fingerprint"].item())
-                if cached_fp == fingerprint:
-                    self.chunks = list(cached["chunks"])
-                    self.chunk_sources = list(cached["chunk_sources"])
-                    self.embeddings = cached["embeddings"]
-                    self._fingerprint = fingerprint
-                    logger.info(f"✅ Loaded {len(self.chunks)} chunks from embedding cache.")
-                    return
+                self.index = faiss.read_index(_IDX_PATH)
+                meta = np.load(_META_PATH, allow_pickle=True).item()
+                self.chunks  = list(meta["chunks"])
+                self.sources = list(meta["sources"])
+                logger.info(f"✅ FAISS index loaded — {len(self.chunks)} chunks.")
+                return
             except Exception as e:
-                logger.warning(f"Cache load failed: {e}. Rebuilding index.")
+                logger.warning(f"Could not load existing index: {e}. Rebuilding…")
+
+        self._build()
+
+    def _build(self) -> None:
+        """Build a new FAISS index from all KB documents and save to disk."""
+        docs = load_kb_documents(KB_DIR)
+
+        # Fall back to demo content if KB is empty
+        if not docs:
+            logger.warning("No KB documents found — using demo content.")
+            demo = (
+                "demo_content.txt",
+                "Welcome to the Self-Service KB Assistant. "
+                "Upload your own .txt, .md, .pdf, or .docx files via the KB Manager tab. "
+                "The assistant will index them automatically and answer questions from their content."
+            )
+            docs = [demo]
 
         all_chunks: List[str] = []
         all_sources: List[str] = []
-
-        for source_name, content in texts:
-            for chunk in chunk_text(content):
+        for source, text in docs:
+            for chunk in chunk_text(text):
                 all_chunks.append(chunk)
-                all_sources.append(source_name)
+                all_sources.append(source)
 
         if not all_chunks:
-            logger.warning("⚠️ No chunks found for KB index.")
+            logger.warning("No valid chunks produced.")
+            self.index = None
             self.chunks = []
-            self.chunk_sources = []
-            self.embeddings = None
+            self.sources = []
             return
 
-        logger.info(f"Creating embeddings for {len(all_chunks)} chunks...")
-        embeddings = self.model.encode(
-            all_chunks,
-            show_progress_bar=False,
-            convert_to_numpy=True,
-            batch_size=64,
-        )
-        self.chunks = all_chunks
-        self.chunk_sources = all_sources
-        self.embeddings = embeddings
-        self._fingerprint = fingerprint
+        logger.info(f"Encoding {len(all_chunks)} chunks…")
+        embeddings = self.embedder.encode(
+            all_chunks, show_progress_bar=False,
+            convert_to_numpy=True, batch_size=64,
+        ).astype("float32")
+        faiss.normalize_L2(embeddings)
+
+        dim = embeddings.shape[1]
+        index = faiss.IndexFlatIP(dim)
+        index.add(embeddings)
+
+        self.index   = index
+        self.chunks  = all_chunks
+        self.sources = all_sources
 
-        # Save cache
         try:
-            os.makedirs(_CACHE_DIR, exist_ok=True)
-            np.savez_compressed(
-                _CACHE_FILE,
-                chunks=np.array(all_chunks, dtype=object),
-                chunk_sources=np.array(all_sources, dtype=object),
-                embeddings=embeddings,
-                fingerprint=np.array(fingerprint),
-            )
-            logger.info("Embedding cache saved.")
+            faiss.write_index(index, _IDX_PATH)
+            np.save(_META_PATH, {"chunks": np.array(all_chunks, dtype=object),
+                                 "sources": np.array(all_sources, dtype=object)})
+            logger.info("FAISS index saved to disk.")
         except Exception as e:
-            logger.warning(f"Could not save embedding cache: {e}")
+            logger.warning(f"Could not save index: {e}")
 
         logger.info("KB index ready.")
 
-    def reload(self):
-        """Rebuild the index from disk, bypassing cache."""
-        logger.info("Reloading KB index...")
-        self.build_index(force=True)
-        logger.info("KB index reloaded.")
-
-    def search(self, query: str, top_k: int = TOP_K) -> List[Tuple[str, str, float]]:
-        """Return top-k (chunk, source_name, score) for a given query."""
-        if not query.strip():
-            return []
-        if self.embeddings is None or not self.chunks:
+    def rebuild(self) -> str:
+        """Force a full rebuild of the index from current KB documents."""
+        with self._lock:
+            # Remove stale index files so _build always starts fresh
+            for p in (_IDX_PATH, _META_PATH):
+                if os.path.exists(p):
+                    os.remove(p)
+            self._build()
+        if self.index is None or not self.chunks:
+            return "⚠️ Index rebuilt but no documents found. Upload files first."
+        return f"✅ Index rebuilt — {len(self.chunks)} chunks from {len(set(self.sources))} files."
+
+    # ── Retrieval + sentence re-ranking ───────────────────────────
+
+    def retrieve(self, query: str) -> List[Tuple[str, str, float]]:
+        """Retrieve top-K chunks via FAISS cosine similarity."""
+        if not query.strip() or self.index is None or not self.chunks:
             return []
+        q_emb = self.embedder.encode([query], convert_to_numpy=True).astype("float32")
+        faiss.normalize_L2(q_emb)
+        k = min(TOP_K, len(self.chunks))
+        scores, idxs = self.index.search(q_emb, k)
+        results = []
+        for score, idx in zip(scores[0], idxs[0]):
+            if idx < 0 or idx >= len(self.chunks):
+                continue
+            if float(score) < MIN_SIMILARITY:
+                continue
+            results.append((self.chunks[idx], self.sources[idx], float(score)))
+        return results
+
+    def best_sentences(self, query: str, results: List[Tuple[str, str, float]]) -> str:
+        """
+        Re-rank at sentence level:
+        1. Split each retrieved chunk into sentences
+        2. Score each sentence with semantic similarity + lexical overlap
+        3. Pick the top MAX_SENTENCES and join them as context for the LLM
+        """
+        candidate_sents: List[str] = []
+        sent_splitter = re.compile(r'(?<=[.!?])\s+|\n+')
 
-        query_vec = self.model.encode(
-            [query], show_progress_bar=False, convert_to_numpy=True
-        )[0]
+        for chunk, _, _ in results:
+            cleaned = clean_context(chunk)
+            for s in sent_splitter.split(cleaned):
+                s = s.strip()
+                if len(s) >= 25:
+                    candidate_sents.append(s)
 
-        norm_docs  = np.linalg.norm(self.embeddings, axis=1)
-        norm_query = np.linalg.norm(query_vec)
-        denom = norm_docs * norm_query
-        denom = np.where(denom == 0, 1e-10, denom)
-        scores = np.dot(self.embeddings, query_vec) / denom
+        if not candidate_sents:
+            return ""
 
-        top_idx = np.argsort(scores)[::-1][:top_k]
-        return [
-            (self.chunks[i], self.chunk_sources[i], float(scores[i]))
-            for i in top_idx
-        ]
+        # Semantic scores
+        try:
+            q_emb = self.embedder.encode([query], convert_to_numpy=True).astype("float32")
+            s_embs = self.embedder.encode(candidate_sents, convert_to_numpy=True).astype("float32")
+            faiss.normalize_L2(q_emb)
+            faiss.normalize_L2(s_embs)
+            sims = np.dot(s_embs, q_emb.T).reshape(-1)
+        except Exception:
+            sims = np.zeros(len(candidate_sents))
+
+        # Lexical overlap
+        q_words = {w.lower() for w in re.findall(r"\w+", query) if len(w) > 3}
+        lex = np.array([
+            len(q_words & {w.lower() for w in re.findall(r"\w+", s) if len(w) > 3})
+            for s in candidate_sents
+        ], dtype=float)
+
+        combined = 1.5 * sims + 0.5 * lex
+        top_idx = np.argsort(-combined)
+
+        chosen: List[str] = []
+        seen: set = set()
+        for i in top_idx:
+            s = candidate_sents[i].strip()
+            if s and s not in seen:
+                chosen.append(s)
+                seen.add(s)
+            if len(chosen) >= MAX_SENTENCES:
+                break
+
+        return "\n".join(chosen)
 
 
 # -----------------------------
-# LLM SETUP
+# QA MODEL  (FLAN-T5 seq2seq — lightweight, deterministic)
 # -----------------------------
 
-# Single import of torch at module level (not duplicated inside functions)
-try:
-    import torch
-    _torch_available = True
-except ImportError:
-    _torch_available = False
+qa_tokenizer = None
+qa_model     = None
+qa_available = False
+_qa_lock     = threading.Lock()
 
-logger.info("Initializing KB index...")
-kb_index = KBIndex(kb_dir=KB_DIR, model_name=EMBEDDING_MODEL_NAME)
+try:
+    from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+    logger.info(f"Loading QA model: {QA_MODEL_NAME}…")
+    qa_tokenizer = AutoTokenizer.from_pretrained(QA_MODEL_NAME)
+    qa_model     = AutoModelForSeq2SeqLM.from_pretrained(QA_MODEL_NAME)
+    qa_model.eval()
+    qa_available = True
+    logger.info(f"✅ QA model loaded ({QA_MODEL_NAME})")
+except Exception as e:
+    logger.warning(f"⚠️ Could not load QA model: {e}. Will use extractive fallback.")
+
+
+def generate_answer(question: str, context: str) -> Optional[str]:
+    """
+    Generate a grounded answer with FLAN-T5.
+    Uses temperature=0 (deterministic) — correct for factual KB answers.
+    Returns None on failure so the caller can fall back gracefully.
+    """
+    if not qa_available or qa_tokenizer is None or qa_model is None:
+        return None
 
-logger.info("Loading LLM for answer generation...")
-llm_available = False
-llm_tokenizer = None
-llm_model = None
-_llm_lock = threading.Lock()
+    prompt = (
+        "You are a warm, helpful assistant. "
+        "Answer the question using ONLY the information in the context below. "
+        "Always open with a friendly sentence before any list or steps. "
+        "When steps are needed, introduce them with a sentence first (e.g. 'Here is what you can do:'). "
+        "Keep your tone conversational. "
+        "If the context doesn't contain enough information, say so honestly.\n\n"
+        f"Context:\n{context}\n\n"
+        f"Question: {question}\n\n"
+        "Answer:"
+    )
 
-if _torch_available:
     try:
-        from transformers import AutoTokenizer, AutoModelForCausalLM
-
-        logger.info(f"Loading {LLM_MODEL_NAME}...")
-        llm_tokenizer = AutoTokenizer.from_pretrained(LLM_MODEL_NAME)
-
-        # FIX: ensure pad_token is set so eos_token_id is never None at generation time
-        if llm_tokenizer.pad_token is None:
-            llm_tokenizer.pad_token = llm_tokenizer.eos_token
-
-        llm_model = AutoModelForCausalLM.from_pretrained(
-            LLM_MODEL_NAME,
-            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-            device_map="auto" if torch.cuda.is_available() else None,
-        )
+        with _qa_lock:
+            inputs = qa_tokenizer(
+                prompt,
+                return_tensors="pt",
+                truncation=True,
+                max_length=768,
+            )
+            outputs = qa_model.generate(
+                **inputs,
+                max_new_tokens=220,
+                temperature=1.0,   # FLAN-T5 requires temp=1 with do_sample=False
+                do_sample=False,   # deterministic — no random variation in factual answers
+            )
+            answer = qa_tokenizer.decode(outputs[0], skip_special_tokens=True).strip()
+        return answer if answer else None
+    except Exception as e:
+        logger.error(f"QA generation error: {e}")
+        return None
 
-        if not torch.cuda.is_available():
-            llm_model = llm_model.to("cpu")
 
-        llm_model.eval()
-        llm_available = True
-        logger.info(f"✅ LLM loaded on {'GPU' if torch.cuda.is_available() else 'CPU'}")
+# -----------------------------
+# INITIALISE INDEX
+# -----------------------------
 
-    except Exception as e:
-        logger.warning(f"⚠️ Could not load LLM: {e}. Will use fallback retrieval mode.")
-else:
-    logger.warning("⚠️ torch not available. Will use fallback retrieval mode.")
+logger.info("Initialising KB index…")
+kb_index = KBIndex()
 
 
 # -----------------------------
-# CHAT LOGIC
+# CHAT PIPELINE
 # -----------------------------
 
 def normalise_history(history: list) -> List[Tuple[str, str]]:
-    """
-    Normalise Gradio history into a consistent list of (user, assistant) string pairs.
-    - Gradio 6 messages format: list of {"role": ..., "content": ...} dicts
-    - Gradio 4 format: list of [user_str, assistant_str] pairs
-    """
+    """Normalise Gradio history — handles both Gradio 4 (tuples) and Gradio 6 (dicts)."""
     if not history:
         return []
     if isinstance(history[0], dict):
-        pairs = []
+        pairs: List[Tuple[str, str]] = []
         i = 0
         while i < len(history):
             if history[i].get("role") == "user":
@@ -409,547 +493,173 @@ def normalise_history(history: list) -> List[Tuple[str, str]]:
             else:
                 i += 1
         return pairs
-    # Gradio 4: list of [user, assistant] pairs
     return [(str(u or ""), str(a or "")) for u, a in history]
 
 
-def build_llm_prompt(query: str, context: str, history: list) -> str:
-    """
-    Build a TinyLlama chat prompt including recent conversation history
-    so the model can resolve follow-up questions.
-    """
-    system = (
-        "You are a warm, helpful assistant. "
-        "Use the provided context to answer the user's question. "
-        "Always open with a natural, friendly sentence that acknowledges what they asked — "
-        "never start your reply with a bare list or phrases like 'To fix' or 'To do' without a human lead-in first. "
-        "When numbered steps or a list are the clearest way to explain something, use them — "
-        "but always introduce the list with a brief friendly sentence first (e.g. 'Here's what you can do:' or 'Sure! Here are the steps:'). "
-        "Keep your overall tone warm and conversational. "
-        "If the context doesn't have enough information, say so honestly and suggest they rephrase or try different keywords. "
-        "Do NOT mention sources, filenames, or where the information came from."
-    )
-
-    history_text = ""
-    for user_msg, asst_msg in normalise_history(history)[-3:]:
-        if user_msg:
-            history_text += f"<|user|>\n{user_msg}\n</s>\n"
-        if asst_msg:
-            history_text += f"<|assistant|>\n{asst_msg}\n</s>\n"
-
-    return (
-        f"<|system|>\n{system}\n</s>\n"
-        f"{history_text}"
-        f"<|user|>\n"
-        f"Context:\n{context}\n\n"
-        f"Question: {query}\n"
-        f"</s>\n"
-        f"<|assistant|>\n"
-    )
-
-
-def generate_answer_with_llm(
-    query: str,
-    context: str,
-    sources: List[str],
-    history: list,
-) -> Optional[str]:
-    """Generate a natural answer using the local LLM. Returns None on failure."""
-    if not llm_available:
-        return None
-
-    prompt = build_llm_prompt(query, context, history)
-
-    try:
-        # FIX: keep decode() inside the lock so llm_tokenizer can't be
-        # reassigned/cleared by a reload() between generate() and decode()
-        with _llm_lock:
-            inputs = llm_tokenizer(
-                prompt,
-                return_tensors="pt",
-                truncation=True,
-                max_length=1024,
-            )
-
-            if torch.cuda.is_available():
-                inputs = {k: v.to("cuda") for k, v in inputs.items()}
-
-            with torch.no_grad():
-                outputs = llm_model.generate(
-                    **inputs,
-                    max_new_tokens=MAX_NEW_TOKENS,
-                    temperature=0.7,
-                    top_p=0.9,
-                    do_sample=True,
-                    pad_token_id=llm_tokenizer.pad_token_id,  # FIX: use pad_token_id (always set above)
-                )
-
-            # FIX: decode inside the lock — keeps tokenizer reference stable
-            full_response = llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
-
-        # Extract only the final assistant turn
-        if "<|assistant|>" in full_response:
-            answer = full_response.split("<|assistant|>")[-1].strip()
-        else:
-            answer = full_response.strip()
-
-        answer = answer.replace("</s>", "").strip()
-        return answer
-
-    except Exception as e:
-        logger.error(f"LLM generation error: {e}")
-        return None
-
-
-def format_fallback_answer(results: List[Tuple[str, str, float]]) -> str:
-    """Format retrieved chunks into a readable answer when LLM is unavailable."""
-    if not results:
-        return CONFIG["messages"]["no_answer"]
-
-    parts = []
-
-    for chunk, source, score in results:
-        cleaned = clean_context(chunk)
-        label = "🥇" if not parts else "💡"
-        confidence = (
-            "High"   if score >= 0.6 else
-            "Medium" if score >= 0.4 else
-            "Low"
-        )
-        parts.append(
-            f"{label} {cleaned}"
-        )
-        # FIX: removed seen_sources — it was built but never used for anything
-
-    return "\n\n---\n\n".join(parts)
-
-
 def build_answer(query: str, history: list) -> str:
-    """
-    Main RAG pipeline:
-    1. Retrieve relevant chunks
-    2. Filter by similarity threshold
-    3. Build context from ALL top results (up to TOP_K)
-    4. Generate answer via LLM (or fallback)
-    """
-    results = kb_index.search(query, top_k=TOP_K)
+    """Full RAG pipeline: FAISS retrieve → sentence re-rank → FLAN-T5 generate."""
+    results = kb_index.retrieve(query)
 
     if not results:
         return (
-            "I couldn't find any relevant information in the knowledge base.\n\n"
-            "**Suggestions:**\n"
-            "- Try rephrasing with different words\n"
-            "- Use more specific keywords\n"
-            "- Break complex questions into smaller ones"
+            "I couldn't find anything relevant in the knowledge base for your question.\n\n"
+            "**Try:** rephrasing · using different keywords · breaking it into smaller questions"
         )
 
-    filtered = [
-        (chunk, src, score)
-        for chunk, src, score in results
-        if score >= MIN_SIMILARITY
-    ]
+    context = kb_index.best_sentences(query, results)
 
-    if not filtered:
+    if not context:
         return (
-            "I found some content, but it doesn't seem relevant enough to your question.\n\n"
-            "Please try being more specific or using different keywords."
+            "I found some content, but couldn't extract sentences relevant enough to answer.\n\n"
+            "Please try rephrasing your question."
         )
 
-    context_parts = []
-    sources: List[str] = []
-    for chunk, source, _ in filtered:
-        cleaned = clean_context(chunk)
-        context_parts.append(cleaned)
-        if source not in sources:
-            sources.append(source)
-
-    context = " ".join(context_parts)[:CONTEXT_CHARS]
+    answer = generate_answer(query, context)
 
-    if llm_available:
-        llm_answer = generate_answer_with_llm(query, context, sources, history)
-        if llm_answer:
-            return llm_answer
+    if answer:
+        return answer
 
-    return format_fallback_answer(filtered)
+    # Extractive fallback — surface the top re-ranked sentences directly
+    return (
+        "Here's the most relevant information I found:\n\n"
+        + "\n".join(f"- {s}" for s in context.split("\n") if s.strip())
+    )
 
 
 def chat_respond(message: str, history: list) -> str:
     """Gradio ChatInterface callback."""
     if not message or not message.strip():
         return "Please ask me a question about the knowledge base."
-
-    query = message.strip()
-    if len(query) > MAX_QUERY_CHARS:
-        query = query[:MAX_QUERY_CHARS]
-        logger.warning(f"Query truncated to {MAX_QUERY_CHARS} characters.")
-
+    query = message.strip()[:MAX_QUERY_CHARS]
     try:
         return build_answer(query, history or [])
     except Exception as e:
-        logger.error(f"Error generating answer: {e}")
-        return "Sorry, something went wrong while processing your question. Please try again."
+        logger.error(f"chat_respond error: {e}")
+        return "Sorry, something went wrong. Please try again."
 
 
 # -----------------------------
 # KB FILE MANAGEMENT
 # -----------------------------
 
-ALLOWED_EXTENSIONS = {".txt", ".md"}
-MAX_FILE_SIZE_MB = 10
-
-
 def list_kb_files() -> str:
-    """Return a formatted markdown table of current KB files."""
-    paths = sorted(
-        glob.glob(os.path.join(KB_DIR, "*.txt")) +
-        glob.glob(os.path.join(KB_DIR, "*.md"))
-    )
+    patterns = ["*.txt", "*.md", "*.pdf", "*.docx", "*.doc"]
+    paths: List[str] = []
+    for pat in patterns:
+        paths.extend(glob.glob(os.path.join(KB_DIR, pat)))
+    paths = sorted(paths)
     if not paths:
-        return "_No files in knowledge base yet. Upload some documents to get started._"
-
+        return "_No files yet. Upload documents to get started._"
     rows = ["| File | Size |", "|------|------|"]
     for p in paths:
-        size_kb = os.path.getsize(p) / 1024
-        rows.append(f"| {os.path.basename(p)} | {size_kb:.1f} KB |")
+        rows.append(f"| {os.path.basename(p)} | {os.path.getsize(p)/1024:.1f} KB |")
     return "\n".join(rows)
 
 
 def upload_kb_files(files) -> Tuple[str, str]:
-    """
-    Accept uploaded files, validate them, save to KB_DIR, and rebuild the index.
-    Returns (status_message, updated_file_list).
-    """
     if not files:
         return "⚠️ No files selected.", list_kb_files()
-
     os.makedirs(KB_DIR, exist_ok=True)
-
-    saved = []
-    skipped = []
+    saved, skipped = [], []
 
     for file in files:
-        # Gradio passes either a filepath string or a NamedString object
         filepath = file if isinstance(file, str) else file.name
-        original_name = os.path.basename(filepath)
-        ext = os.path.splitext(original_name)[1].lower()
+        name = os.path.basename(filepath)
+        ext  = os.path.splitext(name)[1].lower()
 
         if ext not in ALLOWED_EXTENSIONS:
-            skipped.append(f"{original_name} (unsupported type — use .txt or .md)")
+            skipped.append(f"{name} (unsupported — use .txt .md .pdf .docx)")
             continue
-
-        size_mb = os.path.getsize(filepath) / (1024 * 1024)
-        if size_mb > MAX_FILE_SIZE_MB:
-            skipped.append(f"{original_name} (too large — max {MAX_FILE_SIZE_MB} MB)")
+        if os.path.getsize(filepath) / (1024 * 1024) > MAX_FILE_SIZE_MB:
+            skipped.append(f"{name} (too large — max {MAX_FILE_SIZE_MB} MB)")
             continue
 
-        dest = os.path.join(KB_DIR, original_name)
-        try:
-            with open(filepath, "r", encoding="utf-8", errors="replace") as f:
-                content = f.read()
-            if not content.strip():
-                skipped.append(f"{original_name} (empty file)")
-                continue
-            with open(dest, "w", encoding="utf-8") as f:
-                f.write(content)
-            saved.append(original_name)
-            logger.info(f"KB file saved: {dest}")
-        except Exception as e:
-            skipped.append(f"{original_name} (error: {e})")
-            logger.error(f"Failed to save {original_name}: {e}")
-
-    if saved:
-        logger.info("Rebuilding KB index after upload...")
         try:
-            kb_index.reload()
-            reload_msg = "✅ Index rebuilt successfully."
+            shutil.copy(filepath, os.path.join(KB_DIR, name))
+            saved.append(name)
         except Exception as e:
-            reload_msg = f"⚠️ Index rebuild failed: {e}"
-            logger.error(reload_msg)
-    else:
-        reload_msg = ""
+            skipped.append(f"{name} (error: {e})")
 
-    status_parts = []
+    rebuild_msg = ""
     if saved:
-        status_parts.append(f"✅ **Uploaded:** {', '.join(saved)}")
-    if skipped:
-        status_parts.append(f"⚠️ **Skipped:** {', '.join(skipped)}")
-    if reload_msg:
-        status_parts.append(reload_msg)
+        rebuild_msg = kb_index.rebuild()
 
-    return "\n\n".join(status_parts), list_kb_files()
+    parts = []
+    if saved:    parts.append(f"✅ **Uploaded:** {', '.join(saved)}")
+    if skipped:  parts.append(f"⚠️ **Skipped:** {', '.join(skipped)}")
+    if rebuild_msg: parts.append(rebuild_msg)
+    return "\n\n".join(parts), list_kb_files()
 
 
 def delete_kb_file(filename: str) -> Tuple[str, str]:
-    """Delete a file from the KB directory and rebuild the index."""
-    filename = filename.strip()
+    filename = os.path.basename(filename.strip())
     if not filename:
         return "⚠️ No filename provided.", list_kb_files()
-
-    # Safety: strip any path components — only allow plain filenames
-    filename = os.path.basename(filename)
     ext = os.path.splitext(filename)[1].lower()
     if ext not in ALLOWED_EXTENSIONS:
-        return f"⚠️ Invalid file type: {filename}", list_kb_files()
-
+        return f"⚠️ Invalid file: {filename}", list_kb_files()
     target = os.path.join(KB_DIR, filename)
     if not os.path.exists(target):
         return f"⚠️ File not found: {filename}", list_kb_files()
-
     try:
         os.remove(target)
-        logger.info(f"Deleted KB file: {target}")
-        kb_index.reload()
-        return f"🗑️ **Deleted** `{filename}` and rebuilt index.", list_kb_files()
+        msg = kb_index.rebuild()
+        return f"🗑️ Deleted `{filename}`. {msg}", list_kb_files()
     except Exception as e:
-        logger.error(f"Failed to delete {filename}: {e}")
         return f"❌ Could not delete `{filename}`: {e}", list_kb_files()
 
 
 # -----------------------------
 # GRADIO UI
+# — css= not supported in all Gradio versions;
+#   inject styles via gr.HTML(<style>) inside the Blocks instead.
 # -----------------------------
 
-CUSTOM_CSS = """
-/* ── Base & typography ─────────────────────────────────── */
+STYLE_HTML = """
+<style>
 :root {
-    --radius: 12px;
-    --shadow: 0 2px 12px rgba(0,0,0,.08);
-    --accent: #4f6ef7;
-    --accent-hover: #3a56d4;
-    --surface: #ffffff;
-    --bg: #f4f6fb;
-    --muted: #6b7280;
-    --border: #e5e7eb;
-    --danger: #ef4444;
-    --danger-hover: #dc2626;
-    --success: #22c55e;
+  --accent:#4f6ef7; --accent-h:#3a56d4;
+  --danger:#ef4444; --danger-h:#dc2626;
+  --surface:#fff; --bg:#f4f6fb;
+  --border:#e5e7eb; --muted:#6b7280;
+  --radius:12px; --shadow:0 2px 12px rgba(0,0,0,.08);
 }
-
-body, .gradio-container {
-    background: var(--bg) !important;
-    font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif !important;
-}
-
-/* ── Header ────────────────────────────────────────────── */
-.app-header {
-    background: linear-gradient(135deg, var(--accent) 0%, #7c3aed 100%);
-    color: white;
-    padding: 20px 24px 16px;
-    border-radius: var(--radius) var(--radius) 0 0;
-    margin-bottom: 0;
-}
-.app-header h1 {
-    margin: 0 0 4px;
-    font-size: clamp(1.2rem, 4vw, 1.6rem);
-    font-weight: 700;
-    letter-spacing: -0.02em;
-}
-.app-header p {
-    margin: 0;
-    opacity: 0.85;
-    font-size: clamp(0.8rem, 2.5vw, 0.92rem);
-}
-
-/* ── Tabs ──────────────────────────────────────────────── */
-.tabs > .tab-nav {
-    background: var(--surface) !important;
-    border-bottom: 2px solid var(--border) !important;
-    padding: 0 16px !important;
-    gap: 4px !important;
-}
-.tabs > .tab-nav button {
-    border-radius: var(--radius) var(--radius) 0 0 !important;
-    padding: 10px 18px !important;
-    font-weight: 500 !important;
-    font-size: 0.88rem !important;
-    color: var(--muted) !important;
-    border: none !important;
-    background: transparent !important;
-    transition: color .2s, background .2s !important;
-}
-.tabs > .tab-nav button.selected {
-    color: var(--accent) !important;
-    border-bottom: 2px solid var(--accent) !important;
-    background: transparent !important;
-}
-
-/* ── Chat bubbles ──────────────────────────────────────── */
-.message.user > div {
-    background: var(--accent) !important;
-    color: white !important;
-    border-radius: var(--radius) var(--radius) 4px var(--radius) !important;
-    padding: 10px 14px !important;
-    max-width: 82% !important;
-    font-size: clamp(0.85rem, 2.5vw, 0.95rem) !important;
-    line-height: 1.55 !important;
-    box-shadow: var(--shadow) !important;
-}
-.message.bot > div {
-    background: var(--surface) !important;
-    border: 1px solid var(--border) !important;
-    border-radius: var(--radius) var(--radius) var(--radius) 4px !important;
-    padding: 10px 14px !important;
-    max-width: 88% !important;
-    font-size: clamp(0.85rem, 2.5vw, 0.95rem) !important;
-    line-height: 1.6 !important;
-    box-shadow: var(--shadow) !important;
-}
-
-/* ── Chat input bar ────────────────────────────────────── */
-.chat-input-container, footer .chat-input-container {
-    background: var(--surface) !important;
-    border-top: 1px solid var(--border) !important;
-    padding: 10px 12px !important;
-}
-.chat-input-container textarea {
-    border-radius: 24px !important;
-    border: 1.5px solid var(--border) !important;
-    padding: 10px 16px !important;
-    font-size: 0.93rem !important;
-    resize: none !important;
-    transition: border-color .2s !important;
-}
-.chat-input-container textarea:focus {
-    border-color: var(--accent) !important;
-    outline: none !important;
-    box-shadow: 0 0 0 3px rgba(79,110,247,.15) !important;
-}
-
-/* ── Send button ───────────────────────────────────────── */
-.chat-input-container button[aria-label="Send"] {
-    background: var(--accent) !important;
-    border-radius: 50% !important;
-    width: 40px !important;
-    height: 40px !important;
-    min-width: 40px !important;
-    padding: 0 !important;
-    color: white !important;
-    border: none !important;
-    transition: background .2s, transform .1s !important;
-}
-.chat-input-container button[aria-label="Send"]:hover {
-    background: var(--accent-hover) !important;
-    transform: scale(1.06) !important;
-}
-
-/* ── Example pills ─────────────────────────────────────── */
-.examples-table button, .example {
-    border-radius: 999px !important;
-    border: 1.5px solid var(--accent) !important;
-    color: var(--accent) !important;
-    background: transparent !important;
-    padding: 6px 14px !important;
-    font-size: 0.82rem !important;
-    font-weight: 500 !important;
-    transition: background .2s, color .2s !important;
-    white-space: nowrap !important;
-}
-.examples-table button:hover, .example:hover {
-    background: var(--accent) !important;
-    color: white !important;
-}
-
-/* ── KB Manager cards ──────────────────────────────────── */
-.kb-card {
-    background: var(--surface);
-    border-radius: var(--radius);
-    border: 1px solid var(--border);
-    padding: 20px;
-    box-shadow: var(--shadow);
-}
-
-/* ── File list table ───────────────────────────────────── */
-.kb-file-list table {
-    width: 100%;
-    border-collapse: collapse;
-    font-size: 0.88rem;
-}
-.kb-file-list th {
-    background: var(--bg);
-    padding: 8px 12px;
-    text-align: left;
-    font-weight: 600;
-    color: var(--muted);
-    border-bottom: 1px solid var(--border);
-}
-.kb-file-list td {
-    padding: 8px 12px;
-    border-bottom: 1px solid var(--border);
-}
-
-/* ── Buttons ───────────────────────────────────────────── */
-button.primary-btn {
-    background: var(--accent) !important;
-    color: white !important;
-    border-radius: 8px !important;
-    padding: 10px 20px !important;
-    font-weight: 600 !important;
-    font-size: 0.9rem !important;
-    border: none !important;
-    width: 100% !important;
-    transition: background .2s, transform .1s !important;
-}
-button.primary-btn:hover {
-    background: var(--accent-hover) !important;
-    transform: translateY(-1px) !important;
-}
-button.danger-btn {
-    background: var(--danger) !important;
-    color: white !important;
-    border-radius: 8px !important;
-    padding: 10px 20px !important;
-    font-weight: 600 !important;
-    font-size: 0.9rem !important;
-    border: none !important;
-    width: 100% !important;
-    transition: background .2s !important;
-}
-button.danger-btn:hover { background: var(--danger-hover) !important; }
-
-/* ── Inputs & textboxes ────────────────────────────────── */
-input[type="text"], textarea.gr-text-input {
-    border-radius: 8px !important;
-    border: 1.5px solid var(--border) !important;
-    padding: 9px 13px !important;
-    font-size: 0.9rem !important;
-    width: 100% !important;
-    transition: border-color .2s !important;
-}
-input[type="text"]:focus, textarea.gr-text-input:focus {
-    border-color: var(--accent) !important;
-    box-shadow: 0 0 0 3px rgba(79,110,247,.15) !important;
-    outline: none !important;
-}
-
-/* ── File drop zone ────────────────────────────────────── */
-.file-drop {
-    border: 2px dashed var(--border) !important;
-    border-radius: var(--radius) !important;
-    background: var(--bg) !important;
-    transition: border-color .2s, background .2s !important;
-}
-.file-drop:hover {
-    border-color: var(--accent) !important;
-    background: rgba(79,110,247,.04) !important;
-}
-
-/* ── Status messages ───────────────────────────────────── */
-.status-box {
-    border-radius: 8px;
-    padding: 10px 14px;
-    font-size: 0.88rem;
-    min-height: 36px;
-}
-
-/* ── Mobile responsiveness ─────────────────────────────── */
-@media (max-width: 640px) {
-    .gradio-container { padding: 0 !important; }
-    .app-header { border-radius: 0 !important; padding: 14px 16px 12px !important; }
-    .tabs > .tab-nav button { padding: 8px 12px !important; font-size: 0.82rem !important; }
-    .message.user > div, .message.bot > div { max-width: 95% !important; font-size: 0.88rem !important; }
-    .kb-row { flex-direction: column !important; }
-    .kb-row > * { width: 100% !important; }
+body,.gradio-container{background:var(--bg)!important;
+  font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,sans-serif!important}
+.app-header{background:linear-gradient(135deg,var(--accent) 0%,#7c3aed 100%);
+  color:#fff;padding:20px 24px 16px;border-radius:var(--radius) var(--radius) 0 0;margin-bottom:0}
+.app-header h1{margin:0 0 4px;font-size:clamp(1.2rem,4vw,1.6rem);font-weight:700;letter-spacing:-.02em}
+.app-header p{margin:0;opacity:.85;font-size:clamp(.8rem,2.5vw,.92rem)}
+.tabs>.tab-nav{background:var(--surface)!important;border-bottom:2px solid var(--border)!important;padding:0 16px!important;gap:4px!important}
+.tabs>.tab-nav button{border-radius:var(--radius) var(--radius) 0 0!important;padding:10px 18px!important;
+  font-weight:500!important;font-size:.88rem!important;color:var(--muted)!important;
+  border:none!important;background:transparent!important;transition:color .2s,background .2s!important}
+.tabs>.tab-nav button.selected{color:var(--accent)!important;border-bottom:2px solid var(--accent)!important}
+.message.user>div{background:var(--accent)!important;color:#fff!important;
+  border-radius:var(--radius) var(--radius) 4px var(--radius)!important;
+  padding:10px 14px!important;max-width:82%!important;
+  font-size:clamp(.85rem,2.5vw,.95rem)!important;line-height:1.55!important;box-shadow:var(--shadow)!important}
+.message.bot>div{background:var(--surface)!important;border:1px solid var(--border)!important;
+  border-radius:var(--radius) var(--radius) var(--radius) 4px!important;
+  padding:10px 14px!important;max-width:88%!important;
+  font-size:clamp(.85rem,2.5vw,.95rem)!important;line-height:1.6!important;box-shadow:var(--shadow)!important}
+.chat-input-container textarea{border-radius:24px!important;border:1.5px solid var(--border)!important;
+  padding:10px 16px!important;font-size:.93rem!important;resize:none!important;transition:border-color .2s!important}
+.chat-input-container textarea:focus{border-color:var(--accent)!important;outline:none!important;
+  box-shadow:0 0 0 3px rgba(79,110,247,.15)!important}
+.examples-table button,.example{border-radius:999px!important;border:1.5px solid var(--accent)!important;
+  color:var(--accent)!important;background:transparent!important;padding:6px 14px!important;
+  font-size:.82rem!important;font-weight:500!important;transition:background .2s,color .2s!important;white-space:nowrap!important}
+.examples-table button:hover,.example:hover{background:var(--accent)!important;color:#fff!important}
+@media(max-width:640px){
+  .gradio-container{padding:0!important}
+  .app-header{border-radius:0!important;padding:14px 16px 12px!important}
+  .tabs>.tab-nav button{padding:8px 12px!important;font-size:.82rem!important}
+  .message.user>div,.message.bot>div{max-width:95%!important;font-size:.88rem!important}
+  .kb-row{flex-direction:column!important}
+  .kb-row>*{width:100%!important}
 }
+</style>
 """
 
 examples = [
@@ -958,26 +668,25 @@ examples = [
     if "query" in q
 ] or [
     "What makes a good knowledge base article?",
-    "How could a KB assistant help agents?",
+    "How could a KB assistant help support agents?",
     "Why is self-service important for customer support?",
 ]
 
-with gr.Blocks(
-    title=CONFIG["client"]["name"],
-    css=CUSTOM_CSS,
-) as demo:
+with gr.Blocks(title=CONFIG["client"]["name"]) as demo:
+
+    # Inject styles — compatible with all Gradio versions
+    gr.HTML(STYLE_HTML)
 
-    # ── Header ───────────────────────────────────────────────────
     gr.HTML(f"""
         <div class="app-header">
             <h1>🤖 {CONFIG["client"]["name"]}</h1>
-            <p>Ask me anything — I'll search the knowledge base and answer to the best of my abilities.</p>
+            <p>Ask me anything — I'll search the knowledge base and answer in plain language.</p>
         </div>
     """)
 
     with gr.Tabs(elem_classes="tabs"):
 
-        # ── Tab 1: Chat ──────────────────────────────────────────
+        # ── Tab 1: Chat ──────────────────────────────────────────────
         with gr.TabItem("💬 Chat"):
             gr.ChatInterface(
                 fn=chat_respond,
@@ -985,49 +694,38 @@ with gr.Blocks(
                 cache_examples=False,
             )
 
-        # ── Tab 2: KB Manager ────────────────────────────────────
+        # ── Tab 2: KB Manager ────────────────────────────────────────
         with gr.TabItem("📁 KB Manager"):
-            gr.HTML("<div style='padding:16px 0 4px'><strong>Manage Knowledge Base Documents</strong><br>"
-                    "<span style='color:#6b7280;font-size:0.88rem'>Upload .txt or .md files · Index rebuilds automatically after every change</span></div>")
+            gr.HTML(
+                "<div style='padding:16px 0 4px'>"
+                "<strong>Manage Knowledge Base Documents</strong><br>"
+                "<span style='color:#6b7280;font-size:.88rem'>"
+                "Supported: .txt · .md · .pdf · .docx — Index rebuilds automatically after every change"
+                "</span></div>"
+            )
 
             with gr.Row(elem_classes="kb-row"):
 
-                # Left column — upload
-                with gr.Column(scale=2, elem_classes="kb-card"):
+                with gr.Column(scale=2):
                     upload_input = gr.File(
-                        label="Drop files here or click to browse (.txt / .md, max 10 MB each)",
+                        label="Drop files here or click to browse (max 10 MB each)",
                         file_count="multiple",
-                        file_types=[".txt", ".md"],
-                        elem_classes="file-drop",
+                        file_types=[".txt", ".md", ".pdf", ".docx", ".doc"],
                     )
-                    upload_btn = gr.Button("⬆️ Upload & Index", variant="primary", elem_classes="primary-btn")
-                    upload_status = gr.Markdown(elem_classes="status-box")
+                    upload_btn    = gr.Button("⬆️ Upload & Index", variant="primary")
+                    upload_status = gr.Markdown()
 
-                # Right column — file list + delete
-                with gr.Column(scale=1, elem_classes="kb-card"):
+                with gr.Column(scale=1):
                     gr.Markdown("**Current KB Files**")
-                    kb_file_list = gr.Markdown(value=list_kb_files, elem_classes="kb-file-list")
-
+                    kb_file_list = gr.Markdown(value=list_kb_files)
                     gr.HTML("<hr style='border:none;border-top:1px solid #e5e7eb;margin:12px 0'>")
                     gr.Markdown("**Delete a File**")
-                    delete_input = gr.Textbox(
-                        placeholder="Exact filename, e.g. my_doc.md",
-                        show_label=False,
-                        elem_classes="gr-text-input",
-                    )
-                    delete_btn = gr.Button("🗑️ Delete", variant="stop", elem_classes="danger-btn")
-                    delete_status = gr.Markdown(elem_classes="status-box")
+                    delete_input  = gr.Textbox(placeholder="Exact filename, e.g. guide.pdf", show_label=False)
+                    delete_btn    = gr.Button("🗑️ Delete", variant="stop")
+                    delete_status = gr.Markdown()
 
-            upload_btn.click(
-                fn=upload_kb_files,
-                inputs=[upload_input],
-                outputs=[upload_status, kb_file_list],
-            )
-            delete_btn.click(
-                fn=delete_kb_file,
-                inputs=[delete_input],
-                outputs=[delete_status, kb_file_list],
-            )
+            upload_btn.click(upload_kb_files, inputs=[upload_input], outputs=[upload_status, kb_file_list])
+            delete_btn.click(delete_kb_file,  inputs=[delete_input],  outputs=[delete_status, kb_file_list])
 
 
 # -----------------------------
@@ -1035,13 +733,9 @@ with gr.Blocks(
 # -----------------------------
 
 if __name__ == "__main__":
-    is_huggingface = os.getenv("SPACE_ID") is not None
-    is_container   = os.path.exists("/.dockerenv") or os.getenv("KUBERNETES_SERVICE_HOST") is not None
-
-    if is_huggingface or is_container:
-        env_label = "🤗 HuggingFace Spaces" if is_huggingface else "🐳 container"
-        logger.info(f"Launching on {env_label}...")
+    is_hf        = os.getenv("SPACE_ID") is not None
+    is_container = os.path.exists("/.dockerenv") or bool(os.getenv("KUBERNETES_SERVICE_HOST"))
+    if is_hf or is_container:
         demo.launch(server_name="0.0.0.0", server_port=7860)
     else:
-        logger.info("💻 Launching locally...")
         demo.launch(share=False)