docs: add Turbovec-specific architecture and tech stack documents

SEARCH_ARCHITECTURE_TURBOVEC.md

@@ -0,0 +1,263 @@
+# 📖 Search Architecture Specification (Turbovec Edition)
+## Next-Gen Hybrid Search for Tipitaka Web Application
+
+> **Version:** 3.5.0 (Turbovec Edition)
+> **Updated:** 2026-05-26
+> **Status:** Revised — ใช้ Turbovec เป็น Vector Search Engine หลัก และเพิ่ม SQLite Content Enrichment ใน RAG pipeline
+
+เอกสารนี้ระบุการออกแบบสถาปัตยกรรมการค้นหา V3 ที่ถูกปรับปรุงเพื่อใช้งาน **Turbovec** (In-process Vector Search) แทน Qdrant โดยรวมเข้ากับ Query Understanding ด้วย Local LLM (Qwen2.5-0.5B-Instruct / Qwen3.5-0.8B) และ FTS5 + ONNX Reranker เพื่อความรวดเร็วและน้ำหนักที่เบาที่สุดบน Hugging Face Space
+
+---
+
+## 0. Model Name Reference & Comparison
+
+| Model Role | Platform | ชื่อ model ที่ถูกต้อง | พารามิเตอร์ | จุดเด่น / การใช้งาน |
+|------------|----------|----------------------|------------|-------------------|
+| **Default** (Recommended) | HuggingFace | `Qwen/Qwen2.5-0.5B-Instruct` | 0.5B | โหลดเร็วมาก กินแรมต่ำสุด (~1GB ใน FP32) เหมาะกับ CPU Basic |
+| | Ollama | `qwen2.5:0.5b` | 0.5B | รันในเครื่องได้รวดเร็วมาก |
+| **Alternative** (Comparison) | HuggingFace | `Qwen/Qwen3.5-0.8B` | 0.8B | ตอบโครงสร้างลึกได้ดีกว่าเล็กน้อย แต่ใช้แรม ~1.6GB ใน FP32 และช้ากว่า |
+| | Ollama | `qwen3.5:0.8b` | 0.8B | รันผ่าน Ollama daemon |
+
+---
+
+## 1. System Dataflow
+
+```
+[ User Natural Query (ภาษาพูด) ]
+               │
+               ▼
+   [ 1. Query Transformation ]  ◄── SQLite Query Cache (exact match)
+   Qwen2.5-0.5B-Instruct (Default) / Qwen3.5-0.8B (Alternative)
+   Local: via Ollama HTTP API
+   HF Space: via Transformers (Preloaded on startup)
+   Output: {"fts_queries": [...], "vector_queries": [...]}
+               │
+               ▼ (Fallback: original query)
+               │
+               ├─────────────────────────────────────────┐
+               ▼ asyncio.gather (parallel)               ▼
+   [ 2A. Lexical Search (FTS5) ]           [ 2B. Semantic Search (Turbovec) ]
+   SQLite pages_fts (Prefix matching)       jina-embeddings-v5 (1024d)
+   e.g. "ธัมมทินนา"*                         Turbovec IdMapIndex batch search
+   asyncio.gather(*fts_tasks)               tv_index.search(stacked_vectors)
+               │                                         │
+               └──────────────────┬──────────────────────┘
+                                  ▼
+                       [ 3. RRF Score Fusion ]
+                       Deduplicate: (volume_id, page_number)
+                       RRF(d) = Σ 1/(k=60 + rank)
+                       Top 15 candidates
+                                  │
+                                  ▼
+                [ 3.5 SQLite Content Enrichment ] ◄── ดึงเนื้อหาจาก pages_db
+                (เติมเนื้อหาฉบับเต็มลงใน payload ของ vector candidates ที่ไม่มีข้อความ)
+                                  │
+                                  ▼
+                       [ 4. ONNX Reranking ]
+                       jina-reranker-v2-base-multilingual (max_length=256)
+                       Re-score vs original user query
+                                  │
+                                  ▼
+                    [ 5. Post-Process & Highlight ]
+                    Highlight keywords จาก fts_queries
+                                  │
+               ┌──────────────────┴──────────────────┐
+               ▼                                     ▼
+        [ UI Search Page ]                 [ AI Assistant (RAG) ]
+     (Paginated Reader Links)           (DeepSeek / Gemma Generation)
+```
+
+---
+
+## 2. Layer Specifications
+
+### Layer 1: Query Transformation — Dual Runtime & Model Comparison
+*(เหมือนรุ่น V3.4.0 — ใช้ Qwen ในการแปลงข้อความภาษาพูดให้กลายเป็น FTS และ Vector query)*
+
+### Layer 2: Parallel Retrieval (FTS5 & Turbovec)
+- FTS5 และ Vector Search ทำงานแบบขนานผ่าน `asyncio.gather`
+- **FTS5**: ค้นหาคีย์เวิร์ดในตารางเสมือน `pages_fts`
+- **Turbovec (Vector)**: ทำการแปลงคิวรีเป็นเวกเตอร์ 1024 มิติ จากนั้นส่งแบบกลุ่ม (Batch) โดย Stack เวกเตอร์เป็น NumPy Array ไปยัง `tv_index.search(vecs, k=limit)` การประมวลผลเกิดขึ้นในหน่วยความจำของ Process Python ทันที ไม่มี overhead จาก Network หรือ Client-Server serialization
+
+### Layer 3: RRF Score Fusion & SQLite Enrichment
+- หลังจากรวมคะแนนด้วย Reciprocal Rank Fusion (RRF) และกรองผู้เข้ารอบสูงสุด (เช่น Top 15)
+- **SQLite Content Enrichment (ขั้นตอนสำคัญ)**: เนื่องจากดัชนี Turbovec (`.tvim`) เก็บเพียง ID ตัวเลขและค่าคะแนนเพื่อประหยัดแรมและลดขนาดไฟล์ เราจึงจำเป็นต้องทำการ Lazy Load ข้อความตัวเต็ม (`content_text`) ของผลลัพธ์เวกเตอร์ โดยเปิด Transaction ไปสืบค้นกับ SQLite In-memory อย่างรวดเร็วก่อนนำข้อมูลไปประมวลผลต่อ
+
+### Layer 4: ONNX Reranking
+- นำคู่คิวรีต้นฉบับของผู้ใช้และข้อความจากขั้นตอน Enrichment มา Rerank คะแนนใหม่ด้วย `jina-reranker-v2-base-multilingual` รันบน ONNX CPU ด้วยความยาว Tokenizer สูงสุด `max_length=256`
+
+---
+
+## 3. RAM Budget Comparison
+
+ด้วยการสลับจาก Qdrant มาใช้ Turbovec ทำให้ประหยัด RAM ได้มหาศาลเนื่องจากไม่ต้องมี Qdrant process รันค้าง
+
+### Local (RTX Laptop / PC Dev)
+
+| Component | RAM (Qdrant Backend) | RAM (Turbovec Backend) |
+|-----------|--------------------|-----------------------|
+| SQLite in-memory | ~238 MB | ~238 MB |
+| Vector Engine | **~1.2–1.5 GB** (Qdrant Embedded) | **~14 MB** (Turbovec Index) |
+| Jina-v5 (ST in-process) | ~1.2 GB | ~1.2 GB |
+| ONNX Reranker | ~500 MB | ~500 MB |
+| Qwen LLM (Ollama) | ~0.5 GB | ~0.5 GB |
+| FastAPI + Python overhead | ~300 MB | ~300 MB |
+| **รวม** | **~3.9–4.2 GB** | **~2.7–3.0 GB** ✅ |
+
+### HF Space (CPU Basic = 16GB)
+
+| Component | RAM (Qdrant Backend) | RAM (Turbovec Backend) |
+|-----------|--------------------|-----------------------|
+| SQLite in-memory | ~238 MB | ~238 MB |
+| Vector Engine | **~1.2–1.5 GB** (Qdrant Embedded) | **~14 MB** (Turbovec Index) |
+| Jina-v5 (ST in-process) | ~1.2 GB | ~1.2 GB |
+| ONNX Reranker | ~500 MB | ~500 MB |
+| Qwen LLM (in-process, FP32) | ~1.0 GB | ~1.0 GB |
+| FastAPI + Python + Ubuntu OS | ~800 MB | ~800 MB |
+| **รวม** | **~5.0–5.2 GB** | **~3.5–3.7 GB** ✅ |
+| **Headroom ที่เหลือ** | **~10.8 GB** | **~12.3 GB** ✅ |
+
+---
+
+## 4. Latency & Performance Profile
+
+จากการรัน Benchmark เปรียบเทียบความเร็วระหว่างการสืบค้นเวกเตอร์ด้วย Random Queries (k=30, 100 queries) พบว่า Turbovec มีประสิทธิภาพเหนือกว่าอย่างก้าวกระโดด:
+
+| Metric | Turbovec (4-bit SQ) | Qdrant Local Server |
+|--------|---------------------|---------------------|
+| **Average Latency (Mean)** | **1.425 ms** | **19.418 ms** (ช้ากว่า ~13.5 เท่า) |
+| **Median (p50)** | **1.353 ms** | **18.724 ms** |
+| **90th Percentile** | **1.621 ms** | **23.115 ms** |
+| **Throughput (QPS)** | **701.7 queries/sec** | **51.5 queries/sec** (ต่ำกว่า ~13.6 เท่า) |
+| **Disk Storage** | **13.2 MB** (`.tvim` file) | **~600+ MB** (snapshots/data) |
+| **RAM Idle Overhead** | **~14 MB** | **~150–300 MB** (Docker Server) |
+
+---
+
+## 5. Implementation Blueprint
+
+### 5.1 SearchService Implementation (Batch Search & SQLite Enrichment)
+
+```python
+# app/services/search_service.py
+import asyncio
+from typing import List
+import numpy as np
+import anyio
+from app.database.sqlite_db import get_db
+
+class SearchService:
+    def __init__(self, db, rag_service=None, query_transform_service=None):
+        self.db = db
+        self.rag_service = rag_service
+        self.qts = query_transform_service
+
+    async def search_hybrid(self, query: str, limit: int = 10, offset: int = 0) -> dict:
+        # 1. Transform query (มี Cache ป้องกันการยิง LLM ซ้ำ)
+        transformed = await self.qts.transform(query)
+        fts_queries = transformed["fts_queries"]
+        vector_queries = transformed["vector_queries"]
+
+        # 2. ค้นหา FTS5 และ Vector คู่ขนานกันจริงๆ
+        fts_tasks = [self._get_fts_results(fq) for fq in fts_queries]
+        vector_tasks = [self._get_vector_batch_results(vector_queries, limit=30)]
+
+        # รันงานทั้งหมดแบบขนาน
+        fts_results_list, [vector_results_list] = await asyncio.gather(
+            asyncio.gather(*fts_tasks),
+            vector_tasks
+        )
+
+        # 3. รวมคะแนนด้วย RRF (Reciprocal Rank Fusion)
+        rrf_scores, candidate_data = {}, {}
+        k = 60
+
+        for results in fts_results_list:
+            for rank, item in enumerate(results):
+                key = (item["volume_id"], item["page_number"])
+                rrf_scores[key] = rrf_scores.get(key, 0.0) + 1.0 / (k + rank + 1)
+                candidate_data.setdefault(key, item)
+
+        for results in vector_results_list:
+            for rank, item in enumerate(results):
+                key = (item["volume_id"], item["page_number"])
+                rrf_scores[key] = rrf_scores.get(key, 0.0) + 1.0 / (k + rank + 1)
+                candidate_data.setdefault(key, item)
+
+        # คัดกรองผู้เข้ารอบ 15 อันดับแรกเพื่อส่งให้ Reranker
+        top_keys = sorted(rrf_scores, key=rrf_scores.get, reverse=True)[:15]
+        top_candidates = [candidate_data[ky] for ky in top_keys]
+
+        # 3.5 SQLite Content Enrichment (เติมข้อความเต็มที่ไม่มีในเวกเตอร์ดัชนี)
+        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:
+                            # ป้องกันปัญหารับค่า float/int จาก SQLite
+                            c["content_text"] = row["content_text"]
+            except Exception as e:
+                import logging
+                logging.getLogger(__name__).warning(f"Enriching candidates content failed: {e}")
+
+        # 4. Reranking ด้วยโมเดล ONNX Reranker กับประโยคคำถามเดิม
+        if top_candidates and self.rag_service and self.rag_service.reranker and self.rag_service.reranker != "error":
+            final_results = await self._rerank_candidates(query, top_candidates)
+        else:
+            final_results = top_candidates
+
+        # 5. จัดรูปแบบและทำ Highlight คีย์เวิร์ด
+        return self._format_response(final_results, limit, offset, fts_queries)
+
+    async def _get_vector_batch_results(self, query_texts: List[str], limit: int = 30) -> List[List[dict]]:
+        """ทำ Batch Search บน Turbovec โดยประมวลผลรวดเดียว"""
+        if not self.rag_service or not self.rag_service.tv_index or not query_texts:
+            return [[] for _ in query_texts]
+
+        tv = self.rag_service.tv_index
+
+        def _blocking():
+            # 1. แปลงคำค้นทั้งหมดเป็นเวกเตอร์
+            query_vectors = []
+            valid_indices = []
+            for idx, text in enumerate(query_texts):
+                vec = self.rag_service._get_embedding(text)
+                if vec:
+                    query_vectors.append(vec)
+                    valid_indices.append(idx)
+
+            if not query_vectors:
+                return [[] for _ in query_texts]
+
+            # 2. ซ้อน NumPy Array เพื่อทำค้นหาแบบกลุ่มใน Turbovec
+            vecs = np.array(query_vectors, 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
+                    # ถอดรหัส ID: UID = volume * 100,000 + page
+                    # และแปลงเป็น int ป้องกันปัญหา numpy.uint64 ใน SQLite
+                    vol = int(uid) // 100_000
+                    page = int(uid) % 100_000
+                    vec_results.append({
+                        "volume_id": int(vol),
+                        "page_number": int(page),
+                        "content_text": "",   # โหลดภายหลังในขั้นตอน Enrichment
+                        "score": float(score)
+                    })
+                final_results[req_idx] = vec_results
+            return final_results
+
+        return await anyio.to_thread.run_sync(_blocking)
+```

