hi

.gitignore

@@ -0,0 +1 @@
+app_origin.py

app.py

@@ -2,7 +2,6 @@
 # -*- coding: utf-8 -*-
 # ---------- 環境與快取設定 (應置於最前) ----------
 import os
-import json
 import time
 from typing import List, Dict, Any
 from contextlib import asynccontextmanager
@@ -20,8 +19,8 @@ from linebot.v3.webhook import WebhookParser
 from linebot.v3.exceptions import InvalidSignatureError
 # --------------------------------------------------------------
 from openai import OpenAI
-from tavily import TavilyClient  # 新增 Tavily 客戶端
-from sentence_transformers import SentenceTransformer, util  # 新增用於向量相似度排序（CPU友好）
+from tavily import TavilyClient  # Tavily 客戶端
+from sentence_transformers import SentenceTransformer, util  # 用於向量相似度排序（CPU友好）
 
 # ==== CONFIG (從環境變數載入，或使用預設值) ====
 def _require_env(var: str) -> str:
@@ -34,24 +33,24 @@ def _require_env(var: str) -> str:
 CHANNEL_SECRET = _require_env("CHANNEL_SECRET")
 CHANNEL_ACCESS_TOKEN = _require_env("CHANNEL_ACCESS_TOKEN")
 
-# Tavily API Key (從環境變數讀取以確保安全)
-TAVILY_API_KEY = "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"
+# Tavily API Key (強制從環境變數讀取，移除硬編碼)
+TAVILY_API_KEY = _require_env("TAVILY_API_KEY")
 
-# LLM API 設定
+# LLM API 設定（改用 OpenRouter）
 LLM_API_CONFIG = {
-    "base_url": os.getenv("LLM_BASE_URL", "https://litellm-ekkks8gsocw.dgx-coolify.apmic.ai/"),
-    "api_key": os.getenv("LLM_API_KEY", "sk-eT_04m428oAPUD5kUmIhVA"),
+    "base_url": os.getenv("LLM_BASE_URL", "https://openrouter.ai/api/v1"),
+    "api_key": _require_env("OPENROUTER_API_KEY"),  # 強制要求 OpenRouter API Key
 }
 
-# LLM 模型設定 (改用 azure-gpt-4.1，降低 max_tokens 以避免超時)
+# LLM 模型設定 (預設改用 gpt-4o，性價比高)
 LLM_MODEL_CONFIG = {
-    "model": os.getenv("LLM_MODEL", "azure-gpt-4.1"),
-    "max_tokens": int(os.getenv("MAX_TOKENS", 2000)),  # 降低上限以提升回應速度
+    "model": os.getenv("LLM_MODEL", "xiaomi/mimo-v2-flash:free"),
+    "max_tokens": int(os.getenv("MAX_TOKENS", 2000)),
     "temperature": float(os.getenv("TEMPERATURE", 0.3)),
     "seed": int(os.getenv("LLM_SEED", 42)),
 }
 
