feat: full optimization - Groq LLM, disease cache, deploy configs

- Switch backend LLM from Gemini to Groq (llama-3.3-70b-versatile)
- Add GroqKeyManager: round-robin key rotation with 429 cooldown
- Add DiseaseCache: SQLite 7-day TTL cache - 0 LLM calls on cache HIT
- SessionStore: WAL mode + cleanup_expired() on startup
- Fix nhan_xet_tong_quan field in evaluation JSON (was 'nhan_xet')
- Restore proper Vietnamese diacritics in all LLM prompts
- Migrate Tailwind from CDN to PostCSS pipeline
- Add tenacity retry on rate limit errors
- ragService.ts: use VITE_RAG_API_URL env var (not hardcoded localhost)
- Add render.yaml (Render.com free tier backend deploy)
- Add vercel.json (Vercel frontend deploy)
- Add rag_project/Dockerfile (HuggingFace Spaces alternative)
- Update .gitignore: exclude secrets, DB files, training data

.env.example

@@ -0,0 +1,26 @@
+# Backend Environment Variables
+# Copy this file to .env and fill in your values
+# DO NOT COMMIT the actual .env file — it contains secrets!
+
+# ── Groq API Keys (get free keys at console.groq.com) ──
+# Two keys for round-robin rotation to stay within rate limits
+GROQ_API_KEY_1=gsk_your_first_key_here
+GROQ_API_KEY_2=gsk_your_second_key_here
+GROQ_MODEL=llama-3.3-70b-versatile
+
+# ── Google Gemini key (used by frontend only — optional for backend) ──
+GOOGLE_API_KEY=your_google_api_key_here
+
+# ── CORS: comma-separated list of allowed frontend origins ──
+# Local dev:    http://localhost:3000,http://localhost:5173
+# Production:   https://your-app.vercel.app
+ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173
+
+# ── Optional API protection (leave blank to disable) ──
+API_SECRET_KEY=
+# For production: https://yourdomain.com
+ALLOWED_ORIGINS=http://localhost:3000,http://localhost:5173
+
+# Optional: Protect API endpoints with a static secret key
+# Leave empty to disable authentication (development only)
+API_SECRET_KEY=

.gitignore

@@ -2,6 +2,13 @@
 .env
 *.env
 
+# SQLite databases (generated at runtime)
+sessions.db
+disease_cache.db
+
+# Training data (not needed for API)
+pediatric_finetune_15k_vietnamese.jsonl
+
 # python
 __pycache__/
 *.pyc

Dockerfile

@@ -0,0 +1,43 @@
+# ── HuggingFace Spaces compatible Dockerfile ──────────────────────────────
+# Port MUST be 7860 for HF Spaces.
+# Runs as user 1000 (HF requirement).
+
+FROM python:3.10-slim
+
+# System deps
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential curl git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create non-root user (required by HF Spaces)
+RUN useradd -m -u 1000 appuser
+
+WORKDIR /app
+
+# Install Python deps first (better layer caching)
+COPY requirements_api.txt .
+RUN pip install --no-cache-dir -r requirements_api.txt
+
+# Copy application files
+COPY . .
+
+# Set ownership
+RUN chown -R appuser:appuser /app
+
+USER appuser
+
+# Pre-build FAISS index at image build time (bakes the 4.4 MB index in)
+# Sentence-transformer model is downloaded here and cached in /home/appuser/.cache
+RUN python src/build_faiss.py
+
+# Environment defaults (override via HF Space secrets)
+ENV GROQ_API_KEY_1=""
+ENV GROQ_API_KEY_2=""
+ENV GROQ_MODEL="llama-3.3-70b-versatile"
+ENV ALLOWED_ORIGINS="*"
+ENV PORT=7860
+
+# Expose HF Spaces port
+EXPOSE 7860
+
+CMD ["python", "api_server_fastapi.py"]

Dockerfile.backend

@@ -0,0 +1,12 @@
+FROM python:3.11-slim
+WORKDIR /app
+
+# Install dependencies
+COPY requirements_api.txt .
+RUN pip install --no-cache-dir -r requirements_api.txt
+
+# Copy source
+COPY . .
+
+EXPOSE 8001
+CMD ["python", "api_server_fastapi.py"]

api_server_fastapi.py

@@ -5,7 +5,7 @@ Endpoints:
 - GET /api/diseases - Lấy danh sách bệnh từ JSON
 - POST /api/start-case - Nhận bệnh, tạo case với triệu chứng
 - POST /api/evaluate - Nhận đáp án user, trả về kết quả so sánh
-- Docs: http://localhost:5000/docs (Swagger UI)
+- Docs: http://localhost:8001/docs (Swagger UI)
 """
 import sys
 import io
@@ -14,8 +14,11 @@ import io
 sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8', errors='replace')
 sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8', errors='replace')
 
-from fastapi import FastAPI, HTTPException
+import asyncio
+
+from fastapi import FastAPI, HTTPException, Depends, Security
 from fastapi.middleware.cors import CORSMiddleware
+from fastapi.security.api_key import APIKeyHeader
 from pydantic import BaseModel
 from typing import Optional, List, Dict, Any
 import json
@@ -31,6 +34,8 @@ from config import Config
 from doctor_evaluator import DoctorEvaluator
 from vector_store import VectorStoreManager
 from rag_chain import RAGChain
+from session_store import SessionStore
+from disease_cache import DiseaseCache
 
 app = FastAPI(
     title="Medical RAG API",
@@ -40,15 +45,31 @@ app = FastAPI(
     redoc_url="/redoc"
 )
 
-# Configure CORS
+# Configure CORS — restrict to known frontend origins via ALLOWED_ORIGINS env var
+_allowed_origins_env = os.getenv(
+    "ALLOWED_ORIGINS", "http://localhost:3000,http://localhost:5173"
+)
+ALLOWED_ORIGINS = [o.strip() for o in _allowed_origins_env.split(",") if o.strip()]
+
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  # In production, specify exact origins
+    allow_origins=ALLOWED_ORIGINS,
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# Optional API key authentication (set API_SECRET_KEY env var to enable)
+_API_SECRET_KEY = os.getenv("API_SECRET_KEY", "")
+_api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+async def verify_api_key(api_key: str = Security(_api_key_header)):
+    """If API_SECRET_KEY is configured, require matching X-API-Key header."""
+    if _API_SECRET_KEY and api_key != _API_SECRET_KEY:
+        raise HTTPException(status_code=403, detail="Invalid or missing API key")
+    return api_key
+
 # Initialize RAG system
 print("[*] Initializing RAG system...")
 vs_manager = VectorStoreManager()
@@ -60,8 +81,12 @@ rag = RAGChain(vs_manager)
 evaluator = DoctorEvaluator(rag)
 print("[OK] RAG system ready!")
 
-# Store active sessions
-active_sessions: Dict[str, Dict[str, Any]] = {}
+# Persistent session store (SQLite)
+session_store = SessionStore()
+session_store.cleanup_expired()   # remove stale sessions from previous runs
+
+# Disease-level result cache (7-day TTL, avoids repeating RAG queries for same disease)
+disease_cache = DiseaseCache()
 
 
 # Pydantic models for request/response
@@ -189,64 +214,85 @@ async def get_diseases(
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/start-case", response_model=StartCaseResponse)
+@app.post("/api/start-case", response_model=StartCaseResponse, dependencies=[Depends(verify_api_key)])
 async def start_case(request: StartCaseRequest):
     """
