update

app.py

@@ -45,7 +45,7 @@ print(f"is_env_local: {is_env_local}")
 print("===gr__version__===")
 print(gr.__version__)
 
-
+# KEY CONFIG
 if is_env_local:
     with open("local_config.json") as f:
         config = json.load(f)
@@ -53,6 +53,11 @@ if is_env_local:
         GCS_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
         DRIVE_KEY = json.dumps(config["GOOGLE_APPLICATION_CREDENTIALS_JSON"])
         OPEN_AI_KEY = config["OPEN_AI_KEY"]
+        OPEN_AI_ASSISTANT_ID_GPT4_BOT1 = config["OPEN_AI_ASSISTANT_ID_GPT4_BOT1"]
+        OPEN_AI_ASSISTANT_ID_GPT3_BOT1 = config["OPEN_AI_ASSISTANT_ID_GPT3_BOT1"]
+        OPEN_AI_KEY_BOT2 = config["OPEN_AI_KEY_BOT2"]
+        OPEN_AI_ASSISTANT_ID_GPT4_BOT2 = config["OPEN_AI_ASSISTANT_ID_GPT4_BOT2"]
+        OPEN_AI_ASSISTANT_ID_GPT3_BOT2 = config["OPEN_AI_ASSISTANT_ID_GPT3_BOT2"]
         GROQ_API_KEY = config["GROQ_API_KEY"]
         JUTOR_CHAT_KEY = config["JUTOR_CHAT_KEY"]
         AWS_ACCESS_KEY = config["AWS_ACCESS_KEY"]
@@ -64,6 +69,11 @@ else:
     GCS_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
     DRIVE_KEY = os.getenv("GOOGLE_APPLICATION_CREDENTIALS_JSON")
     OPEN_AI_KEY = os.getenv("OPEN_AI_KEY")
+    OPEN_AI_ASSISTANT_ID_GPT4_BOT1 = os.getenv("OPEN_AI_ASSISTANT_ID_GPT4_BOT1")
+    OPEN_AI_ASSISTANT_ID_GPT3_BOT1 = os.getenv("OPEN_AI_ASSISTANT_ID_GPT3_BOT1")
+    OPEN_AI_KEY_BOT2 = os.getenv("OPEN_AI_KEY_BOT2")
+    OPEN_AI_ASSISTANT_ID_GPT4_BOT2 = os.getenv("OPEN_AI_ASSISTANT_ID_GPT4_BOT2")
+    OPEN_AI_ASSISTANT_ID_GPT3_BOT2 = os.getenv("OPEN_AI_ASSISTANT_ID_GPT3_BOT2")
     GROQ_API_KEY = os.getenv("GROQ_API_KEY")
     JUTOR_CHAT_KEY = os.getenv("JUTOR_CHAT_KEY")
     AWS_ACCESS_KEY = os.getenv("AWS_ACCESS_KEY")
@@ -73,8 +83,9 @@ else:
 
 TRANSCRIPTS = []
 CURRENT_INDEX = 0
+CHAT_LIMIT = 10
 
-OPEN_AI_CLIENT = OpenAI(api_key=OPEN_AI_KEY)
+# CLIENTS CONFIG
 GROQ_CLIENT = Groq(api_key=GROQ_API_KEY)
 GCS_SERVICE = GoogleCloudStorage(GCS_KEY)
 GCS_CLIENT = GCS_SERVICE.client
@@ -85,6 +96,39 @@ BEDROCK_CLIENT = boto3.client(
     region_name=AWS_REGION_NAME,
 )
 
+# check open ai access
+def check_open_ai_access(open_ai_api_key):
+    # set key in OpenAI client and run to check status, if it is work, return True
+    client = OpenAI(api_key=open_ai_api_key)
+    try:
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "user", "content": "This is a test."},
+            ],
+        )
+        if response.choices[0].message.content:
+            return True
+        else:
+            return False
+    except Exception as e:
+        print(f"Error: {str(e)}")
+        return False
+
+open_ai_api_key_assistant_id_list = [
+    {"account":"bot1", "open_ai_api_key": OPEN_AI_KEY, "assistant_gpt4_id": OPEN_AI_ASSISTANT_ID_GPT4_BOT1, "assistant_gpt3_id": OPEN_AI_ASSISTANT_ID_GPT3_BOT1},
+    {"account":"bot2", "open_ai_api_key": OPEN_AI_KEY_BOT2, "assistant_gpt4_id": OPEN_AI_ASSISTANT_ID_GPT4_BOT2, "assistant_gpt3_id": OPEN_AI_ASSISTANT_ID_GPT3_BOT2},
+]
+for open_ai_api_key_assistant_id in open_ai_api_key_assistant_id_list:
+    account = open_ai_api_key_assistant_id["account"]
+    open_ai_api_key = open_ai_api_key_assistant_id["open_ai_api_key"]
+    if check_open_ai_access(open_ai_api_key):
+        OPEN_AI_CLIENT = OpenAI(api_key=open_ai_api_key)
+        OPEN_AI_ASSISTANT_ID_GPT4 = open_ai_api_key_assistant_id["assistant_gpt4_id"]
+        OPEN_AI_ASSISTANT_ID_GPT3 = open_ai_api_key_assistant_id["assistant_gpt3_id"]
+        print(f"OpenAI access is OK, account: {account}")
+        break
+
 # 驗證 password
 def verify_password(password):
     if password == PASSWORD:
@@ -371,7 +415,14 @@ def generate_transcription_by_whisper(video_id):
  
 def get_video_duration(video_id):
     yt = YouTube(f'https://www.youtube.com/watch?v={video_id}')
-    return yt.length
+    try:
+        video_duration = yt.length
+    except:
+        video_duration = None
+
+    print(f"video_duration: {video_duration}")
+    
+    return video_duration
 
 def process_transcript_and_screenshots_on_gcs(video_id):
     print("====process_transcript_and_screenshots_on_gcs====")
@@ -384,7 +435,7 @@ def process_transcript_and_screenshots_on_gcs(video_id):
     # 检查逐字稿是否存在
     is_new_transcript = False
     is_transcript_exists = GCS_SERVICE.check_file_exists(bucket_name, transcript_blob_name)
-    video_length = get_video_duration(video_id)
+    video_duration = get_video_duration(video_id)
     if not is_transcript_exists:
         print("逐字稿文件不存在于GCS中，重新建立")
         # 从YouTube获取逐字稿并上传
@@ -400,8 +451,9 @@ def process_transcript_and_screenshots_on_gcs(video_id):
         else:
             print("沒有找到字幕")
             transcript = generate_transcription_by_whisper(video_id)
-
-        transcript = [entry for entry in transcript if entry['start'] <= video_length]
+        if video_duration:
+            transcript = [entry for entry in transcript if entry['start'] <= video_duration]
+        
         transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
         GCS_SERVICE.upload_json_string(bucket_name, transcript_blob_name, transcript_text)
 
@@ -411,7 +463,8 @@ def process_transcript_and_screenshots_on_gcs(video_id):
         print("逐字稿已存在于GCS中")
         transcript_text = GCS_SERVICE.download_as_string(bucket_name, transcript_blob_name)
         transcript = json.loads(transcript_text)
-        transcript = [entry for entry in transcript if entry['start'] <= video_length]
+        if video_duration:
+            transcript = [entry for entry in transcript if entry['start'] <= video_duration]
 
     # print("===確認其他衍生文件===")
     # source = "gcs"
@@ -605,13 +658,22 @@ def download_youtube_video(youtube_id, output_path=OUTPUT_PATH):
     # Create the output directory if it doesn't exist
     if not os.path.exists(output_path):
         os.makedirs(output_path)
-
+    
     # Download the video
