hi

Dockerfile

@@ -26,7 +26,7 @@ COPY . /app
 
 # ---- Healthcheck ----
 HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
-    CMD curl -f http://localhost:${PORT:-7860}/health || exit 1  # 改為 /health 路由
+    CMD curl -f http://localhost:${PORT:-7860}/health || exit 1
 
 # ---- Port & CMD ----
 EXPOSE 7860

app.py

@@ -2,7 +2,7 @@
 # -*- coding: utf-8 -*-
 """
 DrugQA (ZH) — 優化版 FastAPI LINE Webhook
-結合了 Intent Detection, Answer Validation, 和更穩健的 RAG 流程。
+整合 kaggle_rag.py 的 RAG 邏輯，包括 LLM 意圖偵測、子查詢分解、Intent-aware 檢索 & Rerank。
 """
 
 # ---------- 環境與快取設定 (應置於最前) ----------
@@ -32,7 +32,7 @@ import pandas as pd
 from fastapi import FastAPI, Request, Response, HTTPException, status
 import uvicorn
 import jieba
-from fuzzywuzzy import process
+from fuzzywuzzy import fuzz, process
 from rank_bm25 import BM25Okapi
 from sentence_transformers import SentenceTransformer, CrossEncoder
 import faiss
@@ -40,35 +40,180 @@ import torch
 from openai import OpenAI
 from tenacity import retry, stop_after_attempt, wait_fixed
 