-    Gọi các hàm CÓ SẴN như trong main.py
-    1. find_symptoms() - RAG tìm triệu chứng
-    2. generate_case() - Gemini tạo case
-    3. get_detailed_standard_knowledge() - RAG lấy đáp án chuẩn
+    1. find_symptoms() + get_detailed_standard_knowledge() run IN PARALLEL
+    2. generate_case() runs after symptoms are ready
+    3. Session persisted to SQLite
     """
     try:
         disease = request.disease.strip()
         session_id = request.sessionId
-        
+
         if not disease:
             raise HTTPException(status_code=400, detail="Disease name is required")
-        
+
         print(f"[INFO] Starting case for disease: {disease}")
         print(f"[INFO] Session ID: {session_id}")
-        
-        # 1. RAG tìm TRIỆU CHỨNG (như main.py)
-        print("[INFO] Step 1: Finding symptoms...")
-        symptoms, symptom_sources = evaluator.find_symptoms(disease)
-        print(f"[INFO] Found symptoms (first 200 chars): {symptoms[:200]}...")
-        
-        # 2. GEMINI tạo CASE (như main.py)
+
+        loop = asyncio.get_running_loop()
+
+        # Check disease-level cache first (0 LLM calls if HIT)
+        cached = disease_cache.get(disease)
+        if cached:
+            print(f"[INFO] Disease cache HIT for '{disease}' — skipping RAG queries")
+            symptoms = cached["symptoms"]
+            standard_data = cached["standard"]
+            all_sources_raw = cached["sources"]
+        else:
+            # Cache MISS — run symptoms + standard in parallel, then cache results
+            print("[INFO] Disease cache MISS — running RAG queries in parallel...")
+            (symptoms, symptom_sources), (standard_data, std_sources) = await asyncio.gather(
+                loop.run_in_executor(None, evaluator.find_symptoms, disease),
+                loop.run_in_executor(None, evaluator.get_detailed_standard_knowledge, disease),
+            )
+            all_sources_raw = symptom_sources + std_sources
+            # Cache for future requests
+            disease_cache.set(disease, symptoms, standard_data, [
+                {"file": d.metadata.get("source_file",""), "title": d.metadata.get("chunk_title",""),
+                 "section": d.metadata.get("section_title","")} for d in all_sources_raw[:5]
+            ])
+
+        print(f"[INFO] Symptoms (first 200 chars): {symptoms[:200]}...")
+        print(f"[INFO] Standard data length: {len(standard_data)} chars")
+
+        # Step 2: generate case (depends on symptoms output)
         print("[INFO] Step 2: Generating patient case...")
-        patient_case = evaluator.generate_case(disease, symptoms)
+        patient_case = await loop.run_in_executor(
+            None, evaluator.generate_case, disease, symptoms
+        )
         print(f"[INFO] Generated case (first 200 chars): {patient_case[:200]}...")
-        
-        # 3. RAG lấy đáp án chuẩn (như main.py)
-        print("[INFO] Step 3: Getting standard knowledge...")
-        standard_data, all_sources = evaluator.get_detailed_standard_knowledge(disease)
-        print(f"[INFO] Standard data retrieved (length: {len(standard_data)} chars)")
-        
-        # Lưu vào session để /evaluate dùng
-        session_data = {
+
+        # Pre-format sources (Document objects or plain dicts -> plain dicts for JSON storage)
+        formatted_sources = []
+        for src in (all_sources_raw if not cached else all_sources_raw)[:5]:
+            if isinstance(src, dict):
+                formatted_sources.append(src)
+            else:
+                formatted_sources.append({
+                    'file':    src.metadata.get('source_file', ''),
+                    'title':   src.metadata.get('chunk_title', ''),
+                    'section': src.metadata.get('section_title', ''),
+                })
+
+        # Persist session to SQLite
+        session_store.set(session_id, {
             'disease': disease,
             'case': patient_case,
             'symptoms': symptoms,
             'standard': standard_data,
-            'sources': all_sources
-        }
-        active_sessions[session_id] = session_data
-        
+            'sources': formatted_sources,
+        })
+
         return StartCaseResponse(
             success=True,
             sessionId=session_id,
             case=patient_case,
             symptoms=symptoms[:300] + "...",
-            sources=[
-                {
-                    'file': doc.metadata.get('source_file', ''),
-                    'title': doc.metadata.get('chunk_title', ''),
-                    'section': doc.metadata.get('section_title', '')
-                }
-                for doc in all_sources[:3]
-            ]
+            sources=formatted_sources[:3],
         )
-    
+
     except HTTPException:
         raise
     except Exception as e:
@@ -256,7 +302,7 @@ async def start_case(request: StartCaseRequest):
         raise HTTPException(status_code=500, detail=str(e))
 
 
-@app.post("/api/evaluate", response_model=EvaluateResponse)
+@app.post("/api/evaluate", response_model=EvaluateResponse, dependencies=[Depends(verify_api_key)])
 async def evaluate_diagnosis(request: EvaluateRequest):
     """
     Nhận câu trả lời user, so sánh với đáp án chuẩn đã có trong session
@@ -264,21 +310,23 @@ async def evaluate_diagnosis(request: EvaluateRequest):
     try:
         session_id = request.sessionId
         diagnosis = request.diagnosis
-        
-        if not session_id or session_id not in active_sessions:
+
+        if not session_id:
+            raise HTTPException(status_code=400, detail="Session ID required")
+
+        session_data = session_store.get(session_id)
+        if session_data is None:
             raise HTTPException(status_code=400, detail="Invalid or expired session")
-        
-        session_data = active_sessions[session_id]
+
         disease = session_data['disease']
         patient_case = session_data['case']
         standard_answer = session_data['standard']
-        sources = session_data['sources']
-        
+
         print(f"[INFO] Evaluating diagnosis for: {disease}")
         print(f"[INFO] Session ID: {session_id}")
         print(f"[INFO] User diagnosis: {diagnosis.dict()}")
-        
-        # Format user's answer
+
+        # Format user’s answer
         user_answer = f"""
 CHẨN ĐOÁN:
 - Lâm sàng: {diagnosis.clinical or 'Không có'}
@@ -291,29 +339,29 @@ KẾ HOẠCH ĐIỀU TRỊ:
 - Thuốc: {diagnosis.medication or 'Không có'}
 """
         print(f"[INFO] Formatted user answer (first 300 chars): {user_answer[:300]}...")
