hi

app.py

@@ -2,12 +2,12 @@
 # -*- coding: utf-8 -*-
 # ---------- 環境與快取設定 (應置於最前) ----------
 import os
-import time
-from typing import List, Dict, Any
+from typing import List, Dict
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, Request, HTTPException, status
+from fastapi import FastAPI, Request, HTTPException
 import uvicorn
-# ----------------- LINE Bot SDK v3 修正引用方式 -----------------
+
+# ----------------- LINE Bot SDK v3 -----------------
 from linebot.v3.messaging import (
     AsyncApiClient,
     AsyncMessagingApi,
@@ -17,40 +17,35 @@ from linebot.v3.messaging import (
 )
 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
+from sentence_transformers import SentenceTransformer, util
+from tenacity import retry, stop_after_attempt, wait_exponential
 
-# ==== CONFIG (從環境變數載入，或使用預設值) ====
+# ==== CONFIG ====
 def _require_env(var: str) -> str:
     v = os.getenv(var)
     if not v:
         raise RuntimeError(f"FATAL: Missing required environment variable: {var}")
     return v
 
-# 從環境變數讀取 LINE Bot 的憑證
 CHANNEL_SECRET = _require_env("CHANNEL_SECRET")
 CHANNEL_ACCESS_TOKEN = _require_env("CHANNEL_ACCESS_TOKEN")
-
-# Tavily API Key (強制從環境變數讀取，移除硬編碼)
 TAVILY_API_KEY = _require_env("TAVILY_API_KEY")
 
-# LLM API 設定（改用 OpenRouter）
 LLM_API_CONFIG = {
     "base_url": os.getenv("LLM_BASE_URL", "https://litellm-ekkks8gsocw.dgx-coolify.apmic.ai/"),
-    "api_key": _require_env("OPENROUTER_API_KEY"),  # 強制要求 OpenRouter API Key
+    "api_key": _require_env("OPENROUTER_API_KEY"),
 }
 
-# LLM 模型設定 (預設改用 gpt-4o，性價比高)
 LLM_MODEL_CONFIG = {
-    "model": os.getenv("LLM_MODEL", 'gemini-3-pro'),
+    "model": os.getenv("LLM_MODEL", "gemini-3-pro"),
     "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.）整理內容，讓它適合手機閱讀。
@@ -60,13 +55,11 @@ SYSTEM_PROMPT = """你是一個友好的AI助手，請用簡單、親切的文
 聖經問題從希伯來文角度回答，確認來源可靠性。
 回應盡量結構化，清晰。"""
 
-# ---------- 記憶體儲存對話歷史 ----------
-conversations: Dict[str, List[Dict[str, str]]] = {}  # {user_id: messages_list}
+# ---------- 記憶體儲存 ----------
+conversations: Dict[str, List[Dict[str, str]]] = {}
+pending_chunks: Dict[str, List[str]] = {}
 
-# ---------- 儲存待發送的剩餘 chunks ----------
-pending_chunks: Dict[str, List[str]] = {}  # {user_id: remaining_chunks}
-
-# ---------- 將長訊息分割以符合 LINE API 限制 ----------
+# ---------- 長訊息分割 ----------
 def split_text_for_line(text: str, max_length: int = 4900) -> List[str]:
     if len(text) <= max_length:
         return [text]
@@ -82,109 +75,90 @@ def split_text_for_line(text: str, max_length: int = 4900) -> List[str]:
         text = text[split_pos:].lstrip()
     return chunks
 
-# ---------- 估算 token 數 (粗略，用於限制輸入長度) ----------
+# ---------- token 粗估 ----------
 def estimate_tokens(messages: List[Dict[str, str]]) -> int:
     total = 0
     for msg in messages:
-        total += len(msg["content"].split()) * 1.3  # 粗估 token
-    return total
+        total += len(msg["content"].split()) * 1.3
+    return int(total)
 
-# ---------- 網路搜尋函數（優化：嵌入模型由 ChatPipeline 預載） ----------
+# ---------- 網路搜尋（已修復相似度 bug） ----------
 def perform_web_search(query: str, max_results: int = 5) -> str:
-    """使用 Tavily 進行網路搜尋，計算向量相似度排序結果，並返回摘要。"""
-    print(f"開始網路搜尋：查詢詞 = '{query}'，最大結果數 = {max_results}")
+    print(f"開始網路搜尋：查詢詞 = '{query}'")
     try:
         client = TavilyClient(api_key=TAVILY_API_KEY)
         response = client.search(query, max_results=max_results, include_answer=True)
-        if not response['results']:
-            print("搜尋完成：沒有找到相關結果。")
+        
+        if not response.get('results'):
             return "沒有找到相關的網路搜尋結果。"
         
-        # 使用 ChatPipeline 中預載的 embedder
         embedder = chat_pipeline.embedder
         query_emb = embedder.encode(query)
         
         results_with_scores = []
         for result in response['results']:
-            content = result['content']
-            content_emb = embedder.encode(content)
+            content_emb = embedder.encode(result['content'])
             score = util.cos_sim(query_emb, content_emb)[0][0].item()
             results_with_scores.append((score, result))
         
         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]
         
-        if not relevant_results:
-            print("搜尋完成：沒有高度相關的結果。")
+        relevant_with_scores = [item for item in results_with_scores if item[0] > 0.3]
+        
+        if not relevant_with_scores:
             return "沒有找到高度相關的網路搜尋結果。"
         
-        search_summary = "以下是相關的網路搜尋結果摘要（已按文字相似度排序）：\n"
+        search_summary = "以下是相關的網路搜尋結果摘要（已按相似度排序）：\n"
         search_summary += f"AI總結：{response.get('answer', '無總結可用')}\n\n"
-        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)}")
+        
+        for i, (score, result) in enumerate(relevant_with_scores[:5], 1):
+            print(f"結果 {i}: 標題='{result['title']}'，相似度={score:.2f}，來源={result['url']}")
+            search_summary += f"{i}. [{score:.2f}] {result['title']}\n   {result['content'][:300]}...\n   來源: {result['url']}\n\n"
+        
         return search_summary