-# ---------- 應用程式設定 (集中管理) ----------
-class AppConfig:
-    # 檔案路徑
-    CSV_PATH = os.getenv("CSV_PATH", "cleaned_combined.csv")
-    SENTENCES_PKL = os.getenv("SENTENCES_PKL", "/tmp/drug_sentences.pkl")
-    META_PKL = os.getenv("META_PKL", "/tmp/drug_meta.pkl")
-    FAISS_INDEX = os.getenv("FAISS_INDEX", "/tmp/drug_sentences.index")
-    BM25_PKL = os.getenv("BM25_PKL", "/tmp/bm25.pkl")
-    
-    # LINE Bot 設定
-    CHANNEL_ACCESS_TOKEN = os.getenv("CHANNEL_ACCESS_TOKEN")
-    CHANNEL_SECRET = os.getenv("CHANNEL_SECRET")
-
-    # LLM & RAG 模型設定
-    LITELLM_API_KEY = os.getenv("LITELLM_API_KEY")
-    LITELLM_BASE_URL = os.getenv("LITELLM_BASE_URL")
-    LM_MODEL = os.getenv("LM_MODEL", "gemma-7b-it") # 預設模型
-    EMBEDDING_MODEL_ID = "DMetaSoul/Dmeta-embedding-zh"
-    RERANKER_MODEL_ID = "BAAI/bge-reranker-v2-m3"
-
-    # RAG 搜尋參數
-    FUZZY_MATCH_THRESHOLD = 85
-    TOP_K_FAISS = 20
-    TOP_K_BM25 = 20
-    TOP_K_RERANK = 10
-    MAX_CONTEXT_CHARS = 4000
-    
-    # 應用程式狀態
-    STATE = type('state', (), {})()
+# ---- 匯入 (從 kaggle_rag.py 整合) ----
+import ast
+from typing import List, Dict, Any
+
+# ==== CONFIG (從 kaggle_rag.py 整合並調整為環境變數) ====
+CSV_PATH = os.getenv("CSV_PATH", "cleaned_combined.csv")
+FAISS_INDEX = os.getenv("FAISS_INDEX", "/tmp/drug_sentences.index")
+SENTENCES_PKL = os.getenv("SENTENCES_PKL", "/tmp/drug_sentences.pkl")
+META_PKL = os.getenv("META_PKL", "/tmp/drug_meta.pkl")
+BM25_PKL = os.getenv("BM25_PKL", "/tmp/bm25.pkl")
+
+TOP_K_SENTENCES = int(os.getenv("TOP_K_SENTENCES", 30))
+PRE_RERANK_K = int(os.getenv("PRE_RERANK_K", 30))
+MAX_RERANK_CANDIDATES = int(os.getenv("MAX_RERANK_CANDIDATES", 50))
+
+EMBEDDING_MODEL = os.getenv("EMBEDDING_MODEL", "DMetaSoul/Dmeta-embedding-zh")
+RERANKER_MODEL = os.getenv("RERANKER_MODEL", "BAAI/bge-reranker-v2-m3")
+
+_SENT_SPLIT_RE = re.compile(r"[。！？\n]")
+DRUG_STOPWORDS = {"藥", "劑", "錠", "膠囊", "糖漿", "乳膏", "貼片"}
+
+SECTION_WEIGHTS = {
+    "用法及用量": 1.0,
+    "病人使用須知": 1.0,
+    "儲存條件": 1.0,
+    "警語及注意事項": 1.0,
+    "禁忌": 1.0,
+    "副作用": 1.0,
+    "藥物交互作用": 1.0,
+    "其他": 1.0,
+}
+
+RERANK_THRESHOLD = float(os.getenv("RERANK_THRESHOLD", 0.5))
+
+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",
+}
+
+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", 12000)),
+    "max_tokens": int(os.getenv("MAX_TOKENS", 2048)),
+    "temperature": float(os.getenv("TEMPERATURE", 0.0)),
+    "top_p": float(os.getenv("TOP_P", 0.95)),
+    "stop_tokens": ["==="],
+}
+
+# --- 修改: 意圖分類類別已更新為新的精細化分類 (從 kaggle_rag.py)
+INTENT_CATEGORIES = [
+    "操作 (Administration)",
+    "保存/攜帶 (Storage & Handling)",
+    "副作用/異常 (Side Effects / Issues)",
+    "劑型相關 (Dosage Form Concerns)",
+    "時間/併用 (Timing & Interaction)",
+    "劑量調整 (Dosage Adjustment)", 
+    "禁忌症/適應症 (Contraindications/Indications)"
+]
+
+DISCLAIMER = "本資訊僅供參考，若您對藥物使用有任何疑問，請務必諮詢您的醫師或藥師。"
+
+# ---- 工具函式 (從 kaggle_rag.py 整合) ----
+def ensure_csv_path(path: str) -> str:
+    if os.path.exists(path):
+        return path
+    log.warning(f"找不到輸入檔案：{path}，嘗試自動搜尋...")
+    # 簡化搜尋邏輯，假設在工作目錄
+    return path  # 如需擴展，可添加 os.walk
+
+def pick_text_column(df: pd.DataFrame) -> str:
+    candidates = ["content", "text", "sentence", "chunk", "cleaned_text"]
+    for c in candidates:
+        if c in df.columns:
+            return c
+    raise RuntimeError(f"CSV 缺少文字欄位，至少需包含其中之一：{candidates}")
+
+def split_sentences(text: str) -> list:
+    if not isinstance(text, str):
+        return []
+    paragraphs = text.split("\n")
+    sents = []
+    for p in paragraphs:
+        if re.match(r"^\d+\.", p):
+            sents.append(p.strip())
+        else:
+            para_sents = [s.strip() for s in _SENT_SPLIT_RE.split(p) if s.strip()]
+            combined = ""
+            for s in para_sents:
+                combined += s + "。"
+                if len(combined) >= 50:
+                    sents.append(combined.strip())
+                    combined = ""
+            if combined:
+                sents.append(combined.strip())
+    return [s for s in sents if len(s) > 6]
+
+def load_embedding_model():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    log.info(f"載入 embedding 模型：{EMBEDDING_MODEL} 至 {device}...")
+    try:
+        model = SentenceTransformer(EMBEDDING_MODEL, device=device)
+    except Exception as e:
+        log.warning(f"載入模型至 {device} 失敗: {e}。嘗試切換至 CPU。")
+        device = "cpu"
+        model = SentenceTransformer(EMBEDDING_MODEL, device=device)
+    return model
+
+def load_reranker_model():
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    log.info(f"載入 reranker 模型：{RERANKER_MODEL} 至 {device}...")
+    try:
+        model = CrossEncoder(RERANKER_MODEL, device=device)
+    except Exception as e:
+        log.warning(f"載入模型至 {device} 失敗: {e}。嘗試切換至 CPU。")
+        device = "cpu"
+        model = CrossEncoder(RERANKER_MODEL, device=device)
+    return model
+
+def build_sentence_index(csv_path, faiss_path, sentences_pkl, meta_pkl, embedding_model):
+    log.info("建立 chunk 向量索引...")
+    df = pd.read_csv(csv_path, dtype=str)
+    text_col = pick_text_column(df)
+    texts = df[text_col].fillna("").astype(str).tolist()
+
+    metas = []
+    for i, row in df.iterrows():
+        metas.append({
+            "row_idx": int(i),
+            "chunk_id": row.get("chunk_id"),
+            "source_file": row.get("source_file"),
+            "section": row.get("section"),
+            "drug_id": row.get("drug_id"),
+            "drug_name_norm": str(row.get("drug_name_norm", "")).lower(),
+        })
+
+    unique_texts_meta = {}
+    for t, m in zip(texts, metas):
+        t = t.strip()
+        if t and len(t) >= 6:
+            key = t[:100]
+            if key not in unique_texts_meta:
+                unique_texts_meta[key] = (t, m)
+    filtered_texts = [v[0] for v in unique_texts_meta.values()]
+    filtered_meta = [v[1] for v in unique_texts_meta.values()]
+
+    if not filtered_texts:
+        raise RuntimeError("沒有可用 chunk 建立索引")
+
+    emb = embedding_model.encode(filtered_texts, show_progress_bar=True, convert_to_numpy=True).astype("float32")
+    faiss.normalize_L2(emb)
+
+    index = faiss.IndexFlatIP(emb.shape[1])
+    index.add(emb)
+    faiss.write_index(index, faiss_path)
+
+    with open(sentences_pkl, "wb") as f:
+        pickle.dump(filtered_texts, f)
+    with open(meta_pkl, "wb") as f:
+        pickle.dump(filtered_meta, f)
+
+    return index, filtered_texts, filtered_meta
 
 # ---------- 日誌設定 ----------
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
@@ -80,85 +225,77 @@ app = FastAPI(
     description="提供基於RAG的台灣藥品資訊查詢服務",
     version="2.0.0"
 )
