Add RAG integration: Flask API server, disease selector, evaluation system with improved case generation

.env.example

@@ -0,0 +1,15 @@
+# RAG Project Configuration
+
+# Gemini API Key for RAG evaluation
+GOOGLE_API_KEY=your_gemini_api_key_here
+
+# Embedding Model
+EMBEDDING_MODEL=VoVanPhuc/sup-SimCSE-VietNamese-phobert-base
+
+# Flask API Configuration
+FLASK_PORT=5000
+FLASK_HOST=0.0.0.0
+FLASK_DEBUG=True
+
+# FAISS Configuration
+FAISS_INDEX_PATH=faiss_cache/faiss_index

.gitignore

@@ -0,0 +1,22 @@
+# secrets
+.env
+*.env
+
+# python
+__pycache__/
+*.pyc
+.venv/
+venv/
+
+# vscode
+.vscode/
+
+# data & cache (RAG)
+faiss_cache/
+store/
+wandb/
+
+# model files
+*.bin
+*.pt
+*.ckpt

api_server.py

@@ -0,0 +1,262 @@
+"""
+Flask API Server để tích hợp RAG vào Chatbot
+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
+"""
+
+from flask import Flask, request, jsonify
+from flask_cors import CORS
+import json
+import sys
+import os
+
+# Add src to path
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from data_loader import DataLoader
+from config import Config
+from doctor_evaluator import DoctorEvaluator
+from vector_store import VectorStoreManager
+from rag_chain import RAGChain
+
+app = Flask(__name__)
+CORS(app)  # Enable CORS for React app
+
+# Initialize RAG system
+print("🚀 Initializing RAG system...")
+vs_manager = VectorStoreManager()
+if not vs_manager.vector_store:
+    print("❌ FAISS index not found. Run: python build_faiss.py")
+    sys.exit(1)
+
+rag = RAGChain(vs_manager)
+evaluator = DoctorEvaluator(rag)
+print("✅ RAG system ready!")
+
+# Store active sessions
+active_sessions = {}
+
+
+@app.route('/api/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({
+        'status': 'healthy',
+        'message': 'RAG API Server is running',
+        'embedding_model': Config.EMBEDDING_MODEL
+    })
+
+
+@app.route('/api/diseases', methods=['GET'])
+def get_diseases():
+    """
+    Lấy danh sách bệnh từ 3 file JSON (Index field)
+    Returns: { diseases: [{ id, name, category, source }] }
+    """
+    try:
+        diseases = []
+        data_dir = os.path.join(os.path.dirname(__file__), 'data')
+        
+        # Mapping files to categories
+        files = [
+            ('BoYTe200_v3.json', 'procedures'),
+            ('NHIKHOA2.json', 'pediatrics'),
+            ('PHACDODIEUTRI_2016.json', 'treatment')
+        ]
+        
+        for filename, category in files:
+            filepath = os.path.join(data_dir, filename)
+            with open(filepath, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                for item in data:
+                    diseases.append({
+                        'id': f"{category}_{item['id']}",
+                        'name': item['Index'],
+                        'category': category,
+                        'source': filename,
+                        'sections': item.get('level1_items', [])
+                    })
+        
+        return jsonify({
+            'success': True,
+            'diseases': diseases,
+            'total': len(diseases)
+        })
+    
+    except Exception as e:
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/start-case', methods=['POST'])
+def start_case():
+    """
+    Nhận tên bệnh, tìm triệu chứng và tạo case
+    Input: { disease: string, sessionId: string }
+    Output: { case: string, symptoms: string, sessionId: string }
+    """
+    try:
+        data = request.json
+        disease = data.get('disease', '').strip()
+        session_id = data.get('sessionId')
+        
+        if not disease:
+            return jsonify({
+                'success': False,
+                'error': 'Disease name is required'
+            }), 400
+        
+        print(f"📋 Starting case for disease: {disease}")
+        
+        # 1. RAG tìm triệu chứng
+        print("🔍 Finding symptoms...")
+        symptoms, symptom_sources = evaluator.find_symptoms(disease)
+        
+        # 2. Gemini tạo case
+        print("✍️ Generating patient case...")
+        patient_case = evaluator.generate_case(disease, symptoms)
+        
+        # Store session data
+        session_data = {
+            'disease': disease,
+            'symptoms': symptoms,
+            'case': patient_case,
+            'symptom_sources': [
+                {
+                    'file': doc.metadata.get('source_file', ''),
+                    'title': doc.metadata.get('main_title', ''),
+                    'section': doc.metadata.get('sub_title', '')
+                }
+                for doc in symptom_sources[:3]
+            ]
+        }
+        active_sessions[session_id] = session_data
+        
+        return jsonify({
+            'success': True,
+            'sessionId': session_id,
+            'case': patient_case,
+            'symptoms': symptoms[:300] + "...",  # Truncate for display
+            'sources': session_data['symptom_sources']
+        })
+    
+    except Exception as e:
+        print(f"❌ Error in start_case: {str(e)}")
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+@app.route('/api/evaluate', methods=['POST'])
+def evaluate_diagnosis():
+    """
+    Nhận câu trả lời user, so sánh với đáp án chuẩn
+    Input: { 
+        sessionId: string,
+        diagnosis: {
+            clinical: string,
+            paraclinical: string,
+            definitiveDiagnosis: string,
+            differentialDiagnosis: string,
+            treatment: string,
+            medication: string
+        }
+    }
+    Output: {
+        standardAnswer: { ... },
+        evaluation: { ... },
+        sources: [ ... ]
+    }
+    """
+    try:
+        data = request.json
+        session_id = data.get('sessionId')
+        diagnosis = data.get('diagnosis', {})
+        
+        if not session_id or session_id not in active_sessions:
+            return jsonify({
+                'success': False,
+                'error': 'Invalid session ID'
+            }), 400
+        
+        session_data = active_sessions[session_id]
+        disease = session_data['disease']
+        
+        print(f"📊 Evaluating diagnosis for: {disease}")
+        
+        # Format user's answer
+        user_answer = f"""
+CHẨN ĐOÁN:
+- Lâm sàng: {diagnosis.get('clinical', 'Không có')}
+- Cận lâm sàng: {diagnosis.get('paraclinical', 'Không có')}
+- Chẩn đoán xác định: {diagnosis.get('definitiveDiagnosis', 'Không có')}
+- Chẩn đoán phân biệt: {diagnosis.get('differentialDiagnosis', 'Không có')}
+
+KẾ HOẠCH ĐIỀU TRỊ:
+- Cách điều trị: {diagnosis.get('treatment', 'Không có')}
+- Thuốc: {diagnosis.get('medication', 'Không có')}
+"""
+        
+        print("🔍 Finding standard answer...")
+        # Get standard answer from RAG
+        standard_data, all_sources = evaluator.get_detailed_standard_knowledge(disease)
+        
+        print("🤖 Evaluating with Gemini...")
+        # Evaluate with Gemini
+        evaluation_json = evaluator.detailed_evaluation(user_answer, standard_data)
+        
+        # Parse JSON from evaluation
+        try:
+            # Extract JSON from markdown code blocks if present
+            eval_text = evaluation_json.strip()
+            if eval_text.startswith('```'):
+                eval_text = eval_text.split('```')[1]
+                if eval_text.startswith('json'):
+                    eval_text = eval_text[4:]
+            evaluation_obj = json.loads(eval_text.strip())
+        except:
+            # If parsing fails, return as text
+            evaluation_obj = {
+                'evaluation_text': evaluation_json,
+                'diem_so': 'N/A'
+            }
+        
+        # Format sources
+        formatted_sources = [
+            {
+                'file': doc.metadata.get('source_file', ''),
+                'title': doc.metadata.get('main_title', ''),
+                'section': doc.metadata.get('sub_title', ''),
+                'content': doc.page_content[:200] + "..."
+            }
+            for doc in all_sources[:5]
+        ]
+        
+        return jsonify({
+            'success': True,
+            'case': session_data['case'],
+            'standardAnswer': standard_data,
+            'evaluation': evaluation_obj,
+            'sources': formatted_sources
+        })
+    
+    except Exception as e:
+        print(f"❌ Error in evaluate: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return jsonify({
+            'success': False,
+            'error': str(e)
+        }), 500
+
+
+if __name__ == '__main__':
+    print("🌟 Starting Flask API Server...")
+    print(f"📡 Server will run on http://localhost:5000")
+    print(f"🔑 Using API Key: {Config.GOOGLE_API_KEY[:20]}...")
+    app.run(debug=True, host='0.0.0.0', port=5000)