-    yt = YouTube(youtube_url)
-    video_stream = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first()
-    video_stream.download(output_path=output_path, filename=youtube_id+".mp4")
+    try:
+        yt = YouTube(youtube_url)
+        video_stream = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first()
+        video_stream.download(output_path=output_path, filename=youtube_id+".mp4")
+        print(f"[Pytube] Video downloaded successfully: {output_path}/{youtube_id}.mp4")
+    except Exception as e:
+        ydl_opts = {
+            'format': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',  # This ensures the best quality combining video and audio
+            'outtmpl': os.path.join(output_path, f'{youtube_id}.mp4'),  # Output filename template
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            ydl.download([youtube_url])
 
-    print(f"Video downloaded successfully: {output_path}/{youtube_id}.mp4")
+        print(f"[yt_dlp] Video downloaded successfully: {output_path}/{youtube_id}.mp4")
 
 def screenshot_youtube_video(youtube_id, snapshot_sec):    
     video_path = f'{OUTPUT_PATH}/{youtube_id}.mp4'
@@ -1208,7 +1270,6 @@ def change_questions(password, df_string):
     print("=====get_questions=====")
     return q1, q2, q3
 
-# 「關鍵時刻」另外獨立成一個 tab，時間戳記和文字的下方附上對應的截圖，重點摘要的「關鍵時刻」加上截圖資訊
 def get_key_moments(video_id, formatted_simple_transcript, formatted_transcript, source):
     if source == "gcs":
         print("===get_key_moments on gcs===")
@@ -1277,19 +1338,19 @@ def generate_key_moments(formatted_simple_transcript, formatted_transcript):
         1. 小範圍切出不同段落的相對應時間軸的重點摘要，
         2. 每一小段最多不超過 1/5 的總內容，也就是大約 3~5段的重點（例如五～十分鐘的影片就一段大約1~2分鐘，最多三分鐘，但如果是超過十分鐘的影片，那一小段大約 2~3分鐘，以此類推）
         3. 注意不要遺漏任何一段時間軸的內容 從零秒開始
-        4. 如果頭尾的情節不是重點，就併入到附近的段落，特別是打招呼或是介紹人物就是不重要的情節
-        5. transcript 逐字稿的集合（要有合理的標點符號)，要完整跟原來的一樣，不要省略
-        以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
+        4. 如果頭尾的情節不是重點，特別是打招呼或是介紹人物、或是say goodbye 就是不重要的情節，就不用擷取
+        5. 以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
         6. 關鍵字從transcript  extract to keyword，保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式
-        7. text, transcript, keywords please use or transfer zh-TW, it's very important
+        7. text, keywords please use or transfer zh-TW, it's very important
 
-        並用 JSON 格式返回 key_moments:[{{
+        Example: retrun JSON 
+        {{key_moments:[{{
             "start": "00:00", 
             "end": "01:00", 
             "text": "逐字稿的重點摘要",
-            "transcript": "逐字稿的集合（要有合理的標點符號)，要完整跟原來的一樣，不要省略",
             "keywords": ["關鍵字", "關鍵字"]
-        }}]
+            }}]
+        }}
     """
 
     try:
@@ -1337,8 +1398,18 @@ def generate_key_moments(formatted_simple_transcript, formatted_transcript):
         response = BEDROCK_CLIENT.invoke_model(**kwargs)
         response_body = json.loads(response.get('body').read())
         response_completion = response_body.get('content')[0].get('text')
+        print(f"response_completion: {response_completion}")
+
         key_moments = json.loads(response_completion)["key_moments"]
 
+    # "transcript": get text from formatted_simple_transcript
+    for moment in key_moments:
+        start_time = parse_time(moment['start'])
+        end_time = parse_time(moment['end'])
+        # 使用轉換後的 timedelta 物件進行時間
+        moment['transcript'] = "，".join([entry['text'] for entry in formatted_simple_transcript
+                                        if start_time <= parse_time(entry['start_time']) <= end_time])
+
     print("=====key_moments=====")
     print(key_moments)
     print("=====key_moments=====")
@@ -2011,17 +2082,22 @@ def download_exam_result(content):
     return word_path
 
 # ---- Chatbot ----
-def get_instructions(content_subject, content_grade, key_moments):
+def get_instructions(content_subject, content_grade, key_moments, socratic_mode=True):
+    if socratic_mode:
+        method = "Socratic style, guide thinking, no direct answers. this is very important, please be seriously following."
+    else:
+        method = "direct answers, but encourage user to think more."
+
     instructions = f"""
         subject: {content_subject}
         grade: {content_grade}
         context: {key_moments}
         Assistant Role: you are a {content_subject} assistant. you can call yourself as  {content_subject} 學伴
         User Role: {content_grade} th-grade student.