+
+# ---------- 應用程式設定 (集中管理) ----------
+class AppConfig:
+    # LINE Bot 設定
+    CHANNEL_ACCESS_TOKEN = os.getenv("CHANNEL_ACCESS_TOKEN")
+    CHANNEL_SECRET = os.getenv("CHANNEL_SECRET")
+
+    # 其他設定已在全局
+
 CONFIG = AppConfig()
 
-# ---------- 核心 RAG 邏輯 (封裝成類別) ----------
+# ---------- 核心 RAG 邏輯 (封裝成類別，整合 kaggle_rag.py) ----------
 class RagPipeline:
     def __init__(self, config):
         self.config = config
-        self.state = config.STATE
-        self.llm_client = OpenAI(api_key=config.LITELLM_API_KEY, base_url=config.LITELLM_BASE_URL)
+        self.state = type('state', (), {})()
+        self.llm_client = OpenAI(api_key=LLM_API_CONFIG["api_key"], base_url=LLM_API_CONFIG["base_url"])
+        self.embedding_model = load_embedding_model()
+        self.reranker = load_reranker_model()
+        self.csv_path = ensure_csv_path(CSV_PATH)
+        self.df_csv = pd.read_csv(self.csv_path, dtype=str)
 
     def _load_data(self):
         """在啟動時載入所有必要的模型與資料"""
         log.info("開始載入資料與模型...")
         # 載入 CSV
-        if os.path.exists(self.config.CSV_PATH):
-            self.state.df_csv = pd.read_csv(self.config.CSV_PATH, dtype=str).fillna('')
-            self.state.df_csv['drug_name_norm_normalized'] = self.state.df_csv['drug_name_norm'].str.lower().str.replace(r'[^\w\s]', '', regex=True).str.strip()
-            log.info(f"成功載入 CSV: {self.config.CSV_PATH} (rows={len(self.state.df_csv)})")
+        if os.path.exists(self.csv_path):
+            self.df_csv = pd.read_csv(self.csv_path, dtype=str).fillna('')
+            self.df_csv['drug_name_norm_normalized'] = self.df_csv['drug_name_norm'].str.lower().str.replace(r'[^\w\s]', '', regex=True).str.strip()
+            log.info(f"成功載入 CSV: {self.csv_path} (rows={len(self.df_csv)})")
         else:
-            log.error(f"錯誤: 找不到 CSV 檔案於 {self.config.CSV_PATH}")
-            self.state.df_csv = None
+            log.error(f"錯誤: 找不到 CSV 檔案於 {self.csv_path}")
+            self.df_csv = None
 
         # 載入語料庫與模型
-        self.state.sentences, self.state.meta = self._ensure_pkl_exists(self.config.SENTENCES_PKL, self.config.META_PKL)
-        self.state.emb_model = SentenceTransformer(self.config.EMBEDDING_MODEL_ID)
-        self.state.reranker_model = CrossEncoder(self.config.RERANKER_MODEL_ID)
-        self.state.faiss_index = self._ensure_faiss_index()
+        self.state.index, self.state.sentences, self.state.meta = self._load_or_build_sentence_index()
         self.state.bm25 = self._ensure_bm25_index()
         log.info("所有模型與資料載入完成。")
 
