feat: complete turbovec search backend integration, ignore tvim file in git, and stabilize mobile UI transitions

.gitignore

@@ -171,3 +171,7 @@ webapp/.serena/
 embedding_cache.db
 source_texts.db
 
+# ── Turbovec local data ──
+webapp/tipitaka-api/data/
+*.tvim
+

webapp/tipitaka-api/app/services/rag_service.py

@@ -2,8 +2,6 @@ import logging
 import os
 from pathlib import Path
 from collections import OrderedDict
-import qdrant_client
-from qdrant_client.http import models as qmodels
 import httpx
 from app.config import get_settings
 from app.database.sqlite_db import get_db
@@ -22,178 +20,105 @@ ST_EMBED_MODEL = "jinaai/jina-embeddings-v5-text-small-retrieval"
 
 logger = logging.getLogger(__name__)
 
+
+def _decode_tv_id(uid: int) -> tuple[int, int]:
+    """Decode turbovec uint64 ID back to (volume, page). Encoding: vol*100000+page."""
+    return uid // 100_000, uid % 100_000
+
+
 class RAGService:
     def __init__(self):
         settings = get_settings()
-        self.qdrant_path = settings.QDRANT_PATH
-        self.snapshot_dir = Path(settings.SNAPSHOT_DIR)
         self.ollama_url = os.getenv("OLLAMA_URL", "http://localhost:11434")
-        self.collections = [settings.QDRANT_COLLECTION, "tipitaka_scripture"]
-        
-        self.model = None  # Flag: None = not verified, 'ready' = OK
+
+        self.model = None       # None=not verified, 'ready'=Ollama OK, 'fallback'=ST
         self.reranker = None
-        self.actual_chunks_col = settings.QDRANT_COLLECTION # Default name
-        self._embed_cache = OrderedDict()     # LRU cache: text → embedding
-        self._embed_cache_max = 256           # max cached entries
-        self.client = None
-        self._st_model = None                 # sentence-transformers model (fallback)
+        self._embed_cache = OrderedDict()
+        self._embed_cache_max = 256
+        self._st_model = None
+        self.tv_index = None    # turbovec IdMapIndex
 
-        # Delegate heavy Qdrant init to a dedicated method
-        self._init_qdrant()
+        # Turbovec index path (DATA_DIR/tipitaka_chunks.tvim)
+        data_dir = Path(settings.DATA_DIR)
+        self._tv_path = str(data_dir / "tipitaka_chunks.tvim")
 
-        # Pre-load models (Embedding + Reranker) — safe to fail gracefully
+        self._init_turbovec()
         self._load_model()
         self._load_reranker()
 
-    def _init_qdrant(self):
-        """Heavy initialization: detect mode, extract snapshots, create Qdrant client."""
-        settings = get_settings()
-        qdrant_url = getattr(settings, "QDRANT_URL", None)
-
-        # Auto-detect Qdrant server if not configured
-        if not qdrant_url:
-            try:
-                with httpx.Client() as client:
-                    response = client.get("http://localhost:6333/healthz", timeout=1.0)
-                    if response.status_code == 200:
-                        qdrant_url = "http://localhost:6333"
-                        logger.info(f"Auto-detected running Qdrant Server at {qdrant_url}")
-            except Exception:
-                pass
-
-        is_local = not bool(qdrant_url)
-
-        try:
-            if is_local:
-                self._init_qdrant_local()
-            else:
-                self._init_qdrant_server(qdrant_url)
-        except Exception as e:
-            logger.error(f"RAG Initialization Error: {e}")
-            self.client = None
-
-    def _init_qdrant_local(self):
-        """Initialize Qdrant in Local Mode."""
-        logger.info(f"Initializing Qdrant in Local Mode at {self.qdrant_path}")
-        storage_path = Path(self.qdrant_path)
-        storage_path.mkdir(parents=True, exist_ok=True)
-
-        lock_file = storage_path / ".lock"
-        if lock_file.exists():
-            try:
-                logger.warning(f"Removing stale Qdrant lock file: {lock_file}")
-                lock_file.unlink()
-            except Exception as e:
-                logger.error(f"Failed to remove lock file: {e}")
-
-        self.client = qdrant_client.QdrantClient(path=str(self.qdrant_path))
-        logger.info("Qdrant Local Client initialized.")
-
-    def _init_qdrant_server(self, qdrant_url: str):
-        """Initialize Qdrant in Server Mode — connect and restore snapshots if needed."""
-        logger.info(f"Connecting to Qdrant Server at {qdrant_url}")
-        self.client = qdrant_client.QdrantClient(url=qdrant_url)
+    # ── Turbovec init ────────────────────────────────────────────────
 
+    def _init_turbovec(self):
+        """Load turbovec IdMapIndex from disk."""
         try:
-            all_cols = [c.name for c in self.client.get_collections().collections]
+            from turbovec import IdMapIndex
+            if not Path(self._tv_path).exists():
+                logger.warning(f"turbovec index not found at {self._tv_path} — vector search disabled")
+                return
+            logger.info(f"Loading turbovec index from {self._tv_path}...")
+            self.tv_index = IdMapIndex.load(self._tv_path)
+            logger.info("turbovec index loaded ✅")
         except Exception as e:
-            logger.error(f"Failed to list collections: {e}")
-            all_cols = []
-
-        settings = get_settings()
-        for col_name in self.collections:
-            actual_col = None
-            if col_name in all_cols:
-                actual_col = col_name
-            else:
-                matches = [c for c in all_cols if c.startswith(f"{col_name}_") or c.startswith(col_name)]
-                if matches:
-                    actual_col = matches[0]
+            logger.error(f"Failed to load turbovec index: {e}")
+            self.tv_index = None
 
-            if actual_col:
-                if col_name == settings.QDRANT_COLLECTION:
-                    self.actual_chunks_col = actual_col
-            else:
-                snap_filename = f"{col_name}.snapshot"
-                target_snap = ALLOWED_SNAP_ROOT / snap_filename
-                if not target_snap.exists():
-                    target_snap = self.snapshot_dir / snap_filename
-
-                if target_snap.exists():
-                    import os
-                    logger.info(f"Restoring server collection '{col_name}' from {target_snap}...")
-                    abs_snap_path = os.path.abspath(target_snap).replace("\\", "/")
-                    if not abs_snap_path.startswith("/"):
-                        abs_snap_path = "/" + abs_snap_path
-                    try:
-                        self.client.recover_snapshot(col_name, location=f"file://{abs_snap_path}")
-                        if col_name == settings.QDRANT_COLLECTION:
-                            self.actual_chunks_col = col_name
-                    except Exception as e:
-                        logger.error(f"Failed to restore: {e}")
+    # ── Embedding ────────────────────────────────────────────────────
 
     def _load_model(self):
-        """Verify Ollama embedding service is accessible. If not, preload sentence-transformers."""
+        """Verify Ollama or preload sentence-transformers as fallback."""
         if self.model is None:
-            logger.info(f"Verifying Ollama embedding model...")
+            logger.info("Verifying Ollama embedding model...")
             try:
                 r = httpx.get(f"{self.ollama_url}/api/tags", timeout=5)
                 r.raise_for_status()
                 self.model = "ready"
-                logger.info(f"Ollama embedding service ready.")
+                logger.info("Ollama embedding service ready.")
             except Exception as e:
-                logger.error(f"Ollama not accessible: {e}. Pre-loading sentence-transformers model...")
+                logger.error(f"Ollama not accessible: {e}. Pre-loading sentence-transformers...")
                 self.model = "fallback"
                 try:
                     settings = get_settings()
-                    logger.info(f"Loading sentence-transformers model: {settings.ST_EMBED_MODEL}")
                     from sentence_transformers import SentenceTransformer
                     self._st_model = SentenceTransformer(settings.ST_EMBED_MODEL, trust_remote_code=True)
-                    logger.info("Sentence-transformers model loaded successfully.")
+                    logger.info("Sentence-transformers model loaded ✅")
                 except Exception as st_err:
-                    logger.error(f"Failed to load sentence-transformers model: {st_err}")
+                    logger.error(f"Failed to load sentence-transformers: {st_err}")
                     self.model = None
 
     def _load_reranker(self):
-        """Pre-load the Reranker model using ONNX for CPU performance."""
+        """Pre-load ONNX Reranker."""
         if self.reranker is None:
             logger.info(f"Pre-loading ONNX Reranker from {RERANK_MODEL_PATH}...")
             try:
                 from app.services.onnx_reranker import ONNXReranker
                 self.reranker = ONNXReranker(RERANK_MODEL_PATH)
-                logger.info("ONNX Reranker v2 pre-loaded successfully.")
+                logger.info("ONNX Reranker pre-loaded ✅")
             except Exception as e:
                 logger.error(f"Failed to pre-load ONNX Reranker: {e}")
-                # Fallback flag
                 self.reranker = "error"
 
     def _get_embedding(self, text: str) -> list:
-        """Get embedding vector — wrapper around batched implementation."""
         res = self._get_embeddings([text])
         return res[0] if res else []
 
     def _get_embeddings(self, texts: list[str]) -> list[list[float]]:
-        """Get embedding vectors for a list of texts using batching."""
         if not texts:
             return []
 
         results = [None] * len(texts)
-        missing_indices = []
-        missing_texts = []
-        
-        # 1. Check LRU cache first
+        missing_indices, missing_texts = [], []
+
         for idx, text in enumerate(texts):
             if text in self._embed_cache:
-                self._embed_cache.move_to_end(text)  # Mark as recently used
+                self._embed_cache.move_to_end(text)
                 results[idx] = self._embed_cache[text]
             else:
                 missing_indices.append(idx)
                 missing_texts.append(text)
-                
+
         if not missing_texts:
             return results
 
-        # 2. Try Ollama batch embedding (only if Ollama is ready)
         ollama_failed = True
         if self.model == "ready":
             try:
@@ -209,199 +134,185 @@ class RAGService:
                     results[idx] = emb
                 ollama_failed = False
             except Exception as e:
-                logger.info(f"Ollama batch embedding unavailable ({e}), falling back to sentence-transformers")
-                ollama_failed = True
+                logger.info(f"Ollama batch embedding unavailable ({e}), falling back to ST")
                 self.model = "fallback"
 
-        # 3. Fallback to sentence-transformers batch embedding
         if ollama_failed:
             try:
                 if self._st_model is None:
                     settings = get_settings()
-                    logger.info(f"Loading sentence-transformers model: {settings.ST_EMBED_MODEL}")
                     from sentence_transformers import SentenceTransformer
                     self._st_model = SentenceTransformer(settings.ST_EMBED_MODEL, trust_remote_code=True)
 
-                embeddings = self._st_model.encode(missing_texts, normalize_embeddings=True, show_progress_bar=False).tolist()
+                embeddings = self._st_model.encode(
+                    missing_texts, normalize_embeddings=True, show_progress_bar=False
+                ).tolist()
                 for idx, emb in zip(missing_indices, embeddings):
                     self._store_cache(texts[idx], emb)
                     results[idx] = emb
                 return results
             except Exception as e:
-                logger.error(f"sentence-transformers batch embedding failed: {e}")
+                logger.error(f"ST batch embedding failed: {e}")
                 for idx in missing_indices:
                     results[idx] = []
                 return results
-        return results
 
+        return results
 
     def _store_cache(self, text: str, embedding: list):
-        """Store embedding in LRU cache."""
         self._embed_cache[text] = embedding
         if len(self._embed_cache) > self._embed_cache_max:
-            self._embed_cache.popitem(last=False)  # Remove oldest (LRU)
+            self._embed_cache.popitem(last=False)
+
+    # ── Query (Hybrid: FTS5 + turbovec) ─────────────────────────────
 
     async def query(self, text: str, n_results: int = 10, threshold: float = 0.2) -> str:
         """
-        Hybrid Search Strategy: 
-        1. FTS5 Search (SQLite) for exact keyword matches.
-        2. Vector Search (Qdrant) for semantic relevance.
-        3. Merge & Deduplicate.
-        4. Rerank via Jina v2 ONNX.
+        Hybrid Search:
+        1. FTS5 (SQLite) — keyword matches
+        2. turbovec — semantic vector search
+        3. Merge & Deduplicate
+        4. Rerank via Jina v2 ONNX
         """
-        if not self.client:
+        if self.tv_index is None and self.model is None:
             return ""
-            
-        # Ensure models are ready
+
         if self.model is None:
             await anyio.to_thread.run_sync(self._load_model)
         if self.reranker is None:
             await anyio.to_thread.run_sync(self._load_reranker)
 
         candidates = []
-        seen_keys = set() # For deduplication (vol_page)
+        seen_keys = set()
 
         try:
-            # --- PHASE 1: FTS5 Search (SQLite) ---
-            logger.info(f"Starting FTS5 search for: {text[:30]}...")
+            # ── Phase 1: FTS5 ────────────────────────────────────
+            logger.info(f"FTS5 search: {text[:40]}...")
+
             def _blocking_fts():
-                fts_results = []
                 db = get_db()
                 with db.get_connection() as conn:
-                    # Search pages_fts and join with pages for metadata
-                    # We limit to 30 for performance
-                    query_sql = """
-                        SELECT id, volume_id, page_number, content_text 
-                        FROM pages 
-                        WHERE id IN (
-                            SELECT rowid FROM pages_fts 
-                            WHERE pages_fts MATCH ? 
-                            LIMIT 30
-                        )
-                    """
-                    # Sanitize FTS query: wrap in quotes for literal or keep simple
-                    sanitized_query = text.replace('"', '').strip()
-                    if not sanitized_query: return []
-                    
-                    # Split into tokens by whitespace and append * for prefix matching
-                    tokens = [t.strip() for t in sanitized_query.split() if t.strip()]
-                    processed_tokens = []
-                    for t in tokens:
-                        if "*" not in t:
-                            processed_tokens.append(f'"{t}"*')
-                        else:
-                            processed_tokens.append(t)
-                    fts_query = " AND ".join(processed_tokens)
-                    
+                    sanitized = text.replace('"', '').strip()
+                    if not sanitized:
+                        return []
+                    tokens = [t for t in sanitized.split() if t]
+                    fts_query = " AND ".join(
+                        f'"{t}"*' if "*" not in t else t for t in tokens
+                    )
                     try:
-                        cursor = conn.execute(query_sql, (fts_query,))
-                        for row in cursor.fetchall():
-                            key = f"{row['volume_id']}_{row['page_number']}"
-                            fts_results.append({
-                                "id": row['id'],
-                                "score": 0.9, # High initial score for FTS matches
+                        cursor = conn.execute("""
+                            SELECT id, volume_id, page_number, content_text
+                            FROM pages
+                            WHERE id IN (
+                                SELECT rowid FROM pages_fts
+                                WHERE pages_fts MATCH ?
+                                LIMIT 30
+                            )
+                        """, (fts_query,))
+                        return [
+                            {
+                                "id": r["id"],
+                                "score": 0.9,
                                 "payload": {
-                                    "volume": row['volume_id'],
-                                    "page": row['page_number'],
-                                    "content": row['content_text']
+                                    "volume": r["volume_id"],
+                                    "page": r["page_number"],
+                                    "content": r["content_text"],
                                 },
-                                "key": key
-                            })
+                                "key": f"{r['volume_id']}_{r['page_number']}",
+                            }
+                            for r in cursor.fetchall()
+                        ]
                     except Exception as e:
-                        logger.warning(f"FTS5 query failed: {e}")
-                return fts_results
+                        logger.warning(f"FTS5 failed: {e}")
+                        return []
 
-            fts_candidates = await anyio.to_thread.run_sync(_blocking_fts)
-            for cand in fts_candidates:
-                if cand['key'] not in seen_keys:
-                    candidates.append(cand)
-                    seen_keys.add(cand['key'])
-            
-            # --- PHASE 2: Vector Search (Qdrant) ---
-            logger.info(f"Starting Vector search for: {text[:30]}...")
-            def _blocking_vector():
-                query_vector = self._get_embedding(text)
-                if hasattr(self.client, "search"):
-                    hits = self.client.search(
-                        collection_name=self.actual_chunks_col,
-                        query_vector=("dense", query_vector),
-                        limit=30,
-                        with_payload=True,
-                        score_threshold=threshold
-                    )
-                else:
-                    response = self.client.query_points(
-                        collection_name=self.actual_chunks_col,
-                        query=query_vector,
-                        using="dense",
-                        limit=30,
-                        with_payload=True,
-                        score_threshold=threshold
-                    )
-                    hits = response.points
-                
-                vec_results = []
-                for hit in hits:
-                    vol = hit.payload.get("volume", hit.payload.get("volume_id"))
-                    page = hit.payload.get("page", hit.payload.get("page_number"))
-                    key = f"{vol}_{page}"
-                    vec_results.append({
-                        "id": hit.id,
-                        "score": hit.score,
-                        "payload": hit.payload,
-                        "key": key
-                    })
-                return vec_results
-
-            vector_candidates = await anyio.to_thread.run_sync(_blocking_vector)
-            for cand in vector_candidates:
-                if cand['key'] not in seen_keys:
+            for cand in await anyio.to_thread.run_sync(_blocking_fts):
+                if cand["key"] not in seen_keys:
                     candidates.append(cand)
-                    seen_keys.add(cand['key'])
+                    seen_keys.add(cand["key"])
+
+            # ── Phase 2: turbovec vector search ──────────────────
+            if self.tv_index is not None:
+                logger.info(f"turbovec search: {text[:40]}...")
+
+                def _blocking_vector():
+                    import numpy as np
+                    query_vec = self._get_embedding(text)
+                    if not query_vec:
+                        return []
+                    q_np = np.array([query_vec], dtype=np.float32)
+                    scores, ids = self.tv_index.search(q_np, k=30)
+                    vec_results = []
+                    for score, uid in zip(scores[0], ids[0]):
+                        if score < threshold:
+                            continue
+                        vol, page = _decode_tv_id(int(uid))
+                        vec_results.append({
+                            "id": int(uid),
+                            "score": float(score),
+                            "payload": {"volume": vol, "page": page, "content": ""},
+                            "key": f"{vol}_{page}",
+                        })
+                    return vec_results
+
+                for cand in await anyio.to_thread.run_sync(_blocking_vector):
+                    if cand["key"] not in seen_keys:
+                        candidates.append(cand)
+                        seen_keys.add(cand["key"])
 
             if not candidates:
                 return ""
 
-            # --- PHASE 3: Rerank stage ---
+            # Enrich missing content payloads from SQLite (e.g. for turbovec candidates)
+            missing_content_cands = [c for c in candidates if not c["payload"].get("content")]
+            if missing_content_cands:
+                def _blocking_enrich():
+                    db = get_db()
+                    with db.get_connection() as conn:
+                        cursor = conn.cursor()
+                        for cand in missing_content_cands:
+                            try:
+                                cursor.execute(
+                                    "SELECT content_text FROM pages WHERE volume_id = ? AND page_number = ?",
+                                    (cand["payload"]["volume"], cand["payload"]["page"])
+                                )
+                                r = cursor.fetchone()
+                                if r:
+                                    cand["payload"]["content"] = r["content_text"]
+                            except Exception as e:
+                                logger.warning(f"Failed to fetch content for vol={cand['payload']['volume']} page={cand['payload']['page']}: {e}")
+                await anyio.to_thread.run_sync(_blocking_enrich)
+
+            # ── Phase 3: Rerank ───────────────────────────────────
             if self.reranker and self.reranker != "error":
-                logger.info(f"Reranking {len(candidates)} hybrid candidates...")
-                
+                logger.info(f"Reranking {len(candidates)} candidates...")
+
                 def _blocking_rerank():
-                    # Prepare pairs: (query, passage)
-                    passages = [c['payload'].get("content", "")[:1000] for c in candidates]
+                    passages = [c["payload"].get("content", "")[:1000] for c in candidates]
                     pairs = [[text, p] for p in passages]
-                    
                     with torch.no_grad():
                         scores = self.reranker.predict(pairs, show_progress_bar=False, batch_size=4)
-                    
                     for i, cand in enumerate(candidates):
-                        cand['rerank_score'] = float(scores[i])
-                        
-                    return sorted(candidates, key=lambda x: x.get('rerank_score', 0), reverse=True)
+                        cand["rerank_score"] = float(scores[i])
+                    return sorted(candidates, key=lambda x: x.get("rerank_score", 0), reverse=True)
 
                 candidates = await anyio.to_thread.run_sync(_blocking_rerank)