requirements.txt

@@ -0,0 +1,16 @@
+langchain-core>=0.3.17,<0.4.0
+langchain-community>=0.3.7,<0.4.0
+langchain-huggingface
+langchain-google-genai
+
+faiss-cpu
+sentence-transformers
+google-generativeai
+python-dotenv
+
+
+unsloth
+transformers
+torch
+accelerate
+bitsandbytes

requirements_api.txt

@@ -0,0 +1,2 @@
+flask==3.0.0
+flask-cors==4.0.0

src/build_faiss.py

@@ -0,0 +1,9 @@
+from vector_store import VectorStoreManager
+from data_loader import DataLoader
+
+if __name__ == "__main__":
+    print(" BUILD FAISS CACHE (2p)")
+    all_docs = DataLoader.load_all_chunks()
+    vs = VectorStoreManager()
+    vs.build_and_cache(all_docs)  # Embed + SAVE
+    print(" DONE! Cache ready!")

src/config.py

@@ -0,0 +1,29 @@
+import os
+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"
+    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 
+    # 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
+"""

src/data_loader.py

@@ -0,0 +1,68 @@
+import json 
+from pathlib import Path
+from typing import List
+from langchain_core.documents import Document
+from config import Config
+
+class DataLoader:
+    @staticmethod
+    def load_all_chunks() -> List[Document]:
+        BASE_DIR = Path(Config.BASE_DIR)
+        DATA_DIR = BASE_DIR / 'data'
+        all_docs = []
+        
+        json_files = [Path(f) for f in Config.CHUNK_FILES if Path(f).exists()]
+        print("LOADING CHUNKS TỪ TẤT CẢ JSON:")
+        
+        for json_file in json_files:
+            print(f"{json_file.name}...")
+            with open(json_file, 'r', encoding='utf-8') as f:
+                chapters = json.load(f)
+            
+            #  MỖI chap = 1 chunk
+            """
+            #  Gom lại theo 1 FILE JSON - CÓ 1 SAMPLE - 1 CHUNK 
+            # file_chunks chứa all chunks của json đó 
+            # Các chunk được tổ chức lại theo DOCUMENT (page_content + metadata)
+            # Với page_content là từng content trong contents của section
+            """
+            file_chunks = []
+            for chap in chapters:
+                chunk = {
+                    "chunk_id": chap.get("id"),
+                    "title": chap.get("Index"),
+                    "level1_items": chap.get("level1_items", []),
+                    "contents": chap.get("contents", [])
+                }
+                # Mặc dù là content khác nhau nhưng vẫn thuộc cùng chunk_id, chunk_title
+                for i, section in enumerate(chunk["contents"]):
+                    doc = Document(
+                        page_content=section.get("content", ""),
+                        metadata={
+                            "source_file": json_file.name,
+                            "chunk_id": str(chunk["chunk_id"]),
+                            "chunk_title": chunk["title"],
+                            "section_id": f"{chunk['chunk_id']}.{i+1}",
+                            "section_title": section.get("title", "")
+                        }
+                    )
+                    file_chunks.append(doc)
+            
+            all_docs.extend(file_chunks)
+            print(f"{len(file_chunks)} docs từ {len(chapters)} chunks")
+        
+        print(f"\nTỔNG {len(all_docs)} documents!")
+        return all_docs
+
+# TEST: python data_loader.py
+if __name__ == "__main__":
+    docs = DataLoader.load_all_chunks()
+    print("\n SAMPLE DOC:")
+    print("Content:", docs[0].page_content)
+    print("Metadata:", docs[0].metadata) 
+
+    """
+    OUTPUT SAMPLE
+Content: Đặt stent khí  phế quản là kỹ thuật đặt một giá đỡ vào khí, phế quản làm rộng và duy trì khẩu kính đường thở để điều trị một số trường hợp hẹp khí, phế quản bẩm sinh hoặc mắc phải. Đặt stent có thể th
+Metadata: {'source_file': 'BoYTe200_v3.json', 'chunk_id': '1', 'chunk_title': 'NỘI SOI ĐẶT STENT KHÍ PHẾ QUẢN BẰNG ỐNG CỨNG', 'section_id': '1.1', 'section_title': 'ĐẠI CƯƠNG'}
+    """

src/doctor_evaluator.py

@@ -0,0 +1,166 @@
+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
+
+class DoctorEvaluator:
+    def __init__(self, rag):
+        self.rag = rag
+        self.evaluator_llm = ChatGoogleGenerativeAI(
+            model="gemini-2.5-flash",
+            google_api_key=Config.GOOGLE_API_KEY,
+            temperature=0.1
+        )
+        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} lâm sàng",
+            f"{disease} triệu chứng",
+            f"{disease} dấu hiệu"
+        ]
+        
+        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']}
+            """
+        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

