hi

app.py

@@ -1,14 +1,3 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-DrugQA (ZH) — 優化版 FastAPI LINE Webhook (最終版)
-整合 RAG 邏輯，包含 LLM 意圖偵測、子查詢分解、Intent-aware 檢索與 Rerank。
-新增動態字數調整、多次互動邏輯與對話狀態管理，提升使用者體驗。
-僅支援十種藥物。
-"""
-
-# ---------- 環境與快取設定 ----------
 import os
 import pathlib
 import re
@@ -28,9 +17,8 @@ from contextlib import asynccontextmanager
 import unicodedata
 from collections import defaultdict
 import asyncio
-import aiohttp  # 新增：導入 aiohttp 用於異步 HTTP 請求
 
-# ------------ 第三方函式庫 -------------
+# 第三方函式庫
 import numpy as np
 import pandas as pd
 import jieba
@@ -44,7 +32,7 @@ import requests
 import uvicorn
 from fastapi import FastAPI, Request, Response, HTTPException, status, BackgroundTasks
 
-# ---- 限制 PyTorch 執行緒數量，避免 CPU 環境下過度佔用資源 ----
+# 限制 PyTorch 執行緒數量，避免 CPU 環境下過度佔用資源
 torch.set_num_threads(int(os.getenv("TORCH_NUM_THREADS", "1")))
 
 # ===== CONFIG =====
@@ -55,30 +43,24 @@ def _require_env(var: str) -> str:
         raise RuntimeError(f"FATAL: Missing required environment variable: {var}")
     return v
 
-
 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", 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")
-
 LLM_API_CONFIG = {
     "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_simple": int(os.getenv("MAX_TOKENS_SIMPLE", 256)),
@@ -95,7 +77,6 @@ INTENT_CATEGORIES = [
     "劑量調整 (Dosage Adjustment)",
     "禁忌症/適應症 (Contraindications/Indications)",
 ]
-
 INTENT_TO_SECTION = {
     "操作 (Administration)": ["用法用量", "病人使用須知"],
     "保存/攜帶 (Storage & Handling)": ["包裝及儲存"],
@@ -105,7 +86,6 @@ INTENT_TO_SECTION = {
     "劑量調整 (Dosage Adjustment)": ["用法用量"],
     "禁忌症/適應症 (Contraindications/Indications)": ["適應症", "禁忌", "警語與注意事項"],
 }
-
 DRUG_NAME_MAPPING = {
     "fentanyl patch": "fentanyl",
     "spiriva respimat": "spiriva",
@@ -122,7 +102,6 @@ SUPPORTED_DRUGS = list(DRUG_NAME_MAPPING.keys())
 DISCLAIMER = (
     "本資訊僅供參考，若您對藥物使用有任何疑問，請務必諮詢您的醫師或藥師。"
 )
-
 REFERENCE_MAPPING = {
     "如何用藥？": "病人使用須知、用法用量",
     "如何保存與攜帶？": "包裝及儲存",
@@ -130,7 +109,6 @@ REFERENCE_MAPPING = {
     "每次劑量多少？": "用法用量、藥袋上的醫囑",
     "用藥時間？": "用法用量、藥袋上的醫囑",
 }
-
 REFERENCE_TO_INTENT = {
     "如何用藥？": ["操作 (Administration)"],
     "如何保存與攜帶？": ["保存/攜帶 (Storage & Handling)"],
@@ -138,20 +116,16 @@ REFERENCE_TO_INTENT = {
     "每次劑量多少？": ["劑量調整 (Dosage Adjustment)"],
     "用藥時間？": ["時間/併用 (Timing & Interaction)"],
 }
-
 PROMPT_TEMPLATES = {
     "analyze_query": """
 請分析以下使用者問題，並完成以下三個任務：
-1. 將問題分解為 1-3 個核心子問題。
-2. 從清單中選擇所有相關的意圖分類。
-3. 評估問題複雜度，返回 'simple'（單一問題或簡單意圖）或 'complex'（多子問題或複雜意圖，如副作用、劑量調整）。
-
+將問題分解為 1-3 個核心子問題。
+從清單中選擇所有相關的意圖分類。
+評估問題複雜度，返回 'simple'（單一問題或簡單意圖）或 'complex'（多子問題或複雜意圖，如副作用、劑量調整）。
 請嚴格以 JSON 格式回覆，包含 'sub_queries' (字串陣列)、'intents' (字串陣列) 和 'complexity' (字串) 三個鍵。
 範例: {{"sub_queries": ["子問題一", "子問題二"], "intents": ["分類名稱一", "分類名稱二"], "complexity": "simple"}}
-
 意圖分類清單：
 {options}。
-
 使用者問題：{query}
 """,
     "expand_query": """