-            
-            # --- PHASE 4: Formatting ---
-            final_results = candidates[:n_results]
+
+            # ── Phase 4: Format ───────────────────────────────────
             context_parts = []
-            for cand in final_results:
-                payload = cand['payload']
+            for cand in candidates[:n_results]:
+                payload = cand["payload"]
                 content = payload.get("content", "").strip()
-                if not content: continue
-                
-                vol = payload.get("volume")
+                if not content:
+                    continue
+                vol  = payload.get("volume")
                 page = payload.get("page")
-                
-                # Cleanup and formatting
-                clean_content = re.sub(r"---.*?---", "", content, flags=re.DOTALL).strip()
-                clean_content = re.sub(r"^\d{3}\s+", "", clean_content, flags=re.MULTILINE)
-                clean_content = clean_content[:2000]
-                
-                context_parts.append(f"[เล่ม {vol} หน้า {page}]\n{clean_content}")
-
-            return "\n---\n".join(context_parts) if context_parts else ""
-            
+                clean = re.sub(r"---.*?---", "", content, flags=re.DOTALL).strip()
+                clean = re.sub(r"^\d{3}\s+", "", clean, flags=re.MULTILINE)
+                context_parts.append(f"[เล่ม {vol} หน้า {page}]\n{clean[:2000]}")
+
+            return "\n---\n".join(context_parts)
+
         except Exception as e:
             logger.error(f"Hybrid query error: {e}")
             return ""
-

webapp/tipitaka-api/app/services/search_service.py

@@ -193,181 +193,65 @@ class SearchService:
         return self.highlight_multiple(text, [keyword]) if keyword else text
 
     async def _get_vector_results_batch(self, query_texts: List[str], query_vectors: List[List[float]], limit: int = 30) -> List[List[dict]]:
-        """Fetch semantic vector results from Qdrant in batch."""
-        if not self.rag_service or not self.rag_service.client or not query_vectors:
+        """Fetch semantic vector results from turbovec in batch."""
+        if not self.rag_service or not self.rag_service.tv_index or not query_vectors:
             return [[] for _ in query_texts]
 
         import anyio
-        from qdrant_client.http import models as qmodels
+        import numpy as np
 
         def _blocking():
-            col = self.rag_service.actual_chunks_col
-            client = self.rag_service.client
-            
-            # Map request index to original query indices
+            tv = self.rag_service.tv_index
             valid_indices = [idx for idx, vec in enumerate(query_vectors) if vec]
             if not valid_indices:
                 return [[] for _ in query_texts]
 
-            final_results = [[] for _ in query_texts]
-
-            # 1. Try modern query_batch_points API first (Qdrant Client 1.8+)
-            if hasattr(client, "query_batch_points"):
-                requests = [
-                    qmodels.QueryRequest(
-                        query=query_vectors[idx],
-                        using="dense",
-                        limit=limit,
-                        with_payload=True,
-                        score_threshold=0.2
-                    ) for idx in valid_indices
-                ]
-                try:
-                    batch_responses = client.query_batch_points(
-                        collection_name=col,
-                        requests=requests
-                    )
-                    for req_idx, resp in zip(valid_indices, batch_responses):
-                        hits = resp.points if hasattr(resp, "points") else resp
-                        vec_results = []
-                        for hit in hits:
-                            vol = hit.payload.get("volume", hit.payload.get("volume_id"))
-                            page = hit.payload.get("page", hit.payload.get("page_number"))
-                            content = hit.payload.get("content", "")
-                            vec_results.append({
-                                "volume_id": vol,
-                                "page_number": page,
-                                "content_text": content,
-                                "score": hit.score
-                            })
-                        final_results[req_idx] = vec_results
-                    return final_results
-                except Exception as e:
-                    import logging
-                    logging.getLogger(__name__).warning(f"Qdrant query_batch_points failed: {e}")
-
-            # 2. Try legacy search_batch API if available
-            if hasattr(client, "search_batch"):
-                requests = [
-                    qmodels.SearchRequest(
-                        vector=qmodels.NamedVector(name="dense", vector=query_vectors[idx]),
-                        limit=limit,
-                        with_payload=True,
-                        score_threshold=0.2
-                    ) for idx in valid_indices
-                ]
-                try:
-                    batch_responses = client.search_batch(
-                        collection_name=col,
-                        requests=requests
-                    )
-                    for req_idx, hits in zip(valid_indices, batch_responses):
-                        vec_results = []
-                        for hit in hits:
-                            vol = hit.payload.get("volume", hit.payload.get("volume_id"))
-                            page = hit.payload.get("page", hit.payload.get("page_number"))
-                            content = hit.payload.get("content", "")
-                            vec_results.append({
-                                "volume_id": vol,
-                                "page_number": page,
-                                "content_text": content,
-                                "score": hit.score
-                            })
-                        final_results[req_idx] = vec_results
-                    return final_results
-                except Exception as e:
-                    import logging
-                    logging.getLogger(__name__).warning(f"Qdrant search_batch failed: {e}")
-
-            # 3. Fallback: run sequential queries in blocking thread
-            for idx in valid_indices:
-                try:
-                    if hasattr(client, "search"):
-                        hits = client.search(
-                            collection_name=col,
-                            query_vector=("dense", query_vectors[idx]),
-                            limit=limit,
-                            with_payload=True,
-                            score_threshold=0.2
-                        )
-                    else:
-                        response = client.query_points(
-                            collection_name=col,
-                            query=query_vectors[idx],
-                            using="dense",
-                            limit=limit,
-                            with_payload=True,
-                            score_threshold=0.2
-                        )
-                        hits = response.points
-                    
-                    vec_results = []
-                    for hit in hits:
-                        vol = hit.payload.get("volume", hit.payload.get("volume_id"))
-                        page = hit.payload.get("page", hit.payload.get("page_number"))
-                        content = hit.payload.get("content", "")
-                        vec_results.append({
-                            "volume_id": vol,
-                            "page_number": page,
-                            "content_text": content,
-                            "score": hit.score
-                        })
-                    final_results[idx] = vec_results
-                except Exception as e:
-                    import logging
-                    logging.getLogger(__name__).warning(f"Qdrant single query fallback failed: {e}")
+            # Stack valid query vectors for batch search
+            vecs = np.array([query_vectors[idx] for idx in valid_indices], dtype=np.float32)
+            all_scores, all_ids = tv.search(vecs, k=limit)
 