src/embeddings.py

@@ -0,0 +1,65 @@
+from langchain_huggingface import HuggingFaceEmbeddings
+from config import Config 
+from numpy import dot
+from numpy.linalg import norm
+
+class EmbeddingsManager:
+    # Khởi tạo model embedding từ cofig ngay khi gọi class
+    def __init__(self):
+        self.embeddings = HuggingFaceEmbeddings(
+            model_name=Config.EMBEDDING_MODEL
+        )
+    
+    def get_embeddings(self):
+        return self.embeddings 
+
+# Code thêm cái này xíu hiểu hơn bản chất so sánh vector embed
+def cosine(a, b):
+    return dot(a, b) / (norm(a) * norm(b))
+
+# TEST: python embeddings.py
+if __name__ == "__main__":
+    print("Loading embedding model...")
+    em = EmbeddingsManager()
+    embeddings = em.get_embeddings()
+
+    text = "Sốt ở trẻ em là tình trạng thân nhiệt tăng."
+    vec = embeddings.embed_query(text)
+
+    print("Vector length:", len(vec))
+    print("First 5 values:", vec[:5])  
+
+     # ---- Test 2: cosine similarity ----
+    v1 = embeddings.embed_query("Sốt ở trẻ em")
+    v2 = embeddings.embed_query("Trẻ bị sốt cao")
+    v3 = embeddings.embed_query("Gãy xương tay")
+
+    print("\n COSINE SIMILARITY TEST")
+    print("v1 ↔ v2 (gần nghĩa):", cosine(v1, v2))
+    print("v1 ↔ v3 (khác nghĩa):", cosine(v1, v3))
+
+    """ 
+     OUTPUT VÀ EXPLAIN DỄ HIỂU: 
+     1. OUTPUT: 
+     Vector length: 384
+     First 5 values: [-0.02630099654197693, 0.01091383583843708, 0.0058159008622169495, -0.05811420455574989, -0.051191169768571854]
+    
+     2. EXPLAIN 
+    - Là tọa độ ngữ nghĩa của câu
+
+    - Không có ý nghĩa đơn lẻ
+
+    - Chỉ có ý nghĩa khi so sánh với vector khác
+        
+        v1 = embed("Sốt ở trẻ em")
+        v2 = embed("Trẻ bị sốt cao")
+        v3 = embed("Gãy xương tay") 
+
+       => v1 ≈ v2   (gần)
+          v1 ≠ v3   (xa)
+        
+    => FAISS dùng cosine similarity / L2 distance để tìm câu gần nghĩa nhất
+
+    """
+
+

src/hybrid_retriever.py

@@ -0,0 +1,39 @@
+from langchain_community.vectorstores import FAISS
+import re
+
+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())
+        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)
+            
+            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)
+        
+        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/main.py

