hi

app.py

@@ -40,495 +40,360 @@ from sentence_transformers import SentenceTransformer, CrossEncoder
 import faiss
 import torch
 from openai import OpenAI
-from tenacity import retry, stop_after_attempt, wait_fixed
 import requests
 
-# [MODIFIED] 限制 PyTorch 執行緒數量，避免在 CPU 環境下過度佔用資源
-torch.set_num_threads(int(os.getenv("TORCH_NUM_THREADS", "1")))
-
-# ==== CONFIG (從環境變數載入，或使用預設值) ====
-# [MODIFIED] 新增環境變數健檢函式
-def _require_env(var: str) -> str:
-    v = os.getenv(var)
-    if not v:
-        raise RuntimeError(f"FATAL: Missing required environment variable: {var}")
-    return v
-
-# [MODIFIED] 檢查 LLM 相關環境變數
-def _require_llm_config():
-    for k in ("LITELLM_BASE_URL", "LITELLM_API_KEY", "LM_MODEL"):
-        _require_env(k)
+# ---------- 應用程式設定與環境變數 ----------
+# 預設值皆針對 Dockerfile 設定
+SECRET_TOKEN = os.getenv("LINE_CHANNEL_SECRET", "YOUR_SECRET_TOKEN")
+ACCESS_TOKEN = os.getenv("LINE_CHANNEL_ACCESS_TOKEN", "YOUR_ACCESS_TOKEN")
+RERANKER_MODEL = os.getenv("RERANKER_MODEL", "BAAI/bge-reranker-v2-m3")
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "DMetaSoul/Dmeta-embedding-zh")
+OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
 
-CSV_PATH = os.getenv("CSV_PATH", "cleaned_combined.csv")
-FAISS_INDEX = os.getenv("FAISS_INDEX", "drug_sentences.index")
+# 資料來源檔案路徑
+SENTENCE_FAISS = os.getenv("SENTENCE_FAISS", "drug_sentences.index")
 SENTENCES_PKL = os.getenv("SENTENCES_PKL", "drug_sentences.pkl")
 BM25_PKL = os.getenv("BM25_PKL", "bm25.pkl")
+DRUG_VOCAB_JSON = os.getenv("DRUG_VOCAB_JSON", "drug_vocab.json")
+PHARMACY_DATA = os.getenv("PHARMACY_DATA", "pharmacy_data.csv")
 
-TOP_K_SENTENCES = int(os.getenv("TOP_K_SENTENCES", 15))
-PRE_RERANK_K = int(os.getenv("PRE_RERANK_K", 30))
-MAX_RERANK_CANDIDATES = int(os.getenv("MAX_RERANK_CANDIDATES", 30))
+# 針對 LINE API 訊息長度限制
+MAX_REPLY_LEN = 4800
 
-EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "DMetaSoul/Dmeta-embedding-zh")
-RERANKER_MODEL = os.getenv("RERANKER_MODEL", "BAAI/bge-reranker-v2-m3")
+# 設定日誌
+logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+log = logging.getLogger(__name__)
 