-        Method: Socratic style, guide thinking, no direct answers. this is very important, please be seriously following.
+        Method: {method}
         Language: Traditional Chinese ZH-TW (it's very important), suitable for {content_grade} th-grade level.
         Response: 
-        - if user say hi or hello or any greeting, just say hi back and introduce yourself. Then ask user to ask question in context.
+        - if user say hi or hello or any greeting, just say hi back and introduce yourself. Then tell user to ask question in context.
         - Single question, under 100 characters
         - include math symbols (use LaTeX $ to cover before and after, ex: $x^2$)
         - hint with video timestamp which format 【參考：00:00:00】. 
@@ -2032,48 +2108,66 @@ def get_instructions(content_subject, content_grade, key_moments):
     """
     return instructions
 
-def chat_with_ai(ai_name, password, video_id, user_data, trascript_state, key_moments, user_message, chat_history, content_subject, content_grade, questions_answers_json, socratic_mode=False):
+def chat_with_any_ai(ai_type, password, video_id, user_data, transcript_state, key_moments, user_message, chat_history, content_subject, content_grade, questions_answers_json, socratic_mode=False, thread_id=None, ai_name=None):
+    print(f"ai_type: {ai_type}")
+    print(f"user_data: {user_data}")
     verify_password(password)
+    verify_message_length(user_message, max_length=1500)
 
-    print("=====user_data=====")
-    print(f"user_data: {user_data}")
+    is_questions_answers_exists, question_message, answer_message = check_questions_answers(user_message, questions_answers_json)
+    if is_questions_answers_exists:
+        chat_history = update_chat_history(question_message, answer_message, chat_history)
+        send_btn_update, send_feedback_btn_update = update_send_and_feedback_buttons(chat_history, CHAT_LIMIT)
+        time.sleep(3)
 
-    questions_answers_json = json.loads(questions_answers_json)
-    for qa in questions_answers_json:
-        question = qa["question"]
-        answer = qa["answer"]
-        if user_message == question and answer != "":
-            print("=== in questions_answers_json==")
-            print(f"question: {question}")
-            print(f"answer: {answer}")
-            # 更新聊天历史
-            new_chat_history = (user_message, answer)
-            if chat_history is None:
-                chat_history = [new_chat_history]
-            else:
-                chat_history.append(new_chat_history)
+        return "", chat_history, send_btn_update, send_feedback_btn_update, thread_id
+    
+    verify_chat_limit(chat_history, CHAT_LIMIT)
 
-            # 等待 3 秒
-            time.sleep(3)
+    if ai_type == "chat_completions":
+        chatbot_config = get_chatbot_config(ai_name, transcript_state, key_moments, content_subject, content_grade, video_id, socratic_mode)
+        chatbot = Chatbot(chatbot_config)
+        response_text = chatbot.chat(user_message, chat_history)
+        thread_id = ""
+    elif ai_type == "assistant":
+        client = OPEN_AI_CLIENT
+        assistant_id = OPEN_AI_ASSISTANT_ID_GPT4 #GPT 4 turbo
+        if isinstance(key_moments, str):
+            key_moments_json = json.loads(key_moments)
+        else:
+            key_moments_json = key_moments
+        # key_moments_json remove images
+        for moment in key_moments_json:
+            moment.pop('images', None)
+            moment.pop('end', None)
+            moment.pop('transcript', None)
+        key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
+        instructions = get_instructions(content_subject, content_grade, key_moments_text, socratic_mode)
+        print(f"=== instructions:{instructions} ===")
+        metadata={
+            "video_id": video_id,
+            "user_data": user_data,
+            "content_subject": content_subject,
+            "content_grade": content_grade,
+            "socratic_mode": str(socratic_mode),
+            "assistant_id": assistant_id,
+            "is_streaming": "false",
+        }
+        user_message_note = "/n 請嚴格遵循instructions，擔任一位蘇格拉底家教，絕對不要重複 user 的問句，請用引導的方式指引方向，請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，請在回答的最後標註【參考：（時）:（分）:（秒）】，（如果是反問學生，就只問一個問題，請幫助學生更好的理解資料，字數在100字以內，回答時如果講到數學專有名詞，請用數學符號代替文字（Latex 用 $ 字號 render, ex: $x^2$)"
+        user_content = user_message + user_message_note
+        response_text, thread_id = handle_conversation_by_open_ai_assistant(client, user_content, instructions, assistant_id, thread_id, metadata, fallback=True)
 
-            return "", chat_history
+    # 更新聊天历史
+    chat_history = update_chat_history(user_message, response_text, chat_history)
+    send_btn_update, send_feedback_btn_update = update_send_and_feedback_buttons(chat_history, CHAT_LIMIT)
 
-    if chat_history is not None and len(chat_history) > 11:
-        error_msg = "此次對話超過上限（對話一輪10次）"
-        raise gr.Error(error_msg)
+    # 返回聊天历史和空字符串清空输入框
+    return "", chat_history, send_btn_update, send_feedback_btn_update, thread_id
 
+def get_chatbot_config(ai_name, transcript_state, key_moments, content_subject, content_grade, video_id, socratic_mode=True):
     if not ai_name in ["foxcat", "lili", "maimai"]:
         ai_name = "foxcat"
 
-    # if ai_name == "jutor":
-    #     ai_client = ""
-    # elif ai_name == "claude3":
-    #     ai_client = BEDROCK_CLIENT
-    # elif ai_name == "groq":
-    #     ai_client = GROQ_CLIENT
-    # else:
-    #     ai_client = ""
-        
     ai_name_clients_model = {
         "foxcat": {
             "ai_name": "foxcat",
@@ -2085,11 +2179,6 @@ def chat_with_ai(ai_name, password, video_id, user_data, trascript_state, key_mo
             "ai_client": BEDROCK_CLIENT,
             "ai_model_name": "claude3",
         },
-        # "maimai": {
-        #     "ai_name": "maimai",
-        #     "ai_client": OPEN_AI_CLIENT,
-        #     "ai_model_name": "openai",
-        # }
         "maimai": {
             "ai_name": "maimai",
             "ai_client": GROQ_CLIENT,
@@ -2099,10 +2188,10 @@ def chat_with_ai(ai_name, password, video_id, user_data, trascript_state, key_mo
     ai_client = ai_name_clients_model.get(ai_name, "foxcat")["ai_client"]
     ai_model_name = ai_name_clients_model.get(ai_name, "foxcat")["ai_model_name"]
 
-    if isinstance(trascript_state, str):
-        simple_transcript = json.loads(trascript_state)
+    if isinstance(transcript_state, str):
+        simple_transcript = json.loads(transcript_state)
     else:
-        simple_transcript = trascript_state
+        simple_transcript = transcript_state
   
     if isinstance(key_moments, str):
         key_moments_json = json.loads(key_moments)
@@ -2115,7 +2204,7 @@ def chat_with_ai(ai_name, password, video_id, user_data, trascript_state, key_mo
         moment.pop('transcript', None)
     key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
 
-    instructions = get_instructions(content_subject, content_grade, key_moments_text)
+    instructions = get_instructions(content_subject, content_grade, key_moments_text, socratic_mode)
 
     chatbot_config = {
         "video_id": video_id,
@@ -2129,155 +2218,185 @@ def chat_with_ai(ai_name, password, video_id, user_data, trascript_state, key_mo
         "instructions": instructions
     }
 
-    try:
-        chatbot = Chatbot(chatbot_config)
-        response_completion = chatbot.chat(user_message, chat_history, socratic_mode, ai_model_name)
-    except Exception as e:
-        print(f"Error: {e}")
-        response_completion = "學習精靈有點累，請稍後再試！"
-
-    try:
-        # 更新聊天历史
-        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
-
-def chat_with_opan_ai_assistant(password, youtube_id, user_data, thread_id, trascript_state, key_moments, user_message, chat_history, content_subject, content_grade, questions_answers_json, socratic_mode=False):
-    verify_password(password)
-
-    print("=====user_data=====")
-    print(f"user_data: {user_data}")
-
-    # 先計算 user_message 是否超過 500 個字
-    if len(user_message) > 1500:
-        error_msg = "你的訊息太長了，請縮短訊息長度至五百��以內"
-        raise gr.Error(error_msg)
+    return chatbot_config
+
+def feedback_with_ai(ai_type, chat_history, thread_id=None):
+    # prompt: 請依據以上的對話(chat_history)，總結我的「提問力」，並給予我是否有「問對問題」的回饋和建議
+    system_content = """
+        你是一個擅長引導問答素養的老師，user 為學生的提問跟回答，請精讀對話過程，針對 user 給予回饋就好，根據以下 Rule:
+        - 請使用繁體中文 zh-TW 總結 user 的提問力，並給予是否有問對問題的回饋和建議
+        - 不採計【預設提問】的問題，如果 user 的提問都來自【預設提問】，表達用戶善於使用系統，請給予回饋並鼓勵 user 親自提問更具體的問題
+        - 如果用戶提問都相當簡短，甚至就是一個字或都是一個數字（像是 user: 1, user:2），請給予回饋並建議 user 提問更具體的問題
+        - 如果用戶提問內容只有符號或是亂碼，像是？,！, ..., 3bhwbqhfw2vve2 等，請給予回饋並建議 user 提問更具體的問題
+        - 如果用戶提問內容有色情、暴力、仇恨、不當言論等，請給予嚴厲的回饋並建議 user 提問更具體的問題
+        - 並用第二人稱「你」來代表 user
+        - 請禮貌，並給予鼓勵
+    """
+    chat_history_conversation = ""
+    # 標註 user and assistant as string
+    # chat_history 第一組不採計
+    for chat in chat_history[1:]:
+        user_message = chat[0]
+        assistant_message = chat[1]
+        chat_history_conversation += f"User: {user_message}\nAssistant: {assistant_message}\n"
     
-    questions_answers_json = json.loads(questions_answers_json)
-    for qa in questions_answers_json:
-        question = qa["question"]
-        answer = qa["answer"]
-        if user_message == question and answer != "":
-            print("=== in questions_answers_json==")
-            print(f"question: {question}")
-            print(f"answer: {answer}")
-            print(f"thread_id: {thread_id}")
-            # 更新聊天历史
-            new_chat_history = (user_message, answer)
-            if chat_history is None:
-                chat_history = [new_chat_history]
-            else:
-                chat_history.append(new_chat_history)
-
-            # 等待 3 秒
-            time.sleep(3)
+    feedback_request_message = "請依據以上的對話，總結我的「提問力」，並給予我是否有「問對問題」的回饋和建議"
+    user_content = f"""conversation: {chat_history_conversation}
+        {feedback_request_message}
+        最後根據提問力表現，給予提問建議、提問表現，並用 emoji 來表示評分：
+        🟢：（表現很好的回饋，給予正向肯定）
+        🟡：（還可以加油的的回饋，給予明確的建議）
+        🔴：（非常不懂提問的回饋，給予鼓勵並給出明確示範）
+
+        example:
+        另一方面，你表達「我不想學了」這個情感，其實也是一種重要的反饋。這顯示你可能感到挫折或疲倦。在這種情況下，表達出你的感受是好的，但如果能具體說明是什麼讓你感到這樣，或是有什麼具體的學習障礙，會更有助於找到解決方案。
+        給予你的建議是，嘗試在提問時更明確一些，這樣不僅能幫助你獲得更好的學習支持，也能提高你的問題解決技巧。
+        ......
+        提問建議：在提問時，試著具體並清晰地表達你的需求和疑惑，這樣能更有效地得到幫助。
+        提問表現：【🟡】加油，持續練習，你的提問力會越來越好！
+    """
 
-            return "", chat_history, thread_id
+    client = OPEN_AI_CLIENT
 
+    if ai_type == "chat_completions":
+        model_name = "gpt-4-turbo"
+        response_text = handle_conversation_by_open_ai_chat_completions(client, model_name, user_content, system_content)
+    elif ai_type == "assistant":
+        assistant_id = OPEN_AI_ASSISTANT_ID_GPT4 #GPT 4 turbo
+        # assistant_id = OPEN_AI_ASSISTANT_ID_GPT3 #GPT 3.5 turbo
+        response_text, thread_id = handle_conversation_by_open_ai_assistant(client, user_content, system_content, assistant_id, thread_id, metadata=None, fallback=True)
     
-    # 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
-    if chat_history is not None and len(chat_history) > 10:
-        error_msg = "此次對話超過上限（對話一輪10次）"
-        raise gr.Error(error_msg)
+    chat_history = update_chat_history(feedback_request_message, response_text, chat_history)
+    feedback_btn_update = gr.update(value="已回饋", interactive=False, variant="secondary")
 
-    try:
-        assistant_id = "asst_Mk151eZmKhNxzG7L9Awqz6iZ" #GPT 4 turbo
-        # assistant_id = "asst_sCA7F5opi2g7AvGnYeRfoSfT" #GPT 3.5 turbo
-
-        client = OPEN_AI_CLIENT
-        # 直接安排逐字稿資料 in instructions
-        # if isinstance(trascript_state, str):
-        #     trascript_json = json.loads(trascript_state)
-        # else:
-        #     trascript_json = trascript_state
-        # # 移除 embed_url, screenshot_path
-        # for entry in trascript_json:
-        #     entry.pop('end_time', None)
-        # trascript_text = json.dumps(trascript_json, ensure_ascii=False)
+    return chat_history, feedback_btn_update
 
-        if isinstance(key_moments, str):
-            key_moments_json = json.loads(key_moments)
-        else:
-            key_moments_json = key_moments
-        # key_moments_json remove images
-        for moment in key_moments_json:
-            moment.pop('images', None)
-            moment.pop('end', None)
-            moment.pop('transcript', None)
-        key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
-        
-        instructions = get_instructions(content_subject, content_grade, key_moments_text)
-        print("=== instructions ===")
-        print(instructions)
+def handle_conversation_by_open_ai_chat_completions(client, model_name, user_content, system_content):
+    response = client.chat.completions.create(
+        model=model_name,
+        messages=[
+            {"role": "system", "content": system_content},
+            {"role": "user", "content": user_content}
+        ],
+        max_tokens=4000,
+    )
+    response_text = response.choices[0].message.content.strip()
+    return response_text
 
-        # 创建线程
+def handle_conversation_by_open_ai_assistant(client, user_message, instructions, assistant_id, thread_id=None, metadata=None, fallback=False):
+    """
+    Handles the creation and management of a conversation thread.
+    :param client: The OpenAI client object.
+    :param thread_id: The existing thread ID, if any.
+    :param user_message: The message from the user.
+    :param instructions: System instructions for the assistant.
+    :param assistant_id: ID of the assistant to use.
+    :param metadata: Additional metadata to add to the thread.
+    :param fallback: Whether to use a fallback method in case of failure.
+    :return: A string with the response text or an error message.
+    """
+    try:
         if not thread_id:
-            thread = client.beta.threads.create(
-
-            )
+            thread = client.beta.threads.create()
             thread_id = thread.id
         else:
             thread = client.beta.threads.retrieve(thread_id)
-        
-        # add meta data to thread
-        client.beta.threads.update(
-            thread_id=thread_id,
-            metadata={
-                "youtube_id": youtube_id,
-                "user_data": user_data,
-                "content_subject": content_subject,
-                "content_grade": content_grade,
-                "socratic_mode": socratic_mode,
-                "assistant_id": assistant_id,
-                "is_streaming": "false",
-            }
-        )           
 
-        # 向线程添加用户的消息
-        client.beta.threads.messages.create(
-            thread_id=thread.id,
-            role="user",
-            content=user_message + "/n 請嚴格遵循instructions，擔任一位蘇格拉底家教，絕對不要重複 user 的問句，請用引導的方式指引方向，請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，請在回答的最後標註【參考：（時）:（分）:（秒）】，（如果是反問學生，就只問一個問題，請幫助學生更好的理解資料，字數在100字以內，回答時如果講到數學專有名詞，請用數學符號代替文字（Latex 用 $ 字號 render, ex: $x^2$)"
-        )
+        if metadata:
+            client.beta.threads.update(thread_id=thread.id, metadata=metadata)
 
-        # 运行助手，生成响应
-        run = client.beta.threads.runs.create(
-            thread_id=thread.id,
-            assistant_id=assistant_id,
-            instructions=instructions,
-        )
+        # Send the user message to the thread
+        client.beta.threads.messages.create(thread_id=thread.id, role="user", content=user_message)
 
-        # 等待助手响应，设定最大等待时间为 30 秒
+        # Run the assistant
+        run = client.beta.threads.runs.create(thread_id=thread.id, assistant_id=assistant_id, instructions=instructions)
+        
+        # Wait for the response
         run_status = poll_run_status(run.id, thread.id, timeout=30)
-        # 获取助手的响应消息
+        
         if run_status == "completed":
             messages = client.beta.threads.messages.list(thread_id=thread.id)
-            # [MessageContentText(text=Text(annotations=[], value='您好！有什麼我可以幫助您的嗎？如果有任何問題或需要指導，請隨時告訴我！'), type='text')]
             response_text = messages.data[0].content[0].text.value
         else:
             response_text = "學習精靈有點累，請稍後再試！"
 
-        # 更新聊天历史
-        new_chat_history = (user_message, response_text)
-        if chat_history is None:
-            chat_history = [new_chat_history]
-        else:
-            chat_history.append(new_chat_history)
     except Exception as e:
-        print(f"Error: {e}")
-        raise gr.Error(f"Error: {e}")
+        if fallback:
+            response = client.chat.completions.create(
+                model="gpt-4-turbo",
+                messages=[
+                    {"role": "system", "content": instructions},
+                    {"role": "user", "content": user_message}
+                ],
+                max_tokens=4000,
+            )
+            response_text = response.choices[0].message.content.strip()
+        else:
+            print(f"Error: {e}")
+            raise gr.Error(f"Error: {e}")
 
-    # 返回聊天历史和空字符串清空输入框
-    return "", chat_history, thread.id
+    return response_text, thread_id
+
+def verify_message_length(user_message, max_length=500):
+    # 驗證用戶消息的長度
+    if len(user_message) > max_length:
+        error_msg = "你的訊息太長了，請縮短訊息長度至五百字以內"
+        raise gr.Error(error_msg)
+
+def check_questions_answers(user_message, questions_answers_json):
+    """檢查問答是否存在，並處理相關邏輯"""
+    is_questions_answers_exists = False
+    answer = ""
+    # 解析問答數據
+    if isinstance(questions_answers_json, str):
+        qa_data = json.loads(questions_answers_json)
+    else:
+        qa_data = questions_answers_json
+    
+    question_message = ""
+    answer_message = ""
+    for qa in qa_data:
+        if user_message == qa["question"] and qa["answer"]:
+            is_questions_answers_exists = True
+            question_message = f"【預設問題】{user_message}"
+            answer_message = qa["answer"]
+            print("=== in questions_answers_json==")
+            print(f"question: {qa['question']}")
+            print(f"answer: {answer_message}")
+            break  # 匹配到答案後退出循環
+
+    return is_questions_answers_exists, question_message, answer_message
+
+def verify_chat_limit(chat_history, chat_limit):
+    if chat_history is not None and len(chat_history) > chat_limit:
+        error_msg = "此次對話超過上限（對話一輪10次）"
+        raise gr.Error(error_msg)
+
+def update_chat_history(user_message, response, chat_history):
+    # 更新聊天歷史的邏輯
+    new_chat_history = (user_message, response)
+    if chat_history is None:
+        chat_history = [new_chat_history]
+    else:
+        chat_history.append(new_chat_history)
+    
+    return chat_history
+
+def update_send_and_feedback_buttons(chat_history, chat_limit):
+    # 计算发送次数
+    send_count = len(chat_history) - 1
+
+    # 根据聊天历史长度更新发送按钮和反馈按钮
+    if len(chat_history) > chat_limit:
+        send_btn_value = f"對話上限 ({send_count}/{chat_limit})"
+        send_btn_update = gr.update(value=send_btn_value, interactive=False)
+        send_feedback_btn_update = gr.update(visible=True)
+    else:
+        send_btn_value = f"發送 ({send_count}/{chat_limit})"
+        send_btn_update = gr.update(value=send_btn_value, interactive=True)
+        send_feedback_btn_update = gr.update(visible=False)
+
+    return send_btn_update, send_feedback_btn_update
 
 def process_open_ai_audio_to_chatbot(password, audio_url):
     verify_password(password)
@@ -2287,15 +2406,37 @@ def process_open_ai_audio_to_chatbot(password, audio_url):
             if file_size > 2000000:
                 raise gr.Error("檔案大小超過，請不要超過 60秒")
             else:
-                response = OPEN_AI_CLIENT.audio.transcriptions.create(
+                transcription = OPEN_AI_CLIENT.audio.transcriptions.create(
                     model="whisper-1",
                     file=audio_file,
                     response_format="text"
                 )   
                 # response 拆解 dict
-                print("=== response ===")
-                print(response)
-                print("=== response ===")
+                print("=== transcription ===")
+                print(transcription)
+                print("=== transcription ===")
+                # 確認 response 是否有數學符號，prompt to LATEX $... $, ex: $x^2$
+                
+        if transcription:
+            system_message = """你是專業的 LATEX 轉換師，擅長將數學符號、公式轉換成 LATEX 格式，並用 LATEX 符號 $...$ 包裹，ex: $x^2$
+            範例：
+            transcription: x的平方加 2x 加 1 等於 0
+            轉成 LATEX 格式：$x^2 + 2x + 1 = 0$ 
+            """
+            user_message = f"""transcription: {transcription}
+            請將 transcription 內的數學、公式、運算式、化學式、物理 formula 內容轉換成 LATEX 格式
+            其他文字都保留原樣
+            也不要給出多餘的敘述            
+            """
+            request = OPEN_AI_CLIENT.chat.completions.create(
+                model="gpt-4-turbo",
+                messages=[
+                    {"role": "system", "content": system_message},
+                    {"role": "user", "content": user_message}
+                ],
+                max_tokens=4000,
+            )
+            response = request.choices[0].message.content.strip()
     else:
         response = ""
 
@@ -2350,7 +2491,7 @@ def poll_run_status(run_id, thread_id, timeout=600, poll_interval=5):
     
     return run.status
 
-def chat_with_opan_ai_assistant_streaming(user_message, chat_history, password, video_id, user_data, thread_id, trascript, key_moments, content_subject, content_grade):
+def chat_with_opan_ai_assistant_streaming(user_message, chat_history, password, video_id, user_data, thread_id, trascript, key_moments, content_subject, content_grade, socratic_mode=True):
     verify_password(password)
 
     print("=====user_data=====")
@@ -2365,13 +2506,14 @@ def chat_with_opan_ai_assistant_streaming(user_message, chat_history, password,
         raise gr.Error(error_msg)
     
     # 如果 chat_history 超過 10 則訊息，直接 return "對話超過上限"
-    if chat_history is not None and len(chat_history) > 11:
-        error_msg = "此次對話超過上限（對話一輪10次）"
+    if chat_history is not None and len(chat_history) > CHAT_LIMIT:
+        error_msg = f"此次對話超過上限（對話一輪{CHAT_LIMIT}次）"
         raise gr.Error(error_msg)
 
     try:
-        assistant_id = "asst_Mk151eZmKhNxzG7L9Awqz6iZ" #GPT 4 turbo
-        # assistant_id = "asst_sCA7F5opi2g7AvGnYeRfoSfT" #GPT 3.5 turbo
+        assistant_id = OPEN_AI_ASSISTANT_ID_GPT4 #GPT 4 turbo
+        # assistant_id = OPEN_AI_ASSISTANT_ID_GPT3 #GPT 3.5 turbo
+
         client = OPEN_AI_CLIENT
         # 直接安排逐字稿資料 in instructions
         # if isinstance(trascript, str):
@@ -2393,7 +2535,7 @@ def chat_with_opan_ai_assistant_streaming(user_message, chat_history, password,
             moment.pop('transcript', None)
         key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
 
-        instructions = get_instructions(content_subject, content_grade, key_moments_text)
+        instructions = get_instructions(content_subject, content_grade, key_moments_text, socratic_mode)
         # 创建线程
         if not thread_id:
             thread = client.beta.threads.create()
@@ -2447,25 +2589,31 @@ def create_thread_id():
 def chatbot_select(chatbot_name):
     chatbot_select_accordion_visible = gr.update(visible=False)
     all_chatbot_select_btn_visible = gr.update(visible=True)
-    chatbot_open_ai_visible = gr.update(visible=False)
     chatbot_open_ai_streaming_visible = gr.update(visible=False)
-    chatbot_jutor_visible = gr.update(visible=False)
+    chatbot_ai_visible = gr.update(visible=False)
     ai_name_update = gr.update(value="foxcat")
-
+    ai_chatbot_thread_id_update = gr.update(value="")
+    
     if chatbot_name == "chatbot_open_ai":
-        chatbot_open_ai_visible = gr.update(visible=True)
+        chatbot_ai_visible = gr.update(visible=True)
+        ai_chatbot_ai_type_update = gr.update(value="assistant")
     elif chatbot_name == "chatbot_open_ai_streaming":
         chatbot_open_ai_streaming_visible = gr.update(visible=True)
+        ai_chatbot_ai_type_update = gr.update(value="assistant_streaming")
     else:
-        chatbot_jutor_visible = gr.update(visible=True)
-        ai_name_update = gr.update(value=chatbot_name) 
+        chatbot_ai_visible = gr.update(visible=True)
+        ai_chatbot_ai_type_update = gr.update(value="chat_completions")
+    
+    ai_name_update = gr.update(value=chatbot_name) 
         
-    return chatbot_select_accordion_visible, all_chatbot_select_btn_visible, chatbot_open_ai_visible, chatbot_open_ai_streaming_visible, chatbot_jutor_visible, ai_name_update
+    return chatbot_select_accordion_visible, all_chatbot_select_btn_visible, \
+        chatbot_open_ai_streaming_visible, chatbot_ai_visible, \
+        ai_name_update, ai_chatbot_ai_type_update, ai_chatbot_thread_id_update
 
-def update_avatar_images(avatar_images, maimai_chatbot_description_value):
+def update_avatar_images(avatar_images, chatbot_description_value):
     value = [[
         "請問你是誰？",
-        maimai_chatbot_description_value
+        chatbot_description_value
     ]]
     ai_chatbot_update = gr.update(avatar_images=avatar_images, value=value)
     return ai_chatbot_update
@@ -2523,9 +2671,9 @@ def init_params(text, request: gr.Request):
         lesson_plan_accordion = gr.update(visible=True)
         exit_ticket_accordion = gr.update(visible=True)
 
-        chatbot_open_ai = gr.update(visible=False)
         chatbot_open_ai_streaming = gr.update(visible=False)
-        chatbot_jutor = gr.update(visible=False)
+        chatbot_ai = gr.update(visible=False)
+        ai_chatbot_params = gr.update(visible=True)
 
         # if youtube_link in query_params
         if "youtube_id" in request.query_params:
@@ -2544,11 +2692,12 @@ def init_params(text, request: gr.Request):
             worksheet_accordion = gr.update(visible=False)
             lesson_plan_accordion = gr.update(visible=False)
             exit_ticket_accordion = gr.update(visible=False)
+            ai_chatbot_params = gr.update(visible=False)
 
     return admin, reading_passage_admin, summary_admin, see_detail, \
         worksheet_accordion, lesson_plan_accordion, exit_ticket_accordion, \
         password_text, youtube_link, \
-        chatbot_open_ai, chatbot_open_ai_streaming, chatbot_jutor
+        chatbot_open_ai_streaming, chatbot_ai, ai_chatbot_params
 
 def update_state(content_subject, content_grade, trascript, key_moments, questions_answers):
     # inputs=[content_subject, content_grade, df_string_output],
@@ -2565,16 +2714,12 @@ def update_state(content_subject, content_grade, trascript, key_moments, questio
     question_1 = questions_answers_json[0]["question"]
     question_2 = questions_answers_json[1]["question"]
     question_3 = questions_answers_json[2]["question"]
-    btn_1 = question_1
-    btn_2 = question_2
-    btn_3 = question_3
     ai_chatbot_question_1 = question_1
     ai_chatbot_question_2 = question_2
     ai_chatbot_question_3 = question_3
 
     return content_subject_state, content_grade_state, trascript_state, key_moments_state, \
         streaming_chat_thread_id_state, \
-        btn_1, btn_2, btn_3, \
         ai_chatbot_question_1, ai_chatbot_question_2, ai_chatbot_question_3
 
 
@@ -2603,65 +2748,6 @@ HEAD = """
             });
         }
     </script>
