0906

app.py

@@ -1,21 +1,16 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
+
 """
 DrugQA (ZH) — 優化版 FastAPI LINE Webhook (最終版)
 整合 RAG 邏輯，包含 LLM 意圖偵測、子查詢分解、Intent-aware 檢索與 Rerank。
-此版本專注於效能、可維護性、健壯性與使用者體驗。
+新增動態字數調整、多次互動邏輯與對話狀態管理，提升使用者體驗。
+僅支援十種藥物。
 """
 
-# ---------- 環境與快取設定 (應置於最前) ----------
+# ---------- 環境與快取設定 ----------
 import os
 import pathlib
-os.environ.setdefault("HF_HOME", "/tmp/hf")
-os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", "/tmp/sentence_transformers")
-os.environ.setdefault("XDG_CACHE_HOME", "/tmp/.cache")
-for d in (os.getenv("HF_HOME"), os.getenv("SENTENCE_TRANSFORMERS_HOME"), os.getenv("XDG_CACHE_HOME")):
-    pathlib.Path(d).mkdir(parents=True, exist_ok=True)
-
-# ---------- Python 標準函式庫 ----------
 import re
 import hmac
 import base64
@@ -31,85 +26,131 @@ from functools import lru_cache
 from dataclasses import dataclass, field
 from contextlib import asynccontextmanager
 import unicodedata
+from collections import defaultdict
+import asyncio
+import aiohttp  # 新增：導入 aiohttp 用於異步 HTTP 請求
 
-# ---------- 第三方函式庫 ----------
+# ------------ 第三方函式庫 -------------
 import numpy as np
 import pandas as pd
-from fastapi import FastAPI, Request, Response, HTTPException, status, BackgroundTasks
-import uvicorn
 import jieba
 from rank_bm25 import BM25Okapi
-from sentence_transformers import SentenceTransformer, CrossEncoder
+from sentence_transformers import SentenceTransformer
 import faiss
 import torch
 from openai import OpenAI
 from tenacity import retry, stop_after_attempt, wait_fixed
 import requests
+import uvicorn
+from fastapi import FastAPI, Request, Response, HTTPException, status, BackgroundTasks
 
-# [MODIFIED] 限制 PyTorch 執行緒數量，避免在 CPU 環境下過度佔用資源
+# ---- 限制 PyTorch 執行緒數量，避免 CPU 環境下過度佔用資源 ----
 torch.set_num_threads(int(os.getenv("TORCH_NUM_THREADS", "1")))
 
-# ==== CONFIG (從環境變數載入，或使用預設值) ====
-# [MODIFIED] 新增環境變數健檢函式
+# ===== CONFIG =====
 def _require_env(var: str) -> str:
+    """Return the value of an environment variable or raise an error."""
     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)
 
+
+# --------- 路徑設定 ------------
 CSV_PATH = os.getenv("CSV_PATH", "cleaned_combined.csv")
 FAISS_INDEX = os.getenv("FAISS_INDEX", "drug_sentences.index")
 SENTENCES_PKL = os.getenv("SENTENCES_PKL", "drug_sentences.pkl")
 BM25_PKL = os.getenv("BM25_PKL", "bm25.pkl")
 
-TOP_K_SENTENCES = int(os.getenv("TOP_K_SENTENCES", 15))
+TOP_K_SENTENCES = int(os.getenv("TOP_K_SENTENCES", 20))
 PRE_RERANK_K = int(os.getenv("PRE_RERANK_K", 30))
 MAX_RERANK_CANDIDATES = int(os.getenv("MAX_RERANK_CANDIDATES", 30))
 
 EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "DMetaSoul/Dmeta-embedding-zh")