@@ -0,0 +1,166 @@
+from data_loader import DataLoader
+from config import Config
+from doctor_evaluator import DoctorEvaluator
+from vector_store import VectorStoreManager
+from rag_chain import RAGChain
+
+def main():
+    # print("LOADING TẤT CẢ CHUNKS...")
+    
+    # # 1. Load TẤT CẢ 3 JSON → Gộp 1 lần
+    # docs = DataLoader.load_all_chunks()
+    
+    # 2. Build FAISS chung
+    vs_manager = VectorStoreManager()
+    # vs_manager.build_from_docs(docs)
+    if not vs_manager.vector_store:
+        print("Chạy: python build_faise.py trước")
+    # 3. Tạo RAG chain
+    rag = RAGChain(vs_manager)
+     
+    print("\n CHATBOT Y TẾ READY!")
+    print(f"API KEY: {Config.GOOGLE_API_KEY}")
+    print(f"Embedding: {Config.EMBEDDING_MODEL}")  
+    print(" Gõ câu hỏi (quit để thoát)")
+    print("-" * 50)
+    
+    print("\n CHỈNH THỨC: 1=Chatbot | 2=Đánh giá bác sĩ")
+    mode = input("Chọn mode (1/2): ").strip()
+    
+    if mode == "2":
+        """
+        # evaluator = DoctorEvaluator(rag)
+        # print("\n ĐÁNH GIÁ BÁC SĨ")
+        # print("Format: Bệnh + Triệu chứng + Trả lời bác sĩ")
+        
+        # disease = input("Bệnh: ").strip()
+        # symptoms = input("Triệu chứng: ").strip()
+        # doctor_answer = input("Trả lời bác sĩ: ").strip()
+        """
+        # standard, evaluation = evaluator.evaluate_doctor(disease, symptoms, doctor_answer)
+        
+        # print("\n ĐÁP ÁN CHUẨN:")
+        # print(standard)
+        # print("\n  NHẬN XÉT:")
+        # print(evaluation) 
+
+        """
+        1. Nhận case: gồm bệnh + triệu chứng 
+        2. Nhận câu trả lời của bác sĩ cho case
+        2. RAG truy tìm đáp án chuẩn (CHẨN ĐOÁN + ĐIỀU TRỊ) của case đó
+        3. So sánh câu trả lời của bác sĩ vs key answer qua gemini theo các tiêu chí (điem manh, diem yeu, da co, thieu, nhan xet tong quan)
+        """ 
+
+        """
+        CÓ THỂ THAY ĐỔI LUỒNG TRÊN THÀNH: 
+        1. Nhận mỗi triệu chứng --> RAG ra được tên bệnh --> RAG tiếp tên bệnh + CHẨN ĐOÁN + ĐIỀU TRỊ (có thể thêm nếu cần thiết)
+        """
+
+        """
+        NHỮNG THỨ CẦN RAG ĐƯỢC: 
+        1. Nhận một câu bất kỳ nằm trong pdf --> RAG đúng mục chứa câu đó 
+        VD: Liều:
+        +Trẻ ≤ 5 tuổi: 4 mg
+        +Trẻ ≥ 5 tuổi và ≤ 13 (15) tuổi: 5 mg
+        +Trẻ ≥ 13 (15) tuổi: 10 mg 
+        ==> SUYỄN TRẺ EM (VI. PHÒNG NGỪA)
+        2. Nhận triêu chứng --> RAG đúng bệnh có triệu chứng đó 
+        3. Nhận mục --> RAG đúng mục đó trả về 
+
+        """
+
+        # result = evaluator.evaluate_doctor(disease, symptoms, doctor_answer)
+
+         
+        # print("\n ĐÁP ÁN CHUẨN:")
+        # print(result['standard'])  
+
+
+        disease = input("\nBỆNH: ").strip()
+        
+        evaluator = DoctorEvaluator(rag)
+        result = evaluator.evaluate_doctor(disease)
+        
+        print("=" * 80)
+        print("\nTHU THẬP ĐẦY ĐỦ - TIẾN HÀNH LUỒNG")
+        print("=" * 80)
+        print("\nCASE BỆNH NHÂN:")
+        print(result['case'])
+        print("=" * 80)
+        print("\nĐÁP ÁN CHUẨN:")
+        print(result['standard'])
+        print("=" * 80)
+        print("\nPHÂN TÍCH CHI TIẾT:")
+        print(result['evaluation'])
+
+         #  TOP 1 + TÀI LIỆU
+        print("\n TOP 1 CHẮC CHẮN:")
+        if result['sources'] and result['sources'][0]:
+            top_doc = result['sources'][0]
+            print(f"[{top_doc.metadata['source_file']}]")
+            print(f" {top_doc.metadata['chunk_title']}")
+            print(f" {top_doc.metadata['section_title']}")
+            print(f" {top_doc.page_content.strip()[:300]}")
+            print()
+        
+        print(" TÀI LIỆU THAM KHẢO:")
+        if result['sources']:
+            for i, doc in enumerate(result['sources'][:3], 1):
+                file = doc.metadata.get("source_file", "N/A")
+                chunk_id = doc.metadata.get("chunk_id", "N/A")
+                chunk_title = doc.metadata.get("chunk_title", "N/A")
+                section_id = doc.metadata.get("section_id", "N/A")
+                section_title = doc.metadata.get("section_title", "N/A")
+                preview = doc.page_content[:80] + "..." 
+                print(f" {i}. [{file}] {chunk_id} | {chunk_title} | {section_id} | {section_title}")
+                print(f"     {preview}")
+            print()
+    
+    else:
+        print("\n CHATBOT Y TẾ READY!")
+        print(f"API KEY: {Config.GOOGLE_API_KEY}")
+        print(f"Embedding: {Config.EMBEDDING_MODEL}")
+        print("Gõ câu hỏi (quit để thoát)")
+        print("-" * 50)
+        
+        # 4. CHAT LOOP - CHỈ HỎI → TRẢ LỜI
+        while True:
+            query = input(" Bạn: ").strip()
+            if query.lower() in ['quit', 'exit', 'bye']:
+                print(" Tạm biệt!")
+                break
+            
+            if not query:
+                continue
+                
+            print(" Đang trả lời...")
+            answer, sources = rag.query(query)  # LẤY CẢ sources
+            
+            print(f"\n Trả lời: {answer}\n")
+
+            #  TOP 1 CHẮC CHẮN - FULL CONTENT
+            if sources and sources[0]:
+                top_doc = sources[0]
+                print(" TOP 1 CHẮC CHẮN:")
+                print(f" [{top_doc.metadata['source_file']}]")
+                print(f"  {top_doc.metadata['chunk_title']}")
+                print(f"  {top_doc.metadata['section_title']}")
+                print(f"  {top_doc.page_content.strip()[:300]}")  # FULL content
+                print()
+            
+            #  IN 3 RETRIEVED DOCS
+            if sources:
+                print(" TÀI LIỆU THAM KHẢO:")
+                for i, doc in enumerate(sources[:3], 1):  # Top 3
+                    file = doc.metadata.get("source_file", "N/A")
+                    chunk_id = doc.metadata.get("chunk_id", "N/A")
+                    chunk_title = doc.metadata.get("chunk_title", "N/A")
+                    section_id = doc.metadata.get("section_id", "N/A")
+                    section_title = doc.metadata.get("section_title", "N/A")
+                    preview = doc.page_content[:80] + "..." 
+                    print(f"  {i}. [{file}] {chunk_id} | {chunk_title} | {section_id} | {section_title}")
+                    print(f"     {preview}")
+                print()
+
+if __name__ == "__main__":
+    main()

src/rag_chain.py