-# 系統提示詞（精簡版，強調使用最新資料）
+# 系統提示詞（保持原樣）
 SYSTEM_PROMPT = """你是一個友好的AI助手，請用簡單、親切的文字回覆用戶的問題。
 回答複雜問題時，先給概念，再給詳細解釋。
 使用條列式（如 - 或 1. 2. 3.）整理內容，讓它適合手機閱讀。
@@ -90,9 +89,9 @@ def estimate_tokens(messages: List[Dict[str, str]]) -> int:
         total += len(msg["content"].split()) * 1.3  # 粗估 token
     return total
 
-# ---------- 網路搜尋函數（Tavily API，top 5 結果，向量相似度排序，CPU 環境友好） ----------
-def perform_web_search(query: str, max_results: int = 5) -> str:  # 改為 top 5
-    """使用 Tavily 進行網路搜尋，計算向量相似度（文字意義）排序結果，並返回摘要。同時 log/print 檢索過程。"""
+# ---------- 網路搜尋函數（優化：嵌入模型由 ChatPipeline 預載） ----------
+def perform_web_search(query: str, max_results: int = 5) -> str:
+    """使用 Tavily 進行網路搜尋，計算向量相似度排序結果，並返回摘要。"""
     print(f"開始網路搜尋：查詢詞 = '{query}'，最大結果數 = {max_results}")
     try:
         client = TavilyClient(api_key=TAVILY_API_KEY)
@@ -101,11 +100,10 @@ def perform_web_search(query: str, max_results: int = 5) -> str:  # 改為 top 5
             print("搜尋完成：沒有找到相關結果。")
             return "沒有找到相關的網路搜尋結果。"
         
-        # 加載輕量嵌入模型（all-MiniLM-L6-v2，CPU 友好，無 GPU 依賴）
-        embedder = SentenceTransformer('all-MiniLM-L6-v2')
+        # 使用 ChatPipeline 中預載的 embedder
+        embedder = chat_pipeline.embedder
         query_emb = embedder.encode(query)
         
-        # 計算每個結果的相似度 (文字意義排序)
         results_with_scores = []
         for result in response['results']:
             content = result['content']
@@ -113,7 +111,6 @@ def perform_web_search(query: str, max_results: int = 5) -> str:  # 改為 top 5
             score = util.cos_sim(query_emb, content_emb)[0][0].item()
             results_with_scores.append((score, result))
         
-        # 排序並過濾相似度 > 0.3 的結果（確保相關性）
         results_with_scores.sort(key=lambda x: x[0], reverse=True)
         relevant_results = [res for score, res in results_with_scores if score > 0.3]
         
@@ -123,8 +120,9 @@ def perform_web_search(query: str, max_results: int = 5) -> str:  # 改為 top 5
         
         search_summary = "以下是相關的網路搜尋結果摘要（已按文字相似度排序）：\n"
         search_summary += f"AI總結：{response.get('answer', '無總結可用')}\n\n"
-        for i, result in enumerate(relevant_results[:5], 1):  # 限制 top 5
-            print(f"��果 {i}: 標題 = '{result['title']}'，內容 = '{result['content'][:200]}...'，來源 = '{result['url']}'，相似度 = {results_with_scores[i-1][0]:.2f}")
+        for i, result in enumerate(relevant_results[:5], 1):
+            score = results_with_scores[i-1][0]
+            print(f"結果 {i}: 標題 = '{result['title']}'，內容 = '{result['content'][:200]}...'，來源 = '{result['url']}'，相似度 = {score:.2f}")
             search_summary += f"{i}. {result['title']}: {result['content'][:200]}... (來源: {result['url']})\n"
         print(f"搜尋完成：總結果數 = {len(response['results'])}, 相關結果數 = {len(relevant_results)}")
         return search_summary
@@ -133,18 +131,29 @@ def perform_web_search(query: str, max_results: int = 5) -> str:  # 改為 top 5
         return f"搜尋時發生錯誤：{str(e)}。請稍後再試。"
 
 # ---------- 聊天處理流程 (新增 retry 和 timeout) ----------
-from tenacity import retry, stop_after_attempt, wait_exponential  # 需要 pip install tenacity
+from tenacity import retry, stop_after_attempt, wait_exponential
 
 class ChatPipeline:
     def __init__(self):
         if not LLM_API_CONFIG["api_key"] or not LLM_API_CONFIG["base_url"]:
             raise ValueError("LLM API Key or Base URL is not configured.")
-        self.llm_client = OpenAI(api_key=LLM_API_CONFIG["api_key"], base_url=LLM_API_CONFIG["base_url"])
+        
+        # 預載入嵌入模型（大幅提升搜尋速度）
+        self.embedder = SentenceTransformer('all-MiniLM-L6-v2')
+        
+        # OpenAI client（相容 OpenRouter，並加入建議 headers）
+        self.llm_client = OpenAI(
+            api_key=LLM_API_CONFIG["api_key"],
+            base_url=LLM_API_CONFIG["base_url"],
+            default_headers={
+                "HTTP-Referer": os.getenv("SITE_URL", "https://your-line-bot.example.com"),  # 建議設定你的網站域名
+                "X-Title": os.getenv("SITE_NAME", "My LINE Bot"),  # 建議設定 Bot 名稱
+            }
+        )
 
     @retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=4, max=10))
     def _llm_call(self, messages: List[Dict[str, str]]) -> str:
         try:
-            # 估算 token 並 print 監控
             token_est = estimate_tokens(messages)
             print(f"LLM 呼叫：估計 token = {token_est}")
             if token_est > 50000:
@@ -156,7 +165,7 @@ class ChatPipeline:
                 max_tokens=LLM_MODEL_CONFIG["max_tokens"],
                 temperature=LLM_MODEL_CONFIG["temperature"],
                 seed=LLM_MODEL_CONFIG["seed"],
-                timeout=30.0,  # 30 秒 timeout
+                timeout=30.0,
             )
             content = response.choices[0].message.content or ""
             return content
@@ -168,7 +177,6 @@ class ChatPipeline:
         return conversations.get(user_id, [])
 
     def update_conversation_history(self, user_id: str, messages: List[Dict[str, str]]):
-        # 限制歷史：保留最近 20 條訊息 (約 10 輪)
         recent = messages[-20:]
         conversations[user_id] = recent
 
@@ -189,21 +197,19 @@ class ChatPipeline:
         messages = [{"role": "system", "content": SYSTEM_PROMPT}]
         messages.extend(history)
         messages.append({"role": "user", "content": user_text})
-        if "沒有找到" not in search_results:  # 只在有結果時加入
+        if "沒有找到" not in search_results:
             messages.append({"role": "system", "content": f"網路搜尋結果：{search_results}"})
         
         response = self._llm_call(messages)
         response = response.replace('*', '')
         
-        # 更新歷史紀錄
         history.append({"role": "user", "content": user_text})
         history.append({"role": "assistant", "content": response})
         self.update_conversation_history(user_id, history)
         
-        # 如果回應過長，檢查 chunks 數量，如果超過5，生成摘要
         chunks = split_text_for_line(response)
         if len(chunks) > 5:
-            summary_prompt = [{"role": "system", "content": "請將以下內容生成一個簡潔但完整的中文摘要，保留關鍵事實和細節，長度控制在20000字元內。"}]
+            summary_prompt = [{"role": "system", "content": "請將以下內容生成一個簡潔但完整的中文摘要，保留關鍵事實和細節，長度控制在2000字元內。"}]
             summary_prompt.append({"role": "user", "content": response})
             summary = self._llm_call(summary_prompt)
             summary = summary.replace('*', '')
@@ -219,22 +225,17 @@ async def lifespan(app: FastAPI):
     yield
 
 app = FastAPI(lifespan=lifespan)
-chat_pipeline = None
+chat_pipeline = None  # 會在 lifespan 中初始化
 
-# ----------------- LINE Bot API v3 初始化修正 -----------------
-# 建立一個 Configuration 物件，並傳入你的 Access Token
+# ----------------- LINE Bot API v3 初始化 -----------------
 configuration = Configuration(access_token=CHANNEL_ACCESS_TOKEN)
-# 使用 Configuration 物件來初始化 AsyncApiClient 和 AsyncMessagingApi
 async_api_client = AsyncApiClient(configuration)
 line_bot_api = AsyncMessagingApi(async_api_client)
-# 建立 WebhookParser 來解析請求
 parser = WebhookParser(CHANNEL_SECRET)
-# --------------------------------------------------------------
 
 # ---------- LINE Webhook 處理 ----------
 @app.post("/webhook")
 async def line_webhook(request: Request):
-    # 驗證簽名
     signature = request.headers['X-Line-Signature']
     body = await request.body()
     try:
@@ -243,7 +244,6 @@ async def line_webhook(request: Request):
         raise HTTPException(status_code=400, detail="Invalid signature")
 
     for event in events:
-        # 只處理文字訊息事件
         if event.type != 'message' or event.message.type != 'text':
             continue
 
@@ -256,7 +256,6 @@ async def line_webhook(request: Request):
             
         try:
             if user_text.lower() == "繼續" and user_id in pending_chunks:
-                # 處理繼續發送剩餘 chunks
                 remaining = pending_chunks[user_id]
                 if not remaining:
                     ai_response = "沒有更多內容了。"
@@ -276,22 +275,19 @@ async def line_webhook(request: Request):
                             messages=messages_to_send
                         )
                     )
-                    continue  # 結束本次處理
+                    continue
             
-            # 正常處理查詢
             ai_response = chat_pipeline.answer_question(user_id, user_text)
             chunks = split_text_for_line(ai_response)
             
             if len(chunks) <= 5:
                 messages_to_send = [TextMessage(text=chunk) for chunk in chunks]
             else:
-                # 發送前5個，並儲存剩餘
                 chunks_to_send = chunks[:5]
                 messages_to_send = [TextMessage(text=chunk) for chunk in chunks_to_send]
                 messages_to_send[-1].text += "\n\n內容過長，請回覆 '繼續' 以查看下一部分。"
                 pending_chunks[user_id] = chunks[5:]
             
-            # 發送訊息
             await line_bot_api.reply_message(
                 ReplyMessageRequest(
                     reply_token=reply_token,
@@ -301,12 +297,11 @@ async def line_webhook(request: Request):
         except Exception as e:
             print(f"Error processing message: {e}")
             error_message = "抱歉，系統發生錯誤，請稍後再試。"
-            # 使用 await 來呼叫非同步的 reply_message
             await line_bot_api.reply_message(
-                    ReplyMessageRequest(
-                        reply_token=reply_token,
-                        messages=[TextMessage(text=error_message)]
-                    )
+                ReplyMessageRequest(
+                    reply_token=reply_token,
+                    messages=[TextMessage(text=error_message)]
+                )
             )
             
     return {"status": "ok"}
@@ -316,7 +311,7 @@ async def line_webhook(request: Request):
 async def health_check():
     return {"status": "ok"}
 
-# 根路由，避免 404
+# 根路由
 @app.get("/")
 async def root():
     return {"message": "LINE Bot is running"}