+    
     except Exception as e:
         print(f"網路搜尋錯誤：{e}")
-        return f"搜尋時發生錯誤：{str(e)}。請稍後再試。"
-
-# ---------- 聊天處理流程 (新增 retry 和 timeout) ----------
-from tenacity import retry, stop_after_attempt, wait_exponential
+        return "搜尋時發生錯誤，請稍後再試。"
 
+# ---------- ChatPipeline ----------
 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.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 名稱
+                "HTTP-Referer": os.getenv("SITE_URL", "https://your-line-bot.example.com"),
+                "X-Title": os.getenv("SITE_NAME", "My LINE 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_est = estimate_tokens(messages)
-            print(f"LLM 呼叫：估計 token = {token_est}")
-            if token_est > 50000:
-                raise ValueError("輸入過長，超過 token 限制")
-            
-            response = self.llm_client.chat.completions.create(
-                model=LLM_MODEL_CONFIG["model"],
-                messages=messages,
-                max_tokens=LLM_MODEL_CONFIG["max_tokens"],
-                temperature=LLM_MODEL_CONFIG["temperature"],
-                seed=LLM_MODEL_CONFIG["seed"],
-                timeout=30.0,
-            )
-            content = response.choices[0].message.content or ""
-            return content
-        except Exception as e:
-            print(f"LLM call error (retry): {e}")
-            raise
+        token_est = estimate_tokens(messages)
+        if token_est > 50000:
+            raise ValueError("輸入過長")
+        
+        response = self.llm_client.chat.completions.create(
+            model=LLM_MODEL_CONFIG["model"],
+            messages=messages,
+            max_tokens=LLM_MODEL_CONFIG["max_tokens"],
+            temperature=LLM_MODEL_CONFIG["temperature"],
+            seed=LLM_MODEL_CONFIG["seed"],
+            timeout=30.0,
+        )
+        return response.choices[0].message.content or ""
 
     def get_conversation_history(self, user_id: str) -> List[Dict[str, str]]:
         return conversations.get(user_id, [])
 
     def update_conversation_history(self, user_id: str, messages: List[Dict[str, str]]):
-        recent = messages[-20:]
-        conversations[user_id] = recent
+        conversations[user_id] = messages[-20:]
 
     def clear_conversation_history(self, user_id: str):
-        if user_id in conversations:
-            del conversations[user_id]
-        if user_id in pending_chunks:
-            del pending_chunks[user_id]
+        conversations.pop(user_id, None)
+        pending_chunks.pop(user_id, None)
 
     def answer_question(self, user_id: str, user_text: str) -> str:
         if user_text.strip().lower() == "/clear":
@@ -197,6 +171,7 @@ class ChatPipeline:
         messages = [{"role": "system", "content": SYSTEM_PROMPT}]
         messages.extend(history)
         messages.append({"role": "user", "content": user_text})
+        
         if "沒有找到" not in search_results:
             messages.append({"role": "system", "content": f"網路搜尋結果：{search_results}"})
         
@@ -209,15 +184,16 @@ class ChatPipeline:
         
         chunks = split_text_for_line(response)
         if len(chunks) > 5:
-            summary_prompt = [{"role": "system", "content": "請將以下內容生成一個簡潔但完整的中文摘要，保留關鍵事實和細節，長度控制在2000字元內。"}]
-            summary_prompt.append({"role": "user", "content": response})
-            summary = self._llm_call(summary_prompt)
-            summary = summary.replace('*', '')
-            return summary + "\n(完整回應過長，已提供摘要。如需細節，請分次詢問。)"
+            summary_prompt = [
+                {"role": "system", "content": "請將以下內容生成一個簡潔但完整的中文摘要，保留關鍵事實和細節，長度控制在2000字元內。"},
+                {"role": "user", "content": response}
+            ]
+            summary = self._llm_call(summary_prompt).replace('*', '')
+            return summary + "\n\n(完整回應過長，已提供摘要。如需細節，請分次詢問或回覆「繼續」)"
         
         return response
 
-# ---------- FastAPI 應用程式設置 ----------
+# ---------- FastAPI ----------
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     global chat_pipeline
@@ -225,19 +201,18 @@ async def lifespan(app: FastAPI):
     yield
 
 app = FastAPI(lifespan=lifespan)
-chat_pipeline = None  # 會在 lifespan 中初始化
+chat_pipeline = None
 
-# ----------------- LINE Bot API v3 初始化 -----------------
 configuration = Configuration(access_token=CHANNEL_ACCESS_TOKEN)
 async_api_client = AsyncApiClient(configuration)
 line_bot_api = AsyncMessagingApi(async_api_client)
 parser = WebhookParser(CHANNEL_SECRET)
 
-# ---------- LINE Webhook 處理 ----------
 @app.post("/webhook")
 async def line_webhook(request: Request):
-    signature = request.headers['X-Line-Signature']
+    signature = request.headers.get('X-Line-Signature', '')
     body = await request.body()
+    
     try:
         events = parser.parse(body.decode(), signature)
     except InvalidSignatureError:
@@ -253,8 +228,9 @@ async def line_webhook(request: Request):
 
         if not user_text:
             continue
-            
+
         try:
+            # 處理「繼續」
             if user_text.lower() == "繼續" and user_id in pending_chunks:
                 remaining = pending_chunks[user_id]
                 if not remaining:
@@ -264,54 +240,44 @@ async def line_webhook(request: Request):
                     chunks_to_send = remaining[:send_count]
                     messages_to_send = [TextMessage(text=chunk) for chunk in chunks_to_send]
                     if len(remaining) > send_count:
-                        messages_to_send[-1].text += "\n\n內容過長，請回覆 '繼續' 以查看下一部分。"
+                        messages_to_send[-1].text += "\n\n內容過長，請回覆「繼續」查看下一部分。"
                         pending_chunks[user_id] = remaining[send_count:]
                     else:
                         messages_to_send[-1].text += "\n\n內容已全部發送。"
-                        del pending_chunks[user_id]
-                    await line_bot_api.reply_message(
-                        ReplyMessageRequest(
-                            reply_token=reply_token,
-                            messages=messages_to_send
-                        )
-                    )
+                        pending_chunks.pop(user_id, None)
+                    
+                    await line_bot_api.reply_message(ReplyMessageRequest(reply_token=reply_token, messages=messages_to_send))
                     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:
                 chunks_to_send = chunks[:5]
                 messages_to_send = [TextMessage(text=chunk) for chunk in chunks_to_send]
-                messages_to_send[-1].text += "\n\n內容過長，請回覆 '繼續' 以查看下一部分。"
+                messages_to_send[-1].text += "\n\n內容過長，請回覆「繼續」查看下一部分。"
                 pending_chunks[user_id] = chunks[5:]
-            
-            await line_bot_api.reply_message(
-                ReplyMessageRequest(
-                    reply_token=reply_token,
-                    messages=messages_to_send
-                )
-            )
+
+            await line_bot_api.reply_message(ReplyMessageRequest(reply_token=reply_token, messages=messages_to_send))
+
         except Exception as e:
             print(f"Error processing message: {e}")
-            error_message = "抱歉，系統發生錯誤，請稍後再試。"
             await line_bot_api.reply_message(
                 ReplyMessageRequest(
                     reply_token=reply_token,
-                    messages=[TextMessage(text=error_message)]
+                    messages=[TextMessage(text="抱歉，系統發生錯誤，請稍後再試。")]
                 )
             )
-            
+    
     return {"status": "ok"}
 
-# 健康檢查端點
 @app.get("/health")
 async def health_check():
     return {"status": "ok"}
 
-# 根路由
 @app.get("/")
 async def root():
     return {"message": "LINE Bot is running"}