-
-    <script>
-        function changeImage(direction, count, galleryIndex) {
-            // Find the current visible image by iterating over possible indices
-            var currentImage = null;
-            var currentIndex = -1;
-            for (var i = 0; i < count; i++) {
-                var img = document.querySelector('.slide-image-' + galleryIndex + '-' + i);
-                if (img && img.style.display !== 'none') {
-                    currentImage = img;
-                    currentIndex = i;
-                    break;
-                }
-            }
-
-            // If no current image is visible, show the first one and return
-            if (currentImage === null) {
-                document.querySelector('.slide-image-' + galleryIndex + '-0').style.display = 'block';
-                console.error('No current image found for galleryIndex ' + galleryIndex + ', defaulting to first image.');
-                return;
-            }
-
-            // Hide the current image
-            currentImage.style.display = 'none';
-
-            // Calculate the index of the next image to show
-            var newIndex = (currentIndex + direction + count) % count;
-
-            // Select the next image and show it
-            var nextImage = document.querySelector('.slide-image-' + galleryIndex + '-' + newIndex);
-            if (nextImage) {
-                nextImage.style.display = 'block';
-            } else {
-                console.error('No image found for galleryIndex ' + galleryIndex + ' and newIndex ' + newIndex);
-            }
-        }
-    </script>
-
-    <script>
-        var selectButtons = document.querySelectorAll('.chatbot_select_btn');
-
-        // 为每个按钮添加点击事件监听器
-        selectButtons.forEach(function(button) {
-            button.addEventListener('click', function() {
-                // 获取 #chatbot_select_accordion 下的第一个 button 元素
-                var firstButton = document.querySelector('#chatbot_select_accordion button');
-                var displayDiv = document.querySelector('#chatbot_select_accordion div:nth-child(3)');
-                // 检查这个按钮是否存在
-                if (firstButton) {
-                    // 移除 'open' 类
-                    firstButton.classList.remove('open');
-                }
-                if (displayDiv) {
-                    // display none
-                    displayDiv.style.display = 'none';
-                }
-            });
-        });
-    </script>
 """
 
 with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, secondary_hue=gr.themes.colors.amber, text_size = gr.themes.sizes.text_lg), head=HEAD) as demo:
@@ -2682,13 +2768,31 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
     with gr.Tab("AI小精靈"):
         with gr.Row():
             all_chatbot_select_btn = gr.Button("選擇 AI 小精靈 👈", elem_id="all_chatbot_select_btn", visible=False, variant="secondary", size="sm")
+        with gr.Row() as ai_chatbot_params:
+            ai_name = gr.Dropdown(
+                label="選擇 AI 助理", 
+                choices=[
+                    ("飛特精靈","chatbot_open_ai"), 
+                    ("飛特音速","chatbot_open_ai_streaming"), 
+                    ("梨梨","lili"), 
+                    ("麥麥","maimai"), 
+                    ("狐狸貓","foxcat")
+                ], 
+                value="foxcat",
+                visible=True
+            )
+            ai_chatbot_ai_type = gr.Textbox(value="chat_completions", visible=True)
+            ai_chatbot_thread_id = gr.Textbox(label="thread_id", visible=True)
+            ai_chatbot_socratic_mode_btn = gr.Checkbox(label="蘇格拉底家教助理模式", value=True, visible=True)
+            latex_delimiters = [{"left": "$", "right": "$", "display": False}]
         with gr.Accordion("選擇 AI 小精靈", elem_id="chatbot_select_accordion") as chatbot_select_accordion:
             with gr.Row():
                 user_avatar = "https://em-content.zobj.net/source/google/263/flushed-face_1f633.png"
-                ai_chatbot_bot_avatar = "https://junyitopicimg.s3.amazonaws.com/s4byy--icon.jpe?v=20200513013523726"
-                with gr.Column(scale=1, variant="panel", visible=False):
-                    chatbot_avatar_url = "https://junyitopicimg.s3.amazonaws.com/s4byy--icon.jpe?v=20200513013523726"
-                    chatbot_description = """Hi，我是你的AI學伴【飛特精靈】，\n
+                # 飛特精靈
+                with gr.Column(scale=1, variant="panel", visible=True):
+                    vaitor_chatbot_avatar_url = "https://junyitopicimg.s3.amazonaws.com/s4byy--icon.jpe?v=20200513013523726"
+                    vaitor_chatbot_avatar_images = gr.State([user_avatar, vaitor_chatbot_avatar_url])
+                    vaitor_chatbot_description = """Hi，我是你的AI學伴【飛特精靈】，\n
                     我可以陪你一起學習本次的內容，有什麼問題都可以問我喔！\n
                     🤔 如果你不知道怎麼發問，可以點擊左下方的問題一、問題二、問題三，我會幫你生成問題！\n
                     🗣️ 也可以點擊右下方用語音輸入，我會幫你轉換成文字，厲害吧！\n
@@ -2697,21 +2801,10 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     🦄 如果達到上限，或是遇到精靈很累，請問問其他朋友，像是飛特音速說話的速度比較快，你是否跟得上呢？你也可以和其他精靈互動看看喔！\n
                     """
                     chatbot_open_ai_name = gr.State("chatbot_open_ai")