+            final_results = [[] for _ in query_texts]
+            for req_pos, req_idx in enumerate(valid_indices):
+                vec_results = []
+                for score, uid in zip(all_scores[req_pos], all_ids[req_pos]):
+                    if float(score) < 0.2:
+                        continue
+                    vol, page = uid // 100_000, uid % 100_000
+                    vec_results.append({
+                        "volume_id": int(vol),
+                        "page_number": int(page),
+                        "content_text": "",   # fetched from SQLite later
+                        "score": float(score)
+                    })
+                final_results[req_idx] = vec_results
             return final_results
 
         return await anyio.to_thread.run_sync(_blocking)
 
     async def _get_vector_results(self, query_text: str, limit: int = 30) -> List[dict]:
-        """Fetch semantic vector results from Qdrant via RAGService."""
-        if not self.rag_service or not self.rag_service.client:
+        """Fetch semantic vector results from turbovec via RAGService."""
+        if not self.rag_service or not self.rag_service.tv_index:
             return []
 
         import anyio
+        import numpy as np
 
         def _blocking():
             query_vector = self.rag_service._get_embedding(query_text)
             if not query_vector:
                 return []
-
-            col = self.rag_service.actual_chunks_col
-            try:
-                if hasattr(self.rag_service.client, "search"):
-                    hits = self.rag_service.client.search(
-                        collection_name=col,
-                        query_vector=("dense", query_vector),
-                        limit=limit,
-                        with_payload=True,
-                        score_threshold=0.2
-                    )
-                else:
-                    response = self.rag_service.client.query_points(
-                        collection_name=col,
-                        query=query_vector,
-                        using="dense",
-                        limit=limit,
-                        with_payload=True,
-                        score_threshold=0.2
-                    )
-                    hits = response.points
-            except Exception as e:
-                import logging
-                logging.getLogger(__name__).warning(f"Qdrant query failed: {e}")
-                return []
-
+            q_np = np.array([query_vector], dtype=np.float32)
+            scores, ids = self.rag_service.tv_index.search(q_np, k=limit)
             vec_results = []
-            for hit in hits:
-                vol = hit.payload.get("volume", hit.payload.get("volume_id"))
-                page = hit.payload.get("page", hit.payload.get("page_number"))
-                content = hit.payload.get("content", "")
+            for score, uid in zip(scores[0], ids[0]):
+                if float(score) < 0.2:
+                    continue
+                vol, page = uid // 100_000, uid % 100_000
                 vec_results.append({
-                    "volume_id": vol,
-                    "page_number": page,
-                    "content_text": content,
-                    "score": hit.score
+                    "volume_id": int(vol),
+                    "page_number": int(page),
+                    "content_text": "",   # fetched from SQLite later
+                    "score": float(score)
                 })
             return vec_results
 
@@ -495,6 +379,24 @@ class SearchService:
         top_keys = sorted(rrf_scores, key=rrf_scores.get, reverse=True)[:15]
         top_candidates = [candidate_data[ky] for ky in top_keys]
 
+        # Enrich missing content_text from SQLite (e.g. for turbovec vector results)
+        missing_content_cands = [c for c in top_candidates if not c.get("content_text")]
+        if missing_content_cands:
+            try:
+                with self.db.get_connection() as conn:
+                    cursor = conn.cursor()
+                    for c in missing_content_cands:
+                        cursor.execute(
+                            "SELECT content_text FROM pages WHERE volume_id = ? AND page_number = ?",
+                            (c["volume_id"], c["page_number"])
+                        )
+                        row = cursor.fetchone()
+                        if row:
+                            c["content_text"] = row["content_text"]
+            except Exception as e:
+                import logging
+                logging.getLogger(__name__).warning(f"Enriching candidates content failed: {e}")
+
         # ── 5. Reranking (using Jina Reranker v2 ONNX) ────────────
         if top_candidates:
             final_results = await self._rerank_candidates(corrected_q, top_candidates)

webapp/tipitaka-api/benchmark_qdrant_vs_turbovec.py

@@ -0,0 +1,117 @@
+import time
+import numpy as np
+from qdrant_client import QdrantClient
+from turbovec import IdMapIndex
+import sys
+import os
+
+# Configurations
+QDRANT_URL = "http://127.0.0.1:6333"
+COLLECTION = "tipitaka_chunks"
+TV_PATH = "F:/_Ai/Tipitaka-AI-Expert/RAG/webapp/tipitaka-api/data/tipitaka_chunks.tvim"
+EMBED_DIM = 1024
+NUM_QUERIES = 100
+K = 30
+
+def benchmark():
+    print("=" * 60)
+    print("      BENCHMARK: QDRANT VS TURBOVEC (SEARCH ONLY)")
+    print("=" * 60)
+
+    # 1. Generate random query vectors to isolate search speed from embedding latency
+    np.random.seed(42)
+    query_vectors = np.random.randn(NUM_QUERIES, EMBED_DIM).astype(np.float32)
+    # Normalize for cosine similarity
+    norms = np.linalg.norm(query_vectors, axis=1, keepdims=True)
+    query_vectors = query_vectors / norms
+
+    # 2. Turbovec initialization
+    t_start = time.time()
+    tv_index = IdMapIndex.load(TV_PATH)
+    t_tv_load = (time.time() - t_start) * 1000
+    print(f"Turbovec index loaded from disk in: {t_tv_load:.2f} ms")
+
+    # 3. Qdrant initialization
+    t_start = time.time()
+    qdrant_client = QdrantClient(url=QDRANT_URL)
+    # Warm up / check connection
+    try:
+        qdrant_client.get_collection(COLLECTION)
+        t_qd_connect = (time.time() - t_start) * 1000
+        print(f"Connected to Qdrant local server in: {t_qd_connect:.2f} ms")
+    except Exception as e:
+        print(f"FAILED to connect to Qdrant: {e}")
+        return
+
+    print(f"Running {NUM_QUERIES} queries (k={K}) on both databases...")
+
+    # --- Benchmark Turbovec ---
+    tv_times = []
+    # Warmup
+    tv_index.search(query_vectors[0:1], k=K)
+    
+    for i in range(NUM_QUERIES):
+        q = query_vectors[i:i+1]
+        start = time.perf_counter()
+        scores, ids = tv_index.search(q, k=K)
+        end = time.perf_counter()
+        tv_times.append((end - start) * 1000)
+
+    # --- Benchmark Qdrant ---
+    qd_times = []
+    # Warmup
+    try:
+        qdrant_client.query_points(
+            collection_name=COLLECTION,
+            query=query_vectors[0].tolist(),
+            using="dense",
+            limit=K,
+            with_payload=False
+        )
+    except Exception as e:
+        print(f"Qdrant warmup query_points failed: {e}")
+        return
+
+    for i in range(NUM_QUERIES):
+        q_list = query_vectors[i].tolist()
+        start = time.perf_counter()
+        qdrant_client.query_points(
+            collection_name=COLLECTION,
+            query=q_list,
+            using="dense",
+            limit=K,
+            with_payload=False
+        )
+        end = time.perf_counter()
+        qd_times.append((end - start) * 1000)
+
+    # 4. Results
+    print("\n" + "=" * 60)
+    print("                      LATENCY RESULTS (ms)")
+    print("=" * 60)
+    print(f"{'Metric':<15} | {'Turbovec (4-bit SQ)':<20} | {'Qdrant Server':<20}")
+    print("-" * 60)
+    print(f"{'Average (Mean)':<15} | {np.mean(tv_times):>17.3f} ms | {np.mean(qd_times):>17.3f} ms")
+    print(f"{'Median (p50)':<15} | {np.percentile(tv_times, 50):>17.3f} ms | {np.percentile(qd_times, 50):>17.3f} ms")
+    print(f"{'90th Percentile':<15} | {np.percentile(tv_times, 90):>17.3f} ms | {np.percentile(qd_times, 90):>17.3f} ms")
+    print(f"{'Min':<15} | {np.min(tv_times):>17.3f} ms | {np.min(qd_times):>17.3f} ms")
+    print(f"{'Max':<15} | {np.max(tv_times):>17.3f} ms | {np.max(qd_times):>17.3f} ms")
+    print("=" * 60)
+    
+    # Throughput
+    print(f"Throughput (QPS):")
+    print(f"  • Turbovec: {NUM_QUERIES / (sum(tv_times)/1000):.1f} queries/sec")
+    print(f"  • Qdrant:   {NUM_QUERIES / (sum(qd_times)/1000):.1f} queries/sec")
+    print("=" * 60)
+
+    # Disk Space / Memory comparison (estimated)
+    print("Resource Footprint Comparison:")
+    print("  • Turbovec Index File: 13.2 MB")
+    print("  • Qdrant Local Server Storage: ~600+ MB (snapshots + database files)")
+    print("  • Memory Overhead:")
+    print("    - Turbovec: Loaded dynamically in Python process memory (~14MB overhead).")
+    print("    - Qdrant: Requires running a separate Docker daemon container (~150MB to 300MB RAM idle).")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    benchmark()