-    def _ensure_pkl_exists(self, sentences_path, meta_path):
-        if os.path.exists(sentences_path) and os.path.exists(meta_path):
-            with open(sentences_path, "rb") as f_sent, open(meta_path, "rb") as f_meta:
-                return pickle.load(f_sent), pickle.load(f_meta)
-        log.warning(f"PKL 檔案不存在，將從 CSV 重新建立。")
-        if self.state.df_csv is None: return [], []
-        
-        sentences = self.state.df_csv["content"].tolist()
-        meta = self.state.df_csv[["drug_name_zh", "section"]].to_dict(orient="records")
-        
-        with open(sentences_path, "wb") as f_sent, open(meta_path, "wb") as f_meta:
-            pickle.dump(sentences, f_sent)
-            pickle.dump(meta, f_meta)
-        log.info(f"已建立並儲存 PKL 檔案於 {sentences_path} 與 {meta_path}")
-        return sentences, meta
-
-    def _ensure_faiss_index(self):
-        if os.path.exists(self.config.FAISS_INDEX):
-            log.info(f"正在從 {self.config.FAISS_INDEX} 載入 FAISS 索引...")
-            return faiss.read_index(self.config.FAISS_INDEX)
-        
-        log.warning("FAISS 索引不存在，正在建立新的索引...")
-        if not self.state.sentences: return None
-        embeddings = self.state.emb_model.encode(self.state.sentences, convert_to_tensor=True, show_progress_bar=True)
-        index = faiss.IndexFlatIP(embeddings.shape[1])
-        index.add(embeddings.cpu().numpy())
-        faiss.write_index(index, self.config.FAISS_INDEX)
-        log.info(f"FAISS 索引已建立並儲存至 {self.config.FAISS_INDEX}")
-        return index
+    def _load_or_build_sentence_index(self):
+        if os.path.exists(FAISS_INDEX) and os.path.exists(SENTENCES_PKL) and os.path.exists(META_PKL):
+            log.info("載入已存在的索引...")
+            index = faiss.read_index(FAISS_INDEX)
+            with open(SENTENCES_PKL, "rb") as f:
+                sentences = pickle.load(f)
+            with open(META_PKL, "rb") as f:
+                meta = pickle.load(f)
+            return index, sentences, meta
+
+        return build_sentence_index(self.csv_path, FAISS_INDEX, SENTENCES_PKL, META_PKL, self.embedding_model)
 
     def _ensure_bm25_index(self):
-        if os.path.exists(self.config.BM25_PKL):
-            with open(self.config.BM25_PKL, "rb") as f:
+        if os.path.exists(BM25_PKL):
+            with open(BM25_PKL, "rb") as f:
                 return pickle.load(f)
 
         log.warning("BM25 索引不存在，正在建立新的索引...")
         if not self.state.sentences: return None
-        tokenized_corpus = [list(jieba.cut(s)) for s in self.state.sentences]
+        tokenized_corpus = [jieba.lcut(s) for s in self.state.sentences]
         bm25 = BM25Okapi(tokenized_corpus)
-        with open(self.config.BM25_PKL, "wb") as f:
+        with open(BM25_PKL, "wb") as f:
             pickle.dump(bm25, f)
-        log.info(f"BM25 索引已建立並儲存至 {self.config.BM25_PKL}")
+        log.info(f"BM25 索引已建立並儲存至 {BM25_PKL}")
         return bm25
 
     @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-    def _llm_call(self, messages, temperature=0.2, max_tokens=1024):
