hi

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.index filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,36 @@
+FROM python:3.11-slim
+
+# ---- System deps ----
+RUN apt-get update && apt-get upgrade -y && apt-get install -y --no-install-recommends \
+    build-essential \
+    git \
+    curl \
+    libgomp1 \
+ && rm -rf /var/lib/apt/lists/*
+
+# ---- Workdir ----
+WORKDIR /app
+
+# ---- Copy requirement & install ----
+COPY requirements.txt /app/requirements.txt
+RUN pip install --no-cache-dir -U pip \
+ && pip install --no-cache-dir -r /app/requirements.txt
+
+# ---- Runtime cache to /tmp (writeable) ----
+ENV HF_HOME=/tmp/hf \
+    SENTENCE_TRANSFORMERS_HOME=/tmp/sentence_transformers \
+    XDG_CACHE_HOME=/tmp/.cache
+
+# ---- Copy app ----
+COPY . /app
+
+# ---- Healthcheck ----
+HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# ---- Port & CMD ----
+EXPOSE 7860
+ENV PORT=7860 \
+    PYTHONUNBUFFERED=1
+
+CMD ["sh", "-c", "uvicorn app:app --host 0.0.0.0 --port ${PORT:-7860} --log-level info"]

app.py

@@ -0,0 +1,677 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+DrugQA (ZH) — FastAPI LINE webhook only (/webhook).
+
+僅使用這些 HF 環境變數：
+- CHANNEL_ACCESS_TOKEN
+- CHANNEL_SECRET
+- LITELLM_API_KEY
+- LITELLM_BASE_URL
+- LM_MODEL
+
+優先載入專案根目錄的檔案（drug_sentences.pkl / drug_sentences.index / bm25.pkl），
+若不存在才退回 /tmp。重建索引時只嘗試寫到 /tmp，避免唯讀權限問題。
+所有快取統一 /tmp。
+"""
+
+# ---------- 先設定快取目錄（import transformers 前） ----------
+import os, pathlib, errno
+os.environ.setdefault("HF_HOME", "/tmp/hf")
+os.environ.setdefault("SENTENCE_TRANSFORMERS_HOME", "/tmp/sentence_transformers")
+os.environ.setdefault("XDG_CACHE_HOME", "/tmp/.cache")
+os.environ.pop("TRANSFORMERS_CACHE", None)  # 已棄用
+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)
+
+# ---------- Imports ----------
+import re, hmac, base64, hashlib, pickle, logging, time, json
+from typing import List, Dict, Any, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+try:
+    import torch  # 僅用於檢查裝置
+except Exception:
+    torch = None
+
+try:
+    import faiss  # type: ignore
+except Exception as e:
+    raise RuntimeError(f"faiss not available: {e}")
+
+try:
+    from sentence_transformers import SentenceTransformer, CrossEncoder  # type: ignore
+except Exception:
+    SentenceTransformer = None
+
+try:
+    from rank_bm25 import BM25Okapi  # type: ignore
+except Exception:
+    BM25Okapi = None
+
+try:
+    import jieba  # type: ignore
+except Exception:
+    jieba = None
+
+try:
+    from fuzzywuzzy import fuzz  # type: ignore
+except Exception:
+    fuzz = None
+
+try:
+    import requests  # type: ignore
+except Exception:
+    requests = None
+
+from fastapi import FastAPI, HTTPException, Header, Request
+
+# ---------- Logging ----------
+LOG_LEVEL = (os.getenv("LOG_LEVEL") or "INFO").upper()
+logging.basicConfig(level=LOG_LEVEL, format="%(asctime)s - %(levelname)s - %(message)s")
+log = logging.getLogger("app")
+
+# ---------- 只讀取你指定的 HF 環境變數 ----------
+CHANNEL_ACCESS_TOKEN = os.getenv("CHANNEL_ACCESS_TOKEN")
+CHANNEL_SECRET       = os.getenv("CHANNEL_SECRET")
+LITELLM_API_KEY      = os.getenv("LITELLM_API_KEY")
+LITELLM_BASE_URL     = os.getenv("LITELLM_BASE_URL")
+LM_MODEL             = os.getenv("LM_MODEL")
+
+# ---------- 檢索設定（固定常數） ----------
+TOP_K_SENTENCES   = 10
+BM25_WEIGHT       = 0.6
+SEM_WEIGHT        = 0.4
+EMBEDDING_MODEL_ID= "DMetaSoul/Dmeta-embedding-zh"
+RERANKER_MODEL_ID = "BAAI/bge-reranker-v2-m3"
+USE_CPU           = True  # HF 預設 CPU
+RERANK_THRESHOLD  = 0.5
+MAX_CONTEXT_CHARS = 8000
+DISCLAIMER = "*免責聲明：本資訊僅供參考，若有疑問請諮詢醫師或藥師。*"
+
+# 藥名映射與停用詞
+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",
+}
+DRUG_STOPWORDS = {"藥", "劑", "錠", "膠囊", "糖漿", "乳膏", "貼片"}
+
+# 意圖分類
+INTENT_CATEGORIES = [
+    "操作 (Administration)",
+    "保存/攜帶 (Storage & Handling)",
+    "副作用/異常 (Side Effects / Issues)",
+    "劑型相關 (Dosage Form Concerns)",
+    "時間/併用 (Timing & Interaction)",
+    "劑量調整 (Dosage Adjustment)", 
+    "禁忌症/適應症 (Contraindications/Indications)"
+]
+
+# 章節權重
+SECTION_WEIGHTS = {
+    "用法及用量": 1.0,
+    "病人使用須知": 1.0,
+    "儲存條件": 1.0,
+    "警語及注意事項": 1.0,
+    "禁忌": 1.0,
+    "副作用": 1.0,
+    "藥物交互作用": 1.0,
+    "其他": 1.0,
+    "包裝及儲存": 1.0,
+    "不良反應": 1.0,
+}
+
+IMPORTANT_SECTIONS = ["用法及用量", "病人使用須知", "包裝及儲存", "不良反應", "警語及注意事項"]
+
+# ---------- 路徑工具 ----------
+def pick_existing_or_tmp(candidates: List[str]) -> str:
+    for p in candidates:
+        if os.path.exists(p):
+            return p
+    base = os.path.basename(candidates[0])
+    fallback = os.path.join("/tmp", base)
+    pathlib.Path(fallback).parent.mkdir(parents=True, exist_ok=True)
+    return fallback
+
+def safe_pickle_dump(obj: Any, preferred_path: str) -> str:
+    try:
+        pathlib.Path(preferred_path).parent.mkdir(parents=True, exist_ok=True)
+        with open(preferred_path, "wb") as f:
+            pickle.dump(obj, f)
+        return preferred_path
+    except OSError as e:
+        if e.errno == errno.EACCES:
+            alt = os.path.join("/tmp", os.path.basename(preferred_path))
+            try:
+                with open(alt, "wb") as f:
+                    pickle.dump(obj, f)
+                log.warning("No write permission for %s, saved to %s instead.", preferred_path, alt)
+                return alt
+            except Exception as ee:
+                log.warning("Failed to save to /tmp as well: %s", ee)
+        else:
+            log.warning("pickle dump failed: %s", e)
+    except Exception as e:
+        log.warning("pickle dump failed: %s", e)
+    return ""
+
+def safe_faiss_write(index, preferred_path: str) -> str:
+    try:
+        pathlib.Path(preferred_path).parent.mkdir(parents=True, exist_ok=True)
+        faiss.write_index(index, preferred_path)
+        return preferred_path
+    except OSError as e:
+        if e.errno == errno.EACCES:
+            alt = os.path.join("/tmp", os.path.basename(preferred_path))
+            try:
+                faiss.write_index(index, alt)
+                log.warning("No write permission for %s, saved FAISS to %s instead.", preferred_path, alt)
+                return alt
+            except Exception as ee:
+                log.warning("Failed to save FAISS to /tmp as well: %s", ee)
+        else:
+            log.warning("faiss write failed: %s", e)
+    except Exception as e:
+        log.warning("faiss write failed: %s", e)
+    return ""
+
+# ---------- 檔案路徑（優先專案根目錄，其次 /app，最後 /tmp） ----------
+CWD = os.getcwd()
+SENTENCES_PKL = pick_existing_or_tmp([
+    os.path.join(CWD, "drug_sentences.pkl"),
+    "/app/drug_sentences.pkl",
+    "/tmp/drug_sentences.pkl",
+])
+FAISS_INDEX = pick_existing_or_tmp([
+    os.path.join(CWD, "drug_sentences.index"),
+    "/app/drug_sentences.index",
+    "/tmp/drug_sentences.index",
+])
+BM25_PKL = pick_existing_or_tmp([
+    os.path.join(CWD, "bm25.pkl"),
+    "/app/bm25.pkl",
+    "/tmp/bm25.pkl",
+])
+CSV_PATH = pick_existing_or_tmp([
+    os.path.join(CWD, "cleaned_combined.csv"),
+    "/app/cleaned_combined.csv",
+    "/tmp/cleaned_combined.csv",
+])
+
+# ---------- FastAPI ----------
+app = FastAPI(title="DrugQA (ZH) — LINE Webhook Only")
+
+# ---------- Helpers ----------
+_ZH_SPLIT_RE = re.compile(r"[。！？\n]")
+
+def split_sentences(text: str) -> List[str]:
+    if not isinstance(text, str): return []
+    sents = [s.strip() for s in _ZH_SPLIT_RE.split(text) if s.strip()]
+    return [s for s in sents if len(s) > 6]
+
+def tokenize_zh(s: str) -> List[str]:
+    if not isinstance(s, str) or not s: return []
+    if jieba is None: return s.strip().split()
+    return [t for t in jieba.lcut(s) if t.strip()]
+
+class State:
+    sentences: List[str] = []
+    meta: List[Dict[str, Any]] = []
+    emb_model: Optional[Any] = None
+    reranker_model: Optional[Any] = None
+    faiss_index: Optional[Any] = None
+    bm25: Optional[Any] = None
+    df_csv: Optional[pd.DataFrame] = None
+    user_sessions: Dict[str, Dict[str, Any]] = {}  # 簡易 session 快取
+
+STATE = State()
+
+# ---------- 載入與建立 ----------
+def ensure_sentences_meta() -> Tuple[List[str], List[Dict[str, Any]]]:
+    if os.path.exists(SENTENCES_PKL):
+        try:
+            with open(SENTENCES_PKL, "rb") as f:
+                obj = pickle.load(f)
+            sents = obj.get("sentences", []) if isinstance(obj, dict) else []
+            meta  = obj.get("meta", []) if isinstance(obj, dict) else []
+            log.info("Loaded sentences/meta: %s (n=%d)", SENTENCES_PKL, len(sents))
+            return sents, meta
+        except Exception as e:
+            log.warning("Failed to load sentences pkl (%s). Corpus will be empty.", e)
+    else:
+        log.info("Sentences pkl not found: %s", SENTENCES_PKL)
+    return [], []
+
+def load_embedding_model(model_id: str):
+    if SentenceTransformer is None:
+        log.warning("sentence-transformers 不可用；僅以 BM25 檢索。")
+        return None
+    device = "cpu" if (USE_CPU or (torch is None)) else ("cuda" if torch.cuda.is_available() else "cpu")
+    log.info("Load SentenceTransformer: %s on %s", model_id, device)
+    try:
+        return SentenceTransformer(model_id, device=device)
+    except Exception as e:
+        log.warning("載入 embedding 失敗：%s", e)
+        return None
+
+def load_reranker_model(model_id: str):
+    if CrossEncoder is None:
+        log.warning("CrossEncoder 不可用；略過 rerank。")
+        return None
+    device = "cpu" if (USE_CPU or (torch is None)) else ("cuda" if torch.cuda.is_available() else "cpu")
+    log.info("Load CrossEncoder: %s on %s", model_id, device)
+    try:
+        return CrossEncoder(model_id, device=device)
+    except Exception as e:
+        log.warning("載入 reranker 失敗：%s", e)
+        return None
+
+def ensure_faiss(index_path: str, sentences: List[str]):
+    if os.path.exists(index_path):
+        try:
+            idx = faiss.read_index(index_path)
+            log.info("Loaded FAISS: %s (ntotal=%d)", index_path, getattr(idx, "ntotal", -1))
+            return idx
+        except Exception as e:
+            log.warning("FAISS 載入失敗（%s）", e)
+    if not sentences or STATE.emb_model is None:
+        log.warning("缺少語料或嵌入模型，無法建立 FAISS。")
+        return None
+    try:
+        vecs = STATE.emb_model.encode(sentences, show_progress_bar=False, convert_to_numpy=True).astype("float32")
+        faiss.normalize_L2(vecs)
+        idx = faiss.IndexFlatIP(vecs.shape[1])
+        idx.add(vecs)
+        safe_faiss_write(idx, index_path)
+        return idx
+    except Exception as e:
+        log.warning("FAISS 建立失敗：%s", e)
+        return None
+
+def ensure_bm25(path: str, sentences: List[str]):
+    if not sentences or BM25Okapi is None:
+        return None
+    if os.path.exists(path):
+        try:
+            with open(path, "rb") as f:
+                obj = pickle.load(f)
+            if isinstance(obj, dict):
+                cand = obj.get("bm25")
+                if cand is None and obj.get("tokenized"):
+                    cand = BM25Okapi(obj["tokenized"])
+                bm25 = cand if cand is not None else obj
+            else:
+                bm25 = obj
+            if hasattr(bm25, "get_scores"):
+                _ = bm25.get_scores(tokenize_zh("測試"))
+                log.info("Loaded BM25: %s", path)
+                return bm25
+            else:
+                raise ValueError("bm25 object missing get_scores")
+        except Exception as e:
+            log.warning("BM25 載入失敗（%s），將用現有 sentences 重建。", e)
+    tokenized = [tokenize_zh(s) for s in sentences]
+    try:
+        bm25 = BM25Okapi(tokenized)
+        safe_pickle_dump({"bm25": bm25, "tokenized": tokenized, "sentences": sentences}, path)
+        return bm25
+    except Exception as e:
+        log.warning("BM25 建立失敗：%s", e)
+        return None
+
+# ---------- 藥名預處理 ----------
+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] if len(parts) > 1 else query
+    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)
+    candidates = list(candidates)
+    # 自動加空格
+    query = re.sub(r'([a-zA-Z])([a-zA-Z0-9\s]*\W)', r'\1 \2', query)  # e.g., "Fentanylpatch" -> "Fentanyl patch"
+    return [c for c in candidates if len(c) > 1], query
+
+def find_drug_ids_from_name(query: str, df: pd.DataFrame) -> List[str]:
+    aliases, query = extract_drug_candidates_from_query(query)
+    drug_scores = {}
+    name_cols = [c for c in ["drug_name_norm", "drug_name", "name", "trade_name"] if c in df.columns]
+    id_col = "drug_id" if "drug_id" in df.columns else None
+    if not id_col:
+        df['temp_drug_id'] = df['chunk_id'].apply(lambda x: str(x).split('_')[0] if pd.notna(x) else None)
+        id_col = 'temp_drug_id'
+    for _, row in df.iterrows():
+        current_drug_id = row.get(id_col)
+        if not current_drug_id:
+            continue
+        name_joined = " ".join([str(row.get(c, "")).lower() for c in name_cols])
+        if not name_joined.strip():
+            continue
+        max_score_for_this_row = 0
+        for token in aliases:
+            tl = token.lower()
+            score = 0
+            if tl and tl not in DRUG_STOPWORDS:
+                if fuzz.ratio(tl, name_joined) > 80:
+                    score = 2.0 if re.search(r'[a-zA-Z]', tl) else 1.5
+                    score *= (1 + len(tl) / 20)
+                if score > max_score_for_this_row:
+                    max_score_for_this_row = score
+        if max_score_for_this_row > 0:
+            current_max = drug_scores.get(current_drug_id, 0)
+            if max_score_for_this_row > current_max:
+                drug_scores[current_drug_id] = max_score_for_this_row
+    return list(drug_scores.keys())
+
+# ---------- 意圖偵測與權重調整 ----------
+def detect_intent(query: str) -> List[str]:
+    prompt = f"根據以下問題偵測意圖類別，從 {INTENT_CATEGORIES} 中選1-2個最相關的。以JSON輸出['intents': [...]]。問題：{query}"
+    resp = call_llm(prompt, max_tokens=50)
+    try:
+        data = json.loads(resp)
+        return data.get("intents", [])
+    except:
+        return []
+
+def adjust_section_weights(intents: list) -> dict:
+    weights = SECTION_WEIGHTS.copy()
+    if not intents:
+        return weights
+    for intent in intents:
+        if "操作" in intent or "劑型相關" in intent:
+            weights["用法及用量"] *= 1.8
+            weights["病人使用須知"] *= 1.5
+        elif "保存" in intent:
+            weights["儲存條件"] *= 1.8
+            weights["包裝及儲存"] *= 1.8
+        elif "副作用" in intent:
+            weights["副作用"] *= 1.8
+            weights["不良反應"] *= 1.8
+            weights["警語及注意事項"] *= 1.5
+            weights["禁忌"] *= 1.5
+        elif "時間/併用" in intent:
+            weights["用法及用量"] *= 1.4
+            weights["病人使用須知"] *= 1.4
+            weights["藥物交互作用"] *= 1.6
+        elif "劑量調整" in intent:
+            weights["用法及用量"] *= 1.8
+            weights["病人使用須知"] *= 1.5
+        elif "禁忌症" in intent:
+            weights["禁忌"] *= 2.0
+            weights["警語及注意事項"] *= 1.8
+    # 強制重要章節
+    for sec in IMPORTANT_SECTIONS:
+        weights[sec] = max(weights.get(sec, 1.0), 1.5)
+    return weights
+
+# ---------- 檢索與 LLM ----------
+def bm25_search(query: str, bm25, sentences, top_k: int = 50) -> List[int]:
+    if bm25 is None: return []
+    try:
+        toks = tokenize_zh(query)
+        scores = bm25.get_scores(toks)
+        idxs = np.argsort(-np.asarray(scores))[:top_k]
+        return [int(i) for i in idxs]
+    except Exception as e:
+        log.warning("BM25 搜尋失敗：%s", e)
+        return []
+
+def semantic_search(query: str, index, emb_model, top_k: int = 50) -> List[Tuple[int, float]]:
+    if emb_model is None: return []
+    try:
+        qv = emb_model.encode([query], convert_to_numpy=True).astype("float32")
+        faiss.normalize_L2(qv)
+        if index is not None:
+            k = min(top_k, getattr(index, "ntotal", 0))
+            if k <= 0: return []
+            D, I = index.search(qv, k)
+            return list(zip(I[0].tolist(), D[0].tolist()))
+        return []
+    except Exception as e:
+        log.warning("Semantic 搜尋失敗：%s", e)
+        return []
+
+def rerank_results(query: str, candidates: List[Tuple[int, float, float, float]], sentences, reranker, top_k: int, threshold: float) -> List[Dict]:
+    if not candidates or reranker is None:
+        return [{"idx": c[0], "rerank_score": 0.0, "fused": c[1], "sem": c[2], "bm": c[3], "text": sentences[c[0]]} for c in candidates[:top_k]]
+    pairs = [[query, sentences[idx]] for idx, _, _, _ in candidates]
+    scores = reranker.predict(pairs, batch_size=8)
+    ranked = sorted(zip(candidates, scores), key=lambda x: x[1], reverse=True)
+    out = []
+    for (idx, fused, sem, bm), sc in ranked:
+        if sc > threshold:
+            out.append({"idx": idx, "rerank_score": float(sc), "fused": fused, "sem": sem, "bm": bm, "text": sentences[idx]})
+        if len(out) >= top_k:
+            break
+    return out or [{"idx": -1, "rerank_score": 0.0, "fused": 0.0, "sem": 0.0, "bm": 0.0, "text": "無相關資料，請諮詢醫師或藥師。"}]
+
+def fuse_and_select(query: str, sentences, meta, bm25, index, emb_model, reranker, top_k: int = TOP_K_SENTENCES) -> List[int]:
+    intents = detect_intent(query)
+    weights = adjust_section_weights(intents)
+    df = STATE.df_csv
+    drug_ids = find_drug_ids_from_name(query, df)
+    relevant_indices = [i for i, m in enumerate(meta) if m.get("drug_id") in drug_ids]
+    if not relevant_indices:
+        return []
+    relevant_sentences = [sentences[i] for i in relevant_indices]
+    relevant_meta = [meta[i] for i in relevant_indices]
+    relevant_bm25 = BM25Okapi([tokenize_zh(s) for s in relevant_sentences])
+    bm_idx = bm25_search(query, relevant_bm25, relevant_sentences, top_k * 2)
+    sem = semantic_search(query, index, emb_model, top_k * 2)
+    scores: Dict[int, float] = {}
+    for rank, rel_i in enumerate(bm_idx):
+        global_i = relevant_indices[rel_i]
+        section = relevant_meta[rel_i].get("section", "其他")
+        section_weight = weights.get(section, 1.0)
+        scores[global_i] = scores.get(global_i, 0.0) + BM25_WEIGHT * (1.0 / (1 + rank)) * section_weight
+    for global_i, s in sem:
+        if global_i in relevant_indices:
+            rel_i = relevant_indices.index(global_i)
+            section = relevant_meta[rel_i].get("section", "其他")
+            section_weight = weights.get(section, 1.0)
+            scores[global_i] = scores.get(global_i, 0.0) + SEM_WEIGHT * float(s) * section_weight
+    # 強制追加重要章節
+    added = set()
+    for sec in IMPORTANT_SECTIONS:
+        sec_indices = [i for i in relevant_indices if meta[i].get("section") == sec]
+        if sec_indices and not any(i in scores for i in sec_indices):
+            scores[sec_indices[0]] = 1.0  # 追加一個
+            added.add(sec_indices[0])
+    candidates = sorted(scores.items(), key=lambda x: -x[1])[:top_k * 2]
+    candidates = [(i, score, 0.0, 0.0) for i, score in candidates]  # 簡化為 (idx, fused, sem, bm)
+    reranked = rerank_results(query, candidates, sentences, reranker, top_k, RERANK_THRESHOLD)
+    idxs = [r["idx"] for r in reranked]
+    # 追加重要章節若缺失
+    for sec in IMPORTANT_SECTIONS:
+        if not any(meta[i].get("section") == sec for i in idxs if i >= 0):
+            sec_idx = next((i for i in relevant_indices if meta[i].get("section") == sec), None)
+            if sec_idx:
+                idxs.append(sec_idx)
+    return idxs[:top_k]
+
+def build_context(idxs: List[int], sentences: List[str], meta: List[Dict[str, Any]]) -> str:
+    ctx_lines, total_len, seen = [], 0, set()
+    for i in idxs:
+        if i < 0: continue
+        text = sentences[i]
+        if text in seen: continue
+        chunk_id = meta[i].get("chunk_id", "None")
+        line = f"[S{chunk_id}]: {text}"
+        if total_len + len(line) > MAX_CONTEXT_CHARS: break
+        ctx_lines.append(line)
+        total_len += len(line) + 1
+        seen.add(text)
+    return "\n".join(ctx_lines) or "[SNone]: 沒有找到相關資料，請諮詢醫師或藥師。"
+
+def build_prompt(query: str, contexts: str, intents: List[str]) -> str:
+    trouble_shooting = ""
+    if "操作" in " ".join(intents) or "劑型相關" in " ".join(intents):
+        trouble_shooting = "檢查組裝：問用戶平時怎麼用，有什麼問題。示範步驟。若不會組裝，建議示範或諮醫。優先藥袋醫囑，其次用法用量/病人使用須知。"
+    elif "保存" in " ".join(intents):
+        trouble_shooting = "檢查保存：問怎麼存，避免水/熱/潮濕，否則失效。標準：室溫<30°C或冷藏2-8°C [Sxxx]。旅遊：用原瓶避熱。"
+    elif "副作用" in " ".join(intents):
+        trouble_shooting = "常見：頭痛等 [Sxxx]；嚴重：立即停藥諮醫 [Sxxx]。合併不良反應/警語。"
+    elif "劑量" in " ".join(intents) or "時間" in " ".join(intents):
+        trouble_shooting = "優先藥袋醫囑（如每日1顆，早餐後）。範圍 [Sxxx]。特殊：病人使用須知。"
+    return (
+        f"你是一位專業、有同理心的藥師。使用下列參考片段回答問題。若片段無相關資訊，請說不知道。{trouble_shooting}\n"
+        f"回答用台灣繁中，親切易懂，分2-3小段，每段<150字。末尾加'了解嗎？(回是/否)'。結尾加{DISCLAIMER}\n"
+        f"問題：{query}\n"
+        f"參考片段：\n{contexts}\n"
+    )
+
+def call_llm(prompt: str, max_tokens: int = 2048) -> Optional[str]:
+    try:
+        from openai import OpenAI
+    except Exception as e:
+        log.warning("openai client 不可用：%s", e)
+        return None
+    if not (LITELLM_API_KEY and LM_MODEL and LITELLM_BASE_URL):
+        log.warning("LLM 未完整設定；略過生成。")
+        return None
+    client = OpenAI(base_url=LITELLM_BASE_URL, api_key=LITELLM_API_KEY)
+    try:
+        t0 = time.time()
+        resp = client.chat.completions.create(
+            model=LM_MODEL,
+            messages=[
+                {"role": "system", "content": "你是一位專業、有同理心的藥師。回答忠於資料，不可捏造。語言親切，用台灣繁中+英文藥名。"},
+                {"role": "user", "content": prompt},
+            ],
+            temperature=0.2,
+            timeout=10,
+            max_tokens=max_tokens,
+        )
+        used = time.time() - t0
+        log.info("LLM ok (%.2fs)", used)
+        return (resp.choices[0].message.content or "").strip()
+    except Exception as e:
+        log.warning("LLM 失敗：%s", e)
+        return None
+
+async def answer_pipeline(query: str, user_id: str) -> str:
+    if not query or not isinstance(query, str):
+        return "請提供有效問題。"
+    if not STATE.sentences:
+        return "目前尚未載入語料，請稍後再試。"
+    session = STATE.user_sessions.get(user_id, {})
+    if "prev_query" in session and query.lower() in ["是", "否"]:
+        # 簡易互動
+        if query.lower() == "是":
+            return "太好了！若還有問題，請告訴我。" + DISCLAIMER
+        else:
+            return f"抱歉沒說明清楚。關於{session['prev_query']}，請再說詳細點，或直接問醫師。" + DISCLAIMER
+    intents = detect_intent(query)
+    idxs = fuse_and_select(query, STATE.sentences, STATE.meta, STATE.bm25, STATE.faiss_index, STATE.emb_model, STATE.reranker_model, top_k=TOP_K_SENTENCES)
+    contexts = build_context(idxs, STATE.sentences, STATE.meta)
+    ans = None
+    if LM_MODEL and LITELLM_API_KEY and LITELLM_BASE_URL:
+        ans = call_llm(build_prompt(query, contexts, intents))
+    if not ans:
+        ans = ("；".join([STATE.sentences[i] for i in idxs[:3] if i >= 0])) if idxs else "抱歉，暫時找不到相關資訊。"
+    STATE.user_sessions[user_id] = {"prev_query": query}
+    return ans
+
+# ---------- LINE 驗簽與回覆 ----------
+def verify_line_signature(body_bytes: bytes, signature: str) -> bool:
+    if not CHANNEL_SECRET:
+        log.warning("CHANNEL_SECRET 未設定；跳過簽章驗證（僅供測試）。")
+        return True
+    try:
+        mac = hmac.new(CHANNEL_SECRET.encode("utf-8"), body_bytes, hashlib.sha256).digest()
+        expected = base64.b64encode(mac).decode("utf-8")
+        return hmac.compare_digest(expected, signature)
+    except Exception as e:
+        log.warning("簽章驗證錯誤：%s", e)
+        return False
+
+def line_reply(reply_token: str, text: str) -> None:
+    if not CHANNEL_ACCESS_TOKEN or requests is None:
+        log.warning("缺少 CHANNEL_ACCESS_TOKEN 或 requests；略過回覆。")
+        return
+    url = "https://api.line.me/v2/bot/message/reply"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {CHANNEL_ACCESS_TOKEN}",
+    }
+    data = {"replyToken": reply_token, "messages": [{"type": "text", "text": text[:4900]}]}
+    try:
+        r = requests.post(url, headers=headers, json=data, timeout=10)
+        if r.status_code != 200:
+            log.warning("LINE 回覆失敗：%s %s", r.status_code, r.text[:200])
+    except Exception as e:
+        log.warning("LINE 回覆例外：%s", e)
+
+# ---------- 只有這一條路由：POST /webhook ----------
+@app.post("/webhook")
+async def webhook(request: Request, x_line_signature: str = Header(default="")):
+    body = await request.body()
+    if not verify_line_signature(body, x_line_signature):
+        raise HTTPException(status_code=401, detail="Invalid LINE signature")
+    try:
+        payload = await request.json()
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid JSON body")
+
+    events = payload.get("events", [])
+    for ev in events:
+        if ev.get("type") == "message" and ev.get("message", {}).get("type") == "text":
+            reply_token = ev.get("replyToken")
+            user_id = ev.get("source", {}).get("userId", "unknown")
+            user_text = (ev.get("message", {}).get("text") or "").strip()
+            try:
+                answer = await answer_pipeline(user_text, user_id)
+            except Exception as e:
+                log.warning("Pipeline 失敗：%s", e)
+                answer = "抱歉，系統暫時無法回覆。"
+            if reply_token:
+                line_reply(reply_token, answer)
+    return {"ok": True}
+
+# ---------- 啟動 ----------
+@app.on_event("startup")
+async def _startup():
+    log.info("===== Application Startup =====")
+    try:
+        if torch is not None:
+            log.info("PyTorch version %s available.", torch.__version__)
+    except Exception:
+        pass
+    # 載入語料與索引
+    STATE.sentences, STATE.meta = ensure_sentences_meta()
+    STATE.emb_model = load_embedding_model(EMBEDDING_MODEL_ID)
+    STATE.reranker_model = load_reranker_model(RERANKER_MODEL_ID)
+    STATE.faiss_index = ensure_faiss(FAISS_INDEX, STATE.sentences)
+    STATE.bm25 = ensure_bm25(BM25_PKL, STATE.sentences)
+    if os.path.exists(CSV_PATH):
+        STATE.df_csv = pd.read_csv(CSV_PATH, dtype=str)
+    log.info("LLM via LiteLLM: base=%s model=%s", str(LITELLM_BASE_URL), str(LM_MODEL))
+    log.info("Startup complete.")
+
+@app.get("/")
+async def health():
+    return {"status": "healthy"}
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", "7860"))
+    uvicorn.run("app:app", host="0.0.0.0", port=port, log_level=LOG_LEVEL.lower(), reload=False)

bm25.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ad46c08ef71f81d8e8dc06257fbfc3e01ab86eaa20433ce53d9b4dcbb4c856f5
+size 1916642

drug_sentences.index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6556d88b7fae8e0707c56d4ec69aab976dcf803a0a5f00b752144785ded7c760
+size 2245677

drug_sentences.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:20462391beeb1b905dafa790dce37f959769cfc5731189683af7e679cc80fcf5
+size 609283

requirements.txt

@@ -0,0 +1,26 @@
+# Web server
+fastapi
+uvicorn[standard]
+gunicorn  # Optional: for better concurrency if needed
+
+# LINE Bot SDK（固定版本，避免 API 變動）
+line-bot-sdk==3.11.0
+
+# NLP / RAG
+numpy
+pandas
+jieba
+rank-bm25
+fuzzywuzzy
+python-Levenshtein
+
+# 向量索引與嵌入
+faiss-cpu
+sentence-transformers==3.0.1
+torch --extra-index-url https://download.pytorch.org/whl/cpu
+
+# OpenAI client (連到 LiteLLM gateway)
+openai
+
+# HTTP 請求（LINE 回覆）
+requests