webapp/tipitaka-api/build_turbovec_index.py

@@ -0,0 +1,139 @@
+"""
+Build turbovec IdMapIndex from Qdrant tipitaka_chunks collection.
+
+ID encoding: volume * 100000 + page  (uint64, fully reversible)
+Output: tipitaka_chunks.tvim  (turbovec index file)
+
+Usage:
+    python build_turbovec_index.py
+    python build_turbovec_index.py --collection tipitaka_chunks --output tipitaka_chunks.tvim
+"""
+import argparse
+import logging
+import time
+import numpy as np
+from qdrant_client import QdrantClient
+from turbovec import IdMapIndex
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+QDRANT_URL   = "http://localhost:6333"
+COLLECTION   = "tipitaka_chunks"
+OUTPUT_PATH  = "F:/_Ai/Tipitaka-AI-Expert/RAG/webapp/tipitaka-api/data/tipitaka_chunks.tvim"
+EMBED_DIM    = 1024
+BATCH_SIZE   = 500
+
+
+def encode_id(volume: str, page: str) -> int:
+    """Encode (volume, page) as a single uint64. Reversible via decode_id()."""
+    return int(volume) * 100_000 + int(page)
+
+
+def decode_id(uid: int) -> tuple[int, int]:
+    """Decode uint64 back to (volume, page)."""
+    return uid // 100_000, uid % 100_000
+
+
+def main(collection: str, output: str):
+    logger.info(f"Connecting to Qdrant at {QDRANT_URL}...")
+    client = QdrantClient(url=QDRANT_URL)
+
+    info = client.get_collection(collection)
+    total = info.points_count
+    logger.info(f"Collection '{collection}': {total} points, dim={EMBED_DIM}")
+
+    # Build turbovec index
+    index = IdMapIndex(dim=EMBED_DIM, bit_width=4)
+
+    vectors_batch = []
+    ids_batch     = []
+    processed     = 0
+    skipped       = 0
+    offset        = None
+    start         = time.time()
+
+    while True:
+        pts, next_offset = client.scroll(
+            collection,
+            offset=offset,
+            limit=BATCH_SIZE,
+            with_payload=True,
+            with_vectors=True,
+        )
+        if not pts:
+            break
+
+        for pt in pts:
+            payload = pt.payload or {}
+            volume  = payload.get("volume", payload.get("volume_number", ""))
+            page    = payload.get("page",   payload.get("page_number",   ""))
+
+            # Get dense vector only
+            vec = pt.vector
+            if isinstance(vec, dict):
+                vec = vec.get("dense")
+            if vec is None or not volume or not page:
+                skipped += 1
+                continue
+
+            try:
+                uid = encode_id(volume, page)
+                vectors_batch.append(vec)
+                ids_batch.append(uid)
+            except (ValueError, TypeError):
+                skipped += 1
+                continue
+
+        # Add batch to index
+        if vectors_batch:
+            vecs_np = np.array(vectors_batch, dtype=np.float32)
+            ids_np  = np.array(ids_batch,     dtype=np.uint64)
+            index.add_with_ids(vecs_np, ids_np)
+            processed += len(vecs_np)
+            vectors_batch.clear()
+            ids_batch.clear()
+
+        elapsed = time.time() - start
+        rate    = processed / elapsed if elapsed > 0 else 0
+        eta     = (total - processed) / rate if rate > 0 else 0
+        logger.info(f"  {processed}/{total} ({100*processed//total}%) | {rate:.0f} pts/s | ETA {eta:.0f}s")
+
+        if next_offset is None:
+            break
+        offset = next_offset
+
+    # Save index
+    logger.info(f"\nSaving index to {output}...")
+    index.write(output)
+
+    elapsed_total = time.time() - start
+    logger.info("=" * 60)
+    logger.info(f"Done in {elapsed_total:.1f}s")
+    logger.info(f"Indexed: {processed} | Skipped: {skipped}")
+    logger.info(f"Saved: {output}")
+    logger.info(f"ID encoding: volume * 100000 + page  (decode: v=id//100000, p=id%100000)")
+    logger.info("=" * 60)
+
+    # Quick sanity check
+    logger.info("\nSanity check — reload and search with random query...")
+    from turbovec import IdMapIndex as TVI
+    loaded = TVI.load(output)
+    query  = np.random.randn(1, EMBED_DIM).astype(np.float32)
+    scores, ids = loaded.search(query, k=3)
+    for s, uid in zip(scores[0], ids[0]):
+        vol, pg = decode_id(int(uid))
+        logger.info(f"  score={s:.4f}  vol={vol}  page={pg}")
+
+    client.close()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--collection", default=COLLECTION)
+    parser.add_argument("--output",     default=OUTPUT_PATH)
+    args = parser.parse_args()
+
+    import os
+    os.makedirs(os.path.dirname(args.output), exist_ok=True)
+    main(args.collection, args.output)

webapp/tipitaka-api/download_assets.py