-        
-        print("[INFO] Step 1: Evaluating with Gemini...")
-        # Gemini đánh giá (dùng hàm CÓ SẴN: detailed_evaluation)
-        evaluation_result = evaluator.detailed_evaluation(user_answer, standard_answer)
-        print(f"[INFO] Step 2: Evaluation result (first 500 chars): {evaluation_result[:500]}...")
-        
+
+        # Run Groq evaluation (blocking I/O — executed off the event loop)
+        print("[INFO] Step 1: Evaluating with Groq...")
+        loop = asyncio.get_running_loop()
+        evaluation_result = await loop.run_in_executor(
+            None, evaluator.detailed_evaluation, user_answer, standard_answer
+        )
+        print(f"[INFO] Evaluation result (first 500 chars): {evaluation_result[:500]}...")
+
         # Parse JSON from evaluation
-        print("[INFO] Step 3: Parsing JSON evaluation...")
+        print("[INFO] Step 2: Parsing JSON evaluation...")
         try:
-            import json
-            # Remove markdown code blocks if present
+            import json as _json
             eval_text = evaluation_result.strip()
             if eval_text.startswith('```'):
                 lines = eval_text.split('\n')
                 eval_text = '\n'.join(lines[1:-1]) if len(lines) > 2 else eval_text
                 if eval_text.startswith('json'):
                     eval_text = eval_text[4:].strip()
-            evaluation_obj = json.loads(eval_text)
-            print(f"[INFO] Successfully parsed JSON: {json.dumps(evaluation_obj, ensure_ascii=False, indent=2)[:500]}...")
+            evaluation_obj = _json.loads(eval_text)
+            print(f"[INFO] Successfully parsed JSON")
         except Exception as parse_error:
             print(f"[ERROR] Failed to parse JSON: {parse_error}")
-            print(f"[ERROR] Raw evaluation text: {evaluation_result[:500]}...")
-            # If parsing fails, return as text
             evaluation_obj = {
                 'evaluation_text': evaluation_result,
                 'diem_so': 'N/A',
@@ -324,22 +372,11 @@ KẾ HOẠCH ĐIỀU TRỊ:
                 'dien_giai': evaluation_result,
                 'nhan_xet_tong_quan': 'Lỗi parse JSON'
             }
-        
-        # Format sources
-        formatted_sources = [
-            {
-                'file': doc.metadata.get('source_file', ''),
-                'title': doc.metadata.get('chunk_title', ''),
-                'section': doc.metadata.get('section_title', '')
-            }
-            for doc in sources[:3]
-        ]
-        
-        print("[INFO] Step 4: Formatting response...")
-        print(f"[INFO] Evaluation object keys: {list(evaluation_obj.keys())}")
-        print(f"[INFO] Standard answer length: {len(standard_answer)} chars")
-        print(f"[INFO] Number of sources: {len(formatted_sources)}")
-        
+
+        # Sources are already pre-formatted plain dicts (stored in session)
+        formatted_sources = session_data.get('sources', [])[:3]
+
+        print("[INFO] Step 3: Formatting response...")
         return EvaluateResponse(
             success=True,
             case=patient_case,
@@ -350,7 +387,7 @@ KẾ HOẠCH ĐIỀU TRỊ:
             evaluation=evaluation_obj,
             sources=formatted_sources
         )
-    
+
     except HTTPException:
         raise
     except Exception as e:
@@ -363,13 +400,18 @@ KẾ HOẠCH ĐIỀU TRỊ:
 if __name__ == '__main__':
     print("[*] Starting FastAPI Server...")
     print(f"[*] Server: http://localhost:8001")
-    print(f"[*] Docs: http://localhost:8001/docs")
-    print(f"[*] Using API Key: {Config.GOOGLE_API_KEY[:20]}...")
+    print(f"[*] Docs:   http://localhost:8001/docs")
+    api_key_status = "configured" if Config.GROQ_API_KEY_1 else "NOT SET (set GROQ_API_KEY_1 in .env)"
+    print(f"[*] Groq Key status: {api_key_status}")
+    cors_status = "restricted" if ALLOWED_ORIGINS != ["*"] else "OPEN (*)"
+    print(f"[*] CORS origins ({cors_status}): {ALLOWED_ORIGINS}")
+    auth_status = "enabled" if _API_SECRET_KEY else "disabled (set API_SECRET_KEY to enable)"  
+    print(f"[*] API auth: {auth_status}")
     
     uvicorn.run(
         app,
         host="0.0.0.0",
-        port=8001,
+        port=int(os.getenv("PORT", "8001")),
         log_level="info",
-        reload=False  # Set to True for development
+        reload=False
     )

render.yaml

@@ -0,0 +1,31 @@
+# Render.com deployment config
+# Free tier: 750 h/month — enough for 24/7 with UptimeRobot keep-alive
+# RAM: 512 MB (tight for PhoBERT — recommend HF Spaces if RAM issues occur)
+
+services:
+  - type: web
+    name: medchat-backend
+    env: python
+    region: singapore   # closest to Vietnam
+    plan: free
+
+    # Build: install deps AND pre-build FAISS index
+    buildCommand: |
+      pip install -r requirements_api.txt
+      python src/build_faiss.py
+
+    startCommand: python api_server_fastapi.py
+
+    healthCheckPath: /api/health
+
+    envVars:
+      - key: GROQ_API_KEY_1
+        sync: false          # set manually in Render dashboard
+      - key: GROQ_API_KEY_2
+        sync: false
+      - key: GROQ_MODEL
+        value: llama-3.3-70b-versatile
+      - key: ALLOWED_ORIGINS
+        sync: false          # set to your Vercel URL, e.g. https://medchat.vercel.app
+      - key: PORT
+        value: "8001"

requirements.txt

@@ -1,3 +1,4 @@
+# Core RAG serving dependencies
 langchain-core>=0.3.17,<0.4.0
 langchain-community>=0.3.7,<0.4.0
 langchain-huggingface
@@ -8,9 +9,5 @@ sentence-transformers
 google-generativeai
 python-dotenv
 
-
-unsloth
-transformers
-torch
-accelerate
-bitsandbytes
+# Fine-tuning dependencies are in requirements_finetune.txt
+# Do NOT install those for serving/inference deployments

requirements_api.txt

@@ -1,3 +1,19 @@
+# FastAPI server & runtime dependencies
 fastapi==0.109.0
 uvicorn[standard]==0.27.0
 pydantic==2.5.3
+
+# LangChain stack
+langchain-core>=0.3.17,<0.4.0
+langchain-community>=0.3.7,<0.4.0
+langchain-huggingface
+langchain-groq>=0.3.0,<1.0.0  # must stay on 0.x to share langchain-core 0.3.x
+langchain-google-genai  # kept for optional fallback / frontend
+
+# Vector store & embeddings
+faiss-cpu
+sentence-transformers
+
+# Utilities
+python-dotenv
+tenacity

requirements_finetune.txt

@@ -0,0 +1,8 @@
+# Fine-tuning dependencies — NOT needed for serving/inference
+# Install separately only for model training:
+#   pip install -r requirements_finetune.txt
+unsloth
+transformers
+torch
+accelerate
+bitsandbytes