TIPITAKA_WEB_ARCHITECTURE_TURBOVEC.md

@@ -0,0 +1,373 @@
+# Tipitaka Web Application Architecture (Turbovec Edition)
+## Vite + FastAPI + Turbovec — "Book Sanctuary + Floating AI Consultant"
+
+> **Version:** 2.5.0 (Turbovec Edition)
+> **Date:** 2026-05-26
+> **Status:** Production (local dev & HF Spaces using Turbovec backend)
+> **Based on:** Code at commit `603ead8`
+
+---
+
+## 1. Executive Summary
+
+### 1.1 Vision
+Web Application สำหรับอ่านพระไตรปิฎก มจร. ที่ให้ประสบการณ์การอ่านแบบจิตวิเวก โดยมี AI เป็นผู้ช่วยลอยตัวที่ไม่รบกวนสมาธิ และใช้ Vector Backend ประสิทธิภาพสูงที่ทำงานแบบ In-process (ไม่ต้องใช้ Server แยก) เพื่อความรวดเร็วสูงสุดและประหยัดทรัพยากรบน CPU Basic Free Tier
+
+### 1.2 Key Changes
+
+#### V2.5.0 (2026-05-26) - Turbovec Edition
+
+| Layer | V2.4.0 (Qdrant) | V2.5.0 (Turbovec) |
+|-------|-----------------|-------------------|
+| **Vector Backend** | Qdrant (Embedded snapshot / Server) | **Turbovec IdMapIndex** — In-process vector index file (`tipitaka_chunks.tvim` 4-bit SQ) |
+| **Search Speed** | ~19.42 ms (Qdrant Server queries) | **~1.43 ms** — ~13.5x faster local search latency |
+| **RAM Footprint** | ~1.2–1.5 GB (Qdrant process) | **~14 MB** — run in-process within Python runtime |
+| **Index Size** | ~600+ MB (Snapshots & storage) | **13.2 MB** — quantized using 4-bit scalar quantization |
+| **Database Enrichment**| Vector payload returned by Qdrant | **Dynamic SQLite Lookup** — content fetched from `pages` using decoded volume & page IDs |
+| **Mobile Stability** | Framer Motion layout freezes on swipe | **`mode="popLayout"`** & standalone loading spinner outside of `AnimatePresence` |
+| **ID casting** | Int / string uuid | **Native Python `int()` casting** — prevents `numpy.uint64` being treated as SQL binary BLOB |
+| **Commit** | `f11cd44` | `603ead8` |
+
+---
+
+### 1.3 Tech Stack
+
+```
+┌──────────────────────────────────────────────────────────────────┐
+│                     CLIENT (Browser)                             │
+│  ┌────────────────────────────────────────────────────────────┐ │
+│  │  Vite 6 + React 18 + TypeScript 5                          │ │
+│  │  Tailwind CSS v4 + @tailwindcss/typography                 │ │
+│  │  Framer Motion (animations) + Zustand (state)              │ │
+│  │  Lucide React (icons) + React Markdown + remark-gfm        │ │
+│  └────────────────────────────────────────────────────────────┘ │
+└──────────────────────────┬───────────────────────────────────────┘
+                           │ HTTP / SSE Streaming
+┌──────────────────────────┴───────────────────────────────────────┐
+│                     SERVER (FastAPI Python 3.13)                 │
+│                                                                  │
+│  ┌──────────┐  ┌──────────┐  ┌──────────────┐  ┌────────────┐  │
+│  │ FastAPI  │  │ Local    │  │ Turbovec     │  │ Embedding  │  │
+│  │ Routes   │──│ Services │──│ (In-process) │──│ Provider   │  │
+│  │          │  │          │  │ Index (.tvim)│  └────────────┘  │
+│  └──────────┘  └──────────┘  └──────────────┘  ┌────────────┐  │
+│       │              │                         │ SQLite     │  │
+│       │              ├── SQLite FTS5 ──────────│ (tipitaka) │  │
+│       │              ├── ONNX Reranker (CPU)   └────────────┘  │
+│       │              └── DeepSeek API (streaming)              │
+│       └── Static files (Served Vite build in production)        │
+└──────────────────────────────────────────────────────────────────┘
+```
+
+**Embedding Providers:**
+- **Ollama** (local dev): `jina-embeddings-v5-small-retrieval` GGUF Q6_K (596MB)
+- **sentence-transformers** (HF Space / fallback): `jinaai/jina-embeddings-v5-text-small-retrieval` PyTorch
+- Both produce 1024-dims vectors (`EMBED_DIMS = 1024`)
+
+---
+
+## 2. System Architecture
+
+### 2.1 High-Level Component Diagram
+
+```mermaid
+graph TB
+    subgraph "Client Layer (Vite + React)"
+        UI[User Interface]
+        subgraph "Core Components"
+            APP[AppShell<br/>flex h-screen layout]
+            ND[NavDrawer<br/>320px sidebar]
+            RP[ReaderPanel<br/>Main reading area]
+            RT[RightToolbar<br/>44px controls strip]
+            AIP[AIPopup<br/>Draggable + resizable chat]
+            SP[SelectionPopup<br/>AI from selection]
+            AIF[AIFloatingMenu<br/>Speed Dial Menu]
+        end
+        subgraph "State (Zustand)"
+            RS[ReaderStore<br/>volume, page, content]
+            TS[ThemeStore<br/>theme, fontSize]
+            US[UIStore<br/>navOpen, activeTab]
+            AS[AIStore<br/>messages, mode, useRag, viewMode, width, height, pos]
+            SS[SearchStore<br/>query, results, breakdown]
+        end
+    end
+
+    subgraph "API Layer (FastAPI)"
+        subgraph "Routers"
+            R1[GET /api/pages/volumes]
+            R2[GET /api/pages/volumes/{id}/toc]
+            R3[GET /api/pages/{vol}/{page}]
+            R4[GET /api/search?q=...]
+            R5[GET /api/search/suggestions]
+            R6[POST /api/ask/stream (SSE)]
+            R7[POST /api/ask (non-stream)]
+            R8[GET /api/ask/rag-status]
+            R9[GET /health]
+        end
+        subgraph "Services"
+            S1[PageService<br/>SQLite queries]
+            S2[SearchService<br/>FTS5 + LIKE fallback]
+            S3[PaliUtils<br/>autocorrect pipeline]
+            S4[RAGService<br/>Turbovec + Embedding + Reranker]
+            S5[LLMService<br/>DeepSeek streaming]
+            S6[ONNXReranker<br/>jina-reranker-v2]
+        end
+        subgraph "Data"
+            DB[(SQLite<br/>tipitaka_mcu.db)]
+            VDB[(Turbovec Index<br/>tipitaka_chunks.tvim)]
+        end
+    end
+
+    UI --> APP
+    APP --> ND & RP & RT & AIP & SP & AIF
+    RP --> RS
+    ND --> SS & US
+    RT --> TS & RS
+    AIP --> AS
+    AIF --> AS
+    R1 & R2 & R3 --> S1 --> DB
+    R4 & R5 --> S2 --> DB
+    R4 --> S3
+    R6 & R7 --> S5
+    S5 --> S4 --> VDB
+    S4 --> DB
+    S5 --> DS[(DeepSeek API)]
+    S4 --> EMB[(Embedding<br/>Ollama v5 / ST fallback)]
+    S4 --> RER[(ONNX Reranker)]
+```
+
+### 2.2 Data Flow — Hybrid Search (RAG)
+
+```mermaid
+sequenceDiagram
+    actor User
+    participant Browser
+    participant API as FastAPI
+    participant TV as Turbovec Index
+    participant DB as SQLite (tipitaka_mcu.db)
+    participant EMB as Embedding
+    participant ONNX as ONNX Reranker
+    participant LLM as DeepSeek API
+
+    User->>Browser: ถาม AI (RAG ON)
+    Browser->>API: POST /api/ask/stream {question, use_rag:true}
+
+    par Phase 1: FTS5
+        API->>DB: MATCH query (30 results)
+        DB-->>API: FTS rows + rank
+    and Phase 2: Vector (Turbovec)
+        API->>EMB: query_embedding()
+        alt Ollama available
+            EMB->>OLL: jina-embeddings-v5 GGUF
+            OLL-->>EMB: 1024-dims vector
+        else Fallback
+            EMB->>ST: sentence-transformers PyTorch
+            ST-->>EMB: 1024-dims vector
+        end
+        EMB-->>API: embedding vector
+        API->>TV: tv_index.search(vector, k=30)
+        TV-->>API: scores & ids (volume*100000+page)
+    end
+
+    API->>API: Decode UIDs to vol & page (cast to native int)
+    API->>DB: Enrich payload (Fetch content_text by vol & page)
+    DB-->>API: Content text for missing vector payloads
+
+    API->>API: Merge & deduplicate by (vol, page)
+    API->>ONNX: Rerank candidates
+    ONNX-->>API: Reordered scores
+
+    API->>LLM: context + question (streaming)
+    LLM-->>API: SSE chunks
+    API-->>Browser: data: {chunk: "..."}
+```
+
+### 2.3 Data Flow — Search
+
+```mermaid
+sequenceDiagram
+    actor User
+    participant Browser
+    participant API as FastAPI
+    participant DB as SQLite
+
+    User->>Browser: พิมพ์คำค้น
+    Browser->>Browser: Debounce 280ms → fetchSuggestions
+    Browser->>API: GET /api/search/suggestions?q=...
+    API->>DB: search_log LIKE + POPULAR_TERMS
+    DB-->>API: Suggestions
+    API-->>Browser: ["อริยสัจ", "อริยสัจ 4", ...]
+
+    User->>Browser: Enter
+    Browser->>API: GET /api/search?q=อริยสัจ&limit=50
+
+    par FTS5
+        API->>DB: pages_fts MATCH "อริยสัจ"
+    and LIKE Fallback
+        API->>DB: content_text LIKE '%อริยสัจ%'
+    end
+
+    API->>API: Pali autocorrect pipeline
+    API->>API: Merge & deduplicate
+    API->>API: Highlight <mark>
+    API-->>Browser: {total: 234, results: [...], breakdown: {...}}
+    Browser->>Browser: Render cards + volume bars
+
+    User->>Browser: คลิกผล → เล่ม 12 หน้า 45
+    Browser->>API: GET /api/pages/12/45
+    API-->>Browser: Page content
+```
+
+---
+
+## 3. Frontend Architecture
+
+### 3.1 Project Structure
+*(ยังคงโครงสร้างไฟล์เช่นเดิมตามสถาปัตยกรรม V2.4.0)*
+
+### 3.2 Key Components
+
+#### ReaderPanel (Updated for Mobile Stability)
+- การนำทางทีละหน้า (Page-by-page)
+- Render ข้อความโดยจัดชิดขอบซ้ายขวาอย่างสม่ำเสมอ (`text-justify: inter-character`)
+- **การแก้ไขบั๊กค้างบนมือถือ (Mobile Stability)**:
+  - แก้ไขปัญหาหน้าจอค้างสีขาวบนมือถือขณะปัดหน้า (swipe transitions)
+  - นำสถานะ `loading` spinner ออกนอก Framer Motion `AnimatePresence`
+  - ปรับการทำงานของ `AnimatePresence` ไปใช้ `mode="popLayout"` เพื่อให้สามารถนำทางและเลื่อนเปลี่ยนหน้าได้อย่างต่อเนื่องโดยที่ UI เก่าไม่ระงับการทำงานของ UI ใหม่
+
+#### AIFloatingMenu
+- ปุ่มวงกลม Sparkles/X ที่กางออกเป็น 5 คำสั่งย่อ (Speed Dial)
+- คำสั่ง 1-4 จะดึงเนื้อหาหน้าปัจจุบันเพื่อส่งไปให้ AI ประมวลผลด่วนในหน้าต่าง frosted-glass (Answer Card)
+- คำสั่ง 5 เปิดหน้าแชทหลัก (Chat viewMode)
+
+#### AIPopup
+- พาเนลลอยตัวสำหรับแชทกับ AI (รองรับการลาก drag และปรับขนาด resize และจดจำขนาดผ่าน localStorage)
+- รองรับมุมมอง 2 แบบ: `chat` (สนทนาต่อเนื่อง) และ `answer` (ตอบคำถามสั้นจาก Speed Dial)
+- แสดงคำเตือนกาลามสูตรใน Title Bar กลางหัวข้อเพื่อประหยัดพื้นที่แนวตั้ง
+
+---
+
+## 4. Backend Architecture
+
+### 4.1 Project Structure
+
+```
+tipitaka-api/
+├── app/
+│   ├── main.py               # FastAPI app + lifespan (background init)
+│   ├── config.py             # pydantic-settings
+│   ├── schemas.py            # Pydantic models
+│   │
+│   ├── routers/
+│   │   ├── pages.py           # /api/pages/*
+│   │   ├── search.py          # /api/search
+│   │   └── ai.py              # /api/ask
+│   │
+│   ├── services/
+│   │   ├── page_service.py    # Page retrieval & formatting
+│   │   ├── search_service.py  # FTS5 + LIKE + turbovec + rerank
+│   │   ├── pali_utils.py      # Autocorrect & Thai digit utilities
+│   │   ├── rag_service.py     # turbovec init + dual-mode embedding + rerank
+│   │   ├── llm_service.py     # DeepSeek streaming + context injection
+│   │   └── onnx_reranker.py   # jina-reranker-v2 ONNX CPU inference
+│   │
+│   └── database/
+│       └── sqlite_db.py       # SQLite connection & in-memory backup
+│
+├── models/
+│   └── jina-v2-onnx/          # ONNX reranker model files (~267MB)
+│
+├── tests/                     # Unit tests (35 tests - all passing)
+│
+├── download_assets.py         # Downloads DB & turbovec index from HF dataset
+├── startup.sh                 # HF Spaces entrypoint
+├── requirements.txt
+└── .env
+```
+
+### 4.2 API Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/pages/volumes` | รายการเล่มทั้งหมด |
+| GET | `/api/pages/volumes/{id}/toc` | สารบัญ |
+| GET | `/api/pages/{vol}/{page}` | เนื้อหาหน้าพร้อมข้อมูลเชิงอรรถ |
+| GET | `/api/search` | ค้นหาแบบไฮบริด (FTS5 + turbovec) และการทำไฮไลท์คำ |
+| GET | `/api/search/suggestions` | คำแนะนำการค้นหาประวัติตามความนิยม |
+| POST | `/api/ask/stream` | AI streaming (SSE) |
+| POST | `/api/ask` | AI non-streaming |
+| GET | `/api/ask/rag-status` | ตรวจสอบสถานะการเชื่อมต่อของดัชนี Turbovec |
+| GET | `/health` | ตรวจสอบความพร้อมของเซิร์ฟเวอร์ |
+
+### 4.3 Search Pipeline (SearchService)
+
+```
+query → Pali Autocorrect Pipeline
+      → แปลงอักษรเลขไทย/เลขสากล
+      ├─► FTS5 MATCH (pages_fts)
+      ├─► turbovec vector search
+      │     └─ stack numpy array -> batch query -> tv_index.search()
+      → RRF Score Fusion (Deduplicate & Merge)
+      → SQLite Content Enrichment (ดึงข้อความจาก pages สำหรับ vector results)
+      → ONNX Reranking (jina-reranker-v2 vs original query)
+      → Snippet & Highlight (<mark> tags)
+```
+
+### 4.4 RAG Pipeline (RAGService)
+- เมื่อมีข้อสงสัยธรรมะ RAGService จะทำการค้นหาข้อมูลอ้างอิงผ่าน FTS5 และ Turbovec (In-process) จากนั้นดึงข้อความเต็มจาก SQLite มาเติมลงใน Payload แล้วทำการ Rerank ก่อนส่งให้ DeepSeek API คัดเลือกคำตอบที่ดีที่สุด
+
+### 4.5 Database & Vector Index Details
+
+#### SQLite (tipitaka_mcu.db)
+- เก็บสารบัญ รายชื่อเล่ม และเนื้อหาพระไตรปิฎก 45 เล่ม (~238MB)
+- โหลดขึ้นสู่หน่วยความจำแบบ In-memory (`:memory:`) ตอนสตาร์ทอัป เพื่อดึงข้อความได้รวดเร็วที่สุดระดับไมโครวินาที
+- ใช้ virtual table FTS5 (`pages_fts`) ในการสืบค้นแบบ Lexical
+
+#### Turbovec Index
+- ไฟล์: `tipitaka_chunks.tvim` (~13.2 MB)
+- ใช้จัดเก็บเวกเตอร์ขนาด 1024 มิติ (จาก Jina Embedding v5) ที่ผ่านการทำ Quantization แบบ 4-bit SQ
+- ทำงานแบบ In-process โดยเรียกผ่านคลาส `IdMapIndex.load(self._tv_path)`
+- **ID Encoding**: เข้ารหัส ID เวกเตอร์เป็นเลขจำนวนเต็ม (Integer) ด้วยสูตร `UID = volume_id * 100000 + page_number` เพื่อไม่ต้องเก็บข้อมูล payload ซับซ้อนในตัวเวกเตอร์
+- **ID Casting Fix**: ผลลัพธ์ ID จากการค้นหา Turbovec จะมีชนิดข้อมูลเป็น `numpy.uint64` ซึ่งจำเป็นต้องแปลงเป็น native Python `int()` ก่อนนำไป Query ใน SQLite มิฉะนั้น `sqlite3` driver จะมองเป็น binary BLOB และไม่สามารถดึงข้อมูลเนื้อหาได้ (แสดงผลเป็นหน้าว่าง)
+
+---
+
+## 5. Dual-Mode Embedding System
+
+- ใช้ `jina-embeddings-v5-small-retrieval` (1024 มิติ) ทั้งในระบบพัฒนาท้องถิ่น (Local) และระบบคลาวด์ (HF Space)
+- **Local Dev**: ดึงเวกเตอร์ผ่าน Ollama API (`/api/embed` ด้วยรุ่น GGUF)
+- **Hugging Face Fallback**: ประมวลผลเวกเตอร์ใน Process ด้วยไลบรารี `sentence-transformers` ผ่านโมเดล PyTorch
+- **Cache**: ระบบเก็บเวกเตอร์ใน OrderedDict (LRU cache ขนาด 256 รายการ) ป้องกันการยิงประมวลผลซ้ำคำเดิม
+
+---
+
+## 6. Deployment
+
+### 6.1 Hugging Face Spaces
+- รันบน CPU Basic ฮาร์ดแวร์ฟรี (16GB RAM)
+- ในขั้นตอนสตาร์ทอัป สคริปต์ `download_assets.py` จะดาวน์โหลดไฟล์สำคัญจาก dataset `dhammawatthumpra/tipitaka-storage` ลงมาที่เครื่อง ได้แก่:
+  - `tipitaka_mcu.db` (SQLite)
+  - `tipitaka_chunks.tvim` (ดัชนี Turbovec)
+  - โมเดล ONNX Reranker
+- ด้วยการเปลี่ยนมาใช้ Turbovec ทำให้ไม่ต้องรัน Qdrant container บนเครื่อง ส่งผลให้ลดความซับซ้อนของ Dockerfile และลดโอกาสเกิดข้อผิดพลาดจาก Lock file (`.lock` file) ในรอบการเปิดเครื่องใหม่ได้อย่างเด็ดขาด
+
+---
+
+## 7. Key Design Decisions
+
+### 7.1 Why Turbovec over Qdrant?
+- **Speed**: ในการทดสอบสืบค้นเวกเตอร์ด้วย Random Queries พบว่า Turbovec มี Latency เฉลี่ยเพียง **1.43 ms** ขณะที่ Qdrant Server เฉลี่ย **19.42 ms** (~13.5x speedup)
+- **RAM Overhead**: Qdrant Server ในลักษณะ container/embedded ต้องการแรมอย่างน้อย 150-300MB ขณะที่ Turbovec เป็นการโหลดตรงเข้า Process Python เพิ่มแรมเพียงแค่ **~14 MB** เท่านั้น
+- **Disk Usage**: ตัวไฟล์ดัชนีของ Turbovec หลังย่อขนาด 4-bit SQ เหลือเพียง **13.2 MB** ประหยัดพื้นที่จัดเก็บข้อมูลมากกว่า Qdrant snapshots ที่มีขนาดรวมเกือบ 1 GB
+- **Reliability**: ไม่พึ่งพา REST calls หรือการจัดการ socket connections ช่วยขจัดปัญหา network timeout หรือ Docker instance lock ค้าง
+
+### 7.2 Why SQLite Enrichment?
+- เพื่อให้ตัวไฟล์ดัชนี Turbovec (`.tvim`) มีขนาดเล็กที่สุด (13.2 MB) เราจึงไม่ได้เก็บข้อความพระไตรปิฎก (content_text) ไว้ในดัชนีเวกเตอร์ แต่ใช้วิธีจัดเก็บเฉพาะพิกัด ID เล่มและหน้า (volume/page) 
+- เมื่อค้นพบเวกเตอร์ที่เกี่ยวข้องแล้ว ค่อยไปดึงข้อความฉบับเต็มอย่างรวดเร็วจาก SQLite In-memory ในลักษณะ Lazy Load
+
+### 7.3 Why Casting numpy.uint64 to Native int?
+- ไดรเวอร์ `sqlite3` ของ Python ดำเนินการค้นหาพารามิเตอร์โดยยึดตามประเภทข้อมูลของ Python โดยตรง เมื่อส่งค่า `numpy.uint64` เข้าไป ตัวไดรเวอร์จะไม่แปลงเป็นค่าตัวเลขปกติ แต่จะบันทึกเป็นไบนารีบล็อบ (BLOB) ส่งผลให้ SQL Query ในตาราง `pages` ไม่พบแถวข้อมูลใดๆ (Empty Result)
+- การใช้ `int(uid)` จึงเป็นหัวใจสำคัญที่ทำให้การดึงเนื้อหาทำได้อย่างสมบูรณ์
+
+### 7.4 Why "popLayout" Reader Transitions?
+- เพื่อป้องกันปัญหา UI ค้างขณะปัดเปลี่ยนหน้าบนอุปกรณ์มือถือ ซึ่ง Framer Motion มักจะมีปัญหากับการจัดระเบียบ layout ด้วยโหมด `mode="wait"` เมื่อส่วนประกอบใหม่เข้ามาเร็วกว่าที่ส่วนประกอบเดิมจะเฟดออกสำเร็จ การสลับมาใช้ `popLayout` ทำให้ส่วนประกอบเก่าถูกดีดออกตามพารามิเตอร์ขอบเขตจริง ช่วยให้ระบบสลับหน้าระหว่างการปัดได้อย่างเสถียรและราบรื่น