-LLM_API_CONFIG = {
-    "base_url": os.getenv("LITELLM_BASE_URL"),
-    "api_key": os.getenv("LITELLM_API_KEY"),
-    "model": os.getenv("LM_MODEL")
-}
-
-LLM_MODEL_CONFIG = {
-    "max_context_chars": int(os.getenv("MAX_CONTEXT_CHARS", 10000)),
-    "max_tokens": int(os.getenv("MAX_TOKENS", 1024)),
-    "temperature": float(os.getenv("TEMPERATURE", 0.0)),
-}
-
-INTENT_CATEGORIES = [
-    "操作 (Administration)", "保存/攜帶 (Storage & Handling)", "副作用/異常 (Side Effects / Issues)",
-    "劑型相關 (Dosage Form Concerns)", "時間/併用 (Timing & Interaction)", "劑量調整 (Dosage Adjustment)",
-    "禁忌症/適應症 (Contraindications/Indications)"
-]
-
-DRUG_NAME_MAPPING = {
-    "fentanyl patch": "fentanyl", "spiriva respimat": "spiriva", "augmentin for syrup": "augmentin syrup",
-    "nitrostat": "nitroglycerin", "ozempic": "ozempic", "niflec": "niflec",
-    "fosamax": "fosamax", "humira": "humira", "premarin": "premarin", "smecta": "smecta",
-}
-DISCLAIMER = "本資訊僅供參考，若您對藥物使用有任何疑問，請務務必諮詢您的醫師或藥師。"
-
-PROMPT_TEMPLATES = {
-    "analyze_query": """
-請分析以下使用者問題，並完成以下兩個任務：
-1. 將問題分解為1-3個核心的子問題。
-2. 從清單中選擇所有相關的意圖分類。
-
-請嚴格以 JSON 格式回覆，包含 'sub_queries' (字串陣列) 和 'intents' (字串陣列) 兩個鍵。
-範例: {{"sub_queries": ["子問題一", "子問題二"], "intents": ["分類名稱一", "分類名稱二"]}}
-
-意圖分類清單：
-{options}
-
-使用者問題：{query}
-""",
-    "expand_query": """
-請根據以下意圖：{intents}，擴展這個查詢，加入相關同義詞或術語。
-原始查詢：{query}
-請僅輸出擴展後的查詢，不需任何額外的解釋或格式。
-""",
-    "final_answer": """
-你是一位專業且謹慎的台灣藥師。請嚴格根據「參考資料」回答使用者問題，使用繁體中文。
-
-規則：
-1) 完全依據參考資料，不得捏造或引用外部知識。
-2) 使用清晰的條列式 (例如 1., 2., 3.) 或分段來組織回答，使其易於閱讀。
-3) 如果資料不足以回答，請直接回覆：「根據提供的資料，無法回答您的問題。」
-4) {additional_instruction}
-5) 總結答案，使其簡潔扼要，總長度應在 100 字以內。
-
----
-參考資料：
-{context}
----
+# --- 自定義資料結構 ---
+@dataclass
+class RagState:
+    """應用程式狀態與 RAG 模型物件的單一儲存位置。"""
+    faiss_index: Optional[faiss.Index] = None
+    sentences: Optional[List[str]] = None
+    meta: Optional[List[Dict]] = None
+    bm25: Optional[BM25Okapi] = None
+    bm25_tokenized: Optional[List[List[str]]] = None
+    reranker: Optional[CrossEncoder] = None
+    embedding_model: Optional[SentenceTransformer] = None
+    drug_vocab: Optional[Dict[str, str]] = None
+    pharmacy_df: Optional[pd.DataFrame] = None
+    openai_client: Optional[OpenAI] = None
+
+@dataclass
+class IntentClassifier:
+    """意圖分類器，使用零樣本學習判斷使用者意圖。"""
+    client: OpenAI
+    prompt_template: str = field(init=False)
+
+    def __post_init__(self):
+        self.prompt_template = """你是一個能判斷使用者意圖的 AI 助手。
+請根據以下提供的意圖清單，判斷使用者查詢的意圖。
 
-使用者問題：{query}
+意圖清單：
+- general_qa: 提問有關藥物或健康資訊的通用問題。
+- drug_inquiry: 查詢特定藥物的資訊。
+- pharmacy_search: 詢問藥局的相關資訊。
 
-請直接輸出最終的答案：
+使用者查詢：
+{query}
+
+請直接回覆一個意圖，例如：
+general_qa
 """
-}
 
-# ---------- 日誌設定 ----------
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
-log = logging.getLogger(__name__)
+    def classify_intent(self, query: str) -> str:
+        """根據查詢內容，使用 LLM 判斷意圖。"""
+        log.info(f"分類意圖：{query}")
+        try:
+            response = self.client.chat.completions.create(
+                model="gpt-3.5-turbo", # 或其他適用模型
+                messages=[
+                    {"role": "user", "content": self.prompt_template.format(query=query)}
+                ],
+                temperature=0.0
+            )
+            intent = response.choices[0].message.content.strip().lower()
+            if intent not in ["general_qa", "drug_inquiry", "pharmacy_search"]:
+                log.warning(f"偵測到未知意圖：{intent}，將視為 general_qa。")
+                return "general_qa"
+            log.info(f"意圖判定：{intent}")
+            return intent
+        except Exception as e:
+            log.error(f"意圖分類失敗：{e}，將使用預設意圖 general_qa。")
+            return "general_qa"
 
+# --- RAG 流程與核心邏輯 ---
 @dataclass
-class FusedCandidate:
-    idx: int
-    fused_score: float
-    sem_score: float
-    bm_score: float
+class RagPipeline:
+    """RAG 流程核心處理類別。"""
+    state: RagState = field(default_factory=RagState)
 
-@dataclass
-class RerankResult:
-    idx: int
-    rerank_score: float
-    text: str
-    meta: Dict[str, Any] = field(default_factory=dict)
+    def load_data(self):
+        """載入所有必要的 RAG 相關檔案與模型。"""
+        log.info("開始載入資料與模型...")
 
-# ---------- 核心 RAG 邏輯 ----------
-class RagPipeline:
-    def __init__(self, config):
-        self.config = config
-        self.state = type('state', (), {})()
-        if not LLM_API_CONFIG["api_key"] or not LLM_API_CONFIG["base_url"]:
-             raise ValueError("LLM API Key or Base URL is not configured.")
-        self.llm_client = OpenAI(api_key=LLM_API_CONFIG["api_key"], base_url=LLM_API_CONFIG["base_url"])
-        self.embedding_model = self._load_model(SentenceTransformer, EMBEDDING_MODEL, "embedding")
-        self.reranker = self._load_model(CrossEncoder, RERANKER_MODEL, "reranker")
-        
-        self.drug_name_to_ids: Dict[str, List[str]] = {}
-        self.drug_vocab: Dict[str, set] = {"zh": set(), "en": set()}
+        # 載入 embedding 模型
+        device = "cuda" if torch.cuda.is_available() and torch.cuda.is_available() else "cpu"
+        log.info(f"載入 embedding 模型：{EMBEDDING_MODEL} 至 {device}...")
+        try:
+            self.state.embedding_model = SentenceTransformer(EMBEDDING_MODEL, device=device)
+        except Exception as e:
+            log.error(f"載入 embedding 模型失敗：{e}")
+            raise
 
-    def _load_model(self, model_class, model_name: str, model_type: str):
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        log.info(f"載入 {model_type} 模型：{model_name} 至 {device}...")
+        # 載入 reranker 模型
+        log.info(f"載入 reranker 模型：{RERANKER_MODEL} 至 {device}...")
         try:
-            return model_class(model_name, device=device)
+            self.state.reranker = CrossEncoder(RERANKER_MODEL, device=device)
         except Exception as e:
-            log.warning(f"載入模型至 {device} 失敗: {e}。嘗試切換至 CPU。")
-            return model_class(model_name, device="cpu")
+            log.error(f"載入 reranker 模型失敗：{e}")
+            self.state.reranker = None # Reranker 非必要，失敗可繼續
 
-    def load_data(self):
-        log.info("開始載入資料與模型...")
+        # 載入 FAISS 索引與句子資料
+        log.info("載入 FAISS 索引與句子資料...")
         try:
-            self.df_csv = pd.read_csv(CSV_PATH, dtype=str).fillna('')
-            # [MODIFIED] 增加必要欄位檢查
-            for col in ("drug_name_norm", "drug_id"):
-                if col not in self.df_csv.columns:
-                    raise KeyError(f"CSV 檔案 '{CSV_PATH}' 中缺少必要欄位: {col}")
-
-            self.df_csv['drug_name_norm_normalized'] = (
-                self.df_csv['drug_name_norm'].str.lower().str.replace(r'[^\w\s]', '', regex=True).str.strip()
-            )
-            self.drug_name_to_ids = self.df_csv.groupby('drug_name_norm_normalized')['drug_id'].unique().apply(list).to_dict()
-            # [MODIFIED] 把別名也變成可查鍵
-            for alias, canonical in DRUG_NAME_MAPPING.items():
-                alias_key = re.sub(r'[^\w\s]', '', alias.lower()).strip()
-                canonical_key = re.sub(r'[^\w\s]', '', canonical.lower()).strip()
-                if canonical_key in self.drug_name_to_ids:
-                    self.drug_name_to_ids[alias_key] = self.drug_name_to_ids[canonical_key]
-            self._load_drug_name_vocabulary()
-            
-            log.info("載入 FAISS 索引與句子資料...")
-            self.state.index = faiss.read_index(FAISS_INDEX)
-            self.state.faiss_metric = getattr(self.state.index, "metric_type", faiss.METRIC_L2)
-            if hasattr(self.state.index, "nprobe"):
-                self.state.index.nprobe = int(os.getenv("FAISS_NPROBE", "16"))
+            self.state.faiss_index = faiss.read_index(SENTENCE_FAISS)
             with open(SENTENCES_PKL, "rb") as f:
                 data = pickle.load(f)
-                self.state.sentences = data["sentences"]
-                self.state.meta = data["meta"]
+            self.state.sentences = data["sentences"]
+            self.state.meta = data["meta"]
+        except Exception as e:
+            log.error(f"載入 FAISS 或句子 PKL 失敗：{e}")
+            raise
 
-            log.info("載入 BM25 索引...")
+        # 載入 BM25 索引
+        log.info("載入 BM25 索引...")
+        try:
+            # === [修正] ===
+            # 正確地從 Pickle 檔案中讀取字典，並提取 BM25 物件
             with open(BM25_PKL, "rb") as f:
-                self.state.bm25 = pickle.load(f)
-            if not isinstance(self.state.bm25, BM25Okapi):
-                raise ValueError("Loaded BM25 is not a BM25Okapi instance.")
-        except (FileNotFoundError, KeyError) as e:
-            log.exception(f"資料或索引檔案載入失敗: {e}")
-            raise RuntimeError(f"資料初始化失敗，請檢查檔案路徑與內容: {e}")
-        
-        log.info("所有模型與資料載入完成。")
+                data = pickle.load(f)
+            # 檢查 pickle 檔案是否包含預期的字典結構
+            if not isinstance(data, dict) or "bm25" not in data or not isinstance(data["bm25"], BM25Okapi):
+                raise ValueError("Loaded BM25 is not a BM25Okapi instance or the pickle file has an unexpected format.")
+            self.state.bm25 = data["bm25"]
+            self.state.bm25_tokenized = data["tokenized"]
+            self.state.sentences = data["sentences"]
+            self.state.meta = data["meta"]
+            # =============
+        except Exception as e:
+            log.error(f"載入 BM25 索引失敗：{e}")
+            raise
 
-    def _load_drug_name_vocabulary(self):
+        # 載入藥名詞庫 (jieba 使用)
         log.info("建立藥名詞庫...")
-        for norm_name in self.df_csv['drug_name_norm_normalized'].dropna().unique():
-            parts = norm_name.split()
-            for part in parts:
-                if re.search(r'[\u4e00-\u9fff]', part):
-                    self.drug_vocab["zh"].add(part)
-                    try:
-                        jieba.add_word(part, freq=2_000_000)
-                    except Exception:
-                        pass
-                else:
-                    self.drug_vocab["en"].add(part)
-        for alias in DRUG_NAME_MAPPING:
-            self.drug_vocab["en"].add(alias.lower())
-            if re.search(r'[\u4e00-\u9fff]', alias):
-                try:
-                    jieba.add_word(alias, freq=2_000_000)
-                except Exception:
-                    pass
-
-    @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-    def _llm_call(self, messages, **kwargs) -> str:
         try:
-            config = {**LLM_MODEL_CONFIG, **kwargs}
-            response = self.llm_client.chat.completions.create(
-                model=LLM_API_CONFIG["model"],
-                messages=messages,
-                temperature=config["temperature"],
-                max_tokens=config["max_tokens"],
-            )
-            return response.choices[0].message.content
+            with open(DRUG_VOCAB_JSON, "r", encoding="utf-8") as f:
+                self.state.drug_vocab = json.load(f)
+            for drug_name in self.state.drug_vocab.keys():
+                jieba.add_word(drug_name.lower())
         except Exception as e:
-            log.error(f"LLM API 呼叫失敗: {e}")
-            raise
+            log.warning(f"載入藥名詞庫失敗：{e}。部分藥名可能無法正確斷詞。")
 
-    def answer_question(self, q_orig: str) -> str:
-        start_time = time.time()
-        log.info(f"===== 處理新查詢: '{q_orig}' =====")
+        # 載入藥局資料
+        log.info("載入藥局資料...")
         try:
-            drug_ids = self._find_drug_ids_from_name(q_orig)
-            if not drug_ids:
-                return f"抱歉，資料庫中找不到該藥品。請確認藥品名稱，或直接諮詢醫師/藥師。{DISCLAIMER}"
-            log.info(f"找到藥品 ID: {drug_ids}")
-
-            analysis = self._analyze_query(q_orig)
-            sub_queries, intents = analysis.get("sub_queries", [q_orig]), analysis.get("intents", [])
-            log.info(f"子問題: {sub_queries}, 意圖: {intents}")
-
-            all_candidates = self._retrieve_candidates_for_all_queries(drug_ids, sub_queries, intents)
-            log.info(f"所有子查詢共找到 {len(all_candidates)} 個不重複候選 chunks。")
-
-            reranked_results = self._rerank_with_crossencoder(q_orig, all_candidates)
-            log.info(f"Reranker 最終選出 {len(reranked_results)} 個高品質候選。")
-
-            context = self._build_context(reranked_results)
-            if not context:
-                return f"根據您的問題，找不到相關的具體說明。建議您直接諮詢醫師或藥師以獲得最準確的資訊。{DISCLAIMER}"
-                
-            prompt = self._make_final_prompt(q_orig, context, intents)
-            answer = self._llm_call([{"role": "user", "content": prompt}])
-            
-            final_answer = f"{answer.strip()}\n\n{DISCLAIMER}"
-            log.info(f"===== 查詢處理完成，總耗時: {time.time() - start_time:.2f} 秒 =====")
-            return final_answer
-
+            self.state.pharmacy_df = pd.read_csv(PHARMACY_DATA, dtype=str)
         except Exception as e:
-            log.error(f"處理查詢 '{q_orig}' 時發生嚴重錯誤: {e}", exc_info=True)
-            return f"處理您的問題時發生內部錯誤，請稍後再試。{DISCLAIMER}"
-
-    @lru_cache(maxsize=128)
-    def _find_drug_ids_from_name(self, query: str) -> List[str]:
-        q = query.lower()
-        candidates = extract_drug_candidates_from_query(q, self.drug_vocab)
-        drug_ids = set()
-
-        # 英文：詞邊界；中文：也做子字串掃描
-        for k, ids in self.drug_name_to_ids.items():
-            if re.search(r'[\u4e00-\u9fff]', k):
-                if k in q:
-                    drug_ids.update(ids)
-            else:
-                if re.search(rf"\b{re.escape(k)}\b", q):
-                    drug_ids.update(ids)
-
-        # 仍保留舊的候選詞路徑（補強）
-        for alias in candidates:
-            # [MODIFIED] 英文藥名比對使用詞邊界，避免子字串誤判
-            is_english = not re.search(r'[\u4e00-\u9fff]', alias)
-            for drug_name_norm, ids in self.drug_name_to_ids.items():
-                match = False
-                if is_english:
-                    if re.search(rf"\b{re.escape(alias)}\b", drug_name_norm):
-                        match = True
-                elif alias in drug_name_norm:
-                    match = True
-                
-                if match:
-                    drug_ids.update(ids)
-        return list(drug_ids)
-
-    def _analyze_query(self, query: str) -> Dict[str, Any]:
-        prompt = PROMPT_TEMPLATES["analyze_query"].format(
-            options="\n".join(f"- {c}" for c in INTENT_CATEGORIES),
-            query=query
-        )
-        response_str = self._llm_call([{"role": "user", "content": prompt}], temperature=0.1)
-        return self._safe_json_parse(response_str, default={"sub_queries": [query], "intents": []})
-
-    def _retrieve_candidates_for_all_queries(self, drug_ids: List[str], sub_queries: List[str], intents: List[str]) -> List[FusedCandidate]:
-        drug_ids_set = set(map(str, drug_ids))
-        relevant_indices = {i for i, m in enumerate(self.state.meta) if str(m.get("drug_id", "")) in drug_ids_set}
-        if not relevant_indices: return []
-
-        all_fused_candidates: Dict[int, FusedCandidate] = {}
-        
-        for sub_q in sub_queries:
-            expanded_q = self._expand_query_with_llm(sub_q, tuple(intents))
-            
-            q_emb = self.embedding_model.encode([expanded_q], convert_to_numpy=True).astype("float32")
-            if self.state.faiss_metric == faiss.METRIC_INNER_PRODUCT:
-                faiss.normalize_L2(q_emb)
-            distances, sim_indices = self.state.index.search(q_emb, PRE_RERANK_K)
+            log.warning(f"載入藥局資料失敗：{e}。藥局查詢功能將無法使用。")
+            self.state.pharmacy_df = pd.DataFrame() # 確保為空 DataFrame
 
-            tokenized_query = list(jieba.cut(expanded_q))
-            
-            # [MODIFIED] 先過濾 relevant_indices 再取 TopK
-            bm25_scores = self.state.bm25.get_scores(tokenized_query)
-            rel_idx = np.fromiter(relevant_indices, dtype=int)
-            rel_scores = bm25_scores[rel_idx]
-            top_rel = rel_idx[np.argsort(rel_scores)[::-1][:PRE_RERANK_K]]
-            doc_to_bm25_score = {int(i): float(bm25_scores[i]) for i in top_rel}
-            
-            candidate_scores: Dict[int, Dict[str, float]] = {}
-            
-            # [MODIFIED] 把 distance 轉成「越大越好的相似度」
-            def to_similarity(d: float) -> float:
-                if self.state.faiss_metric == faiss.METRIC_INNER_PRODUCT:
-                    return float(d)                   # IP 越大越好
-                else:  # METRIC_L2（多半是平方 L2）
-                    return 1.0 / (1.0 + float(d))
-
-            for i, dist in zip(sim_indices[0], distances[0]):
-                if i in relevant_indices:
-                    similarity = to_similarity(dist)
-                    candidate_scores[int(i)] = {"sem": float(similarity), "bm": 0.0}
-
-            for i, score in doc_to_bm25_score.items():
-                if i in relevant_indices:
-                    candidate_scores.setdefault(i, {"sem": 0.0, "bm": 0.0})["bm"] = score
-            
-            if not candidate_scores: continue
-            
-            # [MODIFIED] 使用固定的鍵順序來確保分數對齊
-            keys = list(candidate_scores.keys())
-            sem_scores = np.array([candidate_scores[k]['sem'] for k in keys])
-            bm_scores = np.array([candidate_scores[k]['bm'] for k in keys])
-            
-            def norm(x): 
-                rng = x.max() - x.min()
-                return (x - x.min()) / (rng + 1e-8) if rng > 0 else np.zeros_like(x)
+        # 初始化 OpenAI Client
+        if OPENAI_API_KEY:
+            self.state.openai_client = OpenAI(api_key=OPENAI_API_KEY)
+            log.info("OpenAI 客戶端初始化完成。")
+        else:
+            log.warning("未設定 OPENAI_API_KEY，意圖偵測與 LLM 回覆功能將無法使用。")
 
-            sem_n, bm_n = norm(sem_scores), norm(bm_scores)
-            
-            for idx, k in enumerate(keys):
-                fused_score = sem_n[idx] * 0.6 + bm_n[idx] * 0.4
-                
-                if k not in all_fused_candidates or fused_score > all_fused_candidates[k].fused_score:
-                    all_fused_candidates[k] = FusedCandidate(
-                        idx=k, fused_score=fused_score, sem_score=sem_scores[idx], bm_score=bm_scores[idx]
-                    )
-
-        return sorted(all_fused_candidates.values(), key=lambda x: x.fused_score, reverse=True)
-
-    # [MODIFIED] 移除 lru_cache，因對多變的長查詢效果不佳
-    def _expand_query_with_llm(self, query: str, intents: tuple) -> str:
-        if not intents:
-            return query
-            
-        prompt = PROMPT_TEMPLATES["expand_query"].format(intents=list(intents), query=query)
-        
-        try:
-            expanded_query = self._llm_call([{"role": "user", "content": prompt}])
-            if expanded_query and expanded_query.strip():
-                return expanded_query
-            else:
-                log.warning(f"Query expansion for '{query}' returned an empty result. Using original query.")
-                return query
-        except Exception as e:
-            log.error(f"Query expansion for '{query}' failed: {e}. Using original query.")
-            return query
+        log.info("所有資料與模型載入完成。")
 
-    def _rerank_with_crossencoder(self, query: str, candidates: List[FusedCandidate]) -> List[RerankResult]:
-        if not candidates: return []
-        
-        top_candidates = candidates[:MAX_RERANK_CANDIDATES]
-        pairs = [(query, self.state.sentences[c.idx]) for c in top_candidates]
-        scores = self.reranker.predict(pairs, show_progress_bar=False)
-        
-        results = [
-            RerankResult(idx=c.idx, rerank_score=float(score), text=self.state.sentences[c.idx], meta=self.state.meta[c.idx])
-            for c, score in zip(top_candidates, scores)
-        ]
+    def retrieve_by_faiss(self, query: str, top_k: int = 10) -> Tuple[List[str], List[Dict]]:
+        """使用 FAISS 進行向量檢索。"""
+        if self.state.embedding_model is None or self.state.faiss_index is None:
+            log.error("FAISS 或 Embedding 模型未載入。")
+            return [], []
+
+        query_emb = self.state.embedding_model.encode(query, convert_to_numpy=True).astype("float32")
+        faiss.normalize_L2(query_emb)
+        query_emb = query_emb.reshape(1, -1)
+
+        distances, indices = self.state.faiss_index.search(query_emb, top_k)
+        sentences = [self.state.sentences[i] for i in indices[0] if i != -1]
+        metas = [self.state.meta[i] for i in indices[0] if i != -1]
+
+        return sentences, metas
+
+    def retrieve_by_bm25(self, query: str, top_k: int = 10) -> Tuple[List[str], List[Dict]]:
+        """使用 BM25 進行稀疏檢索。"""
+        if self.state.bm25 is None:
+            log.error("BM25 模型未載入。")
+            return [], []
+
+        query_tokenized = jieba.lcut(query)
+        doc_scores = self.state.bm25.get_scores(query_tokenized)
+        top_k_indices = np.argsort(doc_scores)[::-1][:top_k]
         
-        return sorted(results, key=lambda x: x.rerank_score, reverse=True)[:TOP_K_SENTENCES]
-
-    def _build_context(self, reranked_results: List[RerankResult]) -> str:
-        context = ""
-        for res in reranked_results:
-            if len(context) + len(res.text) > LLM_MODEL_CONFIG["max_context_chars"]: break
-            context += res.text + "\n\n"
-        return context.strip()
-
-    def _make_final_prompt(self, query: str, context: str, intents: List[str]) -> str:
-        add_instr = ""
-        if any(i in intents for i in ["劑量調整 (Dosage Adjustment)", "時間/併用 (Timing & Interaction)"]):
-            add_instr = "在回答用藥劑量和時間時，務必提醒使用者，醫師開立的藥袋醫囑優先於仿單的一般建議。"
+        sentences = [self.state.sentences[i] for i in top_k_indices]
+        metas = [self.state.meta[i] for i in top_k_indices]
+
+        return sentences, metas
+
+    def rerank_results(self, query: str, pairs: List[Tuple[str, str]]) -> List[Dict]:
+        """使用 Reranker 模型對結果進行重排序。"""
+        if self.state.reranker is None:
+            log.warning("Reranker 模型未載入，將略過重排序。")
+            return [{"text": pair[1], "score": 0.0, "source": ""} for pair in pairs]
+
+        scores = self.state.reranker.predict(pairs)
+        results = [{"text": pair[1], "score": score, "source": ""} for pair, score in zip(pairs, scores)]
+        results.sort(key=lambda x: x["score"], reverse=True)
+        return results
+
+    def handle_rag_query(self, query: str) -> str:
+        """處理 RAG 查詢的核心邏輯。"""
+        if not self.state.openai_client:
+            return "無法使用 RAG 功能，請檢查 OPENAI_API_KEY 設定。"
         
-        return PROMPT_TEMPLATES["final_answer"].format(
-            additional_instruction=add_instr, context=context, query=query
-        )
-    
-    # [MODIFIED] 增強 JSON 解析的穩健性，從字串中提取 JSON 物件
-    def _safe_json_parse(self, s: str, default: Any = None) -> Any:
-        m = re.search(r'\{.*?\}', s, re.DOTALL)  # 非貪婪
-        if m:
-            s = m.group(0)
         try:
-            return json.loads(s)
-        except Exception:
-            log.warning(f"無法解析 LLM 回傳的 JSON: {s[:200]}...")
-            return default
+            # 1. 意圖偵測
+            intent_classifier = IntentClassifier(self.state.openai_client)
+            intent = intent_classifier.classify_intent(query)
+            
+            # 2. 根據意圖進行不同的檢索與生成流程
+            final_context = ""
+            if intent == "drug_inquiry":
+                # 藥物查詢流程
+                drug_candidates = extract_drug_candidates_from_query(query, self.state.drug_vocab)
+                if not drug_candidates:
+                    return self.generate_llm_response(query, [], intent)
+
+                contexts = []
+                for drug_name in drug_candidates:
+                    contexts.extend(self.retrieve_and_rerank(query, specific_drug=drug_name))
+                final_context = "\n".join([c["text"] for c in contexts])
+            
+            elif intent == "pharmacy_search":
+                # 藥局查詢流程
+                pharmacy_candidates = search_pharmacy(query, self.state.pharmacy_df)
+                if pharmacy_candidates:
+                    response_text = "為您找到以下藥局資訊：\n" + "\n---\n".join([
+                        f"藥局名稱：{p['醫事機構名稱']}\n電話：{p['醫事機構電話']}\n地址：{p['醫事機構地址']}"
+                        for p in pharmacy_candidates
+                    ])
+                    return response_text
+                else:
+                    return "很抱歉，沒有找到符合條件的藥局。"
+            
+            else: # general_qa
+                # 通用查詢流程
+                contexts = self.retrieve_and_rerank(query)
+                final_context = "\n".join([c["text"] for c in contexts])
 
-# ---------- FastAPI 事件與路由 ----------
-app = FastAPI()
-rag_pipeline: Optional[RagPipeline] = None
+            return self.generate_llm_response(query, final_context, intent)
 
-# [MODIFIED] 將 LINE 配置集中管理並進行啟動時檢查
-class AppConfig:
-    CHANNEL_ACCESS_TOKEN = _require_env("CHANNEL_ACCESS_TOKEN")
-    CHANNEL_SECRET = _require_env("CHANNEL_SECRET")
+        except Exception as e:
+            log.error(f"RAG 查詢處理失敗：{e}")
+            return f"對不起，處理您的查詢時發生錯誤：{e}。"
+
+    def retrieve_and_rerank(self, query: str, specific_drug: Optional[str] = None) -> List[Dict]:
+        """執行檢索與重排序步驟。"""
+        # 1. 檢索
+        log.info(f"執行檢索：{query} (藥物：{specific_drug})")
+        faiss_sents, faiss_metas = self.retrieve_by_faiss(query, top_k=20)
+        bm25_sents, bm25_metas = self.retrieve_by_bm25(query, top_k=20)
+        
+        # 2. 合併與去重
+        combined_sents = list(dict.fromkeys(faiss_sents + bm25_sents))
+        
+        # 3. 根據藥名過濾
+        if specific_drug:
+            initial_sentences = self.get_sentences_by_drug_name(specific_drug)
+            combined_sents = list(dict.fromkeys(initial_sentences + combined_sents))
+
+        if not combined_sents:
+            return []
+
+        # 4. 重排序
+        log.info("執行重排序...")
+        pairs = [(query, s) for s in combined_sents]
+        reranked_results = self.rerank_results(query, pairs)
+        return reranked_results[:5] # 取 Top 5
+
+    def get_sentences_by_drug_name(self, drug_name: str) -> List[str]:
+        """從元資料中篩選出與特定藥物相關的句子。"""
+        sentences = []
+        for meta, sentence in zip(self.state.meta, self.state.sentences):
+            if meta.get("drug_name_norm") == drug_name.lower():
+                sentences.append(sentence)
+        return sentences
+
+    def generate_llm_response(self, query: str, context: str, intent: str) -> str:
+        """使用 LLM 生成最終回覆。"""
+        log.info(f"使用 LLM 生成回覆，意圖：{intent}")
+        system_prompt = f"""你是一個專業的藥物與健康資訊問答助理。
+- 請根據使用者提供的「使用者查詢」與「相關資訊」來回答問題。
+- 如果「相關資訊」中沒有足夠的資訊來回答，請禮貌地告知使用者。
+- 你的回答應簡潔、易懂，並使用繁體中文。
+- 在回答中，應明確指出資訊來源是來自衛福部、藥廠、或是其他相關法規文件。
+- 如果使用者詢問的是特定藥物，請在回答中提及藥名。
+- 如果意圖是 `pharmacy_search`，請直接告知使用者這是關於藥局的查詢，並說「很抱歉，我無法提供藥局資訊。」
+- 如果意圖是 `general_qa`，且相關資訊不足，請回答「對不起，我無法回答您的問題。」
+- 如果意圖是 `drug_inquiry`，且相關資訊不足，請回答「對不起，我無法找到該藥物的相關資訊。」
+
+相關資訊：
+{context}
 
-@app.on_event("startup")
-async def startup_event():
-    global rag_pipeline
-    _require_llm_config()
-    rag_pipeline = RagPipeline(AppConfig)
-    rag_pipeline.load_data()
-    log.info("啟動完成，服務準備就緒。")
-
-@app.post("/webhook")
-async def handle_webhook(request: Request, background_tasks: BackgroundTasks):
-    # [MODIFIED] 增強簽章驗證與環境變數檢查
-    signature = request.headers.get("X-Line-Signature")
-    if not signature:
-        raise HTTPException(status_code=400, detail="Missing X-Line-Signature")
-    if not AppConfig.CHANNEL_SECRET:
-        log.error("CHANNEL_SECRET is not configured.")
-        raise HTTPException(status_code=500, detail="Server configuration error")
+使用者查詢：
+{query}
+"""
+        try:
+            response = self.state.openai_client.chat.completions.create(
+                model="gpt-4o-mini",  # 或其他適用模型
+                messages=[
+                    {"role": "system", "content": system_prompt},
+                    {"role": "user", "content": f"問題：{query}"}
+                ],
+                temperature=0.0
+            )
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            log.error(f"LLM 回覆生成失敗：{e}")
+            return "對不起，生成回覆時發生錯誤。"
+
+# --- 藥物與藥局輔助函式 ---
+def search_pharmacy(query: str, df: pd.DataFrame) -> List[Dict]:
+    """根據關鍵字在藥局資料中搜尋。"""
+    if df.empty:
+        return []
+    keywords = jieba.lcut_for_search(query)
+    results = []
+    for _, row in df.iterrows():
+        match_count = sum(1 for k in keywords if k in row.to_string())
+        if match_count > 0:
+            results.append(row.to_dict())
+    return results
 
-    body = await request.body()
-    try:
-        hash = hmac.new(AppConfig.CHANNEL_SECRET.encode('utf-8'), body, hashlib.sha256)
-        expected_signature = base64.b64encode(hash.digest()).decode('utf-8')
-    except Exception as e:
-        log.error(f"Failed to generate signature: {e}")
-        raise HTTPException(status_code=500, detail="Signature generation error")
+def extract_drug_candidates_from_query(query: str, drug_vocab: dict) -> list:
+    """從查詢中提取藥名。"""
+    candidates = set()
+    q_lower = query.lower()
+    for drug_name, normalized_name in drug_vocab.items():
+        if drug_name in q_lower:
+            candidates.add(normalized_name)
+    return list(candidates)
 
-    if not hmac.compare_digest(expected_signature, signature):
-        raise HTTPException(status_code=403, detail="Invalid signature")
+# --- LINE API 相關函式 ---
+def validate_signature(request_body: bytes, signature: str):
+    """驗證 LINE 傳來的簽名。"""
+    hash = hmac.new(SECRET_TOKEN.encode('utf-8'), request_body, hashlib.sha256).digest()
+    return hmac.compare_digest(signature.encode('utf-8'), base64.b64encode(hash))
 
-    try:
-        data = json.loads(body.decode('utf-8'))
-    except json.JSONDecodeError:
-        raise HTTPException(status_code=400, detail="Invalid JSON body")
-
-    for event in data.get("events", []):
-        if event.get("type") == "message" and event.get("message", {}).get("type") == "text":
-            reply_token = event.get("replyToken")
-            user_text = event.get("message", {}).get("text", "").strip()
-            # [MODIFIED] 擷取 target
-            source = event.get("source", {})
-            stype = source.get("type")  # "user" | "group" | "room"
-            target_id = source.get("userId") or source.get("groupId") or source.get("roomId")
-
-            if reply_token and user_text and target_id:
-                # [MODIFIED] 更改回覆策略：立即回覆處理中訊息，避免 replyToken 逾時
-                line_reply(reply_token, "收到您的問題，正在查詢資料庫，請稍候...")
-                # 將耗時的任務交給背景處理，使用 push message 回覆最終答案
-                background_tasks.add_task(process_user_query, stype, target_id, user_text)
-                
-    return Response(status_code=status.HTTP_200_OK)
-
-# [MODIFIED] 調整函式簽名，只接收 user_id 和 text，並使用 push message
-def process_user_query(source_type: str, target_id: str, user_text: str):
-    try:
-        if rag_pipeline:
-            answer = rag_pipeline.answer_question(user_text)
-        else:
-            answer = "系統正在啟動中，請稍後再試。"
-        line_push_generic(source_type, target_id, answer)
-    except Exception as e:
-        log.error(f"背景處理 target_id={target_id} 發生錯誤: {e}", exc_info=True)
-        line_push_generic(source_type, target_id, f"抱歉，處理時發生未預期的錯誤。{DISCLAIMER}")
-
-@retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-def line_api_call(endpoint: str, data: Dict):
+@lru_cache(maxsize=128)
+def line_api_call(endpoint: str, data: dict):
+    """呼叫 LINE Messaging API。"""
     headers = {
         "Content-Type": "application/json",
-        "Authorization": f"Bearer {AppConfig.CHANNEL_ACCESS_TOKEN}"
+        "Authorization": f"Bearer {ACCESS_TOKEN}"
     }
     try:
         response = requests.post(f"https://api.line.me/v2/bot/message/{endpoint}", headers=headers, json=data, timeout=10)
@@ -538,32 +403,78 @@ def line_api_call(endpoint: str, data: Dict):
         raise
 
 def line_reply(reply_token: str, text: str):
-    messages = [{"type": "text", "text": chunk} for chunk in textwrap.wrap(text, 4800, replace_whitespace=False)[:5]]
+    """回覆 LINE 訊息。"""
+    messages = [{"type": "text", "text": chunk} for chunk in textwrap.wrap(text, MAX_REPLY_LEN, replace_whitespace=False)[:5]]
     line_api_call("reply", {"replyToken": reply_token, "messages": messages})
 
 def line_push_generic(source_type: str, target_id: str, text: str):
-    messages = [{"type": "text", "text": chunk} for chunk in textwrap.wrap(text, 4800, replace_whitespace=False)[:5]]
+    """推播 LINE 訊息。"""
+    messages = [{"type": "text", "text": chunk} for chunk in textwrap.wrap(text, MAX_REPLY_LEN, replace_whitespace=False)[:5]]
     endpoint = "push"
     data = {"to": target_id, "messages": messages}
     line_api_call(endpoint, data)
 
-# [MODIFIED] 改善藥名提取的正則表達式
-def extract_drug_candidates_from_query(query: str, drug_vocab: dict) -> list:
-    candidates = set()
-    q_lower = query.lower()
-    # 允許藥名中包含 -, /, . 等符號
-    words = re.findall(r"[a-z0-9][a-z0-9+\-/\.]*", q_lower)
-    for word in words:
-        if word in drug_vocab["en"]:
-            candidates.add(word)
-    
-    for token in jieba.cut(q_lower):
-        if token in drug_vocab["zh"]:
-            candidates.add(token)
-            
-    return list(candidates)
+# --- FastAPI 應用程式設定 ---
+app = FastAPI()
+rag_pipeline = RagPipeline()
+
+@app.on_event("startup")
+async def startup_event():
+    """應用程式啟動時載入所有 RAG 模型。"""
+    try:
+        rag_pipeline.load_data()
+    except Exception as e:
+        log.error(f"應用程式啟動失敗：{e}")
+        # 在 Docker 環境中，啟動失敗會導致容器結束
+        # 這裡的 exit code 3 是為了在 CI/CD 中標記為應用程式層的錯誤
+        # 在本地執行時，這將直接結束程式
+        os._exit(3)
+
+@app.get("/")
+async def root():
+    """根目錄，用於健康檢查。"""
+    return {"message": "Hello, I am a DrugQA bot! Use me with LINE."}
+
+@app.post("/callback")
+async def callback(request: Request, background_tasks: BackgroundTasks):
+    """LINE Webhook 回呼處理。"""
+    signature = request.headers.get("X-Line-Signature")
+    if not signature:
+        raise HTTPException(status_code=400, detail="X-Line-Signature header is missing.")
+
+    body = await request.body()
+    if not validate_signature(body, signature):
+        raise HTTPException(status_code=400, detail="Invalid signature.")
+
+    try:
+        events = json.loads(body)["events"]
+        for event in events:
+            if event["type"] == "message" and event["message"]["type"] == "text":
+                reply_token = event["replyToken"]
+                query_text = event["message"]["text"]
+                # 將耗時的 RAG 任務放入背景執行
+                background_tasks.add_task(process_user_message, reply_token, query_text)
+        return "OK"
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=400, detail="Invalid JSON body.")
+    except Exception as e:
+        log.error(f"處理 LINE 訊息失敗：{e}")
+        raise HTTPException(status_code=500, detail="Internal Server Error.")
+
+def process_user_message(reply_token: str, query: str):
+    """在背景處理使用者訊息。"""
+    try:
+        start_time = time.time()
+        # 處理 RAG 查詢
+        response = rag_pipeline.handle_rag_query(query)
+        end_time = time.time()
+        log.info(f"查詢 '{query}' 處理完成，耗時 {end_time - start_time:.2f} 秒。")
+
+        # 回覆使用者
+        line_reply(reply_token, response)
+    except Exception as e:
+        log.error(f"背景任務執行失敗：{e}")
+        line_reply(reply_token, "對不起，服務目前無法使用，請稍後再試。")
 
-# ---------- 執行 ----------
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port)
+    uvicorn.run("app:app", host="0.0.0.0", port=int(os.getenv("PORT", 8000)), log_level="info")