src/config.py

@@ -1,29 +1,31 @@
 import os
+from pathlib import Path
 from dotenv import load_dotenv
 
 load_dotenv()
 
 class Config:
-    # SỬA ĐƯỜNG DẪN LẠI NHA 
-    BASE_DIR = r"D:\Storage\rag_project"
-    DATA_DIR = f"{BASE_DIR}/data"
+    # Project root directory resolved relative to this file (rag_project/)
+    BASE_DIR = Path(__file__).parent.parent
+    DATA_DIR = BASE_DIR / "data"
     CHUNK_FILES = [
-        f"{DATA_DIR}/BoYTe200_v3.json",
-        f"{DATA_DIR}/NHIKHOA2.json",
-        f"{DATA_DIR}/PHACDODIEUTRI_2016.json"
-    ]    
-    # EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2" # Model embedding 
+        str(DATA_DIR / "BoYTe200_v3.json"),
+        str(DATA_DIR / "NHIKHOA2.json"),
+        str(DATA_DIR / "PHACDODIEUTRI_2016.json"),
+    ]
+
+    # EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
     # EMBEDDING_MODEL = "bkai-foundation-models/vietnamese-bi-encoder"
     EMBEDDING_MODEL = "VoVanPhuc/sup-SimCSE-VietNamese-phobert-base"
-    
-    # GOOGLE API KEY - Thay bằng key của bạn từ https://makersuite.google.com/app/apikey
-    GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY', 'YOUR_API_KEY_HERE')
-    
-    LLM_MODEL = "gemini-2.5-flash" 
-    K_RETRIEVE = 3 # Số Document muốn truy
-    TEMPERATURE = 0 
 
-"""
-AIzaSyABvC8mPrwa0Kgy08mFFzkyeh2_N-Bb3lY
-AIzaSyDJqr4nKDrcfmmuKOdDCHkXRvKA48htD6o
-"""
+    # Groq API keys (set in rag_project/.env)
+    GROQ_API_KEY_1 = os.getenv('GROQ_API_KEY_1', '')
+    GROQ_API_KEY_2 = os.getenv('GROQ_API_KEY_2', '')
+
+    # Keep Google key in case frontend/other services need it
+    GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY', '')
+
+    GROQ_MODEL = os.getenv('GROQ_MODEL', 'llama-3.3-70b-versatile')
+    LLM_MODEL = GROQ_MODEL          # alias used in older code
+    K_RETRIEVE = 3
+    TEMPERATURE = 0

src/disease_cache.py

@@ -0,0 +1,112 @@
+"""
+Disease-level result cache — avoids repeating RAG+LLM queries for the same disease.
+
+Stores (symptoms_text, standard_text, sources_json) per disease in SQLite.
+TTL: 7 days (medical knowledge stable; rebuild only after data update).
+
+Impact:
+  - Cold (first request for a disease):  3 LLM calls + FAISS search
+  - Warm (subsequent requests):          0 LLM calls, 0 FAISS search → ~5 s → <0.1 s
+"""
+import sqlite3
+import json
+import time
+import logging
+from pathlib import Path
+from typing import Optional, Tuple, List, Dict
+
+logger = logging.getLogger(__name__)
+
+TTL_SECONDS = 7 * 24 * 60 * 60   # 7 days
+
+
+class DiseaseCache:
+    def __init__(self, db_path: Optional[str] = None):
+        if db_path is None:
+            db_path = str(Path(__file__).parent.parent / "disease_cache.db")
+        self.db_path = db_path
+        self._init_db()
+        logger.info(f"[DiseaseCache] SQLite cache at: {self.db_path}")
+
+    def _conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _init_db(self):
+        with self._conn() as c:
+            c.execute("""
+                CREATE TABLE IF NOT EXISTS disease_cache (
+                    disease    TEXT PRIMARY KEY,
+                    symptoms   TEXT NOT NULL,
+                    standard   TEXT NOT NULL,
+                    sources    TEXT NOT NULL DEFAULT '[]',
+                    cached_at  REAL NOT NULL
+                )
+            """)
+            c.commit()
+
+    # ── read ──────────────────────────────────────────────────────────────────
+    def get(self, disease: str) -> Optional[Dict]:
+        """Return cached {symptoms, standard, sources} or None if missing/expired."""
+        with self._conn() as c:
+            row = c.execute(
+                "SELECT symptoms, standard, sources, cached_at FROM disease_cache WHERE disease = ?",
+                (disease,)
+            ).fetchone()
+
+        if row is None:
+            return None
+
+        age = time.time() - row["cached_at"]
+        if age > TTL_SECONDS:
+            self.invalidate(disease)
+            logger.info(f"[DiseaseCache] Cache expired for '{disease}' ({age/3600:.1f}h old)")
+            return None
+
+        logger.info(f"[DiseaseCache] Cache HIT for '{disease}' ({age/3600:.1f}h old)")
+        return {
+            "symptoms": row["symptoms"],
+            "standard": row["standard"],
+            "sources":  json.loads(row["sources"]),
+        }
+
+    # ── write ─────────────────────────────────────────────────────────────────
+    def set(self, disease: str, symptoms: str, standard: str, sources: List[Dict]):
+        """Cache symptoms + standard for a disease."""
+        now = time.time()
+        sources_json = json.dumps(sources, ensure_ascii=False)
+        with self._conn() as c:
+            c.execute("""
+                INSERT INTO disease_cache (disease, symptoms, standard, sources, cached_at)
+                VALUES (?, ?, ?, ?, ?)
+                ON CONFLICT(disease) DO UPDATE
+                    SET symptoms=excluded.symptoms,
+                        standard=excluded.standard,
+                        sources=excluded.sources,
+                        cached_at=excluded.cached_at
+            """, (disease, symptoms, standard, sources_json, now))
+            c.commit()
+        logger.info(f"[DiseaseCache] Cached '{disease}'")
+
+    # ── management ────────────────────────────────────────────────────────────
+    def invalidate(self, disease: str):
+        with self._conn() as c:
+            c.execute("DELETE FROM disease_cache WHERE disease = ?", (disease,))
+            c.commit()
+
+    def invalidate_all(self):
+        with self._conn() as c:
+            c.execute("DELETE FROM disease_cache")
+            c.commit()
+        logger.info("[DiseaseCache] All entries invalidated")
+
+    def stats(self) -> Dict:
+        with self._conn() as c:
+            total = c.execute("SELECT COUNT(*) FROM disease_cache").fetchone()[0]
+            fresh = c.execute(
+                "SELECT COUNT(*) FROM disease_cache WHERE cached_at > ?",
+                (time.time() - TTL_SECONDS,)
+            ).fetchone()[0]
+        return {"total": total, "fresh": fresh, "expired": total - fresh}

src/doctor_evaluator.py