+    def _llm_call(self, messages, temperature=LLM_MODEL_CONFIG["temperature"], max_tokens=LLM_MODEL_CONFIG["max_tokens"]):
         """帶有重試機制的 LLM API 呼叫"""
         try:
             response = self.llm_client.chat.completions.create(
-                model=self.config.LM_MODEL,
+                model=LLM_API_CONFIG["model"],
                 messages=messages,
                 temperature=temperature,
                 max_tokens=max_tokens,
@@ -168,165 +305,180 @@ class RagPipeline:
             log.error(f"LLM API 呼叫失敗: {e}")
             raise
 
-    async def answer_question(self, user_question: str) -> str:
-        """處理使用者問題的完整流程"""
-        # 1. 意圖偵測
-        intent = self._detect_intent(user_question)
-        if intent != "drug_query":
-            return "本服務僅提供藥品資訊查詢，無法提供醫療建議或回答一般性問題。若有身體不適，請立即就醫。"
-
-        # 2. 藥品名稱模糊比對
-        drug_name = self._find_drug_name(user_question)
-        if not drug_name:
-            return "抱歉，我無法從您的問題中識別出明確的藥品名稱。請試著提供更完整的藥品名稱，例如：'普拿疼'。"
-
-        # 3. 混合檢索 (Hybrid Search)
-        retrieved_indices = self._hybrid_search(user_question)
-        if not retrieved_indices:
-            return f"抱歉，在資料庫中找不到與 '{drug_name}' 相關的資訊。請確認藥品名稱是否正確。"
-
-        # 4. 重排序 (Reranking)
-        reranked_indices = self._rerank(user_question, retrieved_indices)
-        
-        # 5. 建立上下文 (Context)
-        context = self._build_context(reranked_indices)
-
-        # 6. 生成答案 (Generation)
-        prompt = self._make_generation_prompt(user_question, context)
-        generated_answer = self._llm_call([{"role": "user", "content": prompt}])
-
-        # 7. 答案驗證 (Validation)
-        is_valid, reason = self._validate_answer(user_question, generated_answer, context)
-        log.info(f"答案驗證結果: {'有效' if is_valid else '無效'}, 原因: {reason}")
-        
-        if not is_valid:
-            return "系統生成的答案可能不完全準確，為安全起見，不提供此回覆。請嘗試用其他方式提問，或諮詢專業藥師。"
-        
-        # 8. 格式化最終回覆
-        final_answer = self._format_final_answer(generated_answer, drug_name)
-        return final_answer
-
-    def _detect_intent(self, query: str) -> str:
-        prompt = f"""
-        請判斷以下使用者問題的意圖。意圖只能是以下三者之一：'drug_query', 'medical_advice', 'general_greeting'。
-        - 如果問題在詢問某個具體藥品的資訊（如副作用、用法、成分），意圖是 'drug_query'。
-        - 如果問題在尋求診斷、治療建議或詢問症狀，意圖是 'medical_advice'。
-        - 如果只是打招呼或閒聊，意圖是 'general_greeting'。
-
-        使用者問題: "{query}"
-        意圖:
-        """
-        response = self._llm_call([{"role": "user", "content": prompt}], temperature=0.0, max_tokens=20)
-        # 簡單解析回應
-        if "drug_query" in response.lower(): return "drug_query"
-        if "medical_advice" in response.lower(): return "medical_advice"
-        return "general_greeting"
-
-    def _find_drug_name(self, query: str) -> Optional[str]:
-        unique_drug_names = self.state.df_csv['drug_name_norm'].unique()
-        normalized_query = query.lower().replace(" ", "")
-        
-        best_match = process.extractOne(normalized_query, unique_drug_names, score_cutoff=self.config.FUZZY_MATCH_THRESHOLD)
-        if best_match:
-            log.info(f"模糊比對成功: '{query}' -> '{best_match[0]}' (分數: {best_match[1]})")
-            return best_match[0]
-        log.warning(f"模糊比對失敗: '{query}' 的分數低於 {self.config.FUZZY_MATCH_THRESHOLD}")
-        return None
-
-    def _hybrid_search(self, query: str) -> List[int]:
-        # Vector Search (FAISS)
-        query_embedding = self.state.emb_model.encode([query], convert_to_tensor=True).cpu().numpy()
-        _, faiss_indices = self.state.faiss_index.search(query_embedding, self.config.TOP_K_FAISS)
-        faiss_indices = faiss_indices[0].tolist()
-
-        # Keyword Search (BM25)
-        tokenized_query = list(jieba.cut(query))
-        bm25_scores = self.state.bm25.get_scores(tokenized_query)
-        bm25_indices = np.argsort(bm25_scores)[::-1][:self.config.TOP_K_BM25].tolist()
-
-        # 合併並去重
-        combined_indices = list(dict.fromkeys(faiss_indices + bm25_indices))
-        log.info(f"混合檢索找到 {len(combined_indices)} 個不重複的候選文件。")
-        return combined_indices
-
-    def _rerank(self, query: str, indices: List[int]) -> List[int]:
-        pairs = [(query, self.state.sentences[i]) for i in indices]
-        scores = self.state.reranker_model.predict(pairs, show_progress_bar=False)
-        
-        scored_indices = sorted(zip(indices, scores), key=lambda x: x[1], reverse=True)
-        reranked_indices = [idx for idx, score in scored_indices[:self.config.TOP_K_RERANK]]
-        return reranked_indices
-
-    def _build_context(self, indices: List[int]) -> str:
-        context_parts = []
-        char_count = 0
-        for i in indices:
-            sentence_text = self.state.sentences[i]
-            if char_count + len(sentence_text) > self.config.MAX_CONTEXT_CHARS:
-                break
-            context_parts.append(f"來源[{i+1}]: {sentence_text}")
-            char_count += len(sentence_text)
-        return "\n\n".join(context_parts)
-
-    def _make_generation_prompt(self, query: str, context: str) -> str:
-        return f"""
-        你是一位專業且謹慎��台灣藥師。請根據以下提供的「參考資料」，用繁體中文簡潔且有條理地回答使用者的問題。
-
-        **你的任務**：
-        1.  **完全基於「參考資料」**：你的回答必須完全依據下方提供的資料，禁止使用任何外部知識或進行推測。
-        2.  **格式化輸出**：使用 Markdown 的標題 (##) 和點列 (*) 來組織答案，使其清晰易讀。
-        3.  **引用來源**：如果資料中有多個來源，你不需要在答案中標註來源編號。
-        4.  **無法回答時**：如果參考資料無法回答問題，請直接回覆「根據提供的資料，無法回答此問題。」
-
-        **參考資料**：
-        ---
-        {context}
-        ---
-
-        **使用者問題**：
-        "{query}"
-
-        **你的回答**：
-        """
-
-    def _validate_answer(self, query: str, answer: str, context: str) -> Tuple[bool, str]:
-        prompt = f"""
-        請根據以下提供的「原始資料」，評估「生成答案」是否準確地回答了「使用者問題」。
-        
-        **評估標準**：
-        1.  **事實一致性**：答案中的所有資訊是否都可以在原始資料中找到對應依據？
-        2.  **無遺漏**：答案是否遺漏了與問題相關的關鍵警告或重要資訊？
-        3.  **無捏造**：答案是否包含了原始資料中沒有的資訊？
-
-        **原始資料**：
-        ---
-        {context}
-        ---
-        
-        **使用者問題**：
-        "{query}"
-
-        **生成答案**：
-        "{answer}"
-
-        **評估結果**：
-        請以 JSON 格式回覆，包含 'is_valid' (布林值) 和 'reason' (字串) 兩個鍵。
-        範例: {{"is_valid": true, "reason": "答案忠於原文，且總結了關鍵資訊。"}}
-        範例: {{"is_valid": false, "reason": "答案中提到的'每日三次'在原文中找不到依據。"}}
-        """
-        response = self._llm_call([{"role": "user", "content": prompt}], temperature=0.0, max_tokens=256)
+    async def answer_question(self, q_orig: str) -> str:
+        """處理使用者問題的完整流程 (整合 kaggle_rag.py main 邏輯)"""
         try:
-            result = json.loads(response)
-            return result.get("is_valid", False), result.get("reason", "無效的JSON格式")
-        except json.JSONDecodeError:
-            log.error(f"答案驗證的JSON解析失敗: {response}")
-            return False, "無法解析驗證模型的JSON回覆"
+            drug_ids = self._find_drug_ids_from_name(q_orig, self.df_csv)
+            if not drug_ids:
+                return f"未在資料庫中找到該藥品，請檢查名稱或諮詢醫師/藥師。{DISCLAIMER}"
+
+            attempt = 0
+            max_attempts = 3
+            answer_is_good = False
+            answer, context = "", ""
+
+            while attempt < max_attempts and not answer_is_good:
+                current_prerank_k = PRE_RERANK_K + attempt * 20
+                current_rerank_threshold = RERANK_THRESHOLD if attempt == 0 else max(RERANK_THRESHOLD - 0.1, 0.3)
+                sub_queries = self._decompose_query(q_orig)
+                all_reranked_results = []
+                processed_chunk_ids = set()
+
+                relevant_indices = [i for i, m in enumerate(self.state.meta) if m.get("drug_id") in drug_ids]
+                if not relevant_indices:
+                    return f"找不到 drug_id {drug_ids} 對應的任何 chunks。{DISCLAIMER}"
+
+                relevant_sentences = [self.state.sentences[i] for i in relevant_indices]
+                relevant_meta = [self.state.meta[i] for i in relevant_indices]
+                relevant_bm25 = BM25Okapi([jieba.lcut(s) for s in relevant_sentences])  # 優化：僅對相關drug計算BM25
+
+                for sub_q in sub_queries:
+                    intents = self._detect_intent(sub_q)
+                    expanded_q = self._expand_query_with_llm(sub_q, intents)
+                    weights = self._adjust_section_weights(intents)
+
+                    # 語意搜尋 (FAISS)
+                    sim_indices, sim_scores = self._semantic_search(self.state.index, expanded_q, current_prerank_k * 5, self.embedding_model)
+
+                    tokenized_query = list(jieba.cut(expanded_q))
+
+                    # BM25
+                    bm25_scores_relevant = relevant_bm25.get_scores(tokenized_query) if len(tokenized_query) else np.zeros(len(relevant_sentences))
+                    bm25_scores_all = np.zeros(len(self.state.sentences))
+                    for rel_idx, global_idx in enumerate(relevant_indices):
+                        bm25_scores_all[global_idx] = bm25_scores_relevant[rel_idx]
+
+                    # 融合
+                    candidate_dict = {}
+                    if sim_indices:
+                        for i, sem_score in zip(sim_indices, sim_scores):
+                            if i in set(relevant_indices):
+                                if i not in candidate_dict:
+                                    candidate_dict[i] = {"sem": sem_score, "bm": 0.0}
+
+                    bm25_top_indices = np.argsort(bm25_scores_all)[::-1][:current_prerank_k * 5]
+                    for i in bm25_top_indices:
+                        if i in set(relevant_indices):
+                            bm_score = bm25_scores_all[i]
+                            if i in candidate_dict:
+                                candidate_dict[i]["bm"] = bm_score
+                            else:
+                                candidate_dict[i] = {"sem": 0.0, "bm": bm_score}
+
+                    candidates = []
+                    for i, scores in candidate_dict.items():
+                        section_name = self.state.meta[i].get("section", "其他")
+                        section_weight = weights.get(section_name, 1.0)
+                        fused_score = (scores["sem"] * 0.5 + scores["bm"] * 0.4) * section_weight
+                        candidates.append((i, fused_score, scores["sem"], scores["bm"]))
+
+                    candidates.sort(key=lambda x: x[1], reverse=True)
+
+                    # Reranker
+                    sub_reranked = self._rerank_with_crossencoder(q_orig, candidates, self.state.sentences, self.reranker, TOP_K_SENTENCES, self.state.meta, current_rerank_threshold)
+
+                    for r in sub_reranked:
+                        if r.get('chunk_id') and r['chunk_id'] not in processed_chunk_ids:
+                            all_reranked_results.append(r)
+                            processed_chunk_ids.add(r['chunk_id'])
+                        elif not r.get('chunk_id') and r['idx'] not in {res['idx'] for res in all_reranked_results}:
+                            all_reranked_results.append(r)
+
+                all_reranked_results.sort(key=lambda x: x['rerank_score'], reverse=True)
+
+                context = self._build_context(all_reranked_results, LLM_MODEL_CONFIG["max_context_chars"])
+
+                prompt = self._make_prompt(q_orig, context)
+
+                answer = self._llm_call([{"role": "user", "content": prompt}])
+
+                validation = self._validate_answer(q_orig, answer, context)
+                if validation["score"] >= 75:
+                    answer_is_good = True
+                else:
+                    attempt += 1
+
+            final_answer_formatted = self._format_final_answer(answer, DISCLAIMER)
+            return final_answer_formatted
+        except Exception as e:
+            log.error(f"處理查詢 {q_orig} 時發生錯誤: {e}")
+            return f"處理時發生錯誤，請檢查日志。{DISCLAIMER}"
+
+    # ---- 以下為從 kaggle_rag.py 整合的輔助函式 ----
+    def _find_drug_ids_from_name(self, query: str, df: pd.DataFrame) -> List[str]:
+        candidates = extract_drug_candidates_from_query(query)
+        expanded = expand_aliases(candidates)
+        drug_ids = set()
+        for alias in expanded:
+            matched_rows = df[df['drug_name_norm'].str.lower().str.contains(alias.lower(), na=False)]
+            drug_ids.update(matched_rows['drug_id'].unique())
+        return list(drug_ids)
+
+    def _decompose_query(self, query: str) -> List[str]:
+        prompt = f"將以下問題分解成1-3個子問題：{query}"
+        response = self._llm_call([{"role": "user", "content": prompt}])
+        return ast.literal_eval(response) if response else [query]  # 假設回應為列表字符串
+
+    def _detect_intent(self, query: str) -> List[str]:
+        prompt = f"偵測以下問題的意圖類別，從 {INTENT_CATEGORIES} 中選擇：{query}"
+        response = self._llm_call([{"role": "user", "content": prompt}])
+        return ast.literal_eval(response) if response else []
+
+    def _expand_query_with_llm(self, query: str, intents: List[str]) -> str:
+        prompt = f"基於意圖 {intents} 擴展查詢：{query}"
+        return self._llm_call([{"role": "user", "content": prompt}])
+
+    def _adjust_section_weights(self, intents: List[str]) -> Dict[str, float]:
+        weights = SECTION_WEIGHTS.copy()
+        # 根據 intents 調整權重邏輯 (從 kaggle_rag.py 簡化)
+        return weights
+
+    def _semantic_search(self, index, query: str, top_k: int, embedding_model) -> Tuple[List[int], List[float]]:
+        q_emb = embedding_model.encode([query], convert_to_numpy=True).astype("float32")
+        faiss.normalize_L2(q_emb)
+        distances, indices = index.search(q_emb, top_k)
+        return indices[0].tolist(), distances[0].tolist()
+
+    def _rerank_with_crossencoder(self, query: str, candidates: List[Tuple], sentences: List[str], reranker, top_k: int, meta: List[Dict], threshold: float) -> List[Dict]:
+        pairs = [(query, sentences[i]) for i, _, _, _ in candidates]
+        scores = reranker.predict(pairs)
+        reranked = []
+        for (i, _, sem, bm), score in zip(candidates, scores):
+            if score >= threshold:
+                reranked.append({
+                    "idx": i,
+                    "rerank_score": score,
+                    "sem_score": sem,
+                    "bm_score": bm,
+                    "meta": meta[i],
+                    "text": sentences[i]
+                })
+        reranked.sort(key=lambda x: x['rerank_score'], reverse=True)
+        return reranked[:top_k]
+
+    def _build_context(self, reranked_results: List[Dict], max_chars: int) -> str:
+        context = ""
+        for res in reranked_results:
+            text = res['text']
+            if len(context) + len(text) > max_chars:
+                break
+            context += text + "\n\n"
+        return context.strip()
 
-    def _format_final_answer(self, answer: str, drug_name: str) -> str:
-        disclaimer = f"--- \n*免責聲明：本資訊僅供參考，無法取代專業醫療建議。用藥前請務必諮詢藥師或醫師。資料來源為藥品仿單。*"
-        header = f"## 💊 關於「{drug_name}」\n\n"
-        return header + answer + "\n\n" + disclaimer
+    def _make_prompt(self, query: str, context: str) -> str:
+        return f"基於以下上下文回答問題：{context}\n問題：{query}"
 
+    def _validate_answer(self, query: str, answer: str, context: str) -> Dict:
+        prompt = f"驗證答案是否準確：問題 {query}，答案 {answer}，上下文 {context}"
+        response = self._llm_call([{"role": "user", "content": prompt}])
+        # 假設回應為 JSON 字符串
+        try:
+            return json.loads(response)
+        except:
+            return {"score": 0, "reason": "無法解析"}
+
+    def _format_final_answer(self, answer: str, disclaimer: str) -> str:
+        return f"{answer}\n\n{disclaimer}"
 
 # ---------- FastAPI 事件與路由 ----------
 @app.on_event("startup")
@@ -396,7 +548,38 @@ def line_reply(reply_token: str, text: str):
     except Exception as e:
         log.error(f"LINE API 回覆失敗: {e}")
 
+# ---- 從 kaggle_rag.py 整合的額外工具函式 ----
+def extract_drug_candidates_from_query(query: str) -> list:
+    query = re.sub(r"[A-Za-z]+", lambda m: m.group(0).lower(), query)
+    candidates = set()
+    parts = query.split(":", 1)
+    drug_part = parts[0]
+    for m in re.finditer(r"[a-zA-Z]{3,}", drug_part):
+        candidates.add(m.group(0))
+    for token in re.split(r"[\s,／()（）]+", drug_part):
+        clean_token = re.sub(r'[a-zA-Z0-9\s]+', '', token).strip()
+        if clean_token and clean_token.lower() not in DRUG_STOPWORDS:
+            candidates.add(clean_token)
+    if drug_part.strip():
+        candidates.add(drug_part.strip())
+    for query_name, dataset_name in DRUG_NAME_MAPPING.items():
+        if query_name in query.lower():
+            candidates.add(dataset_name)
+    return [c for c in candidates if len(c) > 1]
+
+def expand_aliases(candidates: list) -> list:
+    out = set()
+    for c in candidates:
+        s = c.strip()
+        if not s:
+            continue
+        out.add(s)
+        out.add(re.sub(r"[^0-9A-Za-z\u4e00-\u9fff]+", "", s))
+        out.add(s.lower())
+        out.add(s.upper())
+    return [x for x in out if x]
+
 # ---------- 執行 (用於本地測試) ----------
 if __name__ == "__main__":
-    port = int(os.getenv("PORT", 8080))
+    port = int(os.getenv("PORT", 7860))
     uvicorn.run(app, host="0.0.0.0", port=port)

requirements.txt

@@ -4,9 +4,6 @@ uvicorn[standard]
 python-multipart
 requests # 用於 LINE reply
 
-# LINE Bot SDK (可選，此處直接使用 requests)
-# line-bot-sdk==3.11.0 
-
 # NLP / RAG
 numpy
 pandas
@@ -24,5 +21,5 @@ torchaudio
 
 # LLM 連接與穩定性
 openai
-litellm  # 修正 ModuleNotFoundError
-tenacity # 新增，用於 API 重試
+litellm
+tenacity # 用於 API 重試