-                    gr.Image(value=chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
-                    chatbot_open_ai_select_btn = gr.Button("👆選擇【飛特精靈】", elem_id="chatbot_btn", visible=True, variant="primary")
-                    gr.Markdown(value=chatbot_description, visible=True)
-                with gr.Column(scale=1, variant="panel", visible=False):
-                    streaming_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/11/1-%E6%98%9F%E7%A9%BA%E9%A0%AD%E8%B2%BC-%E5%A4%AA%E7%A9%BA%E7%8B%90%E7%8B%B8%E8%B2%93-150x150.png"
-                    streaming_chatbot_description = """Hi，我是【飛特音速】， \n
-                    說話比較快，但有什麼問題都可以問我喔！ \n
-                    🚀 我沒有預設問題、也沒有語音輸入，適合快問快答，一起練習問出好問題吧 \n
-                    🔠 擅長用文字表達的你，可以用鍵盤輸入你的問題，我會盡力回答你的問題喔\n
-                    💤 我還在成長，體力有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔～
-                    """
-                    chatbot_open_ai_streaming_name = gr.State("chatbot_open_ai_streaming")
-                    gr.Image(value=streaming_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
-                    chatbot_open_ai_streaming_select_btn = gr.Button("👆選擇【飛特音速】", elem_id="streaming_chatbot_btn", visible=True, variant="primary")
-                    gr.Markdown(value=streaming_chatbot_description, visible=True)
+                    gr.Image(value=vaitor_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
+                    vaitor_chatbot_select_btn = gr.Button("👆選擇【飛特精靈】", elem_id="chatbot_btn", visible=True, variant="primary")
+                    vaitor_chatbot_description_value = gr.Markdown(value=vaitor_chatbot_description, visible=True)
+                # 狐狸貓
                 with gr.Column(scale=1, variant="panel"):
                     foxcat_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/06/%E7%A7%91%E5%AD%B8%E5%BE%BD%E7%AB%A0-2-150x150.png"
                     foxcat_avatar_images = gr.State([user_avatar, foxcat_chatbot_avatar_url])
@@ -2756,37 +2849,23 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     gr.Image(value=maimai_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
                     maimai_chatbot_select_btn = gr.Button("👆選擇【麥麥】", visible=True, variant="primary", elem_classes="chatbot_select_btn")
                     maimai_chatbot_description_value = gr.Markdown(value=maimai_chatbot_description, visible=True)
-                    
-        with gr.Row("飛特精靈") as chatbot_open_ai:
-            with gr.Column():
-                bot_avatar = "https://junyitopicimg.s3.amazonaws.com/s4byy--icon.jpe?v=20200513013523726"
-                latex_delimiters = [{"left": "$", "right": "$", "display": False}]
-                chatbot_greeting = [[
-                    "請問你是誰？",
-                    """Hi，我是你的AI學伴【飛特精靈】，我可以陪你一起學習本次的內容，有什麼問題都可以問我喔！
-                    🤔 如果你不知道怎麼發問，可以點擊左下方的問題一、問題二、問題三，我會幫你生成問題！
-                    🗣️ 也可以點擊右下方用語音輸入，我會幫你轉換成文字，厲害吧！
-                    🔠 或是直接鍵盤輸入你的問題，我會盡力回答你的問題喔！
-                    💤 但我還在成長，體力有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
-                    🦄 如果達到上限，或是遇到精靈很累，請問問其他朋友，像是飛特音速說話的速度比較快，你是否跟得上呢？你也可以和其他精靈互動看看喔！
-                    """,
-                ]]
-                with gr.Row():
-                    chatbot = gr.Chatbot(avatar_images=[user_avatar, bot_avatar], label="OPEN AI", show_share_button=False, likeable=True, show_label=False, latex_delimiters=latex_delimiters,value=chatbot_greeting)
-                with gr.Row():
-                    thread_id = gr.Textbox(label="thread_id", visible=False)
-                    socratic_mode_btn = gr.Checkbox(label="蘇格拉底家教助理模式", value=True, visible=False)
-                with gr.Row():
-                    with gr.Accordion("你也有類似的問題想問嗎？", open=False) as ask_questions_accordion:
-                        btn_1 = gr.Button("問題一")
-                        btn_2 = gr.Button("問題一")
-                        btn_3 = gr.Button("問題一")
-                        gr.Markdown("### 重新生成問題")
-                        btn_create_question = gr.Button("生成其他問題", variant="primary")
-                    openai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath", max_length=60, label="語音輸入")
-                with gr.Row():
-                    msg = gr.Textbox(label="訊息",scale=3)
-                    send_button = gr.Button("送出", variant="primary", scale=1)
+                # 飛特音速
+                with gr.Column(scale=1, variant="panel", visible=True):
+                    streaming_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/11/1-%E6%98%9F%E7%A9%BA%E9%A0%AD%E8%B2%BC-%E5%A4%AA%E7%A9%BA%E7%8B%90%E7%8B%B8%E8%B2%93-150x150.png"
+                    streaming_chatbot_description = """Hi，我是【飛特音速】， \n
+                    說話比較快，但有什麼問題都可以問我喔！ \n
+                    🚀 我沒有預設問題、也沒有語音輸入，適合快問快答，一起練習問出好問題吧 \n
+                    🔠 擅長用文字表達的你，可以用鍵盤輸入你的問題，我會盡力回答你的問題喔\n
+                    💤 我還在成長，體力有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔～
+                    """
+                    chatbot_open_ai_streaming_name = gr.State("chatbot_open_ai_streaming")
+                    gr.Image(value=streaming_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
+                    chatbot_open_ai_streaming_select_btn = gr.Button("👆選擇【飛特音速】", elem_id="streaming_chatbot_btn", visible=True, variant="primary")
+                    gr.Markdown(value=streaming_chatbot_description, visible=True)
+                # 尚未開放
+                with gr.Column(scale=1, variant="panel"): 
+                    gr.Markdown(value="### 尚未開放", visible=True)
+
         with gr.Row("飛特音速") as chatbot_open_ai_streaming:
             with gr.Column():
                 streaming_chat_greeting = """
@@ -2795,7 +2874,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     🔠 鍵盤輸入你的問題，我會盡力回答你的問題喔！\n
                     💤 我還在成長，體力有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
                     """
-                additional_inputs = [password, video_id, user_data, streaming_chat_thread_id_state, trascript_state, key_moments_state, content_subject_state, content_grade_state]
+                additional_inputs = [password, video_id, user_data, streaming_chat_thread_id_state, trascript_state, key_moments_state, content_subject_state, content_grade_state, ai_chatbot_socratic_mode_btn]
                 streaming_chat = gr.ChatInterface(
                     fn=chat_with_opan_ai_assistant_streaming,
                     additional_inputs=additional_inputs,
@@ -2806,7 +2885,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     stop_btn=None,
                     description=streaming_chat_greeting
                 )
-        with gr.Row("其他精靈") as chatbot_jutor:   
+        with gr.Row("一般精靈") as chatbot_ai:   
             with gr.Column():
                 ai_chatbot_greeting = [[
                     "請問你是誰？",
@@ -2817,27 +2896,19 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     💤 精靈們體力都有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
                     """,
                 ]]
-                ai_name = gr.Dropdown(
-                    label="選擇 AI 助理", 
-                    choices=[
-                        ("梨梨","lili"), 
-                        ("麥麥","maimai"), 
-                        ("狐狸貓","foxcat")
-                    ], 
-                    value="foxcat",
-                    visible=False
-                )
-                ai_chatbot = gr.Chatbot(label="ai_chatbot", show_share_button=False, likeable=True, show_label=False, latex_delimiters=latex_delimiters, value=ai_chatbot_greeting)
-                ai_chatbot_socratic_mode_btn = gr.Checkbox(label="蘇格拉底家教助理模式", value=True, visible=False)
                 with gr.Row():
-                    with gr.Accordion("你也有類似的問題想問嗎？", open=False) as ask_questions_accordion_2:
+                    ai_chatbot = gr.Chatbot(label="ai_chatbot", show_share_button=False, likeable=True, show_label=False, latex_delimiters=latex_delimiters, value=ai_chatbot_greeting)                    
+                with gr.Row():
+                    with gr.Accordion("你也有類似的問題想問嗎？ 請按下 ◀︎", open=False) as ask_questions_accordion_2:
                         ai_chatbot_question_1 = gr.Button("問題一")
                         ai_chatbot_question_2 = gr.Button("問題一")
                         ai_chatbot_question_3 = gr.Button("問題一")
+                        create_questions_btn = gr.Button("生成問題", variant="primary")
                     ai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath", max_length=60, label="語音輸入")
                 with gr.Row():
                     ai_msg = gr.Textbox(label="訊息輸入",scale=3)
-                    ai_send_button = gr.Button("送出", variant="primary",scale=1)              
+                    ai_send_button = gr.Button("送出", variant="primary",scale=1)
+                    ai_send_feedback_btn = gr.Button("提問力回饋", variant="primary", scale=1, visible=False)          
     with gr.Tab("文章模式"):
         with gr.Row():
             reading_passage = gr.Markdown(show_label=False, latex_delimiters = [{"left": "$", "right": "$", "display": False}])
@@ -3021,15 +3092,74 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         with gr.Tab("心智圖",elem_id="mind_map_tab"):
             mind_map_html = gr.HTML()
        
-    # --- Event ---
-    chatbot_select_outputs=[chatbot_select_accordion, all_chatbot_select_btn, chatbot_open_ai, chatbot_open_ai_streaming, chatbot_jutor, ai_name]
-
     # OPEN AI CHATBOT SELECT
-    chatbot_open_ai_select_btn.click(
-        chatbot_select,
-        inputs=[chatbot_open_ai_name],
-        outputs=chatbot_select_outputs
-    )
+    chatbot_select_outputs=[
+        chatbot_select_accordion, 
+        all_chatbot_select_btn, 
+        chatbot_open_ai_streaming, 
+        chatbot_ai, 
+        ai_name,
+        ai_chatbot_ai_type,
+        ai_chatbot_thread_id
+    ]
+    # 聊天机器人的配置数据
+    chatbots = [
+        {
+            "button": vaitor_chatbot_select_btn,
+            "name_state": chatbot_open_ai_name,
+            "avatar_images": vaitor_chatbot_avatar_images,
+            "description_value": vaitor_chatbot_description_value,
+            "chatbot_select_outputs": chatbot_select_outputs,
+            "chatbot_output": ai_chatbot
+        },
+        {
+            "button": foxcat_chatbot_select_btn,
+            "name_state": foxcat_chatbot_name,
+            "avatar_images": foxcat_avatar_images,
+            "description_value": foxcat_chatbot_description_value,
+            "chatbot_select_outputs": chatbot_select_outputs,
+            "chatbot_output": ai_chatbot
+        },
+        {
+            "button": lili_chatbot_select_btn,
+            "name_state": lili_chatbot_name,
+            "avatar_images": lili_avatar_images,
+            "description_value": lili_chatbot_description_value,
+            "chatbot_select_outputs": chatbot_select_outputs,
+            "chatbot_output": ai_chatbot
+        },
+        {
+            "button": maimai_chatbot_select_btn,
+            "name_state": maimai_chatbot_name,
+            "avatar_images": maimai_avatar_images,
+            "description_value": maimai_chatbot_description_value,
+            "chatbot_select_outputs": chatbot_select_outputs,
+            "chatbot_output": ai_chatbot
+        }
+    ]
+
+    def setup_chatbot_select_button(chatbot_dict):
+        button = chatbot_dict["button"]
+        chatbot_name_state = chatbot_dict["name_state"]
+        avatar_images = chatbot_dict["avatar_images"]
+        description_value = chatbot_dict["description_value"]
+        chatbot_select_outputs = chatbot_dict["chatbot_select_outputs"]
+        chatbot_output = chatbot_dict["chatbot_output"]
+        button.click(
+            chatbot_select,  # 你可能需要修改这个函数以适应当前的逻辑
+            inputs=[chatbot_name_state],
+            outputs=chatbot_select_outputs
+        ).then(
+            update_avatar_images,
+            inputs=[avatar_images, description_value],
+            outputs=[chatbot_output],
+            scroll_to_output=True
+        )
+
+    for chatbot_dict in chatbots:
+        setup_chatbot_select_button(chatbot_dict)
+
+    # STREAMING CHATBOT SELECT
     chatbot_open_ai_streaming_select_btn.click(
         chatbot_select,
         inputs=[chatbot_open_ai_streaming_name],
@@ -3039,55 +3169,13 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         inputs=[],
         outputs=[streaming_chat_thread_id_state]
     )
-    foxcat_chatbot_select_btn.click(
-        chatbot_select,
-        inputs=[foxcat_chatbot_name],
-        outputs=chatbot_select_outputs
-    ).then(
-        update_avatar_images,
-        inputs=[foxcat_avatar_images, foxcat_chatbot_description_value],
-        outputs=[ai_chatbot],
-        scroll_to_output=True
-    )
-    lili_chatbot_select_btn.click(
-        chatbot_select,
-        inputs=[lili_chatbot_name],
-        outputs=chatbot_select_outputs
-    ).then(
-        update_avatar_images,
-        inputs=[lili_avatar_images, lili_chatbot_description_value],
-        outputs=[ai_chatbot],
-        scroll_to_output=True
-    )
-    maimai_chatbot_select_btn.click(
-        chatbot_select,
-        inputs=[maimai_chatbot_name],
-        outputs=chatbot_select_outputs
-    ).then(
-        update_avatar_images,
-        inputs=[maimai_avatar_images, maimai_chatbot_description_value],
-        outputs=[ai_chatbot],
-        scroll_to_output=True
-    )
+
     # ALL CHATBOT SELECT LIST
     all_chatbot_select_btn.click(
         show_all_chatbot_accordion,
         inputs=[],
         outputs=[chatbot_select_accordion, all_chatbot_select_btn]
     )
-
-    # OPENAI ASSISTANT CHATBOT 模式
-    send_button.click(
-        chat_with_opan_ai_assistant,
-        inputs=[password, video_id, user_data, thread_id, trascript_state, key_moments, msg, chatbot, content_subject, content_grade, questions_answers_json, socratic_mode_btn],
-        outputs=[msg, chatbot, thread_id],
-        scroll_to_output=True
-    )
-    openai_chatbot_audio_input.change(
-        process_open_ai_audio_to_chatbot,
-        inputs=[password, openai_chatbot_audio_input],
-        outputs=[msg]
-    )
     # OPENAI ASSISTANT CHATBOT 連接按鈕點擊事件
     def setup_question_button_click(button, inputs_list, outputs_list, chat_func, scroll_to_output=True):
         button.click(
@@ -3096,35 +3184,43 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         outputs=outputs_list,
         scroll_to_output=scroll_to_output
     )
-    question_buttons = [btn_1, btn_2, btn_3]
-    for question_btn in question_buttons:
-        inputs_list = [password, video_id, user_data, thread_id, trascript_state, key_moments, question_btn, chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn]
-        outputs_list = [msg, chatbot, thread_id]
-        setup_question_button_click(question_btn, inputs_list, outputs_list, chat_with_opan_ai_assistant)
+
+    # 其他精靈 ai_chatbot 模式
+    ai_send_button.click(
+        chat_with_any_ai,
+        inputs=[ai_chatbot_ai_type, password, video_id, user_data, trascript_state, key_moments, ai_msg, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn, ai_chatbot_thread_id, ai_name],
+        outputs=[ai_msg, ai_chatbot, ai_send_button, ai_send_feedback_btn, ai_chatbot_thread_id],
+        scroll_to_output=True
+    )
+    ai_send_feedback_btn.click(
+        feedback_with_ai,
+        inputs=[ai_chatbot_ai_type, ai_chatbot, ai_chatbot_thread_id],
+        outputs=[ai_chatbot, ai_send_feedback_btn],
+        scroll_to_output=True
+    )
+    # 其他精靈 ai_chatbot 连接 QA 按钮点击事件
+    ai_chatbot_question_buttons = [ai_chatbot_question_1, ai_chatbot_question_2, ai_chatbot_question_3]
+    for question_btn in ai_chatbot_question_buttons:
+        inputs_list = [ai_chatbot_ai_type, password, video_id, user_data, trascript_state, key_moments, question_btn, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn, ai_chatbot_thread_id, ai_name]
+        outputs_list = [ai_msg, ai_chatbot, ai_send_button, ai_send_feedback_btn, ai_chatbot_thread_id]
+        setup_question_button_click(question_btn, inputs_list, outputs_list, chat_with_any_ai)
 
     # 為生成問題按鈕設定特殊的點擊事件
-    btn_create_question.click(
+    question_buttons = [
+        ai_chatbot_question_1,
+        ai_chatbot_question_2,
+        ai_chatbot_question_3
+    ]
+    create_questions_btn.click(
         change_questions, 
         inputs=[password, df_string_output], 
         outputs=question_buttons
     )
-
-    # 其他精靈 ai_chatbot 模式
-    ai_send_button.click(
-        chat_with_ai,
-        inputs=[ai_name, password, video_id, user_data, trascript_state, key_moments, ai_msg, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn],
-        outputs=[ai_msg, ai_chatbot],
-        scroll_to_output=True
+    ai_chatbot_audio_input.change(
+        process_open_ai_audio_to_chatbot,
+        inputs=[password, ai_chatbot_audio_input],
+        outputs=[ai_msg]
     )
-    # 其他精靈 ai_chatbot 连接按钮点击事件
-    ai_chatbot_buttons = [ai_chatbot_question_1, ai_chatbot_question_2, ai_chatbot_question_3]
-    for ai_question_btn in ai_chatbot_buttons:
-        inputs_list = [ai_name, password, video_id, user_data, trascript_state, key_moments, ai_question_btn, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn]
-        outputs_list = [ai_msg, ai_chatbot]
-        setup_question_button_click(ai_question_btn, inputs_list, outputs_list, chat_with_ai)
-
-    # file_upload.change(process_file, inputs=file_upload, outputs=df_string_output)
-    # file_upload.change(process_file, inputs=file_upload, outputs=[btn_1, btn_2, btn_3, df_summarise, df_string_output])
 
     # 当输入 YouTube 链接时触发
     process_youtube_link_inputs = [password, youtube_link]
@@ -3160,9 +3256,6 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         trascript_state,
         key_moments_state,
         streaming_chat_thread_id_state,
-        btn_1, 
-        btn_2, 
-        btn_3,
         ai_chatbot_question_1,
         ai_chatbot_question_2,
         ai_chatbot_question_3
@@ -3494,9 +3587,9 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         exit_ticket_accordion,
         password, 
         youtube_link,
-        chatbot_open_ai,
         chatbot_open_ai_streaming,
-        chatbot_jutor
+        chatbot_ai,
+        ai_chatbot_params,
     ]
     demo.load(
         init_params, 

chatbot.py

@@ -10,7 +10,7 @@ class Chatbot:
         self.jutor_chat_key = config.get('jutor_chat_key')
         self.transcript_text = self.get_transcript_text(config.get('transcript'))
         self.key_moments_text = self.get_key_moments_text(config.get('key_moments'))
-        self.ai_name = config.get('ai_name')
+        self.ai_model_name = config.get('ai_model_name')
         self.ai_client = config.get('ai_client')
         self.instructions = config.get('instructions')
 
@@ -39,15 +39,17 @@ class Chatbot:
         return key_moments_text
 
 
-    def chat(self, user_message, chat_history, socratic_mode=False, service_type='openai'):
-        messages = self.prepare_messages(chat_history, user_message)
-        system_prompt = self.instructions
-        service_type_list = ['openai', 'claude3', 'groq_llama3', 'groq_mixtral']
-        if service_type in service_type_list:
+    def chat(self, user_message, chat_history):
+        try:
+            messages = self.prepare_messages(chat_history, user_message)
+            system_prompt = self.instructions
+            service_type = self.ai_model_name
             response_text = self.chat_with_service(service_type, system_prompt, messages)
-            return response_text
-        else:
-            raise gr.Error("不支持此服務")
+        except Exception as e:
+            print(f"Error: {e}")
+            response_text = "學習精靈有點累，請稍後再試！"
+
+        return response_text
 
     def prepare_messages(self, chat_history, user_message):
         messages = []
@@ -62,7 +64,7 @@ class Chatbot:
                     messages.append({"role": "assistant", "content": assistant_msg})
                 
         if user_message:
-            user_message += "/n (請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，不用提到「逐字稿」這個詞，用「內容」代替)，回答時如果有用到數學式，請用數學符號代替純文字（Latex 用 $ 字號 render)"
+            user_message += "/n (請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，不要提到「台灣腔」，不用提到「逐字稿」這個詞，用「內容」代替)，回答時如果有用到數學式，請用數學符號代替純文字（Latex 用 $ 字號 render)"
             messages.append({"role": "user", "content": user_message})
         return messages
 

local_config_example.json

@@ -1,12 +1,21 @@
 {
-    "OUTPUT_PATH": "/Users/young/Downloads",
-    "TRANSCRIPTS": [],
-    "CURRENT_INDEX": 0,
-    "VIDEO_ID": "",
-    "PASSWORD": "1234",
-    "OPEN_AI_KEY": "sk-",
-    "GROQ_API_KEY": "",
-    "JUTOR_CHAT_KEY": "",
-    "GOOGLE_APPLICATION_CREDENTIALS_JSON": {
-      }
-}
+  "OUTPUT_PATH": "/Users/young/Downloads",
+  "TRANSCRIPTS": [],
+  "CURRENT_INDEX": 0,
+  "VIDEO_ID": "",
+  "PASSWORD": "6161",
+  "OPEN_AI_KEY": "sk-proj-xxxxxxxxxx",
+  "OPEN_AI_ASSISTANT_ID_GPT4_BOT1": "asst_3cxxxxxxxxxxjrQio9",
+  "OPEN_AI_ASSISTANT_ID_GPT3_BOT1": "asst_mcuxxxxxxxxxx5L4e",
+  "OPEN_AI_KEY_BOT2": "sk-proj-5HsYxxxxxxxxxxkH4pShu",
+  "OPEN_AI_ASSISTANT_ID_GPT4_BOT2": "asst_3xxxxxxxxxxrQio9",
+  "OPEN_AI_ASSISTANT_ID_GPT3_BOT2": "asst_mxxxxxxxxxx6vg5L4e",
+  "GROQ_API_KEY": "gsk_wcTFnH0eKexxxxxxxxxx4JrXz8IGLUXqrYji",
+  "JUTOR_CHAT_KEY": "b4c318bxxxxxxxxxx76b41fd27",
+  "GOOGLE_APPLICATION_CREDENTIALS_JSON": {
+      "xxxxxxxxxx": "xxxxxxxxx",
+  },
+  "AWS_ACCESS_KEY": "xxxxxxxxxx",
+  "AWS_SECRET_KEY": "xxxxxxxxxx",
+  "AWS_REGION_NAME": "us-west-2"
+}