@@ -1,166 +1,104 @@
-from rag_chain import RAGChain
-from vector_store import VectorStoreManager
-from data_loader import DataLoader
-from config import Config
-from langchain_google_genai import ChatGoogleGenerativeAI
+"""
+DoctorEvaluator — uses Groq LLM (via shared GroqKeyManager) for:
+  1. generate_case()           : 1 LLM call
+  2. detailed_evaluation()     : 1 LLM call  (compact JSON, ~4 fields)
+
+RAG queries reduced:
+  - find_symptoms              : 3 → 1 combined query
+  - get_detailed_standard_knowledge : 6 → 2 combined queries
+Total LLM calls per start-case: 1(symptoms RAG) + 2(standard RAG) + 1(case) = 4
+Total LLM calls per evaluate  : 2(standard RAG) + 1(eval) = 3
+"""
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Dict, Tuple, List
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception
+from rag_chain import RAGChain, get_key_manager, _is_rate_limit
+
 
 class DoctorEvaluator:
-    def __init__(self, rag):
+    def __init__(self, rag: RAGChain):
         self.rag = rag
-        self.evaluator_llm = ChatGoogleGenerativeAI(
-            model="gemini-2.5-flash",
-            google_api_key=Config.GOOGLE_API_KEY,
-            temperature=0.1
+        self._km = get_key_manager()
+        print("DoctorEvaluator: Ready (Groq + RAG)!")
+
+    # ── internal helper ────────────────────────────────────────────────────────
+    def _llm_invoke(self, prompt: str, temperature: float = 0.1) -> str:
+        """Call Groq with retry + key rotation on 429."""
+        @retry(
+            retry=retry_if_exception(_is_rate_limit),
+            wait=wait_exponential(multiplier=1, min=5, max=30),
+            stop=stop_after_attempt(4),
+            reraise=True,
         )
-        print("DoctorEvaluator: Ready (Gemini + RAG)!")
-    
-    def generate_case(self, disease: str, symptoms: str):
-        """DÙNG GEMINI TẠO CASE - NHANH + ỔN ĐỊNH"""
-        prompt = f"""
-Bạn là bác sĩ nhi khoa. Tạo một ca bệnh THỰC TẾ cho bệnh: {disease}
-
-TRIỆU CHỨNG TỪ TÀI LIỆU:
-{symptoms}
-
-YÊU CẦU:
-1. Chỉ tạo lời thoại của mẹ bệnh nhân (3-4 câu)
-2. PHẢI MÔ TẢ các triệu chứng CỤ THỂ của bệnh {disease} từ tài liệu trên
-3. Dùng ngôn ngữ đời thường, tự nhiên
-4. Format: "Bé [tên] nhà chị [tên mẹ] bữa nay bị [triệu chứng cụ thể]. Chị lo lắm! [thêm chi tiết triệu chứng]."
-
-VÍ DỤ TỐT:
-- Bệnh Viêm phổi → "Bé An bị sốt cao 39 độ, ho có đờm, thở nhanh phì phò"
-- Bệnh Suy tim → "Bé Minh thở nhanh, mệt lả, bú kém, chân tay lạnh"
-
-CASE BỆNH:
-"""
-        result = self.evaluator_llm.invoke([prompt])
-        return result.content.strip()
-
-
-    def evaluate_doctor(self, disease: str):
-        print(f"\n ĐÁNH GIÁ: {disease}")
-        print("=" * 80)
-        
-        # 1. RAG tìm TRIỆU CHỨNG
-        print("Hệ thống đang TRUY TÌM TRIỆU CHỨNG:")
-        symptoms, symptom_sources = self.find_symptoms(disease)
-        print(f"Xác định triệu chứng: {symptoms[:100]}...")
-        
-        # 2. GEMINI tạo CASE
-        print("Tiến hành tạo case...")
-        patient_case = self.generate_case(disease, symptoms)
-        print(f"Case hoàn chỉnh:\n{patient_case}")
-        
-        # 3. NHẬP TRẢ LỜI BS
-        doctor_answer = input("\n NHẬP CÂU TRẢ LỜI CỦA BÁC SĨ:\n").strip()
-        
-        # 4. RAG chi tiết + Đánh giá (giữ nguyên)
-        print("\n TRUY TÌM ĐÁP ÁN CHUẨN:")
-        standard_data, all_sources = self.get_detailed_standard_knowledge(disease)
-        evaluation = self.detailed_evaluation(doctor_answer, standard_data)
-        
-        return {
-            'case': patient_case,
-            'standard': standard_data,
-            'evaluation': evaluation,
-            'sources': all_sources
-        }
-
-    def find_symptoms(self, disease: str):
-        """RAG tìm triệu chứng bệnh - CẢI THIỆN"""
-        # Query chi tiết hơn để tìm đúng bệnh
-        queries = [
-            f"{disease} biểu hiện",
-            f"{disease} triệu chứng",
-            f"{disease} dấu hiệu"
+        def _call():
+            try:
+                llm = self._km.build_llm(temperature=temperature)
+                return llm.invoke([prompt])
+            except Exception as exc:
+                if _is_rate_limit(exc):
+                    self._km.mark_rate_limited(self._km.current())
+                    self._km.rotate()
+                raise
+        return _call().content
+
+    # ── public methods ─────────────────────────────────────────────────────────
+    def generate_case(self, disease: str, symptoms: str) -> str:
+        """Tạo ca bệnh nhi bằng 1 LLM call, prompt ngắn gọn."""
+        prompt = (
+            f"Bạn là bác sĩ nhi khoa. Tạo 1 lời thoại của mẹ bệnh nhân (2-3 câu, "
+            f"ngôn ngữ đời thường) mô tả triệu chứng cụ thể của bệnh {disease}.\n"
+            f"Triệu chứng từ tài liệu: {symptoms[:400]}\n"
+            f"Format: 'Bé [tên] nhà chị [tên mẹ] bị [triệu chứng cụ thể]. [Thêm chi tiết].'\n"
+            f"CASE:"
+        )
+        return self._llm_invoke(prompt, temperature=0.3).strip()
+
+    def find_symptoms(self, disease: str) -> Tuple[str, list]:
+        """1 RAG query (thay cho 3 query trước đây)."""
+        answer, sources = self.rag.query(f"{disease} triệu chứng biểu hiện lâm sàng")
+        summary = answer[:600] if answer else f"Không tìm thấy thông tin triệu chứng cho {disease}"
+        return summary, sources
+
+    def get_detailed_standard_knowledge(self, disease: str) -> Tuple[str, list]:
+        """2 RAG queries thay cho 6 query trước đây."""
+        tasks = [
+            ("CHAN_DOAN", f"{disease} lâm sàng cận lâm sàng chẩn đoán xác định phân biệt"),
+            ("DIEU_TRI",  f"{disease} điều trị thuốc"),
         ]
-        
-        all_symptoms = []
-        sources = []
-        for q in queries:
-            print(f" Query: {q}")
-            answer, src = self.rag.query(q)
-            if answer and len(answer.strip()) > 50:  # Chỉ lấy answer có nội dung
-                all_symptoms.append(answer)
-                sources.extend(src)
-        
-        # Gom triệu chứng đầy đủ hơn (không cắt quá ngắn)
-        if all_symptoms:
-            # Lấy 2 answer tốt nhất, mỗi cái 500 ký tự
-            symptoms_summary = "\n\n".join([s[:500] for s in all_symptoms[:2]])
-        else:
-            symptoms_summary = f"Không tìm thấy thông tin triệu chứng cho {disease}"
-        
-        print(f" Tìm thấy triệu chứng: {symptoms_summary[:200]}...")
-        return symptoms_summary, sources
-
-    def get_detailed_standard_knowledge(self, disease: str):
-        """RAG CHẨN ĐOÁN CHI TIẾT + ĐIỀU TRỊ"""
-        queries = {
-            'LAM_SANG': [f"{disease} lâm sàng"],
-            'CAN_LAM_SANG': [f"{disease} cận lâm sàng"],
-            'CHAN_DOAN_XAC_DINH': [f"{disease} chẩn đoán xác định"],
-            'CHAN_DOAN_PHAN_BIET': [f"{disease} chẩn đoán phân biệt"],
-            'DIEU_TRI': [f"{disease} điều trị", f"{disease} thuốc"]
-        }
-        
-        results = {}
-        all_sources = []
-        
-        for section, qlist in queries.items():
-            print(f" {section}:")
-            section_content = []
-            for q in qlist:
-                print(f" {q}")
-                answer, sources = self.rag.query(q)
-                section_content.append(answer)
-                all_sources.extend(sources)
-            results[section] = "\n".join(section_content[:2])
-        
-        # Format đẹp
-        standard_text = f"""
-            CHẨN ĐOÁN LÂM SÀNG:
-            {results['LAM_SANG']}
-
-            CHẨN ĐOÁN CẬN LÂM SÀNG:
-            {results['CAN_LAM_SANG']}
-
-            CHẨN ĐOÁN XÁC ĐỊNH:
-            {results['CHAN_DOAN_XAC_DINH']}
-
-            CHẨN ĐOÁN PHÂN BIỆT:
-            {results['CHAN_DOAN_PHAN_BIET']}
 
-            CÁCH ĐIỀU TRỊ:
-            {results['DIEU_TRI']}
-            """
+        raw: Dict[str, Tuple] = {}
+        with ThreadPoolExecutor(max_workers=2) as pool:
+            futures = {pool.submit(self.rag.query, q): key for key, q in tasks}
+            for future in as_completed(futures):
+                key = futures[future]
+                try:
+                    raw[key] = future.result()
+                except Exception as exc:
+                    print(f"[WARN] {key} query failed: {exc}")
+                    raw[key] = ("Khong tim thay thong tin", [])
+
+        all_sources: list = []
+        for key, _ in tasks:
+            all_sources.extend(raw.get(key, ("", []))[1])
+
+        def r(k): return raw.get(k, ("",))[0]
+
+        standard_text = (
+            f"CHAN DOAN:\n{r('CHAN_DOAN')}\n\n"
+            f"DIEU TRI:\n{r('DIEU_TRI')}"
+        )
         return standard_text, all_sources
-    
-    def detailed_evaluation(self, doctor_answer: str, standard_data: str):
-        """ĐÁNH GIÁ CHI TIẾT + DIỄN GIẢI"""
-        prompt = f"""
-            BẠN LÀ CHUYÊN GIA Y KHOA ĐÁNH GIÁ BÁC SĨ
-
-            CÂU TRẢ LỜI BÁC SĨ:
-            {doctor_answer}
-
-            KIẾN THỨC CHUẨN:
-            {standard_data}
 
-            PHÂN TÍCH CHI TIẾT (JSON):
-            {{
-            "diem_manh": ["..."],
-            "diem_yeu": ["..."],
-            "da_co": ["..."],
-            "thieu": ["..."],
-            "dien_giai": ["Giải thích vì sao đúng/thiếu..."],
-            "diem_so": "85/100",
-            "nhan_xet_tong_quan": "..."
-            }}
-
-            JSON PURE:
-            """
-        
-        result = self.evaluator_llm.invoke([prompt])
-        return result.content
+    def detailed_evaluation(self, doctor_answer: str, standard_data: str) -> str:
+        """Đánh giá ngắn gọn — JSON 4 trường, tối đa 300 token output."""
+        std = standard_data[:1200]
+        doc = doctor_answer[:600]
+        prompt = (
+            "Chuyên gia y khoa đánh giá câu trả lời bác sĩ. Trả về JSON thuần túy, KHÔNG giải thích thêm.\n\n"
+            f"CÂU TRẢ LỜI BÁC SĨ:\n{doc}\n\n"
+            f"KIẾN THỨC CHUẨN (tóm tắt):\n{std}\n\n"
+            "JSON format (ngắn gọn, mỗi mảng tối đa 3 phần tử):\n"
+            '{"diem_so":"85/100","nhan_xet_tong_quan":"2 câu tóm tắt","diem_manh":["...","..."],"thieu":["...","..."]}\n\n'
+            "JSON:"
+        )
+        return self._llm_invoke(prompt, temperature=0)

src/hybrid_retriever.py

@@ -1,39 +1,55 @@
 from langchain_community.vectorstores import FAISS
 import re
 
+# Vietnamese stop words — high-frequency words that corrupt keyword ranking signals
+VIETNAMESE_STOPWORDS = {
+    'và', 'là', 'của', 'có', 'cho', 'với', 'các', 'được', 'trong',
+    'đến', 'khi', 'này', 'bằng', 'theo', 'một', 'những', 'từ', 'hay',
+    'như', 'hoặc', 'về', 'tại', 'trên', 'sau', 'trước', 'cùng', 'để',
+    'không', 'cần', 'phải', 'nên', 'thể', 'vào', 'ra', 'đây', 'đó',
+    'nào', 'mà', 'thì', 'sẽ', 'đã', 'còn', 'vẫn', 'rất', 'nhiều',
+    'đặc', 'biệt', 'thêm', 'khác', 'tất', 'cả', 'nếu', 'bởi', 'vì',
+}
+
+
 class HybridRetriever:
     def __init__(self, vectorstore):
         self.vs = vectorstore
-    
+
     def keyword_search(self, query, k=5):
-        """Exact keyword matching - PRIORITY 1"""
-        keywords = re.findall(r'\b\w{3,}\b', query.lower())
+        """Exact keyword matching with Vietnamese stop-word filtering - PRIORITY 1"""
+        keywords = [
+            w for w in re.findall(r'\b\w{3,}\b', query.lower())
+            if w not in VIETNAMESE_STOPWORDS
+        ]
+        if not keywords:
+            return []
+
         scored_docs = []
-        
         for doc_id, doc in self.vs.docstore._dict.items():
             content_lower = doc.page_content.lower()
             title_lower = doc.metadata.get('chunk_title', '').lower()
-            
-            # Score cao nếu match title + content
-            score = sum(2 if kw in title_lower else 1 
-                       for kw in keywords if kw in content_lower or kw in title_lower)
-            
+
+            # Title match scores 2x; content match scores 1x
+            score = sum(
+                2 if kw in title_lower else 1
+                for kw in keywords
+                if kw in content_lower or kw in title_lower
+            )
             if score > 0:
                 scored_docs.append((score, doc))
-        
+
         scored_docs.sort(reverse=True, key=lambda x: x[0])
         return [doc for _, doc in scored_docs[:k]]
-    
+
     def hybrid_search(self, query, k=3):
         """KEYWORD FIRST → Semantic backup"""
-        # PRIORITY 1: Keyword exact match
-        keyword_docs = self.keyword_search(query, k=k*2)
-        
+        keyword_docs = self.keyword_search(query, k=k * 2)
+
         if keyword_docs:
             print(f" KEYWORD HIT: {len(keyword_docs)} docs")
             return keyword_docs[:k]
-        
-        # PRIORITY 2: Semantic fallback
+
         print(" Semantic fallback...")
         semantic_docs = self.vs.similarity_search(query, k=k)
         return semantic_docs

src/key_manager.py

@@ -0,0 +1,65 @@
+"""
+GroqKeyManager — round-robin key rotation with immediate failover on 429.
+
+Usage:
+    mgr = GroqKeyManager([KEY_1, KEY_2])
+    key = mgr.current()           # get current key
+    key = mgr.rotate()            # advance to next key (call on 429)
+    llm = mgr.build_llm(model)    # ChatGroq with current key
+"""
+import threading
+import time
+import logging
+from typing import List
+
+from langchain_groq import ChatGroq
+
+logger = logging.getLogger(__name__)
+
+
+class GroqKeyManager:
+    """Thread-safe round-robin Groq API key manager."""
+
+    def __init__(self, keys: List[str], model: str = "llama-3.3-70b-versatile"):
+        self._keys = [k.strip() for k in keys if k and k.strip()]
+        if not self._keys:
+            raise ValueError("GroqKeyManager: no valid API keys provided")
+        self._model = model
+        self._idx = 0
+        self._lock = threading.Lock()
+        # per-key cooldown tracking: key → expiry timestamp
+        self._cooldown: dict[str, float] = {}
+        logger.info(f"[KeyManager] {len(self._keys)} Groq key(s) loaded, model={model}")
+
+    def current(self) -> str:
+        with self._lock:
+            return self._keys[self._idx % len(self._keys)]
+
+    def rotate(self) -> str:
+        """Advance to next available (non-cooled-down) key. Returns the new key."""
+        with self._lock:
+            now = time.time()
+            for _ in range(len(self._keys)):
+                self._idx = (self._idx + 1) % len(self._keys)
+                key = self._keys[self._idx]
+                if now >= self._cooldown.get(key, 0):
+                    logger.warning(f"[KeyManager] Rotated to key index {self._idx}")
+                    return key
+            # all keys on cooldown — return current and let tenacity wait
+            logger.warning("[KeyManager] All keys on cooldown, returning current key")
+            return self._keys[self._idx % len(self._keys)]
+
+    def mark_rate_limited(self, key: str, cooldown_secs: int = 62):
+        """Mark a key as rate-limited for cooldown_secs seconds."""
+        with self._lock:
+            self._cooldown[key] = time.time() + cooldown_secs
+            logger.warning(f"[KeyManager] Key ...{key[-6:]} cooled down for {cooldown_secs}s")
+
+    def build_llm(self, temperature: float = 0) -> ChatGroq:
+        """Return a ChatGroq instance using the current key."""
+        return ChatGroq(
+            model=self._model,
+            api_key=self.current(),
+            temperature=temperature,
+            max_tokens=800,   # cap output tokens to save quota
+        )

src/rag_chain.py

@@ -1,83 +1,75 @@
-from langchain_google_genai import ChatGoogleGenerativeAI
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception
 from langchain_core.prompts import PromptTemplate
 from config import Config
+from key_manager import GroqKeyManager
 from hybrid_retriever import HybridRetriever
 from vector_store import VectorStoreManager
 
-class RAGChain:
-    def __init__(self, vector_store_manager: VectorStoreManager):
-        self.llm = ChatGoogleGenerativeAI(
-            model=Config.LLM_MODEL,
-            google_api_key=Config.GOOGLE_API_KEY,
-            temperature=0  #  0 để deterministic
+# Shared key manager -- single instance reused across all RAGChain objects
+_KEY_MANAGER = None
+
+
+def get_key_manager():
+    global _KEY_MANAGER
+    if _KEY_MANAGER is None:
+        _KEY_MANAGER = GroqKeyManager(
+            keys=[Config.GROQ_API_KEY_1, Config.GROQ_API_KEY_2],
+            model=Config.GROQ_MODEL,
         )
-        
-        self.vectorstore = vector_store_manager.vector_store
-        self.retriever = HybridRetriever(self.vectorstore)  #  FIX TYPO
-        
-        #  PROMPT MỚI: TRẢ NỘI DUNG CHUNK + TÓM TẮT
-        self.custom_prompt = PromptTemplate(
-            input_variables=["context", "question"],
-            template="""
-        Bạn là bác sĩ y khoa. Dựa vào TÀI LIỆU sau:
+    return _KEY_MANAGER
 
-        CONTEXT:
-        {context}
 
-        CÂU HỎI: {question}
+def _is_rate_limit(exc):
+    msg = str(exc).lower()
+    return "429" in msg or "quota" in msg or "rate limit" in msg or "ratelimit" in msg
 
-        TRẢ LỜI:
-        1. TRÍCH DẪN ĐÚNG nội dung từ CONTEXT (giữ nguyên văn bản)
-        2. Tóm tắt ngắn gọn nếu cần
-        3. Luôn ưu tiên thông tin từ chunk chính xác nhất
 
-        NỘI DUNG TÀI LIỆU:
-        """
+class RAGChain:
+    def __init__(self, vector_store_manager):
+        self._km = get_key_manager()
+        self.vectorstore = vector_store_manager.vector_store
+        self.retriever = HybridRetriever(self.vectorstore)
+        self.prompt_template = PromptTemplate(
+            input_variables=["context", "question"],
+            template="Tài liệu y khoa:\n{context}\n\nCâu hỏi: {question}\n\nTrả lời ngắn gọn, chọn lọc thông tin quan trọng nhất từ tài liệu (tối đa 200 từ):"
         )
-    
-    def query(self, question: str):
-        """HYBRID RETRIEVAL + FULL CHUNK CONTENT"""
-        
-        #  BƯỚC 1: HYBRID SEARCH - PRIORITY KEYWORD
-        sources = self.retriever.hybrid_search(question, k=4)
-        
-        #  BƯỚC 2: RE-RANK theo keyword match
-        ranked_sources = self.rerank_sources(sources, question)
-        
-        #  BƯỚC 3: Tạo context FULL CONTENT
-        context = self.build_context(ranked_sources)
-        
-        #  BƯỚC 4: Generate với prompt rõ ràng
-        formatted_prompt = self.custom_prompt.format(
-            context=context, 
-            question=question
+
+    def query(self, question):
+        sources = self.retriever.hybrid_search(question, k=3)
+        ranked = self.rerank_sources(sources, question)
+        context = self.build_context(ranked)
+        prompt = self.prompt_template.format(context=context, question=question)
+
+        @retry(
+            retry=retry_if_exception(_is_rate_limit),
+            wait=wait_exponential(multiplier=1, min=5, max=30),
+            stop=stop_after_attempt(4),
+            reraise=True,
         )
-        
-        result = self.llm.invoke([formatted_prompt])
-        return result.content, ranked_sources
-    
+        def _invoke():
+            try:
+                llm = self._km.build_llm(temperature=0)
+                return llm.invoke([prompt])
+            except Exception as exc:
+                if _is_rate_limit(exc):
+                    self._km.mark_rate_limited(self._km.current())
+                    self._km.rotate()
+                raise
+
+        result = _invoke()
+        return result.content, ranked
+
     def rerank_sources(self, sources, question):
-        """RE-RANK: Keyword match > Semantic"""
         keywords = question.lower().split()
-        
-        def score_doc(doc):
-            content = doc.page_content.lower()
-            title = doc.metadata.get('chunk_title', '').lower()
-            score = sum(1 for kw in keywords if kw in content or kw in title)
-            return score
-        
-        return sorted(sources, key=score_doc, reverse=True)
-    
+        def score(doc):
+            text = doc.page_content.lower() + doc.metadata.get("chunk_title", "").lower()
+            return sum(1 for kw in keywords if kw in text)
+        return sorted(sources, key=score, reverse=True)
+
     def build_context(self, sources):
-        """FULL CHUNK CONTENT + METADATA"""
-        context_parts = []
+        parts = []
         for i, doc in enumerate(sources[:3]):
-            file = doc.metadata.get('source_file', 'N/A')
-            chunk_title = doc.metadata.get('chunk_title', 'N/A')
-            section_title = doc.metadata.get('section_title', 'N/A')
-            
-            context_parts.append(
-                f"[{i+1}] {file} | {chunk_title} | {section_title}\n"
-                f"NỘI DUNG:\n{doc.page_content}\n{'='*80}"
-            )
-        return "\n\n".join(context_parts)
+            meta = f"[{i+1}] {doc.metadata.get('source_file','?')} | {doc.metadata.get('chunk_title','?')}"
+            content = doc.page_content[:600]
+            parts.append(f"{meta}\n{content}")
+        return "\n\n".join(parts)

src/session_store.py

@@ -0,0 +1,106 @@
+"""
+SQLite-backed session store with TTL for RAG sessions.
+Replaces the in-memory dict to persist sessions across server restarts
+and prevent unbounded memory growth.
+"""
+import sqlite3
+import json
+import time
+from pathlib import Path
+from typing import Optional, Dict, Any
+
+SESSION_TTL_SECONDS = 24 * 60 * 60  # 24 hours
+
+
+class SessionStore:
+    def __init__(self, db_path: Optional[str] = None):
+        if db_path is None:
+            db_path = str(Path(__file__).parent.parent / "sessions.db")
+        self.db_path = db_path
+        self._init_db()
+        print(f"[SessionStore] SQLite store at: {self.db_path}")
+
+    def _get_conn(self) -> sqlite3.Connection:
+        conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        conn.execute("PRAGMA journal_mode=WAL")  # Better concurrent read performance
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def _init_db(self):
+        with self._get_conn() as conn:
+            conn.execute(
+                """
+                CREATE TABLE IF NOT EXISTS sessions (
+                    session_id TEXT PRIMARY KEY,
+                    data       TEXT NOT NULL,
+                    created_at REAL NOT NULL,
+                    updated_at REAL NOT NULL
+                )
+                """
+            )
+            conn.commit()
+
+    def get(self, session_id: str) -> Optional[Dict[str, Any]]:
+        """Return session data or None if not found / expired."""
+        with self._get_conn() as conn:
+            row = conn.execute(
+                "SELECT data, updated_at FROM sessions WHERE session_id = ?",
+                (session_id,),
+            ).fetchone()
+
+        if row is None:
+            return None
+
+        if time.time() - row["updated_at"] > SESSION_TTL_SECONDS:
+            self.delete(session_id)
+            return None
+
+        return json.loads(row["data"])
+
+    def set(self, session_id: str, data: Dict[str, Any]):
+        """Persist or update a session (all values must be JSON-serialisable)."""
+        now = time.time()
+        data_json = json.dumps(data, ensure_ascii=False)
+        with self._get_conn() as conn:
+            conn.execute(
+                """
+                INSERT INTO sessions (session_id, data, created_at, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(session_id) DO UPDATE
+                    SET data = excluded.data, updated_at = excluded.updated_at
+                """,
+                (session_id, data_json, now, now),
+            )
+            conn.commit()
+
+    def delete(self, session_id: str):
+        with self._get_conn() as conn:
+            conn.execute(
+                "DELETE FROM sessions WHERE session_id = ?", (session_id,)
+            )
+            conn.commit()
+
+    def cleanup_expired(self) -> int:
+        """Delete all sessions older than SESSION_TTL_SECONDS. Returns count deleted."""
+        cutoff = time.time() - SESSION_TTL_SECONDS
+        with self._get_conn() as conn:
+            cur = conn.execute(
+                "DELETE FROM sessions WHERE updated_at < ?", (cutoff,)
+            )
+            conn.commit()
+            deleted = cur.rowcount
+        if deleted:
+            print(f"[SessionStore] Cleaned up {deleted} expired session(s)")
+        return deleted
+
+    def cleanup_expired(self) -> int:
+        """Remove sessions older than TTL. Returns number of rows deleted."""
+        cutoff = time.time() - SESSION_TTL_SECONDS
+        with self._get_conn() as conn:
+            deleted = conn.execute(
+                "DELETE FROM sessions WHERE updated_at < ?", (cutoff,)
+            ).rowcount
+            conn.commit()
+        if deleted:
+            print(f"[SessionStore] Cleaned up {deleted} expired session(s)")
+        return deleted

src/vector_store.py

@@ -4,7 +4,7 @@ from embeddings import EmbeddingsManager
 from typing import List
 from pathlib import Path
 import json
-from pymongo import MongoClient
+# pymongo is only needed for save_documents(); imported lazily below
 
 from data_loader import DataLoader
 
@@ -72,8 +72,8 @@ class VectorStoreManager:
         return self.vector_store.as_retriever(search_kwargs={"k": k})  
     
     def save_documents(self, docs):
-
-        output_dir = Path(r"D:\Storage\rag_project\store")
+        from pymongo import MongoClient  # optional dependency
+        output_dir = Path(__file__).parent.parent / "store"
         output_dir.mkdir(parents=True, exist_ok=True)
 
         records = []