@@ -20,6 +20,7 @@ DB_PATH = Path(settings.DATABASE_PATH)
 QDRANT_DIR = Path(settings.QDRANT_PATH)
 SNAPSHOT_DIR = Path(settings.SNAPSHOT_DIR)
 MODELS_DIR = Path(__file__).resolve().parent / "models"
+TV_PATH = Path(settings.DATA_DIR) / "tipitaka_chunks.tvim"
 
 BUCKET_ID = "dhammawatthumpra/tipitaka-storage"
 RERANK_REPO_ID = "jinaai/jina-reranker-v2-base-multilingual"
@@ -48,10 +49,22 @@ def check_file_exists(path: Path) -> bool:
 
 def download_files() -> None:
     """Download missing files from HF bucket."""
+    import shutil
     hf_token = os.getenv("HF_TOKEN", "")
     from huggingface_hub import hf_hub_download
     
-    # 1. Download Core Assets (DB & Snapshots)
+    # Check and handle Turbovec index file
+    if not check_file_exists(TV_PATH):
+        packaged_tv = Path(__file__).resolve().parent / "data" / "tipitaka_chunks.tvim"
+        if check_file_exists(packaged_tv):
+            print(f"Copying packaged Turbovec index: {packaged_tv} -> {TV_PATH}")
+            TV_PATH.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy(packaged_tv, TV_PATH)
+        else:
+            # Fallback: add to bucket files so it attempts downloading from HF Space bucket
+            BUCKET_FILES.append(("tipitaka_chunks.tvim", str(TV_PATH)))
+            
+    # 1. Download Core Assets (DB, Snapshots, and optionally Turbovec index)
     pending_core = []
     for remote, local_path_str in BUCKET_FILES:
         local_path = Path(local_path_str)
@@ -73,7 +86,6 @@ def download_files() -> None:
                         repo_type="dataset",
                         token=hf_token
                     )
-                    import shutil
                     shutil.copy(downloaded, dest_path)
                 except Exception as e:
                     print(f"FAILED to download {remote}: {e}")
@@ -98,7 +110,6 @@ def download_files() -> None:
                     filename=filename,
                     token=hf_token if hf_token else None
                 )
-                import shutil
                 shutil.copy(downloaded, dest_path)
             except Exception as e:
                 print(f"FAILED to download reranker file {filename}: {e}")
@@ -110,6 +121,9 @@ def verify_assets() -> bool:
     if not DB_PATH.exists():
         missing.append("tipitaka_mcu.db")
     
+    if not TV_PATH.exists():
+        missing.append("tipitaka_chunks.tvim")
+        
     if not (QDRANT_DIR / "meta.json").exists():
         missing.append("qdrant_storage/meta.json")
         

webapp/tipitaka-api/requirements.txt

@@ -17,3 +17,5 @@ anyio>=4.0.0
 pytest>=8.0
 pytest-asyncio>=0.24
 accelerate>=0.27.0
+turbovec>=0.5.3
+

webapp/tipitaka-api/test_rag_query.py

@@ -18,7 +18,7 @@ async def test_retrieval():
     logger.info("Initializing RAGService...")
     service = RAGService()
     