-RERANKER_MODEL = os.getenv("RERANKER_MODEL", "BAAI/bge-reranker-v2-m3")
 
 LLM_API_CONFIG = {
-    "base_url": os.getenv("LITELLM_BASE_URL"),
-    "api_key": os.getenv("LITELLM_API_KEY"),
-    "model": os.getenv("LM_MODEL")
+    "base_url": _require_env("LITELLM_BASE_URL"),
+    "api_key": _require_env("LITELLM_API_KEY"),
+    "model": _require_env("LM_MODEL"),
 }
 
 LLM_MODEL_CONFIG = {
     "max_context_chars": int(os.getenv("MAX_CONTEXT_CHARS", 10000)),
-    "max_tokens": int(os.getenv("MAX_TOKENS", 1024)),
+    "max_tokens_simple": int(os.getenv("MAX_TOKENS_SIMPLE", 256)),
+    "max_tokens_complex": int(os.getenv("MAX_TOKENS_COMPLEX", 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)"
+    "操作 (Administration)",
+    "保存/攜帶 (Storage & Handling)",
+    "副作用/異常 (Side Effects / Issues)",
+    "劑型相關 (Dosage Form Concerns)",
+    "時間/併用 (Timing & Interaction)",
+    "劑量調整 (Dosage Adjustment)",
+    "禁忌症/適應症 (Contraindications/Indications)",
 ]
 
+INTENT_TO_SECTION = {
+    "操作 (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",
+    "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",
+}
+SUPPORTED_DRUGS = list(DRUG_NAME_MAPPING.keys())
+DISCLAIMER = (
+    "本資訊僅供參考，若您對藥物使用有任何疑問，請務必諮詢您的醫師或藥師。"
+)
+
+REFERENCE_MAPPING = {
+    "如何用藥？": "病人使用須知、用法用量",
+    "如何保存與攜帶？": "包裝及儲存",
+    "可能的副作用？": "警語與注意事項、不良反應",
+    "每次劑量多少？": "用法用量、藥袋上的醫囑",
+    "用藥時間？": "用法用量、藥袋上的醫囑",
+}
+
+REFERENCE_TO_INTENT = {
+    "如何用藥？": ["操作 (Administration)"],
+    "如何保存與攜帶？": ["保存/攜帶 (Storage & Handling)"],
+    "可能的副作用？": ["副作用/異常 (Side Effects / Issues)"],
+    "每次劑量多少？": ["劑量調整 (Dosage Adjustment)"],
+    "用藥時間？": ["時間/併用 (Timing & Interaction)"],
 }
-DISCLAIMER = "本資訊僅供參考，若您對藥物使用有任何疑問，請務務必諮詢您的醫師或藥師。"
 
 PROMPT_TEMPLATES = {
     "analyze_query": """
-請分析以下使用者問題，並完成以下兩個任務：
-1. 將問題分解為1-3個核心的子問題。
+請分析以下使用者問題，並完成以下三個任務：
+1. 將問題分解為 1-3 個核心子問題。
 2. 從清單中選擇所有相關的意圖分類。
+3. 評估問題複雜度，返回 'simple'（單一問題或簡單意圖）或 'complex'（多子問題或複雜意圖，如副作用、劑量調整）。
 
-請嚴格以 JSON 格式回覆，包含 'sub_queries' (字串陣列) 和 'intents' (字串陣列) 兩個鍵。
-範例: {{"sub_queries": ["子問題一", "子問題二"], "intents": ["分類名稱一", "分類名稱二"]}}
+請嚴格以 JSON 格式回覆，包含 'sub_queries' (字串陣列)、'intents' (字串陣列) 和 'complexity' (字串) 三個鍵。
+範例: {{"sub_queries": ["子問題一", "子問題二"], "intents": ["分類名稱一", "分類名稱二"], "complexity": "simple"}}
 
 意圖分類清單：
-{options}
+{options}。
 
 使用者問題：{query}
 """,
@@ -119,20 +160,13 @@ PROMPT_TEMPLATES = {
 請僅輸出擴展後的查詢，不需任何額外的解釋或格式。
 """,
     "final_answer": """
-你是一位專業且謹慎的台灣藥師。請嚴格根據「參考資料」回答使用者問題，使用繁體中文。
-
-規則：
-
-所有回答內容必須嚴格依據提供的參考資料，禁止任何形式的捏造或引用外部資訊。
-若資料不足以回答，請回覆：「根據提供的資料，無法回答您的問題。」
-針對原始查詢，以專業、友善的口吻，提供簡潔但資訊完整的中文繁體回答。
-回答字數限制在120字以內。
-
-排版格式：
-
-使用條列式分行呈現，排版需適合LINE對話框顯示。
-回覆結尾必須加上指定提醒語句：「如有不適請立即就醫。」
+您是一位專業、親切的台灣藥師，將在LINE上為使用者解答疑問。請依循以下規範，嚴謹地根據提供的「參考資料」給予回覆：
 
+一、 回覆規範：
+- 回覆語言：使用繁體中文，口語化且易懂，避免專業術語或解釋之。
+- 結構：先以「簡答：」標記提供簡短總結答案（50-100字），然後以「詳答：」標記提供詳細解釋，最後提醒使用者諮詢醫師。
+- 長度：簡答控制在50-100字，詳答根據問題複雜度調整，簡單問題約100-200字，複雜問題（如多步驟的裝置安裝或藥品使用）可達300-500字。
+- 態度：親切、專業、關懷，避免驚嚇使用者。
 {additional_instruction}
 
 ---
@@ -143,19 +177,52 @@ PROMPT_TEMPLATES = {
 使用者問題：{query}
 
 請直接輸出最終的答案：
+""",
+    "analyze_reference": """
+從以下清單選擇最匹配的使用者問題分類，如果沒有匹配，返回 'none'。
+
+分類清單：
+{options}
+
+使用者問題：{query}
+
+請僅輸出分類名稱或 'none'，不需任何額外的解釋或格式。
+""",
+    "clarification": """
+請根據以下使用者問題，生成一個簡潔、禮貌的澄清性提問，以幫助我更精準地回答。問題應引導使用者提供更多細節，例如具體藥名、使用情境，並附上範例問題。請在回覆中明確告知使用者，目前僅支援以下藥物詢問：
+- Fentanyl patch
+- Spiriva Respimat
+- NITROSTAT
+- AUGMENTIN FOR SYRUP
+- Ozempic
+- NIFLEC
+- Fosamax
+- Humira
+- PREMARIN
+- SMECTA
+
+範例：
+使用者問題：這個藥會怎麼樣？
+澄清提問：您好，請問您指的藥物是下列哪一種？目前僅支援以下藥物詢問：Fentanyl patch、Spiriva Respimat...等。例如，您可以問：「Fentanyl patch 的副作用有哪些？」請確認藥名或提供更多細節。
+
+使用者問題：{query}
 """
 }
 
 # ---------- 日誌設定 ----------
-logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(levelname)s - %(message)s",
+)
 log = logging.getLogger(__name__)
 
-# [新增] 統一字串正規化函式
+# ---------- 字串正規化 ----------
 def _norm(s: str) -> str:
-    """統一化字串：NFKC 正規化、轉小寫、移除標點符號與空白。"""
+    """統一化字串：NFKC 正規化、轉小寫、移除標點與空格。"""
     s = unicodedata.normalize("NFKC", s)
     return re.sub(r"[^\w\s]", "", s.lower()).strip()
 
+
 @dataclass
 class FusedCandidate:
     idx: int
@@ -163,6 +230,7 @@ class FusedCandidate:
     sem_score: float
     bm_score: float
 
+
 @dataclass
 class RerankResult:
     idx: int
@@ -170,406 +238,459 @@ class RerankResult:
     text: str
     meta: Dict[str, Any] = field(default_factory=dict)
 
+
+@dataclass
+class ConversationState:
+    query_history: List[str] = field(default_factory=list)
+    drug_ids: List[str] = field(default_factory=list)
+    intents: List[str] = field(default_factory=list)
+    complexity: str = "simple"
+    last_answer: Optional[str] = None
+    clarification_count: int = 0
+
+
 # ---------- 核心 RAG 邏輯 ----------
 class RagPipeline:
     def __init__(self):
-        # [MODIFIED] 不再傳入 AppConfig，直接引用
         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"])
-        # [FIXED] 新增 model_name 屬性
+            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.model_name = LLM_API_CONFIG["model"]
-        self.embedding_model = self._load_model(SentenceTransformer, EMBEDDING_MODEL, "embedding")
-        self.reranker = self._load_model(CrossEncoder, RERANKER_MODEL, "reranker")
-        
+        self.embedding_model = self._load_model(
+            SentenceTransformer, EMBEDDING_MODEL, "embedding"
+        )
         self.drug_name_to_ids: Dict[str, List[str]] = {}
         self.drug_vocab: Dict[str, set] = {"zh": set(), "en": set()}
-        self.state = type('state', (), {})()
+        self.state = type("state", (), {})()
+        self.conversations: Dict[str, ConversationState] = defaultdict(ConversationState)
 
     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}...")
+        log.info(f"載入 {model_type} 模型：{model_name} 於 {device}")
         try:
             return model_class(model_name, device=device)
         except Exception as e:
-            log.warning(f"載入模型至 {device} 失敗: {e}。嘗試切換至 CPU。")
+            log.warning(f"載入 {model_type} 至 {device} 失敗: {e}，嘗試切換至 CPU。")
             try:
                 return model_class(model_name, device="cpu")
             except Exception as e_cpu:
-                log.error(f"切換至 CPU 仍無法載入模型: {model_name}。請確認模型路徑或網路連線。錯誤訊息: {e_cpu}")
+                log.error(f"切換至 CPU 仍無法載入模型: {model_name}。錯誤訊息: {e_cpu}")
                 raise RuntimeError(f"模型載入失敗: {model_name}")
 
     def load_data(self):
         log.info("開始載入資料與模型...")
-        # [MODIFIED] 增加檔案存在性檢查
         for path in [CSV_PATH, FAISS_INDEX, SENTENCES_PKL, BM25_PKL]:
             if not pathlib.Path(path).exists():
                 raise FileNotFoundError(f"必要的資料檔案不存在: {path}")
 
         try:
-            self.df_csv = pd.read_csv(CSV_PATH, dtype=str).fillna('')
-            # [MODIFIED] 增加必要欄位檢查
-            for col in ("drug_name_norm", "drug_id"):
+            self.df_csv = pd.read_csv(CSV_PATH, dtype=str).fillna("")
+            required_cols = ["drug_name_norm", "drug_id", "section", "content"]
+            for col in required_cols:
                 if col not in self.df_csv.columns:
                     raise KeyError(f"CSV 檔案 '{CSV_PATH}' 中缺少必要欄位: {col}")
+        except Exception as e:
+            log.error(f"讀取 CSV 失敗: {e}")
+            raise
+
+        self.drug_name_to_ids = self._build_drug_name_to_ids()
+        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"))
+
+        with open(SENTENCES_PKL, "rb") as f:
+            data = pickle.load(f)
+            self.state.sentences = data["sentences"]
+            self.state.meta = data["meta"]
+
+        log.info("載入 BM25 索引...")
+        with open(BM25_PKL, "rb") as f:
+            bm25_data = pickle.load(f)
+            self.state.bm25 = bm25_data["bm25"]
+        if not isinstance(self.state.bm25, BM25Okapi):
+            raise ValueError("Loaded BM25 is not a BM25Okapi instance.")
 
-            # [MODIFIED] 新增更強大的藥名詞典建立邏輯
-            self.drug_name_to_ids = self._build_drug_name_to_ids()
-            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"))
-            # [新增] 檢查 FAISS 指標類型，若為 IP 則提示
-            if self.state.faiss_metric == faiss.METRIC_INNER_PRODUCT:
-                log.info("FAISS 索引使用內積 (IP) 指標，檢索時將自動進行 L2 正規化以實現餘弦相似度。")
-
-            with open(SENTENCES_PKL, "rb") as f:
-                data = pickle.load(f)
-                self.state.sentences = data["sentences"]
-                self.state.meta = data["meta"]
-
-            log.info("載入 BM25 索引...")
-            with open(BM25_PKL, "rb") as f:
-                # 載入整個字典，然後取 'bm25' 這個鍵
-                bm25_data = pickle.load(f)
-                self.state.bm25 = bm25_data["bm25"]
-            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("所有模型與資料載入完成。")
 
+    @lru_cache(maxsize=128)
+    def _get_drug_name_by_id(self, drug_id: str) -> Optional[str]:
+        row = self.df_csv[self.df_csv["drug_id"] == drug_id]
+        if not row.empty:
+            return row.iloc[0]["drug_name_norm"]
+        return None
+
     def _find_drug_ids_from_name(self, query: str) -> List[str]:
-        # [MODIFIED] 新增更強大的藥名詞典建立邏輯
-        q_norm_parts = set(re.findall(r'[a-z0-9]+|[\u4e00-\u9fff]+', _norm(query)))
+        q_norm_parts = set(
+            re.findall(r"[a-z0-9]+|[\u4e00-\u9fff]+", _norm(query))
+        )
         drug_ids = set()
-
         for part in q_norm_parts:
             if part in self.drug_name_to_ids:
                 drug_ids.update(self.drug_name_to_ids[part])
-
-        return sorted(list(drug_ids))
+        for drug_name, ids in self.drug_name_to_ids.items():
+            if drug_name in _norm(query):
+                drug_ids.update(ids)
+        return sorted(drug_ids)
 
     def _build_drug_name_to_ids(self) -> Dict[str, List[str]]:
-        mapping = {}
+        self.drug_name_to_ids = {}
         for _, row in self.df_csv.iterrows():
-            drug_id = row['drug_id']
-            # 使用 jieba 將中文藥名切分，並將英文名拆分
-            zh_parts = list(jieba.cut(row['drug_name_zh']))
-            en_parts = re.findall(r'[a-zA-Z0-9]+', row['drug_name_en'].lower() if row['drug_name_en'] else '')
-            
-            # 統一使用 _norm 函數處理，以確保與查詢的處理方式一致
-            norm_parts = re.findall(r'[a-z0-9]+|[\u4e00-\u9fff]+', _norm(row['drug_name_norm']))
-            
+            drug_id = row["drug_id"]
+            zh_parts = list(jieba.cut(row["drug_name_zh"]))
+            en_parts = re.findall(
+                r"[a-zA-Z0-9]+", row["drug_name_en"].lower() if row["drug_name_en"] else ""
+            )
+            norm_parts = re.findall(
+                r"[a-z0-9]+|[\u4e00-\u9fff]+", _norm(row["drug_name_norm"])
+            )
             all_parts = set(zh_parts + en_parts + norm_parts)
             for part in all_parts:
                 part = part.strip()
                 if part and len(part) > 1:
-                    mapping.setdefault(part, []).append(drug_id)
-
-            # 將 DRUG_NAME_MAPPING 中的別名也加入
+                    self.drug_name_to_ids.setdefault(part, []).append(drug_id)
             for alias, canonical_name in DRUG_NAME_MAPPING.items():
-                if _norm(canonical_name) in _norm(row['drug_name_norm']):
-                    mapping.setdefault(_norm(alias), []).append(drug_id)
-                    
-        for key in mapping:
-            mapping[key] = sorted(list(set(mapping[key])))
-
-        return mapping
+                if _norm(canonical_name) in _norm(row["drug_name_norm"]):
+                    self.drug_name_to_ids.setdefault(_norm(alias), []).append(drug_id)
+        for key in self.drug_name_to_ids:
+            self.drug_name_to_ids[key] = sorted(set(self.drug_name_to_ids[key]))
+        return self.drug_name_to_ids
 
     def _load_drug_name_vocabulary(self):
         log.info("建立藥名詞庫...")
         for _, row in self.df_csv.iterrows():
-            norm_name = row['drug_name_norm']
-            words = list(re.findall(r'[a-z0-9]+|[\u4e00-\u9fff]+', norm_name))
+            norm_name = row["drug_name_norm"]
+            words = re.findall(r"[a-z0-9]+|[\u4e00-\u9fff]+", norm_name)
             for word in words:
-                if re.search(r'[\u4e00-\u9fff]', word):
+                if re.search(r"[\u4e00-\u9fff]", word):
                     self.drug_vocab["zh"].add(word)
                 else:
                     self.drug_vocab["en"].add(word)
-        
         for alias in DRUG_NAME_MAPPING:
-            if re.search(r'[\u4e00-\u9fff]', alias):
+            if re.search(r"[\u4e00-\u9fff]", alias):
                 self.drug_vocab["zh"].add(alias)
             else:
                 self.drug_vocab["en"].add(alias)
-        
         for word in self.drug_vocab["zh"]:
             try:
                 if word not in jieba.dt.FREQ:
                     jieba.add_word(word, freq=2_000_000)
             except Exception:
                 pass
-    
+
     @tenacity.retry(
         wait=tenacity.wait_fixed(2),
-        stop=tenacity.stop_after_attempt(3),
-        retry=tenacity.retry_if_exception_type(ValueError),
-        before_sleep=tenacity.before_sleep_log(log, logging.WARNING),
-        after=tenacity.after_log(log, logging.INFO)
+        stop=tenacity.stop_after_attempt(5)
     )
-    def _llm_call(self, messages: List[Dict[str, str]], max_tokens: Optional[int] = None, temperature: Optional[float] = None) -> str:
-        """安全地呼叫 LLM API，並處理可能的回應內容為空錯誤。"""
-        log.info(f"LLM 呼叫開始. 模型: {self.model_name}, max_tokens: {max_tokens}, temperature: {temperature}")
-        
-        log.info(f"送出的 LLM 提示 (messages): {json.dumps(messages, ensure_ascii=False, indent=2)}")
-
-        start_time = time.time()
+    def _llm_call(
+        self,
+        messages: List[Dict[str, str]],
+        max_tokens: Optional[int] = None,
+        temperature: Optional[float] = None,
+    ) -> str:
+        log.info(f"LLM 呼叫開始. 模型: {self.model_name}")
         try:
             response = self.llm_client.chat.completions.create(
                 model=self.model_name,
                 messages=messages,
-                max_tokens=max_tokens,
-                temperature=temperature,
+                max_tokens=max_tokens or LLM_MODEL_CONFIG["max_tokens_simple"],
+                temperature=temperature or LLM_MODEL_CONFIG["temperature"],
             )
-            
-            end_time = time.time()
-
-            log.info(f"LLM 收到完整回應: {response.model_dump_json(indent=2)}")
-
-            # --- 修正處：當回傳內容為空時，直接回傳空字串，而非拋出 ValueError ---
-            if not response.choices or not response.choices[0].message.content:
-                log.warning("LLM 呼叫成功 (200 OK)，但回傳內容為空。將回傳空字串。")
-                return ""
-            # --- 修正結束 ---
-
-            content = response.choices[0].message.content
-            log.info(f"LLM 呼叫完成，耗時: {end_time - start_time:.2f} 秒。內容長度: {len(content)} 字。")
-            return content
-
+            content = response.choices[0].message.content or ""
+            return content.strip()
         except Exception as e:
-            log.error(f"LLM API 呼叫失敗: {e}")
+            log.error(f"LLM API 調用失敗: {e}")
             raise
 
-    def answer_question(self, q_orig: str) -> str:
+    async def answer_question(self, target_id: str, q_orig: str) -> Tuple[str, List[str]]:
         start_time = time.time()
-        log.info(f"===== 處理新查詢: '{q_orig}' =====")
+        log.info(f"===== 處理查詢: '{q_orig}' (target_id: {target_id}) =====")
+        conv_state = self.conversations[target_id]
+        conv_state.query_history.append(q_orig)
+
         try:
             drug_ids = self._find_drug_ids_from_name(q_orig)
-
             if not drug_ids:
-                log.info("未從查詢中找到相關藥名，直接返回預設訊息。")
-                return f"未從查詢中找到相關藥名，無法回答您的問題。\n{DISCLAIMER}"
-            
-            log.info(f"步驟 1/5: 找到藥品 ID: {drug_ids}，耗時: {time.time() - start_time:.2f} 秒")
-            step_start = time.time()
-
-            analysis = self._analyze_query(q_orig)
-            sub_queries, intents = analysis.get("sub_queries", [q_orig]), analysis.get("intents", [])
-            is_simple_query = self._is_simple_query(sub_queries, intents)
-            log.info(f"步驟 2/5: 意圖分析完成。子問題: {sub_queries}, 意圖: {intents}。判定為簡單查詢: {is_simple_query}。耗時: {time.time() - step_start:.2f} 秒")
-            step_start = time.time()
-            
-            all_candidates = self._retrieve_candidates_for_all_queries(drug_ids, sub_queries, intents)
-            log.info(f"步驟 3/5: 檢索完成。所有子查詢共找到 {len(all_candidates)} 個不重複候選 chunks。耗時: {time.time() - step_start:.2f} 秒")
-            step_start = time.time()
-
-            if is_simple_query:
-                log.info("偵測到簡單查詢，跳過 Reranker 步驟。")
-                final_candidates = all_candidates[:TOP_K_SENTENCES]
-                reranked_results = [
-                    RerankResult(idx=c.idx, rerank_score=c.fused_score, text=self.state.sentences[c.idx], meta=self.state.meta[c.idx])
-                    for c in final_candidates
-                ]
+                log.info(f"未找到匹配藥物，查詢：{q_orig}")
+                conv_state.clarification_count += 1
+                if conv_state.clarification_count > 3:
+                    return "抱歉，多次無法識別您的問題，請確認藥物名稱或聯繫醫師。\n" + DISCLAIMER, []
+                clarification = self._generate_clarification_query(q_orig)
+                conv_state.last_answer = clarification
+                return f"{clarification}\n\n{DISCLAIMER}", []
+
+            conv_state.drug_ids = drug_ids
+            ref_key = self._match_reference_key(q_orig)
+            complexity = "simple"  # 預設為簡單
+            context = ""
+            intents = []
+
+            if ref_key != 'none' and ref_key in REFERENCE_MAPPING:
+                sections_str = REFERENCE_MAPPING[ref_key]
+                sections = [s.strip() for s in sections_str.split('、') if s.strip() and s != '藥袋上的醫囑']
+                intents = REFERENCE_TO_INTENT.get(ref_key, [])
+                context = self._build_context_from_csv(drug_ids, sections)
+                # 根據參考資料判斷複雜度
+                if any(sec in ["用法用量", "病人使用須知", "劑型相關"] for sec in sections):
+                    complexity = "complex"  # 多步驟的裝置安裝或藥品使用
+                elif any(sec in ["不良反應", "警語與注意事項"] for sec in sections):
+                    complexity = "simple"  # 副作用問題
             else:
-                log.info("偵測到複雜查詢，執行 Reranker。")
-                reranked_results = self._rerank_with_crossencoder(q_orig, all_candidates)
-            
-            log.info(f"步驟 4/5: 最終選出 {len(reranked_results)} 個高品質候選。耗時: {time.time() - step_start:.2f} 秒")
-            step_start = time.time()
-
-            # [新增] 根據意圖，將內容進行排序優化
-            prioritized_results = self._prioritize_context(reranked_results, intents)
-
-            context = self._build_context(prioritized_results)
-            if not context:
-                log.info("沒有足夠的上下文來回答問題。")
-                return f"根據提供的資料，無法回答您的問題。{DISCLAIMER}"
-                
+                return await self._fallback_rag(target_id, q_orig, drug_ids)
+
+            conv_state.intents = intents
+            conv_state.complexity = complexity
+
+            max_tokens = LLM_MODEL_CONFIG["max_tokens_complex"] if complexity == "complex" else LLM_MODEL_CONFIG["max_tokens_simple"]
             prompt = self._make_final_prompt(q_orig, context, intents)
-            answer = self._llm_call([{"role": "user", "content": prompt}])
-            
-            # --- 新增處理：如果 LLM 回傳空字串，則回傳預設訊息 ---
+            answer = self._llm_call(
+                [{"role": "user", "content": prompt}],
+                max_tokens=max_tokens
+            )
             if not answer:
-                log.warning("LLM 回傳的答案為空，將使用預設回覆。")
-                return f"根據提供的資料，無法回答您的問題。{DISCLAIMER}"
-            # --- 處理結束 ---
-            
-            final_answer = f"{answer.strip()}\n\n{DISCLAIMER}"
-            log.info(f"步驟 5/5: 答案生成完成。答案長度: {len(answer.strip())} 字。耗時: {time.time() - step_start:.2f} 秒")
-            log.info(f"===== 查詢處理完成，總耗時: {time.time() - start_time:.2f} 秒 =====")
-            return final_answer
+                return f"無法回答您的問題。\n{DISCLAIMER}", drug_ids
 
+            answer = answer.replace("*", "")
+            conv_state.last_answer = answer
+            final_answer = f"{answer.strip()}\n\n{DISCLAIMER}"
+            log.info(f"查詢處理完成，耗時: {time.time() - start_time:.2f}秒")
+            return final_answer, drug_ids
         except Exception as e:
-            log.error(f"處理查詢 '{q_orig}' 時發生嚴重錯誤: {e}", exc_info=True)
-            return f"處理您的問題時發生內部錯誤，請稍後再試。{DISCLAIMER}"
+            log.error(f"處理查詢時發生錯誤: {e}", exc_info=True)
+            return f"處理時發生內部錯誤，請稍後再試。\n{DISCLAIMER}", []
+
+    async def _fallback_rag(self, target_id: str, q_orig: str, drug_ids: List[str]) -> Tuple[str, List[str]]:
+        conv_state = self.conversations[target_id]
+        analysis = self._analyze_query(q_orig)
+        sub_queries = analysis.get("sub_queries", [q_orig])
+        intents = analysis.get("intents", [])
+        complexity = "simple"  # 預設為簡單
+        sections = []
+        for intent in intents:
+            sections.extend(INTENT_TO_SECTION.get(intent, []))
+        if any(sec in ["用法用量", "病人使用須知", "劑型相關"] for sec in sections):
+            complexity = "complex"
+        elif any(sec in ["不良反應", "警語與注意事項"] for sec in sections):
+            complexity = "simple"
+        conv_state.intents = intents
+        conv_state.complexity = complexity
 
-    def _is_simple_query(self, sub_queries: List[str], intents: List[str]) -> bool:
-        # 如果意圖分析回傳的子查詢數量 <= 1，且意圖分類數量也 <= 1，則判定為簡單問題
-        return len(sub_queries) <= 1 and len(intents) <= 1
+        if not intents:
+            log.info(f"無明確意圖，查詢：{q_orig}")
+            conv_state.clarification_count += 1
+            if conv_state.clarification_count > 3:
+                return "抱歉，多次無法識別您的問題，請確認藥物名稱或聯繫醫師。\n" + DISCLAIMER, drug_ids
+            clarification = self._generate_clarification_query(q_orig)
+            conv_state.last_answer = clarification
+            return f"{clarification}\n\n{DISCLAIMER}", drug_ids
+
+        all_candidates = self._retrieve_candidates_for_all_queries(
+            drug_ids, sub_queries, intents
+        )
+        final_candidates = all_candidates[:TOP_K_SENTENCES]
+
+        reranked_results = [
+            RerankResult(
+                idx=c.idx,
+                rerank_score=c.fused_score,
+                text=self.state.sentences[c.idx],
+                meta=self.state.meta[c.idx],
+            )
+            for c in final_candidates
+        ]
+        prioritized = self._prioritize_context(reranked_results, intents)
+        context = self._build_context(prioritized)
 
-    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
+        if not context:
+            return f"無法回答您的問題，請參閱原始內容。\n{DISCLAIMER}", drug_ids
+
+        max_tokens = LLM_MODEL_CONFIG["max_tokens_complex"] if complexity == "complex" else LLM_MODEL_CONFIG["max_tokens_simple"]
+        prompt = self._make_final_prompt(q_orig, context, intents)
+        answer = self._llm_call(
+            [{"role": "user", "content": prompt}],
+            max_tokens=max_tokens
+        )
+        if not answer:
+            return f"無法回答您的問題。\n{DISCLAIMER}", drug_ids
+
+        answer = answer.replace("*", "")
+        conv_state.last_answer = answer
+        final_answer = f"{answer.strip()}\n\n{DISCLAIMER}"
+        return final_answer, drug_ids
+
+    def _match_reference_key(self, query: str) -> str:
+        options = "\n".join(f"- {k}" for k in REFERENCE_MAPPING.keys())
+        prompt = PROMPT_TEMPLATES["analyze_reference"].format(
+            options=options, query=query
         )
-        response_str = self._llm_call([{"role": "user", "content": prompt}], temperature=0)
-        return self._safe_json_parse(response_str, default={"sub_queries": [query], "intents": []})
+        response_str = self._llm_call([{"role": "user", "content": prompt}])
+        ref_key = response_str.strip().replace('"', '')
+        if ref_key in REFERENCE_MAPPING:
+            return ref_key
+        return 'none'
 
-    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))
-        if drug_ids_set:
-            relevant_indices = {i for i, m in enumerate(self.state.meta) if str(m.get("drug_id", "")) in drug_ids_set}
-        else:
-            relevant_indices = set(range(len(self.state.meta)))
+    def _build_context_from_csv(self, drug_ids: List[str], sections: List[str]) -> str:
+        context = ""
+        for drug_id in drug_ids:
+            drug_df = self.df_csv[self.df_csv['drug_id'] == drug_id]
+            for sec in sections:
+                sec_row = drug_df[drug_df['section'].str.contains(sec, na=False)]
+                if not sec_row.empty:
+                    content = sec_row.iloc[0]['content']
+                    if len(context) + len(content) > LLM_MODEL_CONFIG["max_context_chars"]:
+                        return context.strip()
+                    context += content + "\n\n"
+        return context.strip()
 
-        if not relevant_indices: return []
+    def _analyze_query(self, query: str) -> Dict[str, Any]:
+        options = "\n".join(f"- {c}" for c in INTENT_CATEGORIES)
+        prompt = PROMPT_TEMPLATES["analyze_query"].format(
+            options=options, query=query
+        )
+        response_str = self._llm_call([{"role": "user", "content": prompt}])
+        return self._safe_json_parse(response_str, default={"sub_queries": [query], "intents": [], "complexity": "simple"})
+
+    def _generate_clarification_query(self, query: str) -> str:
+        prompt = PROMPT_TEMPLATES["clarification"].format(query=query)
+        return self._llm_call([{"role": "user", "content": prompt}])
+
+    def _retrieve_candidates_for_all_queries(
+        self, drug_ids: List[str], sub_queries: List[str], intents: List[str]
+    ) -> List[FusedCandidate]:
+        drug_ids_set, relevant_indices = set(map(str, drug_ids)), (
+            {i for i, m in enumerate(self.state.meta) if str(m.get("drug_id")) in drug_ids_set}
+            if drug_ids_set
+            else set(range(len(self.state.meta)))
+        )
+        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))
-            
+            expanded_q = self._expand_query_with_llm(sub_q, 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)
+            distances, sem_indices = self.state.index.search(q_emb, PRE_RERANK_K)
 
             tokenized_query = list(jieba.cut(expanded_q))
-            
             bm25_scores = self.state.bm25.get_scores(tokenized_query)
-            rel_idx = np.fromiter(relevant_indices, dtype=int)
+            rel_idx = np.fromiter(relevant_indices, dtype=np.int64)
             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}
-            
+            doc_to_bm25_score: Dict[int, float] = {
+                int(i): float(bm25_scores[i]) for i in top_rel
+            }
             candidate_scores: Dict[int, Dict[str, float]] = {}
-            
             def to_similarity(d: float) -> float:
-                if self.state.faiss_metric == faiss.METRIC_INNER_PRODUCT:
-                    return float(d)
-                else:
-                    return 1.0 / (1.0 + float(d))
-
-            for i, dist in zip(sim_indices[0], distances[0]):
+                return float(d) if self.state.faiss_metric == faiss.METRIC_INNER_PRODUCT else 1.0 / (1.0 + float(d))
+            for i, dist in zip(sem_indices[0], distances[0]):
                 if i in relevant_indices:
-                    similarity = to_similarity(dist)
-                    candidate_scores[int(i)] = {"sem": float(similarity), "bm": 0.0}
-
+                    candidate_scores[i] = {"sem": to_similarity(dist), "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
-            
+            if not candidate_scores:
+                continue
             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)
+            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):
+                return (x - x.min()) / (x.max() - x.min() + 1e-8) if x.max() - x.min() > 0 else np.zeros_like(x)
 
             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)
 
-    def _expand_query_with_llm(self, query: str, intents: tuple) -> str:
+    def _expand_query_with_llm(self, query: str, intents: List[str]) -> 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():
-                log.info(f"查詢擴展成功。原始: '{query}', 擴展後: '{expanded_query}'")
-                return expanded_query
-            else:
-                log.warning(f"查詢擴展回傳空內容。原始查詢: '{query}'。將使用原始查詢。")
-                return query
-        except Exception as e:
-            log.error(f"查詢擴展失敗: {e}。原始查詢: '{query}'。將使用原始查詢。")
-            return query
-
-    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)
-        ]
-        
-        return sorted(results, key=lambda x: x.rerank_score, reverse=True)[:TOP_K_SENTENCES]
+        prompt = PROMPT_TEMPLATES["expand_query"].format(intents=intents, query=query)
+        expanded = self._llm_call(
+            [{"role": "user", "content": prompt}]
+        )
+        return expanded.strip() if expanded else query
 
     def _prioritize_context(self, results: List[RerankResult], intents: List[str]) -> List[RerankResult]:
-        if "副作用/異常 (Side Effects / Issues)" not in intents:
+        if not intents:
             return results
-        
-        warnings_and_notes = [res for res in results if res.meta.get("section", "").startswith("警語與注意事項")]
-        adverse_reactions = [res for res in results if res.meta.get("section", "").startswith("不良反應")]
-        other_results = [res for res in results if res not in warnings_and_notes and res not in adverse_reactions]
-        
-        prioritized = warnings_and_notes + other_results + adverse_reactions
-        
-        return prioritized
+        prioritized_sections = set()
+        for intent in intents:
+            prioritized_sections.update(INTENT_TO_SECTION.get(intent, []))
+        if not prioritized_sections:
+            return results
+        prioritized, other = [], []
+        for res in results:
+            if res.meta.get("section") in prioritized_sections:
+                prioritized.append(res)
+            else:
+                other.append(res)
+        return prioritized + other
 
     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
+            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 = "在回答用藥劑量和時間時，務必提醒使用者，醫師開立的藥袋醫囑優先於仿單的一般建議。"
+        if any(
+            i
+            in intents
+            for i in
+            ("劑量調整 (Dosage Adjustment)", "時間/併用 (Timing & Interaction)")
+        ):
+            add_instr = (
+                "在回答用藥劑量和時間時，務必提醒使用者，醫師開立的藥袋醫囑優先於仿單的一般建議。"
+            )
         if "保存/攜帶 (Storage & Handling)" in intents:
-            add_instr += "在回答保存與攜帶問題時，除了仿單內容，請根據常識加入實際情境的提醒，例如提醒需冷藏藥品要用保冷袋攜帶。"
-        
+            add_instr += (
+                " 在回答保存與攜帶問題時，除了仿單內容，請根據常識加入實際情境的提醒，例如提醒需冷藏藥品要用保冷袋攜帶。"
+            )
+        add_instr += "\n請根據以下問題與參考資料對應回答："
+        for q, refs in REFERENCE_MAPPING.items():
+            add_instr += f"\n- {q}: {refs}"
         return PROMPT_TEMPLATES["final_answer"].format(
             additional_instruction=add_instr, context=context, query=query
         )
-    
+
     def _safe_json_parse(self, s: str, default: Any = None) -> Any:
         try:
             return json.loads(s)
         except json.JSONDecodeError:
-            log.warning(f"無法解析完整 JSON。嘗試從字串中提取: {s[:200]}...")
-            m = re.search(r'\{.*?\}', s, re.DOTALL)
-            if m:
-                try:
+            try:
+                m = re.search(r"\{.*?\}", s, re.DOTALL)
+                if m:
                     return json.loads(m.group(0))
-                except json.JSONDecodeError:
-                    log.warning(f"提取的 JSON 仍無法解析: {m.group(0)[:100]}...")
+            except json.JSONDecodeError:
+                pass
         return default
 
+
 # ---------- FastAPI 事件與路由 ----------
 class AppConfig:
     CHANNEL_ACCESS_TOKEN = _require_env("CHANNEL_ACCESS_TOKEN")
     CHANNEL_SECRET = _require_env("CHANNEL_SECRET")
 
+
 rag_pipeline: Optional[RagPipeline] = None
 
+
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     _require_llm_config()
@@ -580,21 +701,20 @@ async def lifespan(app: FastAPI):
     yield
     log.info("服務關閉中。")
 
+
 app = FastAPI(lifespan=lifespan)
 
+
 @app.post("/webhook")
 async def handle_webhook(request: Request, background_tasks: BackgroundTasks):
     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")
+        raise HTTPException(status_code=400, detail="Missing LINE X-Line-Signature header")
 
     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')
+        hash_obj = hmac.new(AppConfig.CHANNEL_SECRET.encode("utf-8"), body, hashlib.sha256)
+        expected_signature = base64.b64encode(hash_obj.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")
@@ -603,73 +723,97 @@ async def handle_webhook(request: Request, background_tasks: BackgroundTasks):
         raise HTTPException(status_code=403, detail="Invalid signature")
 
     try:
-        data = json.loads(body.decode('utf-8'))
+        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")
+        if (
+            event.get("type") == "message"
+            and event.get("message", {}).get("type") == "text"
+        ):
             user_text = event.get("message", {}).get("text", "").strip()
             source = event.get("source", {})
             stype = source.get("type")
-            target_id = source.get("userId") or source.get("groupId") or source.get("roomId")
-
-            if reply_token and user_text and target_id:
-                line_reply(reply_token, "收到您的問題，正在查詢資料庫，請稍候...")
-                background_tasks.add_task(process_user_query, stype, target_id, user_text)
-                
+            target_id = (
+                source.get("userId") or source.get("groupId") or source.get("roomId")
+            )
+            if user_text and target_id:
+                background_tasks.add_task(
+                    process_user_query, stype, target_id, user_text
+                )
     return Response(status_code=status.HTTP_200_OK)
 
-def process_user_query(source_type: str, target_id: str, user_text: str):
+
+async 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)
+        if not rag_pipeline:
+            await line_push_generic(source_type, target_id,
+                              "系統正在啟動中，請稍後再試。")
+            return
+        answer, drug_ids = await rag_pipeline.answer_question(target_id, user_text)
+        await 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}")
+        await line_push_generic(
+            source_type,
+            target_id,
+            f"抱歉，處理時發生未預期的錯誤。\n{DISCLAIMER}",
+        )
+
 
 @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-def line_api_call(endpoint: str, data: Dict):
+async def line_api_call(endpoint: str, data: Dict):
     headers = {
         "Content-Type": "application/json",
-        "Authorization": f"Bearer {AppConfig.CHANNEL_ACCESS_TOKEN}"
+        "Authorization": f"Bearer {AppConfig.CHANNEL_ACCESS_TOKEN}",
     }
-    try:
-        response = requests.post(f"https://api.line.me/v2/bot/message/{endpoint}", headers=headers, json=data, timeout=10)
-        response.raise_for_status()
-    except requests.exceptions.RequestException as e:
-        log.error(f"LINE API ({endpoint}) 呼叫失敗: {e} | Response: {e.response.text if e.response else 'N/A'}")
-        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_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]]
-    endpoint = "push"
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+            f"https://api.line.me/v2/bot/message/{endpoint}",
+            headers=headers,
+            json=data,
+            timeout=10,
+        ) as response:
+            response.raise_for_status()
+
+
+async def line_reply(reply_token: str, text: str):
+    messages = [
+        {"type": "text", "text": chunk}
+        for chunk in textwrap.wrap(text, 4800, replace_whitespace=False)[:5]
+    ]
+    await line_api_call("reply", {"replyToken": reply_token, "messages": messages})
+
+
+async 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]
+    ]
+    if "目前僅支援以下藥物詢問" in text:
+        drug_list = "\n".join(f"- {drug}" for drug in SUPPORTED_DRUGS)
+        messages.append({"type": "text", "text": f"支援的藥物清單：\n{drug_list}"})
     data = {"to": target_id, "messages": messages}
-    line_api_call(endpoint, data)
+    await line_api_call("push", data)
+
 
-def extract_drug_candidates_from_query(query: str, drug_vocab: dict) -> list:
+def extract_drug_candidates_from_query(query: str, drug_vocab: dict) -> List[str]:
     candidates = set()
     q_norm = _norm(query)
-    
     for word in re.findall(r"[a-z0-9]+", q_norm):
         if word in drug_vocab["en"]:
             candidates.add(word)
-    
     for token in jieba.cut(q_norm):
         if token in drug_vocab["zh"]:
             candidates.add(token)
-            
+    supported_drugs = set(DRUG_NAME_MAPPING.keys()).union(DRUG_NAME_MAPPING.values())
+    if not candidates.issubset(supported_drugs):
+        candidates = set()
     return list(candidates)
 
+
 # ---------- 執行 ----------
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", 7860))
+    port = int(os.getenv("PORT", "7860"))
     uvicorn.run(app, host="0.0.0.0", port=port)