Tipitaka-Web-Application-Tech-Stack-TURBOVEC-HF.md

@@ -0,0 +1,216 @@
+# Tech Stack Specification: Tipitaka Web Application (Turbovec Edition)
+## Phase 1 — All-on-Hugging-Face with Turbovec Backend
+
+> **Version:** 3.1.0 (Turbovec Edition)
+> **Date:** 2026-05-26
+> **Status:** Production — Live at [dhammadassana-tipitaka.hf.space](https://dhammadassana-tipitaka.hf.space/)
+> **Based on Architecture:** V2.5.0 (commit `603ead8`)
+
+---
+
+## 1. Executive Summary
+
+Phase 1 ออกแบบให้ทุกอย่างรันอยู่บน **Hugging Face Spaces** ในลักษณะการทำงานใน Process เดียวกัน (In-process) เพื่อความเรียบง่าย เสถียรภาพ และประหยัดค่าใช้จ่าย โดยใช้ **Turbovec** เป็น Vector Database หลัก ซึ่งเป็นชุดค้นหาเวกเตอร์น้ำหนักเบาและประมวลผลเร็วระดับเสี้ยววินาที ระบบสามารถทำงานบน HF CPU Basic (Free Tier) ได้อย่างลื่นไหลโดยไม่ต้องใช้ RAM ปริมาณมหาศาล
+
+**สิ่งที่ระบบ Turbovec ยืนยันแล้ว:**
+- การสืบค้นเวกเตอร์เฉลี่ยอยู่ที่ **~1.43 ms** (เร็วกว่า Qdrant 13.5 เท่า)
+- RAG Pipeline ทำงานแบบ In-process ผ่าน `sentence-transformers` -> `Turbovec` -> `SQLite Enrichment` -> `ONNX Reranker` -> `DeepSeek`
+- ประหยัดหน่วยความจำ RAM ของเวกเตอร์เอนจินเหลือเพียง **~14 MB** (ลดลงจาก Qdrant 100 เท่า)
+- ขนาดไฟล์ดัชนีเวกเตอร์ที่ต้องจัดเก็บลดลงเหลือ **13.2 MB** (ผ่านการ Quantize 4-bit SQ)
+
+---
+
+## 2. Architecture Overview
+
+```
+┌─────────────────────────────────────────────────────────┐
+│              Hugging Face Space (CPU Basic)             │
+│                                                         │
+│  ┌─────────────────────────────────────────────────┐   │
+│  │         Vite + React 18 + TypeScript 5           │   │
+│  │      (Static Build — Served by FastAPI)          │   │
+│  └────────────────────┬────────────────────────────┘   │
+│                       │ HTTP / SSE                      │
+│  ┌────────────────────▼────────────────────────────┐   │
+│  │              FastAPI (Python 3.13)               │   │
+│  │                                                  │   │
+│  │  ┌──────────┐  ┌──────────┐  ┌───────────────┐  │   │
+│  │  │ SQLite   │  │ Turbovec │  │ Sentence-     │  │   │
+│  │  │ FTS5     │  │ Index    │  │ Transformers  │  │   │
+│  │  │(in-mem)  │  │ (.tvim)  │  │ (in-process)  │  │   │
+│  │  └──────────┘  └──────────┘  └───────────────┘  │   │
+│  │  ┌──────────────────────────────────────────┐   │   │
+│  │  │       ONNX Reranker (jina-reranker-v2)   │   │   │
+│  │  └──────────────────────────────────────────┘   │   │
+│  └──────────────────────────────────────────────────┘   │
+│                       │                                 │
+│                       ▼ External API                    │
+│              DeepSeek API (Pay-as-you-go)               │
+└─────────────────────────────────────────────────────────┘
+
+Assets: ดาวน์โหลดจาก HF Dataset (dhammawatthumpra/tipitaka-storage) ที่ Startup
+```
+
+---
+
+## 3. Component Specification
+
+### 3.1 Presentation Layer
+
+| รายการ | Detail |
+|--------|--------|
+| **Framework** | Vite 6 + React 18 + TypeScript 5 |
+| **Styling** | Tailwind CSS v4 + Framer Motion + Lucide React |
+| **State** | Zustand (5 stores: Reader, Theme, UI, AI, Search) |
+| **PWA** | manifest.json + Dharma wheel PWA icons + Safari app touch icons |
+| **Transitions** | ReaderPanel ปรับใช้ `mode="popLayout"` พร้อมควบคุม loading spinner ด้านนอก เพื่อแก้ปัญหาจอนิ่งขาวบนอุปกรณ์พกพาขณะปัดเปลี่ยนหน้า |
+
+---
+
+### 3.2 API Layer
+
+| รายการ | Detail |
+|--------|--------|
+| **Framework** | FastAPI (Python 3.13) + Uvicorn |
+| **Workers** | Single worker (ช่วยให้การโหลดโมเดลตัวแปลงและเวกเตอร์ทำงานร่วมกันได้ประหยัดแรมสูงสุด) |
+| **Deployment** | HF Space — port 7860 |
+
+---
+
+### 3.3 Data & Retrieval Layer
+
+#### SQLite FTS5 (Lexical Search)
+- ไฟล์: `tipitaka_mcu.db` (~238MB)
+- โหลดเข้า Memory 100% ผ่าน `sqlite3.backup()` ที่ startup
+- Pipeline: FTS5 MATCH -> LIKE fallback -> Pali Autocorrect -> dedup -> highlight -> snippet
+
+#### Turbovec Index (Vector Search)
+- ไฟล์ดัชนี: `tipitaka_chunks.tvim` (~13.2 MB)
+- รูปแบบ: โหลดขึ้นบน Memory ใน Python process โดยตรง ผ่านโมเดล `turbovec.IdMapIndex` (ไม่ใช่ server แยก)
+- เวกเตอร์ถูกย่อขนาดลงผ่าน 4-bit scalar quantization เหลือ 13.2 MB ทำให้โหลดไวและประหยัดพื้นที่คลาวด์
+- การเข้ารหัสพิกัด: แปลงพิกัดของเวกเตอร์เป็น ID ตัวเลขจำนวนเต็มด้วยสูตร `UID = volume_id * 100_000 + page_number` เพื่อไม่ต้องเก็บข้อมูล Payload อื่นๆ บนเวกเตอร์โดยไม่จำเป็น
+- การแก้ไขพารามิเตอร์ SQLite: แปลงประเภทผลลัพธ์เวกเตอร์ `numpy.uint64` ให้เป็น native `int()` ก่อนค้นหากับฐานข้อมูล `tipitaka_mcu.db` เสมอ เพื่อป้องกันข้อผิดพลาดที่ SQLite จะมองพารามิเตอร์ดังกล่าวเป็นข้อมูลชนิด BLOB
+
+#### ONNX Reranker
+- Model: `jina-reranker-v2-base-multilingual` (ONNX CPU, ~267MB)
+- Sequence Length: ปรับลดความยาวสูงสุดใน tokenization เหลือ `max_length=256` ช่วยเร่งความเร็วในการประเมินคะแนนบน CPU พื้นฐานได้มากกว่าเดิม 4 เท่า
+
+---
+
+### 3.4 Embedding Layer
+
+**ใช้ sentence-transformers in-process เท่านั้น** (ไม่มี Ollama ในระบบ HF Space)
+
+| รายการ | Detail |
+|--------|--------|
+| **Model** | `jinaai/jina-embeddings-v5-text-small-retrieval` |
+| **Runtime** | sentence-transformers (PyTorch, in-process) |
+| **Dimensions** | 1024 dims |
+| **RAM** | ~1.2 GB |
+| **Cache** | LRU 256 entries (OrderedDict) เพื่อสกัดการประมวลผลคำคิวรีซ้ำ |
+
+---
+
+### 3.5 Generative AI Layer
+*(เหมือนเดิม — DeepSeek streaming API ผ่านโมเดล fast/reasoner)*
+
+---
+
+## 4. Data Flow
+
+### 4.1 RAG Pipeline
+
+```
+User Query
+  │
+  ├─► FTS5 MATCH (30 results)                [Lexical]
+  │
+  ├─► ST Embedding → Turbovec Search (30)     [Semantic]
+  │     ├─ ตรวจสอบ LRU cache
+  │     └─ tv_index.search() -> return vol & page IDs
+  │
+  ├─► SQLite Payload Enrichment (ดึง content_text จาก db ด้วย vol & page)
+  ├─► Merge + Deduplicate by (vol, page)
+  │
+  ├─► ONNX Reranker → sort by score
+  │
+  └─► Top N context → DeepSeek API → SSE Stream → Browser
+```
+
+---
+
+## 5. Deployment
+
+### 5.1 HF Spaces Configuration
+- **Visibility**: Protected (ซ่อน Source Code และ Assets)
+- **Build**: Dockerfile (multi-stage)
+- **Port**: 7860
+
+### 5.2 Startup Sequence
+
+```
+1. Dockerfile build: npm ci → vite build → pip install
+2. startup.sh:
+   a. download_assets.py → ดึงไฟล์จาก HF Dataset
+      - tipitaka_mcu.db (~238MB)
+      - tipitaka_chunks.tvim (~13.2MB - โหลดแทน snapshot ดั้งเดิม)
+      - ONNX reranker via huggingface_hub (~267MB)
+   b. ลบ Qdrant .lock file (กรณีมีการเปิดฟังก์ชัน Qdrant ไว้ร่วมกัน)
+   c. uvicorn app.main:app --port 7860
+3. FastAPI lifespan:
+   a. SQLite → โหลดเข้า :memory:
+   b. Turbovec Index → โหลดเข้า���ลาส tv_index ในหน่วยความจำ (~14MB)
+   c. ONNX reranker → โหลดโมเดล
+   d. ST model → โหลด lazy (ครั้งแรกที่มี query)
+```
+
+**เวลา Cold Start ของเครื่อง**: ลดลงเหลือเพียง **~1.5–3 นาที** (เนื่องจากไม่ต้องดาวน์โหลดไฟล์ขนาด 1 GB ของ Qdrant snapshot และข้ามขั้นตอนการดึง snapshot restore ขนาดใหญ่)
+
+### 5.3 RAM Budget (CPU Basic = 16GB)
+
+ด้วยการใช้ Turbovec ทำให้ขยายขนาดพื้นที่ว่างบน RAM ได้มากถึง 12 GB ซึ่งช่วยเพิ่มเสถียรภาพสูงสุดในการประมวลผลคำตอบ RAG
+
+| Component | RAM (Qdrant Embedded) | RAM (Turbovec Edition) |
+|-----------|--------------------|------------------------|
+| SQLite in-memory | ~238 MB | ~238 MB |
+| Vector Index Engine | **~1.2–1.5 GB** | **~14 MB** ✅ |
+| ST Model (Jina-v5) | ~1.2 GB | ~1.2 GB |
+| ONNX Reranker | ~500 MB | ~500 MB |
+| FastAPI + Python overhead | ~300 MB | ~300 MB |
+| Ubuntu OS | ~500 MB | ~500 MB |
+| **รวม** | **~4.0–4.2 GB** | **~2.7–2.8 GB** ✅ |
+| **เหลือ Headroom บนแรม**| **~11.8 GB** | **~13.2 GB** ✅ |
+
+---
+
+## 6. Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `LLM_API_KEY` | — | คีย์ DeepSeek API |
+| `DATA_DIR` | Auto-detect | โฟลเดอร์เก็บข้อมูล SQLite & Turbovec Index |
+| `DATABASE_PATH` | Auto-detect | ไฟล์ที่อยู่ของ SQLite |
+| `SERVE_STATIC` | `true` | ให้ FastAPI ทำหน้าที่เสิร์ฟ Frontend ของ Vite |
+| `ST_EMBED_MODEL` | `jinaai/jina-embeddings-v5-text-small-retrieval` | โมเดลทำเวกเตอร์บน Hugging Face |
+| `PORT` | `7860` | พอร์ตของ HF Space |
+
+---
+
+## 7. Cost Summary
+- **HF PRO Account**: $9.00/เดือน (ประมาณ 315 บาท) เพื่อสิทธิ์การเข้าถึงแบบ Protected
+- **HF Space Hardware (CPU Basic)**: ฟรี
+- **DeepSeek API**: จ่ายตามปริมาณประมวลผลโทเค็นจริง
+- **รวมค่าบริการคงที่**: **$9.00/เดือน**
+
+---
+
+## 8. ข้อจำกัดและแนวทางปรับปรุง
+
+| ข้อจำกัด | ผลกระทบ | แนวทางแก้ไข |
+|---------|---------|-------------|
+| Cold start ในรอบการเปิดเครื่องใหม่ | ระบบหยุดทำงานชั่วคราวเมื่อรีสตาร์ทหลังไม่มีการใช้งาน 48 ชม. | ใช้ HF Persistent Storage หรือ VPS โฮสต์ส่วนตัว |
+| SQLite FTS5 และ Turbovec ค้นแยก | ข้อมูลเวกเตอร์อาจแตกต่างเล็กน้อยจากคำดั้งเดิมก่อน enrichment | ทำ Cache เอนทิตีที่ซับซ้อนขึ้น |
+
+---
+
+*เอกสารนี้ได้รับการปรับปรุงเพื่อสะท้อนประสิทธิภาพจริงของดัชนี Turbovec ที่รันอยู่บนระบบของแอปพลิเคชัน*