-    logger.info(f"Target collection is: {service.actual_chunks_col}")
+    logger.info(f"Target turbovec index is: {service._tv_path}")
     
     queries = [
         "พระสุทินเสพเมถุนธรรมกับอดีตภรรยา 3 ครั้ง เพราะยังไม่มีสิกขาบท",

webapp/tipitaka-api/tests/test_rag_service.py

@@ -14,9 +14,9 @@ class TestEmbeddingCache:
         from app.services.rag_service import RAGService
         with patch.object(RAGService, '_load_model'), \
              patch.object(RAGService, '_load_reranker'), \
-             patch.object(RAGService, '_init_qdrant'):
+             patch.object(RAGService, '_init_turbovec'):
             service = RAGService()
-            service.client = MagicMock()
+            service.tv_index = MagicMock()
             return service
 
     def test_cache_initialized(self, rag_service):
@@ -48,12 +48,13 @@ class TestEmbeddingCache:
 
 
 class TestRAGServiceInit:
-    def test_init_graceful_on_qdrant_failure(self):
-        """RAGService constructor should not crash when Qdrant is unavailable."""
+    def test_init_graceful_on_turbovec_failure(self):
+        """RAGService constructor should not crash when turbovec is unavailable."""
         from app.services.rag_service import RAGService
         with patch.object(RAGService, '_load_model'), \
              patch.object(RAGService, '_load_reranker'), \
-             patch.object(RAGService, '_init_qdrant') as mock_init:
+             patch.object(RAGService, '_init_turbovec') as mock_init:
             service = RAGService()
             mock_init.assert_called_once()
-            assert service.client is None  # _init_qdrant didn't set it
+            assert service.tv_index is None  # _init_turbovec didn't set it
+

webapp/tipitaka-web/src/components/layout/ReaderPanel.tsx

@@ -230,103 +230,105 @@ const ReaderPanel: React.FC = () => {
         />
       </ErrorBoundary>
       <div className="max-w-3xl mx-auto px-4 py-10 lg:py-16">
-        <AnimatePresence custom={direction} mode="wait">
-          {loading ? (
-            <motion.div
-              key="loading"
-              initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
-              className="flex flex-col items-center justify-center py-48 gap-4"
-            >
-              <div className="w-10 h-10 border-4 border-[#c8860a]/20 border-t-[#c8860a] rounded-full animate-spin" />
-              <p className="text-[#c8860a] text-sm animate-pulse">กำลังอัญเชิญข้อความ…</p>
-            </motion.div>
+        {loading && (
+          <div className="flex flex-col items-center justify-center py-48 gap-4">
+            <div className="w-10 h-10 border-4 border-[#c8860a]/20 border-t-[#c8860a] rounded-full animate-spin" />
+            <p className="text-[#c8860a] text-sm animate-pulse">กำลังอัญเชิญข้อความ…</p>
+          </div>
+        )}
 
-          ) : content ? (
-            <motion.article
-              key={`${currentVolume}-${currentPage}`}
-              custom={direction}
-              variants={articleVariants}
-              initial="enter"
-              animate="center"
-              exit="exit"
-              transition={{ duration: 0.35, ease: 'easeOut' }}
-              className={`rounded-xl p-8 lg:p-12 ${readerCls}`}
-              onClick={handleArticleClick}
-            >
-              {currentPage === 1 || content?.page_number === 1 ? (
-                renderFirstPage(
-                  content.content_html_formatted || content.content_html || '',
-                  fontSize,
-                  content.title || ''
-                )
-              ) : (
-                <>
-                  <header className="mb-4 pb-0">
-                    <p className="text-xs text-[#888] tracking-widest uppercase leading-relaxed">
-                      {content.title}
-                    </p>
-                    {content.sections?.filter((s: {level: number}) => s.level === 0).map((sec: {title: string}, i: number) => (
-                      <p key={`l0-${i}`} className="text-xs text-[#888] tracking-widest uppercase leading-relaxed">
-                        {sec.title}
-                      </p>
-                    ))}
-                    {content.sections?.filter((s: {level: number}) => s.level === 1).map((sec: {title: string}, i: number) => (
-                      <p key={`l1-${i}`} className="text-sm text-[#888] tracking-widest uppercase leading-relaxed">
-                        {sec.title}
+        {!loading && (
+          <AnimatePresence custom={direction} mode="popLayout">
+            {content ? (
+              <motion.article
+                key={`${currentVolume}-${currentPage}`}
+                custom={direction}
+                variants={articleVariants}
+                initial="enter"
+                animate="center"
+                exit="exit"
+                transition={{ duration: 0.35, ease: 'easeOut' }}
+                className={`rounded-xl p-8 lg:p-12 ${readerCls}`}
+                onClick={handleArticleClick}
+              >
+                {currentPage === 1 || content?.page_number === 1 ? (
+                  renderFirstPage(
+                    content.content_html_formatted || content.content_html || '',
+                    fontSize,
+                    content.title || ''
+                  )
+                ) : (
+                  <>
+                    <header className="mb-4 pb-0">
+                      <p className="text-xs text-[#888] tracking-widest uppercase leading-relaxed">
+                        {content.title}
                       </p>
-                    ))}
-                  </header>
-                  <div className="border-b border-[#c8860a]/15 mb-5" />
-                  {renderContent(content.content_html_formatted || content.content_html || '', fontSize, content.end_markers || [])}
-                </>
-              )}
+                      {content.sections?.filter((s: {level: number}) => s.level === 0).map((sec: {title: string}, i: number) => (
+                        <p key={`l0-${i}`} className="text-xs text-[#888] tracking-widest uppercase leading-relaxed">
+                          {sec.title}
+                        </p>
+                      ))}
+                      {content.sections?.filter((s: {level: number}) => s.level === 1).map((sec: {title: string}, i: number) => (
+                        <p key={`l1-${i}`} className="text-sm text-[#888] tracking-widest uppercase leading-relaxed">
+                          {sec.title}
+                        </p>
+                      ))}
+                    </header>
+                    <div className="border-b border-[#c8860a]/15 mb-5" />
+                    {renderContent(content.content_html_formatted || content.content_html || '', fontSize, content.end_markers || [])}
+                  </>
+                )}
 
-              {/* Footnotes Section */}
-              {content.footnotes && content.footnotes.length > 0 && (
-                <div className="mt-16 pt-8 border-t border-[#c8860a]/20">
-                  <h5 className="text-[#c8860a] text-xs font-bold tracking-widest uppercase mb-6 flex items-center gap-2">
-                    <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
-                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M16 4v12l-4-2-4 2V4M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z" />
-                    </svg>
-                    เชิงอรรถ
-                  </h5>
-                  <div className="space-y-4">
-                    {content.footnotes.map((fn: any, idx: number) => {
-                      const cleanId = fn.id.replace(/[()\[\]-]/g, '').trim();
-                      return (
-                        <div 
-                          key={idx} 
-                          id={`fn-item-${cleanId}`}
-                          className={`flex gap-3 text-[13px] leading-relaxed ${mutedCls} hover:opacity-100 transition-all p-2 -m-2 rounded-lg cursor-pointer group`}
-                          onClick={() => scrollToElement(`ref-${cleanId}`)}
-                          title="คลิกเพื่อกลับไปยังเนื้อหา"
-                        >
-                          <span className="text-[#c8860a] font-bold min-w-[24px] text-right shrink-0 group-hover:scale-110 transition-transform">{fn.id}</span>
-                          <span className="font-light">{fn.content}</span>
-                        </div>
-                      );
-                    })}
+                {/* Footnotes Section */}
+                {content.footnotes && content.footnotes.length > 0 && (
+                  <div className="mt-16 pt-8 border-t border-[#c8860a]/20">
+                    <h5 className="text-[#c8860a] text-xs font-bold tracking-widest uppercase mb-6 flex items-center gap-2">
+                      <svg className="w-3.5 h-3.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M16 4v12l-4-2-4 2V4M6 20h12a2 2 0 002-2V6a2 2 0 00-2-2H6a2 2 0 00-2 2v12a2 2 0 002 2z" />
+                      </svg>
+                      เชิงอรรถ
+                    </h5>
+                    <div className="space-y-4">
+                      {content.footnotes.map((fn: any, idx: number) => {
+                        const cleanId = fn.id.replace(/[()\[\]-]/g, '').trim();
+                        return (
+                          <div 
+                            key={idx} 
+                            id={`fn-item-${cleanId}`}
+                            className={`flex gap-3 text-[13px] leading-relaxed ${mutedCls} hover:opacity-100 transition-all p-2 -m-2 rounded-lg cursor-pointer group`}
+                            onClick={() => scrollToElement(`ref-${cleanId}`)}
+                            title="คลิกเพื่อกลับไปยังเนื้อหา"
+                          >
+                            <span className="text-[#c8860a] font-bold min-w-[24px] text-right shrink-0 group-hover:scale-110 transition-transform">{fn.id}</span>
+                            <span className="font-light">{fn.content}</span>
+                          </div>
+                        );
+                      })}
+                    </div>
                   </div>
-                </div>
-              )}
-
-              <footer className="mt-12 pt-6 border-t border-[#888]/10 text-center">
-                <span className="text-xs text-[#888]">
-                  — เล่ม {currentVolume} หน้า {currentPage} —
-                </span>
-              </footer>
-            </motion.article>
+                )}
 
-          ) : (
-            <div className="text-center py-40 text-[#888]">
-              <div className="text-5xl mb-6 opacity-40">📖</div>
-              <p className="text-lg">ยังไม่ได้เลือกข้อความ</p>
-              <p className="text-sm mt-2 opacity-60">
-                เลือกเล่มจากสารบัญ หรือค้นหาคำในพระไตรปิฎก
-              </p>
-            </div>
-          )}
-        </AnimatePresence>
+                <footer className="mt-12 pt-6 border-t border-[#888]/10 text-center">
+                  <span className="text-xs text-[#888]">
+                    — เล่ม {currentVolume} หน้า {currentPage} —
+                  </span>
+                </footer>
+              </motion.article>
+            ) : (
+              <motion.div
+                key="empty"
+                initial={{ opacity: 0 }} animate={{ opacity: 1 }} exit={{ opacity: 0 }}
+                className="text-center py-40 text-[#888]"
+              >
+                <div className="text-5xl mb-6 opacity-40">📖</div>
+                <p className="text-lg">ยังไม่ได้เลือกข้อความ</p>
+                <p className="text-sm mt-2 opacity-60">
+                  เลือกเล่มจากสารบัญ หรือค้นหาคำในพระไตรปิฎก
+                </p>
+              </motion.div>
+            )}
+          </AnimatePresence>
+        )}
       </div>
     </div>
   );