@@ -0,0 +1,83 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_core.prompts import PromptTemplate
+from config import Config
+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
+        )
+        
+        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:
+
+        CONTEXT:
+        {context}
+
+        CÂU HỎI: {question}
+
+        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:
+        """
+        )
+    
+    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
+        )
+        
+        result = self.llm.invoke([formatted_prompt])
+        return result.content, ranked_sources
+    
+    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 build_context(self, sources):
+        """FULL CHUNK CONTENT + METADATA"""
+        context_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)

src/vector_store.py

@@ -0,0 +1,169 @@
+from langchain_community.vectorstores import FAISS
+from langchain_core.documents import Document
+from embeddings import EmbeddingsManager
+from typing import List
+from pathlib import Path
+import json
+from pymongo import MongoClient
+
+from data_loader import DataLoader
+
+class VectorStoreManager:
+    def __init__(self):
+        self.embeddings_manager = EmbeddingsManager()
+        self.embeddings = self.embeddings_manager.get_embeddings() #  Chứa model embedding từ class EmbeddingsManager
+        self.vector_store = None
+        # Use relative path from current file location
+        current_dir = Path(__file__).parent.parent  # Go up to rag_project folder
+        self.cache_dir = current_dir / "faiss_cache"
+        self.cache_dir.mkdir(parents=True, exist_ok=True)   
+
+        self.load_faiss_cache() 
+
+    def load_faiss_cache(self):
+        """LOAD FAISS 0.1s"""
+        index_path = self.cache_dir / "faiss_index"
+        if index_path.exists():
+            print(" LOADING FAISS CACHE...")
+            self.vector_store = FAISS.load_local(
+                str(index_path), 
+                self.embeddings, 
+                allow_dangerous_deserialization=True
+            )
+            print(f"LOADED {len(self.vector_store.docstore._dict)} chunks!")
+            return True
+        return False
+
+    def build_and_cache(self, docs):
+        """EMBED + SAVE"""
+        #  FIX: Chỉ check 1 lần
+        if self.vector_store is not None:  # Đã load/cache → skip
+            return
+        
+        print(f" Embedding {len(docs)} chunks...")
+        self.vector_store = FAISS.from_documents(docs, self.embeddings)
+        
+        # SAVE CACHE
+        index_path = self.cache_dir / "faiss_index"
+        self.vector_store.save_local(str(index_path))
+        print(f"SAVED FAISS: {index_path}")
+
+
+    # Hàm này truyền all_docs (List[Document] từ class DataLoader để embedding
+    def build_from_docs(self, docs: List[Document]):
+        """Xây dựng FAISS từ list chunks""" 
+
+        """
+        self.vector_store CHÍNH LÀ nơi lưu trữ:
+
+            + Vector embedding (dạng số) của từng Document
+            + Nội dung gốc (page_content)
+            + Metadata (source_file, chunk_id, title, …)
+            + Chỉ mục FAISS để tìm kiếm nhanh theo độ giống (cosine / L2)
+        """
+
+        self.vector_store = FAISS.from_documents(docs, self.embeddings)
+        print(f"FAISS built with {len(docs)} medical chunks indexed!")
+    
+    def get_retriever(self, k: int = 3):
+        """Trả về retriever với k docs"""
+        if self.vector_store is None:
+            raise ValueError("Vector store not built. Call build_from_docs first.")
+        return self.vector_store.as_retriever(search_kwargs={"k": k})  
+    
+    def save_documents(self, docs):
+
+        output_dir = Path(r"D:\Storage\rag_project\store")
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+        records = []
+        for i, doc in enumerate(docs):
+            records.append({
+                "doc_id": f"doc_{i}",
+                "page_content": doc.page_content,
+                "metadata": doc.metadata
+            })
+
+        #  JSON
+        with open(output_dir / "documents.json", "w", encoding="utf-8") as f:
+            json.dump(records, f, ensure_ascii=False, indent=2)
+
+        #  Mongo
+        client = MongoClient("mongodb://localhost:27017/")
+        col = client["medchat"]["store"]
+        col.delete_many({})
+        col.insert_many(records)
+        client.close()
+
+        print(f"Saved {len(records)} documents") 
+    
+    def save_embeddings(self, docs):
+
+        texts = [doc.page_content for doc in docs]
+        vectors = self.embeddings.embed_documents(texts)
+
+        output_dir = Path(r"D:\Storage\rag_project\store")
+
+        records = []
+        for i, vec in enumerate(vectors):
+            records.append({
+                "doc_id": f"doc_{i}",
+                "embedding": vec
+            })
+
+        #  JSON
+        with open(output_dir / "embeddings.json", "w", encoding="utf-8") as f:
+            json.dump(records, f)
+
+        #  Mongo
+        client = MongoClient("mongodb://localhost:27017/")
+        col = client["medchat"]["embeddings"]
+        col.delete_many({})
+        col.insert_many(records)
+        client.close()
+
+        print(f" Saved {len(records)} embeddings")
+
+
+# TEST: python vector_store.py
+if __name__ == "__main__":
+    print("TEST VECTOR STORE...")
+
+    # docs sample     
+    docs = [
+        Document(
+            page_content="Sốt ở trẻ em là tình trạng thân nhiệt tăng trên 38 độ.",
+            metadata={"title": "Sốt trẻ em"}
+        ),
+        Document(
+            page_content="Tiêu chảy cấp ở trẻ thường do virus hoặc vi khuẩn.",
+            metadata={"title": "Tiêu chảy"}
+        ),
+        Document(
+            page_content="Gãy xương tay cần được cố định và đưa đến cơ sở y t���.",
+            metadata={"title": "Chấn thương"}
+        ),
+    ]
+
+    vs = VectorStoreManager()
+    vs.build_from_docs(docs)
+    print(f"Đã build xong docs")
+
+    retriever = vs.get_retriever(k=2)
+    results = retriever.get_relevant_documents("vi khuẩn")
+
+    print("\n KẾT QUẢ TRUY XUẤT:")
+    for i, doc in enumerate(results):
+        print(f"{i+1}. {doc.metadata['title']} | {doc.page_content[:60]}...")
+
+    print("\n VECTOR STORE OK!") 
+
+    all_docs = DataLoader.load_all_chunks()
+
+    vs.build_from_docs(docs)
+    
+    print(f"Đã build xong all_docs")
+    vs.save_documents(all_docs)
+    vs.save_embeddings(all_docs)
+
+    print("\n HOÀN THÀNH LƯU DOCUMENT VÀ EMBEDING HOÀN TẤT")

start_server.bat

@@ -0,0 +1,7 @@
+@echo off
+cd /d "%~dp0"
+echo Starting RAG API Server...
+echo This will take 30-60 seconds to load models...
+echo.
+python api_server.py
+pause

test/test vector_store.py

@@ -0,0 +1,12 @@
+
+from src.data_loader import DataLoader
+from src.embeddings import EmbeddingsManager
+
+
+docs = DataLoader.load_all_chunks()
+
+em = EmbeddingsManager()
+embeddings_model = em.get_embeddings()
+
+save_documents(docs)
+save_embeddings(docs, embeddings_model)

test/test_chunks_by_file.py

@@ -0,0 +1,80 @@
+import json
+from pathlib import Path
+
+"""
+ BoYTe200_v3.json: 157 chunks  
+ NHIKHOA2.json: 47 chunks     
+ PHACDODIEUTRI_2016.json: 156 chunks
+ TỔNG: 360 chunks logic 
+
+
+chunk = {
+  "chunk_id": chap["id"],
+  "title": chap["Index"], 
+  "level1_items": chap["level1_items"],
+  "contents": [  # Mảng sections
+    {"title": "Section 1", "content": "..."},
+    {"title": "Section 2", "content": "..."},
+    ...
+  ]
+}
+
+"""
+
+BASE_DIR = Path(r"D:\Storage\rag_project")  # sửa cho đúng đường dẫn 
+DATA_DIR = BASE_DIR / "data"
+
+def load_chapters(json_path: Path):
+    with open(json_path, "r", encoding="utf-8") as f:
+        chapters = json.load(f)
+    return chapters
+
+def main():
+    print(" BASE_DIR:", BASE_DIR)
+    print(" DATA_DIR:", DATA_DIR, "\n")
+
+    json_files = list(DATA_DIR.glob("*.json"))
+    if not json_files:
+        print(" Không tìm thấy file .json nào trong data/")
+        return
+
+    total_chunks = 0
+
+    for json_file in json_files:
+        print(f"==============================")
+        print(f" FILE: {json_file.name}")
+        chapters = load_chapters(json_file)
+
+        all_chunks = []
+        for chap in chapters:
+            all_chunks.append({
+                "chunk_id": chap.get("id"),
+                "title": chap.get("Index"),
+                "level1_items": chap.get("level1_items", []),
+                "contents": chap.get("contents", []),
+            })
+
+        num_chunks = len(all_chunks)
+        total_chunks += num_chunks
+        print(f" Số chunk (theo id) trong file này: {num_chunks}")
+
+        # In MẪU 1 chunk đầu tiên của file
+        if num_chunks > 0:
+            sample = all_chunks[0]
+            print("\n MẪU CHUNK ĐẦU TIÊN:")
+            print("  chunk_id:", sample["chunk_id"])
+            print("  title   :", sample["title"])
+            print("  level1_items:", sample["level1_items"])
+            print("  Số sections trong contents:", len(sample["contents"]))
+            if sample["contents"]:
+                sec0 = sample["contents"][0]
+                print("  ➜ Section 1 title :", sec0.get("title"))
+                print("  ➜ Section 1 content preview:",
+                      (sec0.get("content") or "")[:150], "...")
+        print()
+
+    print("====================================")
+    print(" TỔNG SỐ CHUNK (theo id) TỪ TẤT CẢ FILE:", total_chunks)
+
+if __name__ == "__main__":
+    main()

test/test_data_loader.py

@@ -0,0 +1,68 @@
+import os
+import sys
+import json
+from pathlib import Path
+from langchain_core.documents import Document
+
+#  PATH ĐÚNG
+BASE_DIR = Path(r'D:\Storage\rag_project')
+sys.path.insert(0, str(BASE_DIR / 'src'))
+
+print(" Đường dẫn Python search:")
+print(f"  - BASE_DIR: {BASE_DIR}")
+
+#  LOAD TẤT CẢ JSON TRONG DATA/
+DATA_DIR = BASE_DIR / 'data'
+all_docs = []
+
+print("\n TẤT CẢ JSON TRONG DATA:")
+json_files = list(DATA_DIR.glob("*.json"))
+for json_file in json_files:
+    print(f"   {json_file.name}")
+
+# Load TẤT CẢ JSON files
+total_chunks = 0
+for json_file in json_files:
+    print(f"\n Đang load {json_file.name}...")
+    
+    with open(json_file, 'r', encoding='utf-8') as f:
+        chapters = json.load(f)
+    
+    # Tạo chunks như notebook gốc
+    file_chunks = []
+    for chap in chapters:
+        all_chunks = {
+            "chunkid": chap.get("id", "unknown"),
+            "title": chap.get("index", "unknown"),
+            "level1items": chap.get("level1items", []),
+            "contents": chap.get("contents", [])
+        }
+        
+        # Tạo Documents
+        for i, section in enumerate(all_chunks["contents"]):
+            doc = Document(
+                page_content=section["content"],
+                metadata={
+                    "source_file": json_file.name,
+                    "chunkid": all_chunks["chunkid"],
+                    "sectionid": f"{all_chunks['chunkid']}.{i+1}",
+                    "title": all_chunks["title"],
+                    "sectiontitle": section["title"]
+                }
+            )
+            file_chunks.append(doc)
+    
+    all_docs.extend(file_chunks)
+    total_chunks += len(file_chunks)
+    print(f"   {json_file.name}: {len(file_chunks)} chunks")
+
+print(f"\n TỔNG KẾT:")
+print(f" Tổng chunks từ {len(json_files)} files: {total_chunks}")
+print(f" Chunk mẫu 1:")
+if all_docs:
+    doc = all_docs[0]
+    print(f"  File: {doc.metadata['source_file']}")
+    print(f"  Content: {doc.page_content[:150]}...")
+    print(f"  Title: {doc.metadata['title']}")
+
+print("\n READY CHO RAG - FAISS + LLM!")

test/test_embeddings_single.py

@@ -0,0 +1,22 @@
+import sys
+sys.path.append(r'D:\Storage\rag_project\src')
+from langchain_huggingface import HuggingFaceEmbeddings
+from test_single_file_loader import test_single_file
+
+def test_embed_single(filename):
+    print(f"\n EMBED TEST: {filename}")
+    docs = test_single_file(filename)
+    
+    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    
+    # Embed 1 doc mẫu
+    sample_text = docs[0].page_content[:500]
+    vector = embeddings.embed_query(sample_text)
+    
+    print(f" Embedding shape: {len(vector)}")
+    print(f" Vector preview: {vector[:5]}...")
+    print(f" READY cho FAISS!")
+
+if __name__ == "__main__":
+    test_embed_single("NHIKHOA2.json")
+    test_embed_single("PHACDODIEUTRI_2016.json")

test/test_faiss_single.py

@@ -0,0 +1,28 @@
+import sys
+sys.path.append(r'D:\Storage\rag_project\src')
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from test_single_file_loader import test_single_file
+
+def test_faiss_single(filename):
+    print(f"\n FAISS TEST: {filename}")
+    docs = test_single_file(filename)
+    
+    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    
+    print(f" FAISS index created: {len(docs)} vectors")
+    
+    # Test retrieve
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
+    query = "tuần hoàn" if "NHIKHOA" in filename else "đột tử"
+    results = retriever.get_relevant_documents(query)
+    
+    print(f" Query '{query}' → Found {len(results)} docs:")
+    for i, doc in enumerate(results):
+        print(f"  {i+1}. {doc.metadata['chunk_title']}")
+    print(" FAISS OK!")
+
+if __name__ == "__main__":
+    test_faiss_single("NHIKHOA2.json")
+    test_faiss_single("PHACDODIEUTRI_2016.json")

test/test_hybrid.py

@@ -0,0 +1,38 @@
+import sys
+import os
+
+# ✅ FIX PATH - QUAN TRỌNG!
+sys.path.insert(0, r'D:\Storage\rag_project\src')  # Thêm src vào đầu path
+
+from data_loader import DataLoader
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+
+docs = DataLoader.load_all_chunks()
+print(f"✅ Loaded {len(docs)} docs")
+
+embeddings = HuggingFaceEmbeddings(model_name="bkai-foundation-models/vietnamese-bi-encoder")
+vs = FAISS.from_documents(docs, embeddings)
+
+query = "X-quang phổi 60-83% bình thường 3 tháng"
+
+# OLD: FAISS thuần
+old_docs = vs.similarity_search(query, k=3)
+print("\n❌ OLD FAISS:")
+for doc in old_docs:
+    print(f"  {doc.metadata['chunk_title'][:40]} | {doc.metadata['source_file']}")
+
+# NEW: Keyword boost
+keywords = ["X-quang", "phổi", "bình thường", "3 tháng"]
+boosted = []
+for doc_id, doc in vs.docstore._dict.items():
+    score = sum(1 for kw in keywords if kw in doc.page_content.lower())
+    if score > 0:
+        boosted.append(doc)
+        print(f"\n✅ KEYWORD BOOST HIT: score={score}")
+        print(f"  {doc.metadata['chunk_title']}")
+        print(f"  Preview: {doc.page_content[:100]}...")
+        break
+
+if not boosted:
+    print("\n❌ KHÔNG TÌM THẤY KEYWORD NÀO!")

test/test_load_model_ft.py

@@ -0,0 +1,31 @@
+# test_load_model_fixed.py
+from sentence_transformers import SentenceTransformer
+from transformers import AutoTokenizer, AutoModel
+import torch
+from sklearn.metrics.pairwise import cosine_similarity
+import numpy as np
+
+texts = ["Sốt ở trẻ em", "Trẻ bị sốt cao", "Gãy xương tay"]
+
+print("=== sup-SimCSE-VietNamese-phobert-base ===")
+simcse_model = SentenceTransformer("VoVanPhuc/sup-SimCSE-VietNamese-phobert-base")
+simcse_embeds = simcse_model.encode(texts)
+print("v1 ↔ v2:", cosine_similarity([simcse_embeds[0]], [simcse_embeds[1]])[0][0])
+print("v1 ↔ v3:", cosine_similarity([simcse_embeds[0]], [simcse_embeds[2]])[0][0])
+
+print("\n=== PhoBERT gốc ===")
+tokenizer = AutoTokenizer.from_pretrained("vinai/phobert-base")
+phobert_model = AutoModel.from_pretrained("vinai/phobert-base")
+
+def phobert_embed(text):
+    inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=256)
+    with torch.no_grad():
+        outputs = phobert_model(**inputs)
+    attention_mask = inputs['attention_mask']
+    embeddings = outputs.last_hidden_state
+    mask = attention_mask.unsqueeze(-1).expand(embeddings.size()).float()
+    return torch.sum(embeddings * mask, 1) / torch.clamp(mask.sum(1), min=1e-9)
+
+phobert_embeds = [phobert_embed(t).squeeze().numpy() for t in texts]
+print("v1 ↔ v2:", cosine_similarity([phobert_embeds[0]], [phobert_embeds[1]])[0][0])
+print("v1 ↔ v3:", cosine_similarity([phobert_embeds[0]], [phobert_embeds[2]])[0][0])

test/test_rag_single.py

@@ -0,0 +1,67 @@
+import sys
+import os
+sys.path.append(r'D:\Storage\rag_project\src')
+
+# os.environ["GOOGLE_API_KEY"] = "AIzaSyABvC8mPrwa0Kgy08mFFzkyeh2_N-Bb3lY"  # Thay key thật
+
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain.chains import RetrievalQA
+from langchain_core.prompts import PromptTemplate
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_community.vectorstores import FAISS
+from test_single_file_loader import test_single_file
+
+
+def test_rag_single(filename):
+    print(f"\n FULL RAG TEST: {filename}")
+    docs = test_single_file(filename)
+    
+    # Build FAISS
+    print(" Building FAISS...")
+    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    vectorstore = FAISS.from_documents(docs, embeddings)
+    retriever = vectorstore.as_retriever(search_kwargs={"k": 3})
+    
+    # LLM + Prompt
+    print(" Init Gemini...")
+    llm = ChatGoogleGenerativeAI(
+        model="gemini-2.5-flash",
+        temperature=0,
+        google_api_key="AIzaSyBKUfFRLphY4AgTY-j5sr-6s0SFWW0ATyg"  # API KEY Ở ĐÂY
+    )    
+
+    custom_prompt = PromptTemplate(
+        input_variables=["context", "question"],
+        template="""Bạn là bác sĩ nhi khoa. Dựa vào TÀI LIỆU Y KHOA sau:
+
+CONTEXT: {context}
+
+CÂU HỎI: {question}
+
+TRẢ LỜI chính xác dựa trên CONTEXT, ngắn gọn, chuyên nghiệp."""
+    )
+    
+    qa_chain = RetrievalQA.from_chain_type(
+    llm=llm,
+    chain_type="stuff",
+    retriever=retriever,
+    chain_type_kwargs={"prompt": custom_prompt},
+    return_source_documents=True
+)
+    
+    #  CHỈ NHIKHOA2.json - 1 query đúng
+    query = "điều trị suy hô hấp"
+    
+    print(f"\n Query: {query}")
+    result = qa_chain.invoke({"query": query})
+    print(f" Answer: {result['result'][:400]}...")
+    #  FIX: Kiểm tra key tồn tại
+    if 'source_documents' in result:
+        print(f" Sources: {len(result['source_documents'])} docs")
+    else:
+        print(" Sources: Không có source_documents (Gemini 2.5 format)")
+    
+    print("\n RAG SINGLE FILE OK!")
+
+if __name__ == "__main__":
+    test_rag_single("NHIKHOA2.json")

test/test_rq.py

@@ -0,0 +1,4 @@
+from langchain_core.documents import Document
+from langchain_community.vectorstores import FAISS
+
+print("LangChain OK")

test/test_single_file_loader.py

@@ -0,0 +1,61 @@
+import json
+from pathlib import Path
+from langchain_core.documents import Document
+
+BASE_DIR = Path(r"D:\Storage\rag_project")
+DATA_DIR = BASE_DIR / "data"
+
+def test_single_file(filename):
+    json_path = DATA_DIR / filename
+    print(f"\n{'='*60}")
+    print(f" TEST FILE: {filename}")
+    
+    with open(json_path, 'r', encoding='utf-8') as f:
+        chapters = json.load(f)
+    
+    print(f" Chapters: {len(chapters)}")
+    
+    # Tạo chunks ĐÚNG Colab
+    all_chunks = [] 
+    # Tạo từng chunk dựa vào id mỗi sample 
+    for chap in chapters:
+        chunk = {
+            "chunk_id": chap.get("id"),
+            "title": chap.get("Index"),
+            "level1_items": chap.get("level1_items", []),
+            "contents": chap.get("contents", [])
+        }
+        all_chunks.append(chunk)
+    
+    print(f" Chunks: {len(all_chunks)}")
+    
+    # Tạo Documents
+    docs = []
+    # Tạo documents từ all_chunk
+    
+    for chunk in all_chunks:
+        for i, section in enumerate(chunk["contents"]):
+            doc = Document(
+                page_content=section.get("content", ""),
+                metadata={
+                    "source_file": filename,
+                    "chunk_id": chunk["chunk_id"],
+                    "chunk_title": chunk["title"],
+                    "section_id": f"{chunk['chunk_id']}.{i+1}",
+                    "section_title": section.get("title", "")
+                }
+            )
+            docs.append(doc)
+    
+    print(f" Documents: {len(docs)}")
+    print(f" Mẫu doc 0:")
+    print(f"  Title: {docs[0].metadata['chunk_title']}")
+    print(f"  Section: {docs[0].metadata["section_id"]}")
+    print(f"  Content: {docs[0].page_content[:100]}...")
+    return docs
+
+if __name__ == "__main__":
+    # Test từng file
+    test_single_file("NHIKHOA2.json")
+    test_single_file("BoYTe200_v3.json")
+    test_single_file("PHACDODIEUTRI_2016.json")

test/testapi.py

@@ -0,0 +1,13 @@
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+API_KEY = "AIzaSyBhsaHDerIO-IAf7gEPvjs5Mb1hYOjqOMk"
+
+llm = ChatGoogleGenerativeAI(
+    model="gemini-2.5-flash",
+    google_api_key=API_KEY,
+    temperature=0
+)
+
+print(f"API KEY: {API_KEY} READY")
+resp = llm.invoke("helo")
+print(resp.content)

test_api.py

@@ -0,0 +1,22 @@
+"""Test API endpoint để debug lỗi 500"""
+import requests
+import json
+
+url = "http://localhost:5000/api/start-case"
+data = {
+    "disease": "VIÊM PHỔI",
+    "sessionId": "test_123"
+}
+
+print("Testing /api/start-case endpoint...")
+print(f"URL: {url}")
+print(f"Data: {data}")
+print("-" * 80)
+
+try:
+    response = requests.post(url, json=data)
+    print(f"Status Code: {response.status_code}")
+    print(f"Response:\n{json.dumps(response.json(), indent=2, ensure_ascii=False)}")
+except Exception as e:
+    print(f"Error: {e}")
+    print(f"Response text: {response.text if 'response' in locals() else 'No response'}")

test_debug.py

@@ -0,0 +1,19 @@
+"""Test with detailed error logging"""
+import requests
+import json
+
+url = "http://localhost:5000/api/start-case"
+data = {
+    "disease": "SUY TIM",
+    "sessionId": "debug_test"
+}
+
+try:
+    response = requests.post(url, json=data, timeout=60)
+    print(f"Status: {response.status_code}")
+    print(f"Response:\n{json.dumps(response.json(), indent=2, ensure_ascii=False)}")
+except requests.exceptions.Timeout:
+    print("⏱️ Request timeout - server taking too long")
+except Exception as e:
+    print(f"❌ Error: {e}")
+    print(f"Type: {type(e)}")

test_suy_tim.py

@@ -0,0 +1,23 @@
+"""Test API với bệnh SUY TIM"""
+import requests
+import json
+
+url = "http://localhost:5000/api/start-case"
+data = {
+    "disease": "SUY TIM",
+    "sessionId": "test_suy_tim_456"
+}
+
+print("Testing SUY TIM case generation...")
+print(f"URL: {url}")
+print(f"Data: {data}")
+print("-" * 80)
+
+try:
+    response = requests.post(url, json=data)
+    print(f"Status Code: {response.status_code}")
+    result = response.json()
+    print(f"\n✅ Case được tạo:\n{result.get('case', 'N/A')}")
+    print(f"\n📋 Triệu chứng tìm được (500 ký tự đầu):\n{result.get('symptoms', 'N/A')[:500]}")
+except Exception as e:
+    print(f"❌ Error: {e}")