chat_with_ai

app.py

@@ -33,6 +33,8 @@ from storage_service import GoogleCloudStorage
 
 import boto3
 
+from chatbot import Chatbot
+
 is_env_local = os.getenv("IS_ENV_LOCAL", "false") == "true"
 print(f"is_env_local: {is_env_local}")
 
@@ -1161,97 +1163,35 @@ def download_exam_result(content):
     return word_path
 
 # ---- Chatbot ----
-def chat_with_jutor(password, user_message, data, chat_history, socratic_mode=False):
+def chat_with_ai(ai_name, password, video_id, trascript, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
     verify_password(password)
 
-    # 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
     if chat_history is not None and len(chat_history) > 10:
         error_msg = "此次對話超過上限"
         raise gr.Error(error_msg)
 
-    data_json = json.loads(data)
-    for entry in data_json:
-        entry.pop('embed_url', None)  # Remove 'embed_url' if it exists
-        entry.pop('screenshot_path', None) 
-
-    if socratic_mode:
-        sys_content = f"""
-            你是一個擅長資料分析跟影片教學的老師，user 為學生
-            請用 {data} 為資料文本，自行判斷資料的種類，
-            並進行對話，使用 台灣人的口與表達，及繁體中文zh-TW
-
-            如果是影片類型，不用解釋逐字稿格式，直接回答學生問題
-            請你用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-            不要直接給予答案，讓學生自己思考
-            但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
-
-            如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-            或者你可以問學生一些問題，幫助學生更好的理解資料
-
-            如果學生的問題與資料文本無關，請告訴學生你無法回答超出範圍的問題
-
-            最後，在你回答的開頭標註【蘇格拉底助教】
-        """
-    else:
-        sys_content = f"""
-            你是一個擅長資料分析跟影片教學的老師，user 為學生
-            請用 {data} 為資料文本，自行判斷資料的種類，
-            並進行對話，使用 zh-TW
-
-            如果是影片類型，不用解釋逐字稿格式，直接回答學生問題
-            但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生可以找到相對應的時間點
-
-            如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-            或者你可以問學生一些問題，幫助學生更好的理解資料
-
-            如果學生的問題與資料文本無關，請告訴學生你無法回答超出範圍的問題
-        """
-
-    messages = [
-        {"role": "system", "content": sys_content}
-    ]
-
-    # if chat_history is not none, append role, content to messages
-    # chat_history = [(user, assistant), (user, assistant), ...]
-    # In the list, first one is user, then assistant
-    if chat_history is not None:
-        # 如果超過10則訊息，只保留最後10則訊息
-        if len(chat_history) > 10:
-            chat_history = chat_history[-10:]
-
-        for chat in chat_history:
-            old_messages = [
-                {"role": "user", "content": chat[0]},
-                {"role": "assistant", "content": chat[1]}
-            ]
-            messages += old_messages
-    else:
-        pass
-
-    messages.append({"role": "user", "content": user_message})
-    api_endpoint = "https://ci-live-feat-video-ai-dot-junyiacademy.appspot.com/api/v2/jutor/hf-chat"
-    headers = {
-        "Content-Type": "application/json",
-        "x-api-key": JUTOR_CHAT_KEY,
-    }
-    data = {
-        "data": {
-            "messages": messages,
-            "max_tokens": 512,
-            "temperature": 0.9,
-            "model": "gpt-4-1106-preview",
-            "stream": False,
-        }
+    if ai_name == "jutor":
+        ai_client = ""
+    elif ai_name == "claude3":
+        ai_client = BEDROCK_CLIENT
+    elif ai_name == "groq":
+        ai_client = GROQ_CLIENT
+  
+    chatbot_config = {
+        "video_id": video_id,
+        "trascript": trascript,
+        "content_subject": content_subject,
+        "content_grade": content_grade,
+        "jutor_chat_key": JUTOR_CHAT_KEY,
+        "ai_name": ai_name,
+        "ai_client": ai_client
     }
+    chatbot = Chatbot(chatbot_config)
+    response_completion = chatbot.chat(user_message, chat_history, socratic_mode, ai_name)
 
-    response = requests.post(api_endpoint, headers=headers, data=json.dumps(data))
-
-    if response.status_code == 200:
-        # 处理响应数据
-        response_data = response.json()
-        prompt = response_data['data']['choices'][0]['message']['content'].strip()
+    try:
         # 更新聊天历史
-        new_chat_history = (user_message, prompt)
+        new_chat_history = (user_message, response_completion)
         if chat_history is None:
             chat_history = [new_chat_history]
         else:
@@ -1259,102 +1199,11 @@ def chat_with_jutor(password, user_message, data, chat_history, socratic_mode=Fa
 
         # 返回聊天历史和空字符串清空输入框
         return "", chat_history
-    else:
+    except Exception as e:
         # 处理错误情况
-        print(f"Error: {response.status_code}")
+        print(f"Error: {e}")
         return "请求失败，请稍后再试！", chat_history
 
-def chat_with_groq(password, user_message, data, chat_history, socratic_mode=False):
-    verify_password(password)
-
-    # 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
-    if chat_history is not None and len(chat_history) > 10:
-        error_msg = "此次對話超過上限"
-        raise gr.Error(error_msg)
-
-    print("=== 變數：user_message ===")
-    print(user_message)
-    print("=== 變數：chat_history ===")
-    print(chat_history)
-
-    data_json = json.loads(data)
-    for entry in data_json:
-        entry.pop('embed_url', None)  # Remove 'embed_url' if it exists
-        entry.pop('screenshot_path', None) 
-
-    if socratic_mode:
-        sys_content = f"""
-            你是一個擅長資料分析跟影片教學的老師，user 為學生
-            請用 {data} 為資料文本，自行判斷資料的種類，
-            並進行對話，使用 台灣人的口與表達，及繁體中文zh-TW
-
-            如果是影片類型，不用解釋逐字稿格式，直接回答學生問題
-            請你用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-            不要直接給予答案，讓學生自己思考
-            但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
-
-            如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-            或者你可以問學生一些問題，幫助學生更好的理解資料
-
-            如果學生的問題與資料文本無關，請告訴學生你無法回答超出範圍的問題
-
-            最後，在你回答的開頭標註【蘇格拉底助教】
-        """
-    else:
-        sys_content = f"""
-            你是一個擅長資料分析跟影片教學的老師，user 為學生
-            請用 {data} 為資料文本，自行判斷資料的種類，
-            並進行對話，使用 zh-TW
-
-            如果是影片類型，不用解釋逐字稿格式，直接回答學生問題
-            但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生可以找到相對應的時間點
-
-            如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-            或者你可以問學生一些問題，幫助學生更好的理解資料
-
-            如果學生的問題與資料文本無關，請告訴學生你無法回答超出範圍的問題
-        """
-
-    messages = [
-        {"role": "system", "content": sys_content}
-    ]
-
-    # if chat_history is not none, append role, content to messages
-    # chat_history = [(user, assistant), (user, assistant), ...]
-    # In the list, first one is user, then assistant
-    if chat_history is not None:
-        # 如果超過10則訊息，只保留最後10則訊息
-        if len(chat_history) > 10:
-            chat_history = chat_history[-10:]
-
-        for chat in chat_history:
-            old_messages = [
-                {"role": "user", "content": chat[0]},
-                {"role": "assistant", "content": chat[1]}
-            ]
-            messages += old_messages
-    else:
-        pass
-        
-    messages.append({"role": "user", "content": user_message})
-    request_payload = {
-        "model": "mixtral-8x7b-32768",
-        "messages": messages,
-        "max_tokens": 4000  # 設定一個較大的值，可根據需要調整
-    }
-    response = GROQ_CLIENT.chat.completions.create(**request_payload)
-    response_text = response.choices[0].message.content.strip()
-
-    # 更新聊天历史
-    new_chat_history = (user_message, response_text)
-    if chat_history is None:
-        chat_history = [new_chat_history]
-    else:
-        chat_history.append(new_chat_history)
-
-    # 返回聊天历史和空字符串清空输入框
-    return "", chat_history
-
 def chat_with_opan_ai_assistant(password, youtube_id, thread_id, trascript, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
     verify_password(password)
 
@@ -1371,31 +1220,6 @@ def chat_with_opan_ai_assistant(password, youtube_id, thread_id, trascript, user
     try:
         assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq"
         client = OPEN_AI_CLIENT
-        
-        #  從 file 拿逐字稿資料
-        # instructions = f"""
-        #     你是一個擅長資料分析跟影片教學的老師，user 為學生
-        #     請根據 assistant beta 的��傳資料 
-        #     如果 file 內有找到 file.content["{youtube_id}"] 為資料文本，自行判斷資料的種類，
-        #     如果沒有資料，請告訴用戶沒有逐字稿資料，但仍然可以進行對話，使用台灣人的口與表達，及繁體中文 zh-TW 
-        #     請嚴格執行，只根據 file.content["{youtube_id}"]  為資料文本，沒有就是沒有資料，不要引用其他資料
-
-        #     如果是影片類型，不用解釋逐字稿格式，直接回答學生問題
-        #     socratic_mode = {socratic_mode}
-        #     如果 socratic_mode = True，
-        #     - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-        #     - 不要直接給予答案，讓學生自己思考
-        #     - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
-        #     - 在你回答的開頭標註【蘇格拉底助教：{youtube_id} 】
-        #     如果 socratic_mode = False，
-        #     - 直接回答學生問題
-        #     - 在你回答的開頭標註【一般學習精靈：{youtube_id} 】
-        #     如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-        #     或者你可以反問學生一些問題，幫助學生更好的理解資料
-        #     如果學生的問題與資料文本無關，請告訴學生你無法回答超出範圍的問題
-        #     最後只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
-        # """
-
         # 直接安排逐字稿資料 in instructions
         trascript_json = json.loads(trascript)
         # 移除 embed_url, screenshot_path
@@ -1549,103 +1373,6 @@ def poll_run_status(run_id, thread_id, timeout=600, poll_interval=5):
     
     return run.status
 
-def chat_with_claude3(password, video_id, trascript, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
-    verify_password(password)
-
-    # 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
-    if chat_history is not None and len(chat_history) > 10:
-        error_msg = "此次對話超過上限"
-        raise gr.Error(error_msg)
-
-    trascript_json = json.loads(trascript)
-    for entry in trascript_json:
-        entry.pop('embed_url', None)  # Remove 'embed_url' if it exists
-        entry.pop('screenshot_path', None) 
-    trascript_text = json.dumps(trascript_json, ensure_ascii=False, indent=2)
-
-
-    sys_content = f"""
-        科目：{content_subject}
-        年級：{content_grade}
-        逐字稿資料：{trascript_text}
-        -------------------------------------
-        你是一個專業的{content_subject}老師， user 為{content_grade}的學生
-        socratic_mode = {socratic_mode}
-        if socratic_mode is True，
-        - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-        - 一次只問一個問題，字數在100字以內
-        - 不要直接給予答案，讓學生自己思考
-        - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
-        - 在你回答的開頭標註【蘇格拉底助教：{video_id} 】
-        
-        if socratic_mode is False，
-        - 直接回答學生問題，字數在100字以內
-        - 在你回答的開頭標註【一般學習精靈：{video_id} 】
-
-        rule:
-        - 請一定要用繁體中文回答 zh-TW，並用台灣人的口語表達，回答時不用特別說明這是台灣人的語氣，也不用說這是「台語的說法」
-        - 不用提到「逐字稿」這個詞
-        - 如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-        - 或者你可以反問學生一些問題，幫助學生更好的理解資料，字數在100字以內
-        - 如果學生的問題與資料文本無關，請告訴學生你「無法回答超出影片範圍的問題」，並告訴他可以怎麼問什麼樣的問題（一個就好）
-        - 只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
-        - 回答範圍一定要在逐字稿資料內，不要引用其他資料，請嚴格執行
-        - 並在重複問句後給予學生鼓勵，讓學生有學習的動力
-        - 請用 {content_grade} 的學生能懂的方式回答
-
-    """
-        
-
-    messages = []
-    if chat_history is not None:
-        # 如果超過10則訊息，只保留最後10則訊息
-        if len(chat_history) > 10:
-            chat_history = chat_history[-10:]
-
-        for chat in chat_history:
-            old_messages = [
-                {"role": "user", "content": chat[0]},
-                {"role": "assistant", "content": chat[1]}
-            ]
-            messages += old_messages
-    else:
-        pass
-
-    messages.append({"role": "user", "content": user_message})
-    model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
-    # model_id = "anthropic.claude-3-haiku-20240307-v1:0"
-    kwargs = {
-    "modelId": model_id,
-    "contentType": "application/json",
-    "accept": "application/json",
-    "body": json.dumps({
-        "anthropic_version": "bedrock-2023-05-31",
-        "max_tokens": 1000,
-        "system": sys_content,
-        "messages": messages
-    })
-    }
-    # 建立 message API，讀取回應
-    response = BEDROCK_CLIENT.invoke_model(**kwargs)
-    
-    try:
-        # 处理响应数据
-        response_body = json.loads(response.get('body').read())
-        response_completion = response_body.get('content')[0].get('text').strip()
-        # 更新聊天历史
-        new_chat_history = (user_message, response_completion)
-        if chat_history is None:
-            chat_history = [new_chat_history]
-        else:
-            chat_history.append(new_chat_history)
-
-        # 返回聊天历史和空字符串清空输入框
-        return "", chat_history
-    except Exception as e:
-        # 处理错误情况
-        print(f"Error: {e}")
-        return "请求失败，请稍后再试！", chat_history
-    
 # --- Slide mode ---
 def update_slide(direction):
     global TRANSCRIPTS
@@ -1784,17 +1511,26 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     msg = gr.Textbox(label="Message")
                     send_button = gr.Button("Send", variant="primary")
                 with gr.Tab("GROQ"):
+                    groq_ai_name = gr.Textbox(label="AI 助理名稱", value="groq", visible=False)
                     groq_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="groq mode chatbot", show_share_button=False, likeable=True)
                     groq_msg = gr.Textbox(label="Message")
                     groq_send_button = gr.Button("Send", variant="primary")
                 with gr.Tab("JUTOR"):
+                    jutor_ai_name = gr.Textbox(label="AI 助理名稱", value="jutor", visible=False)
                     jutor_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="jutor mode chatbot", show_share_button=False, likeable=True)
                     jutor_msg = gr.Textbox(label="Message")
                     jutor_send_button = gr.Button("Send", variant="primary")
                 with gr.Tab("CLAUDE"):
+                    claude_ai_name = gr.Textbox(label="AI 助理名稱", value="claude3", visible=False)
                     claude_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="claude mode chatbot", show_share_button=False, likeable=True)
                     claude_msg = gr.Textbox(label="Message")
                     claude_send_button = gr.Button("Send", variant="primary")
+                with gr.Tab("ai_chatbot"):
+                    ai_name = gr.Dropdown(label="選擇 AI 助理", choices=["jutor", "claude3", "groq"], value="jutor")
+                    ai_chatbot = gr.Chatbot(avatar_images=[bot_avatar, user_avatar], label="ai_chatbot", show_share_button=False, likeable=True)
+                    ai_msg = gr.Textbox(label="Message")
+                    ai_send_button = gr.Button("Send", variant="primary")
+
     with gr.Tab("教師版"):
         with gr.Row():
             content_subject = gr.Dropdown(label="選擇主題", choices=["數學", "自然", "國文", "英文", "社會","物理", "化學", "生物", "地理", "歷史", "公民"], value="", visible=False)             
@@ -1896,22 +1632,28 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
     )
     # GROQ 模式
     groq_send_button.click(
-        chat_with_groq,
-        inputs=[password, groq_msg, df_string_output, groq_chatbot, socratic_mode_btn],
+        chat_with_ai,
+        inputs=[groq_ai_name, password, video_id, df_string_output, groq_msg, groq_chatbot, content_subject, content_grade, socratic_mode_btn],
         outputs=[groq_msg, groq_chatbot]
     )
     # JUTOR API 模式
     jutor_send_button.click(
-        chat_with_jutor,
-        inputs=[password, jutor_msg, df_string_output, jutor_chatbot, socratic_mode_btn],
+        chat_with_ai,
+        inputs=[jutor_ai_name, password, video_id, df_string_output, jutor_msg, jutor_chatbot, content_subject, content_grade, socratic_mode_btn],
         outputs=[jutor_msg, jutor_chatbot]
     )
     # CLAUDE 模式
     claude_send_button.click(
-        chat_with_claude3,
-        inputs=[password, video_id, df_string_output, claude_msg, claude_chatbot, content_subject, content_grade, socratic_mode_btn],
+        chat_with_ai,
+        inputs=[claude_ai_name, password, video_id, df_string_output, claude_msg, claude_chatbot, content_subject, content_grade, socratic_mode_btn],
         outputs=[claude_msg, claude_chatbot]
     )
+    # ai_chatbot 模式
+    ai_send_button.click(
+        chat_with_ai,
+        inputs=[ai_name, password, video_id, df_string_output, ai_msg, ai_chatbot, content_subject, content_grade, socratic_mode_btn],
+        outputs=[ai_msg, ai_chatbot]
+    )
 
     # 连接按钮点击事件
     btn_1_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, df_string_output, btn_1, chatbot, content_subject, content_grade, socratic_mode_btn]

chatbot.py

@@ -0,0 +1,156 @@
+import gradio as gr
+import json
+import requests
+
+class Chatbot:
+    def __init__(self, config):
+        self.video_id = config.get('video_id')
+        self.content_subject = config.get('content_subject')
+        self.content_grade = config.get('content_grade')
+        self.jutor_chat_key = config.get('jutor_chat_key')
+        self.transcript_text = self.get_transcript_text(config.get('trascript'))
+        self.ai_name = config.get('ai_name')
+        self.ai_client = config.get('ai_client')
+
+    def get_transcript_text(self, transcript_data):
+        transcript_json = json.loads(transcript_data)
+        for entry in transcript_json:
+            entry.pop('embed_url', None)
+            entry.pop('screenshot_path', None)
+        transcript_text = json.dumps(transcript_json, ensure_ascii=False)
+        return transcript_text
+
+    def chat(self, user_message, chat_history, socratic_mode=False, service_type='jutor'):
+        messages = self.prepare_messages(chat_history, user_message)
+        system_prompt = self.prepare_system_prompt(socratic_mode)
+        if service_type in ['jutor', 'groq', 'claude3']:
+            response_text = self.chat_with_service(service_type, system_prompt, messages)
+            return response_text
+        else:
+            raise gr.Error("不支持此服務")
+
+    def prepare_system_prompt(self, socratic_mode):
+        content_subject = self.content_subject
+        content_grade = self.content_grade
+        video_id = self.video_id
+        trascript_text = self.transcript_text
+        socratic_mode = str(socratic_mode)
+        ai_name = self.ai_name
+        system_prompt = f"""
+            科目：{content_subject}
+            年級：{content_grade}
+            逐字稿資料：{trascript_text}
+            -------------------------------------
+            你是一個專業的{content_subject}老師， user 為{content_grade}的學生
+            socratic_mode = {socratic_mode}
+            if socratic_mode is True，
+            - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
+            - 一次只問一個問題，字數在100字以內
+            - 不要直接給予答案，讓學生自己思考
+            - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
+            - 在你回答的開頭標註【{ai_name}|蘇格拉底助教：{video_id} 】
+            
+            if socratic_mode is False，
+            - 直接回答學生問題，字數在100字以內
+            - 在你回答的開頭標註【{ai_name}|一般學習精靈：{video_id} 】
+
+            rule:
+            - 請一定要用繁體中文回答 zh-TW，並用台灣人的口語表達，回答時不用特別說明這是台灣人的語氣，也不用說這是「台語的說法」
+            - 不用提到「逐字稿」這個詞
+            - 如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
+            - 或者你可以反問學生一些問題，幫助學生更好的理解資料，字數在100字以內
+            - 如果學生的問題與資料文本無關，請告訴學生你「無法回答超出影片範圍的問題」，並告訴他可以怎麼問什麼樣的問題（一個就好）
+            - 只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
+            - 回答範圍一定要在逐字稿資料內，不要引用其他資料，請嚴格執行
+            - 並在重複問句後給予學生鼓勵，讓學生有學習的動力
+            - 請用 {content_grade} 的學生能懂的方式回答
+        """
+
+        return system_prompt
+
+    def prepare_messages(self, chat_history, user_message):
+        messages = []
+        if chat_history is not None:
+            if len(chat_history) > 10:
+                chat_history = chat_history[-10:]
+
+            for user_msg, assistant_msg in chat_history:
+                if user_msg:
+                    messages.append({"role": "user", "content": user_msg})
+                if assistant_msg:
+                    messages.append({"role": "assistant", "content": assistant_msg})
+                
+        if user_message:
+            user_message += "/n (請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣)"
+            messages.append({"role": "user", "content": user_message})
+        return messages
+
+    def chat_with_service(self, service_type, system_prompt, messages):
+        if service_type == 'jutor':
+            return self.chat_with_jutor(system_prompt, messages)
+        elif service_type == 'groq':
+            return self.chat_with_groq(system_prompt, messages)
+        elif service_type == 'claude3':
+            return self.chat_with_claude3(system_prompt, messages)
+        else:
+            raise gr.Error("不支持的服务类型")
+
+    def chat_with_jutor(self, system_prompt, messages):
+        messages.insert(0, {"role": "system", "content": system_prompt})
+        api_endpoint = "https://ci-live-feat-video-ai-dot-junyiacademy.appspot.com/api/v2/jutor/hf-chat"
+        headers = {
+            "Content-Type": "application/json",
+            "x-api-key": self.jutor_chat_key,
+        }
+        data = {
+            "data": {
+                "messages": messages,
+                "max_tokens": 512,
+                "temperature": 0.9,
+                "model": "gpt-4-1106-preview",
+                "stream": False,
+            }
+        }
+
+        response = requests.post(api_endpoint, headers=headers, data=json.dumps(data))
+        response_data = response.json()
+        response_completion = response_data['data']['choices'][0]['message']['content'].strip()
+        return response_completion
+
+    def chat_with_groq(self, system_prompt, messages):
+        # system_prompt insert to messages 的最前面 {"role": "system", "content": system_prompt}
+        messages.insert(0, {"role": "system", "content": system_prompt})
+        request_payload = {
+            "model": "mixtral-8x7b-32768",
+            "messages": messages,
+            "max_tokens": 1000  # 設定一個較大的值，可根據需要調整
+        }
+        groq_client = self.ai_client
+        response = groq_client.chat.completions.create(**request_payload)
+        response_completion = response.choices[0].message.content.strip()
+        return response_completion
+
+    def chat_with_claude3(self, system_prompt, messages):
+        if not system_prompt.strip():
+            raise ValueError("System prompt cannot be empty")
+        
+        model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
+        # model_id = "anthropic.claude-3-haiku-20240307-v1:0"
+        kwargs = {
+            "modelId": model_id,
+            "contentType": "application/json",
+            "accept": "application/json",
+            "body": json.dumps({
+                "anthropic_version": "bedrock-2023-05-31",
+                "max_tokens": 1000,
+                "system": system_prompt,
+                "messages": messages
+            })
+        }
+        print(messages)
+        # 建立 message API，讀取回應
+        bedrock_client = self.ai_client
+        response = bedrock_client.invoke_model(**kwargs)
+        response_body = json.loads(response.get('body').read())
+        response_completion = response_body.get('content')[0].get('text').strip()
+        return response_completion