@@ -161,54 +135,41 @@ PROMPT_TEMPLATES = {
 """,
     "final_answer": """
 您是一位專業、親切的台灣藥師，將在LINE上為使用者解答疑問。請依循以下規範，嚴謹地根據提供的「參考資料」給予回覆：
-
 一、 回覆規範：
-- 回覆語言：使用繁體中文，口語化且易懂，避免專業術語或解釋之。
-- 結構：先以「簡答：」標記提供簡短總結答案（50-100字），然後以「詳答：」標記提供詳細解釋，最後提醒使用者諮詢醫師。
-- 長度：簡答控制在50-100字，詳答根據問題複雜度調整，簡單問題約100-200字，複雜問題（如多步驟的裝置安裝或藥品使用）可達300-500字。
-- 態度：親切、專業、關懷，避免驚嚇使用者。
-{additional_instruction}
-
----
-參考資料：
-{context}
----
 
+回覆語言：使用繁體中文，口語化且易懂，避免專業術語或解釋之。
+結構：先以「簡答：」標記提供簡短總結答案（50-100字），然後以「詳答：」標記提供詳細解釋，最後提醒使用者諮詢醫師。
+長度：簡答控制在50-100字，詳答根據問題複雜度調整，簡單問題約100-200字，複雜問題（如多步驟的裝置安裝或藥品使用）可達300-500字。
+態度：親切、專業、關懷，避免驚嚇使用者。 {additional_instruction}
+參考資料： {context}
 使用者問題：{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
+NITROSTAT
+AUGMENTIN FOR SYRUP
+Ozempic
+NIFLEC
+Fosamax
+Humira
+PREMARIN
+SMECTA
 範例：
 使用者問題：這個藥會怎麼樣？
 澄清提問：您好，請問您指的藥物是下列哪一種？目前僅支援以下藥物詢問：Fentanyl patch、Spiriva Respimat...等。例如，您可以問：「Fentanyl patch 的副作用有哪些？」請確認藥名或提供更多細節。
-
 使用者問題：{query}
 """
 }
-
 # ---------- 日誌設定 ----------
 logging.basicConfig(
     level=logging.INFO,
@@ -222,7 +183,6 @@ def _norm(s: str) -> str:
     s = unicodedata.normalize("NFKC", s)
     return re.sub(r"[^\w\s]", "", s.lower()).strip()
 
-
 @dataclass
 class FusedCandidate:
     idx: int
@@ -230,7 +190,6 @@ class FusedCandidate:
     sem_score: float
     bm_score: float
 
-
 @dataclass
 class RerankResult:
     idx: int
@@ -238,7 +197,6 @@ class RerankResult:
     text: str
     meta: Dict[str, Any] = field(default_factory=dict)
 
-
 @dataclass
 class ConversationState:
     query_history: List[str] = field(default_factory=list)
@@ -248,7 +206,6 @@ class ConversationState:
     last_answer: Optional[str] = None
     clarification_count: int = 0
 
-
 # ---------- 核心 RAG 邏輯 ----------
 class RagPipeline:
     def __init__(self):
@@ -314,8 +271,8 @@ class RagPipeline:
         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.")
+            if not isinstance(self.state.bm25, BM25Okapi):
+                raise ValueError("Loaded BM25 is not a BM25Okapi instance.")
 
         log.info("所有模型與資料載入完成。")
 
@@ -334,9 +291,11 @@ class RagPipeline:
         for part in q_norm_parts:
             if part in self.drug_name_to_ids:
                 drug_ids.update(self.drug_name_to_ids[part])
+
         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]]:
@@ -355,11 +314,14 @@ class RagPipeline:
                 part = part.strip()
                 if part and len(part) > 1:
                     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"]):
                     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):
@@ -372,17 +334,19 @@ class RagPipeline:
                     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):
-                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
+
+            for alias in DRUG_NAME_MAPPING:
+                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),
@@ -421,6 +385,7 @@ class RagPipeline:
                 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}", []
@@ -436,31 +401,37 @@ class RagPipeline:
                 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:
+                    return await self._fallback_rag(target_id, q_orig, drug_ids)
             else:
-                return await self._fallback_rag(target_id, q_orig, drug_ids)
+                 # If no direct reference mapping, use fallback RAG
+                 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}],
                 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}"
+
             log.info(f"查詢處理完成，耗時: {time.time() - start_time:.2f}秒")
             return final_answer, drug_ids
+
         except Exception as e:
             log.error(f"處理查詢時發生錯誤: {e}", exc_info=True)
             return f"處理時發生內部錯誤，請稍後再試。\n{DISCLAIMER}", []
@@ -471,13 +442,16 @@ class RagPipeline:
         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
 
@@ -486,6 +460,7 @@ class RagPipeline:
             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
@@ -494,7 +469,6 @@ class RagPipeline:
             drug_ids, sub_queries, intents
         )
         final_candidates = all_candidates[:TOP_K_SENTENCES]
-
         reranked_results = [
             RerankResult(
                 idx=c.idx,
@@ -504,6 +478,7 @@ class RagPipeline:
             )
             for c in final_candidates
         ]
+
         prioritized = self._prioritize_context(reranked_results, intents)
         context = self._build_context(prioritized)
 
@@ -516,6 +491,7 @@ class RagPipeline:
             [{"role": "user", "content": prompt}],
             max_tokens=max_tokens
         )
+
         if not answer:
             return f"無法回答您的問題。\n{DISCLAIMER}", drug_ids
 
@@ -540,9 +516,9 @@ class RagPipeline:
         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']
+                sec_rows = drug_df[drug_df['section'].str.contains(sec, na=False)]
+                for _, row in sec_rows.iterrows():
+                    content = row['content']
                     if len(context) + len(content) > LLM_MODEL_CONFIG["max_context_chars"]:
                         return context.strip()
                     context += content + "\n\n"
@@ -572,32 +548,42 @@ class RagPipeline:
             return []
 
         all_fused_candidates: Dict[int, FusedCandidate] = {}
+
         for sub_q in sub_queries:
             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, 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=np.int64)
             rel_scores = bm25_scores[rel_idx]
             top_rel = rel_idx[np.argsort(rel_scores)[::-1][:PRE_RERANK_K]]
             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:
                 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:
                     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
+
             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])
@@ -606,12 +592,14 @@ class RagPipeline:
                 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: List[str]) -> str:
@@ -626,11 +614,14 @@ class RagPipeline:
     def _prioritize_context(self, results: List[RerankResult], intents: List[str]) -> List[RerankResult]:
         if not intents:
             return results
+
         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:
@@ -665,6 +656,7 @@ class RagPipeline:
         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
         )
@@ -674,22 +666,18 @@ class RagPipeline:
             return json.loads(s)
         except json.JSONDecodeError:
             try:
-                m = re.search(r"\{.*?\}", s, re.DOTALL)
+                m = re.search(r"{.*?}", s, re.DOTALL)
                 if m:
                     return json.loads(m.group(0))
             except json.JSONDecodeError:
                 pass
-        return default
-
+            return default
 
 # ---------- FastAPI 事件與路由 ----------
 class AppConfig:
     CHANNEL_ACCESS_TOKEN = _require_env("CHANNEL_ACCESS_TOKEN")
     CHANNEL_SECRET = _require_env("CHANNEL_SECRET")
-
-
-rag_pipeline: Optional[RagPipeline] = None
-
+    rag_pipeline: Optional[RagPipeline] = None
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -701,10 +689,8 @@ 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")
@@ -712,6 +698,7 @@ async def handle_webhook(request: Request, background_tasks: BackgroundTasks):
         raise HTTPException(status_code=400, detail="Missing LINE X-Line-Signature header")
 
     body = await request.body()
+
     try:
         hash_obj = hmac.new(AppConfig.CHANNEL_SECRET.encode("utf-8"), body, hashlib.sha256)
         expected_signature = base64.b64encode(hash_obj.digest()).decode("utf-8")
@@ -728,65 +715,55 @@ async def handle_webhook(request: Request, background_tasks: BackgroundTasks):
         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"
-        ):
-            user_text = event.get("message", {}).get("text", "").strip()
+        if event.get("type") == "message":
+            msg = event.get("message", {})
             source = event.get("source", {})
             stype = source.get("type")
             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)
 
+            if msg.get("type") == "text" and target_id:
+                user_text = msg.get("text", "").strip()
+                if user_text:
+                    background_tasks.add_task(
+                        process_user_query, stype, target_id, user_text
+                    )
+    return Response(status_code=status.HTTP_200_OK)
 
-async def process_user_query(source_type: str, target_id: str, user_text: str):
+async def process_user_query(source_type: str, target_id: str, input_data: str):
     try:
         if not rag_pipeline:
-            await line_push_generic(source_type, target_id,
+            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)
+
+        answer, drug_ids = await rag_pipeline.answer_question(target_id, input_data)
+        line_push_generic(source_type, target_id, answer)
+
     except Exception as e:
         log.error(f"背景處理 target_id={target_id} 發生錯誤: {e}", exc_info=True)
-        await line_push_generic(
+        line_push_generic(
             source_type,
             target_id,
             f"抱歉，處理時發生未預期的錯誤。\n{DISCLAIMER}",
         )
 
-
 @retry(stop=stop_after_attempt(3), wait=wait_fixed(2))
-async def line_api_call(endpoint: str, data: Dict):
+def line_api_call(endpoint: str, data: Dict):
     headers = {
         "Content-Type": "application/json",
         "Authorization": f"Bearer {AppConfig.CHANNEL_ACCESS_TOKEN}",
     }
-    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})
-
+    response = requests.post(
+        f"https://api.line.me/v2/bot/message/{endpoint}",
+        headers=headers,
+        json=data,
+        timeout=10,
+    )
+    response.raise_for_status()
 
-async def line_push_generic(source_type: str, target_id: str, text: str):
+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]
@@ -794,24 +771,9 @@ async def line_push_generic(source_type: str, target_id: str, text: str):
     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}
-    await line_api_call("push", data)
-
-
-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)
 
+    data = {"to": target_id, "messages": messages}
+    line_api_call("push", data)
 
 # ---------- 執行 ----------
 if __name__ == "__main__":

requirements.txt

@@ -12,4 +12,5 @@ torch
 # LLM 呼叫相關
 openai
 tenacity
-requests
+requests
+aiohttp