update

app.py

@@ -92,96 +92,6 @@ def verify_password(password):
     else:
         raise gr.Error("密碼錯誤")
 
-# ====gcs====
-def gcs_check_file_exists(gcs_client, bucket_name, file_name):
-    """
-    检查 GCS 存储桶中是否存在指定的文件
-    file_name 格式：{folder_name}/{file_name}
-    """
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(file_name)
-    return blob.exists()
-
-def upload_file_to_gcs(gcs_client, bucket_name, destination_blob_name, file_path):
-    """上传文件到指定的 GCS 存储桶"""
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(destination_blob_name)
-    blob.upload_from_filename(file_path)
-    print(f"File {file_path} uploaded to {destination_blob_name} in GCS.")
-
-def upload_file_to_gcs_with_json_string(gcs_client, bucket_name, destination_blob_name, json_string):
-    """上传字符串到指定的 GCS 存储桶"""
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(destination_blob_name)
-    blob.upload_from_string(json_string)
-    print(f"JSON string uploaded to {destination_blob_name} in GCS.")
-
-def download_blob_to_string(gcs_client, bucket_name, source_blob_name):
-    """从 GCS 下载文件内容到字符串"""
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(source_blob_name)
-    return blob.download_as_text()
-
-def make_blob_public(gcs_client, bucket_name, blob_name):
-    """将指定的 GCS 对象设置为公共可读"""
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(blob_name)
-    blob.make_public()
-    print(f"Blob {blob_name} is now publicly accessible at {blob.public_url}")
-
-def get_blob_public_url(gcs_client, bucket_name, blob_name):
-    """获取指定 GCS 对象的公开 URL"""
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(blob_name)
-    return blob.public_url
-
-def upload_img_and_get_public_url(gcs_client, bucket_name, file_name, file_path):
-    """上传图片到 GCS 并获取其公开 URL"""
-    # 上传图片
-    upload_file_to_gcs(gcs_client, bucket_name, file_name, file_path)
-    # 将上传的图片设置为公开
-    make_blob_public(gcs_client, bucket_name, file_name)
-    # 获取图片的公开 URL
-    public_url = get_blob_public_url(gcs_client, bucket_name, file_name)
-    print(f"Public URL for the uploaded image: {public_url}")
-    return public_url
-
-def copy_all_files_from_drive_to_gcs(drive_service, gcs_client, drive_folder_id, bucket_name, gcs_folder_name):
-    # Get all files from the folder
-    query = f"'{drive_folder_id}' in parents and trashed = false"
-    response = drive_service.files().list(q=query).execute()
-    files = response.get('files', [])
-    for file in files:
-        # Copy each file to GCS
-        file_id = file['id']
-        file_name = file['name']
-        gcs_destination_path = f"{gcs_folder_name}/{file_name}"
-        copy_file_from_drive_to_gcs(drive_service, gcs_client, file_id, bucket_name, gcs_destination_path)
-
-def copy_file_from_drive_to_gcs(drive_service, gcs_client, file_id, bucket_name, gcs_destination_path):
-    # Download file content from Drive
-    request = drive_service.files().get_media(fileId=file_id)
-    fh = io.BytesIO()
-    downloader = MediaIoBaseDownload(fh, request)
-    done = False
-    while not done:
-        status, done = downloader.next_chunk()
-    fh.seek(0)
-    file_content = fh.getvalue()
-
-    # Upload file content to GCS
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(gcs_destination_path)
-    blob.upload_from_string(file_content)
-    print(f"File {file_id} copied to GCS at {gcs_destination_path}.")
-
-def delete_blob(gcs_client, bucket_name, blob_name):
-    """删除指定的 GCS 对象"""
-    bucket = gcs_client.bucket(bucket_name)
-    blob = bucket.blob(blob_name)
-    blob.delete()
-    print(f"Blob {blob_name} deleted from GCS.")
-
 # # ====drive====初始化
 def init_drive_service():
     credentials_json_string = DRIVE_KEY
@@ -381,7 +291,11 @@ def extract_youtube_id(url):
         return None
 
 def get_transcript_by_yt_api(video_id):
-    languages = ['zh-TW', 'zh-Hant', 'zh', 'en-US']  # 優先順序列表
+    transcript_list = YouTubeTranscriptApi.list_transcripts(video_id)
+    languages = []
+    for t in transcript_list:
+        languages.append(t.language_code)
+    
     for language in languages:
         try:
             transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=[language])
@@ -483,12 +397,13 @@ def process_transcript_and_screenshots_on_gcs(video_id):
             transcript = generate_transcription_by_whisper(video_id)
 
         transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, transcript_blob_name, transcript_text)
+        GCS_SERVICE.upload_json_string(bucket_name, transcript_blob_name, transcript_text)
+
         is_new_transcript = True
     else:
         # 逐字稿已存在，下载逐字稿内容
         print("逐字稿已存在于GCS中")
-        transcript_text = download_blob_to_string(gcs_client, bucket_name, transcript_blob_name)
+        transcript_text = GCS_SERVICE.download_as_string(bucket_name, transcript_blob_name)
         transcript = json.loads(transcript_text)
 
     # print("===確認其他衍生文件===")
@@ -517,7 +432,7 @@ def process_transcript_and_screenshots_on_gcs(video_id):
             # 截图                    
             screenshot_path = screenshot_youtube_video(video_id, entry['start'])
             screenshot_blob_name = f"{video_id}/{video_id}_{entry['start']}.jpg"
-            img_file_id = upload_img_and_get_public_url(gcs_client, bucket_name, screenshot_blob_name, screenshot_path)
+            img_file_id = GCS_SERVICE.upload_image_and_get_public_url(bucket_name, screenshot_blob_name, screenshot_path)
             entry['img_file_id'] = img_file_id
             print(f"截图已上传到GCS: {img_file_id}")
             is_new_transcript = True
@@ -529,7 +444,7 @@ def process_transcript_and_screenshots_on_gcs(video_id):
         print(transcript)
         print("===更新逐字稿文件===")
         updated_transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, transcript_blob_name, updated_transcript_text)
+        GCS_SERVICE.upload_json_string(bucket_name, transcript_blob_name, updated_transcript_text)
         print("逐字稿已更新，包括截图链接")
         updated_transcript_json = json.loads(updated_transcript_text)
     else:
@@ -723,12 +638,12 @@ def get_reading_passage(video_id, df_string, source):
             reading_passage = generate_reading_passage(df_string)
             reading_passage_json = {"reading_passage": str(reading_passage)}
             reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
-            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, reading_passage_text)
+            GCS_SERVICE.upload_json_string(bucket_name, blob_name, reading_passage_text)
             print("reading_passage已上传到GCS")
         else:
             # reading_passage已存在，下载内容
             print("reading_passage已存在于GCS中")
-            reading_passage_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+            reading_passage_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
             reading_passage_json = json.loads(reading_passage_text)
 
     elif source == "drive":
@@ -767,19 +682,44 @@ def generate_reading_passage(df_string):
         敘述中，請把數學或是專業術語，用 Latex 包覆（$...$），並且不要去改原本的文章
         加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號
     """
-    messages = [
-        {"role": "system", "content": sys_content},
-        {"role": "user", "content": user_content}
-    ]
 
-    request_payload = {
-        "model": "gpt-4-turbo",
-        "messages": messages,
-        "max_tokens": 4000,
-    }
+    try:
+        # 使用 OPEN AI 生成 Reading Passage
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
 
-    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-    reading_passage = response.choices[0].message.content.strip()
+        request_payload = {
+            "model": "gpt-4-turbo",
+            "messages": messages,
+            "max_tokens": 4000,
+        }
+
+        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+        reading_passage = response.choices[0].message.content.strip()
+    except:
+        # 使用 REDROCK 生成 Reading Passage
+        messages = [
+            {"role": "user", "content": user_content}
+        ]
+        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": 4000,
+                "system": sys_content,
+                "messages": messages
+            })
+        }
+        response = BEDROCK_CLIENT.invoke_model(**kwargs)
+        response_body = json.loads(response.get('body').read())
+        reading_passage = response_body.get('content')[0].get('text')
+    
     print("=====reading_passage=====")
     print(reading_passage)
     print("=====reading_passage=====")
@@ -805,12 +745,12 @@ def get_mind_map(video_id, df_string, source):
             mind_map = generate_mind_map(df_string)
             mind_map_json = {"mind_map": str(mind_map)}
             mind_map_text = json.dumps(mind_map_json, ensure_ascii=False, indent=2)
-            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, mind_map_text)
+            GCS_SERVICE.upload_json_string(bucket_name, blob_name, mind_map_text)
             print("mind_map已上傳到GCS")
         else:
             # mindmap已存在，下载内容
             print("mind_map已存在于GCS中")
-            mind_map_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+            mind_map_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
             mind_map_json = json.loads(mind_map_text)
 
     elif source == "drive":
@@ -844,19 +784,43 @@ def generate_mind_map(df_string):
         注意：不需要前後文敘述，直接給出 markdown 文本即可
         這對我很重要
     """
-    messages = [
-        {"role": "system", "content": sys_content},
-        {"role": "user", "content": user_content}
-    ]
 
-    request_payload = {
-        "model": "gpt-4-turbo",
-        "messages": messages,
-        "max_tokens": 4000,
-    }
+    try:
+        # 使用 OPEN AI 生成
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
 
-    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-    mind_map = response.choices[0].message.content.strip()
+        request_payload = {
+            "model": "gpt-4-turbo",
+            "messages": messages,
+            "max_tokens": 4000,
+        }
+
+        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+        mind_map = response.choices[0].message.content.strip()
+    except:
+        # 使用 REDROCK 生成
+        messages = [
+            {"role": "user", "content": user_content}
+        ]
+        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": 4000,
+                "system": sys_content,
+                "messages": messages
+            })
+        }
+        response = BEDROCK_CLIENT.invoke_model(**kwargs)
+        response_body = json.loads(response.get('body').read())
+        mind_map = response_body.get('content')[0].get('text')
     print("=====mind_map=====")
     print(mind_map)
     print("=====mind_map=====")
@@ -889,12 +853,12 @@ def get_video_id_summary(video_id, df_string, source):
             summary = generate_summarise(df_string, meta_data)
             summary_json = {"summary": str(summary)}
             summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
-            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, summary_file_blob_name, summary_text)
+            GCS_SERVICE.upload_json_string(bucket_name, summary_file_blob_name, summary_text)
             print("summary已上传到GCS")
         else:
             # summary已存在，下载内容
             print("summary已存在于GCS中")
-            summary_text = download_blob_to_string(gcs_client, bucket_name, summary_file_blob_name)
+            summary_text = GCS_SERVICE.download_as_string(bucket_name, summary_file_blob_name)
             summary_json = json.loads(summary_text)
 
     elif source == "drive":
@@ -980,19 +944,44 @@ def generate_summarise(df_string, metadata=None):
     #     💡 5. 結論反思（為什麼我們要學這個？）
     #     ❓ 6. 延伸小問題
 
-    messages = [
-        {"role": "system", "content": sys_content},
-        {"role": "user", "content": user_content}
-    ]
+    try: 
+        #OPEN AI
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
+
+        request_payload = {
+            "model": "gpt-4-turbo",
+            "messages": messages,
+            "max_tokens": 4000,
+        }
+
+        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+        df_summarise = response.choices[0].message.content.strip()
+    except:
+        #REDROCK
+        messages = [
+            {"role": "user", "content": user_content}
+        ]
+        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": 4000,
+                "system": sys_content,
+                "messages": messages
+            })
+        }
+        response = BEDROCK_CLIENT.invoke_model(**kwargs)
+        response_body = json.loads(response.get('body').read())
+        df_summarise = response_body.get('content')[0].get('text')
 
-    request_payload = {
-        "model": "gpt-4-turbo",
-        "messages": messages,
-        "max_tokens": 4000,
-    }
 
-    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-    df_summarise = response.choices[0].message.content.strip()
     print("=====df_summarise=====")
     print(df_summarise)
     print("=====df_summarise=====")
@@ -1012,12 +1001,12 @@ def get_questions(video_id, df_string, source="gcs"):
         if not is_questions_exists:
             questions = generate_questions(df_string)
             questions_text = json.dumps(questions, ensure_ascii=False, indent=2)
-            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, questions_text)
+            GCS_SERVICE.upload_json_string(bucket_name, blob_name, questions_text)
             print("questions已上傳到GCS")
         else:
             # 逐字稿已存在，下载逐字稿内容
             print("questions已存在于GCS中")
-            questions_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+            questions_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
             questions = json.loads(questions_text)
     
     elif source == "drive":
@@ -1064,26 +1053,50 @@ def generate_questions(df_string):
 
     sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，並用既有資料為本質猜測用戶可能會問的問題，使用 zh-TW"
     user_content = f"請根據 {content_text} 生成三個問題，並用 JSON 格式返回 questions:[q1的敘述text, q2的敘述text, q3的敘述text]"
-    messages = [
-        {"role": "system", "content": sys_content},
-        {"role": "user", "content": user_content}
-    ]
-    response_format = { "type": "json_object" }
+    
+    try:
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
+        response_format = { "type": "json_object" }
 
-    print("=====messages=====")
-    print(messages)
-    print("=====messages=====")
+        print("=====messages=====")
+        print(messages)
+        print("=====messages=====")
 
 
-    request_payload = {
-        "model": "gpt-4-turbo",
-        "messages": messages,
-        "max_tokens": 4000,
-        "response_format": response_format
-    }
+        request_payload = {
+            "model": "gpt-4-turbo",
+            "messages": messages,
+            "max_tokens": 4000,
+            "response_format": response_format
+        }
+
+        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+        questions = json.loads(response.choices[0].message.content)["questions"]
+    except:
+        messages = [
+            {"role": "user", "content": user_content}
+        ]
+        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": 4000,
+                "system": sys_content,
+                "messages": messages
+            })
+        }
+        response = BEDROCK_CLIENT.invoke_model(**kwargs)
+        response_body = json.loads(response.get('body').read())
+        response_completion = response_body.get('content')[0].get('text')
+        questions = json.loads(response_completion)["questions"]
 
-    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-    questions = json.loads(response.choices[0].message.content)["questions"]
     print("=====json_response=====")
     print(questions)
     print("=====json_response=====")
@@ -1103,12 +1116,12 @@ def get_questions_answers(video_id, df_string, source="gcs"):
             if not is_questions_answers_exists:
                 questions_answers = generate_questions_answers(df_string)
                 questions_answers_text = json.dumps(questions_answers, ensure_ascii=False, indent=2)
-                upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, questions_answers_text)
+                GCS_SERVICE.upload_json_string(bucket_name, blob_name, questions_answers_text)
                 print("questions_answers已上傳到GCS")
             else:
                 # questions_answers已存在，下载内容
                 print("questions_answers已存在于GCS中")
-                questions_answers_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+                questions_answers_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
                 questions_answers = json.loads(questions_answers_text)
         except:
             questions = get_questions(video_id, df_string, source)
@@ -1202,12 +1215,12 @@ def get_key_moments(video_id, formatted_simple_transcript, formatted_transcript,
             key_moments = generate_key_moments(formatted_simple_transcript, formatted_transcript)
             key_moments_json = {"key_moments": key_moments}
             key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
-            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, key_moments_text)
+            GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_text)
             print("key_moments已上傳到GCS")
         else:
             # key_moments已存在，下载内容
             print("key_moments已存在于GCS中")
-            key_moments_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+            key_moments_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
             key_moments_json = json.loads(key_moments_text)
              # 檢查 key_moments 是否有 keywords
             print("===檢查 key_moments 是否有 keywords===")
@@ -1222,8 +1235,8 @@ def get_key_moments(video_id, formatted_simple_transcript, formatted_transcript,
                     has_keywords_added = True
             if has_keywords_added:
                 key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
-                upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, key_moments_text)
-                key_moments_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+                GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_text)
+                key_moments_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
                 key_moments_json = json.loads(key_moments_text)
 
     elif source == "drive":
@@ -1271,30 +1284,53 @@ def generate_key_moments(formatted_simple_transcript, formatted_transcript):
             "keywords": ["關鍵字", "關鍵字"]
         }}]
     """
-    messages = [
-        {"role": "system", "content": sys_content},
-        {"role": "user", "content": user_content}
-    ]
-    response_format = { "type": "json_object" }
-
-    request_payload = {
-        "model": "gpt-4-turbo",
-        "messages": messages,
-        "max_tokens": 4096,
-        "response_format": response_format
-    }
 
     try:
+        #OPEN AI
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
+        response_format = { "type": "json_object" }
+
+        request_payload = {
+            "model": "gpt-4-turbo",
+            "messages": messages,
+            "max_tokens": 4096,
+            "response_format": response_format
+        }
+
         response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
         print("===response===")
         print(dict(response))
         key_moments = json.loads(response.choices[0].message.content)["key_moments"]
     except Exception as e:
-        error_msg = f" {video_id} 關鍵時刻錯誤: {str(e)}"
+        error_msg = f" {video_id} OPEN AI 關鍵時刻錯誤: {str(e)}"
         print("===generate_key_moments error===")
         print(error_msg)
         print("===generate_key_moments error===")
-        raise Exception(error_msg)
+        
+        #REDROCK
+        messages = [
+            {"role": "user", "content": user_content}
+        ]
+        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": 4096,
+                "system": sys_content,
+                "messages": messages
+            })
+        }
+        response = BEDROCK_CLIENT.invoke_model(**kwargs)
+        response_body = json.loads(response.get('body').read())
+        response_completion = response_body.get('content')[0].get('text')
+        key_moments = json.loads(response_completion)["key_moments"]
 
     print("=====key_moments=====")
     print(key_moments)
@@ -1318,18 +1354,43 @@ def generate_key_moments_keywords(transcript):
         不用給上下文，直接給出關鍵字，使用 zh-TW，用逗號分隔， example: 關鍵字1, 關鍵字2
         transcript：{transcript}
     """
-    messages = [
-        {"role": "system", "content": system_content},
-        {"role": "user", "content": user_content}
-    ]
-    request_payload = {
-        "model": "gpt-4-turbo",
-        "messages": messages,
-        "max_tokens": 100,
-    }
 
-    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
-    keywords = response.choices[0].message.content.strip().split(", ")
+    try:
+        # OPEN AI
+        messages = [
+            {"role": "system", "content": system_content},
+            {"role": "user", "content": user_content}
+        ]
+        request_payload = {
+            "model": "gpt-4-turbo",
+            "messages": messages,
+            "max_tokens": 100,
+        }
+
+        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+        keywords = response.choices[0].message.content.strip().split(", ")
+    except:
+        # REDROCK
+        messages = [
+            {"role": "user", "content": user_content}
+        ]
+        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": 100,
+                "system": system_content,
+                "messages": messages
+            })
+        }
+        response = BEDROCK_CLIENT.invoke_model(**kwargs)
+        response_body = json.loads(response.get('body').read())
+        response_completion = response_body.get('content')[0].get('text')
+        keywords = response_completion.strip().split(", ")
     
     return keywords
 
@@ -1415,7 +1476,7 @@ def get_key_moments_html(key_moments):
         background-color: black;
         border-radius: 50%;
         text-decoration: none;
-        color: black;
+        color: white !important;
         opacity: 0.8; 
         transition: opacity 200ms ease;
     }
@@ -1503,10 +1564,10 @@ def get_key_moments_html(key_moments):
             image_elements += f"""
                 <div id="{current_id}" class="gallery__item">
                     <a href="#{prev_id}" class="click-zone click-zone-prev">
-                        <div class="arrow arrow-disabled arrow-prev"> < </div>
+                        <div class="arrow arrow-disabled arrow-prev"> ◀︎ </div>
                     </a> 
                     <a href="#{next_id}" class="click-zone click-zone-next">
-                        <div class="arrow arrow-next"> > </div>
+                        <div class="arrow arrow-next"> ▶︎ </div>
                     </a>
                     <img src="{image}">
                 </div>
@@ -1545,7 +1606,7 @@ def get_LLM_content(video_id, kind):
     # 检查 file 是否存在
     is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
     if is_file_exists:
-        content = download_blob_to_string(gcs_client, bucket_name, blob_name)
+        content = GCS_SERVICE.download_as_string(bucket_name, blob_name)
         content_json = json.loads(content)
         if kind == "reading_passage_latex":
             content_text = content_json["reading_passage"]
@@ -1569,7 +1630,7 @@ def delete_LLM_content(video_id, kind):
     # 检查 file 是否存在
     is_file_exists = GCS_SERVICE.check_file_exists(bucket_name, blob_name)
     if is_file_exists:
-        delete_blob(gcs_client, bucket_name, blob_name)
+        GCS_SERVICE.delete_blob(bucket_name, blob_name)
         print(f"{file_name}已从GCS中删除")
     return gr.update(value="", interactive=False)
 
@@ -1585,17 +1646,17 @@ def update_LLM_content(video_id, new_content, kind):
         print(new_content)
         reading_passage_json = {"reading_passage": str(new_content)}
         reading_passage_text = json.dumps(reading_passage_json, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, reading_passage_text)
+        GCS_SERVICE.upload_json_string(bucket_name, blob_name, reading_passage_text)
         updated_content = new_content
     elif kind == "summary_markdown":
         summary_json = {"summary": str(new_content)}
         summary_text = json.dumps(summary_json, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, summary_text)
+        GCS_SERVICE.upload_json_string(bucket_name, blob_name, summary_text)
         updated_content = new_content
     elif kind == "mind_map":
         mind_map_json = {"mind_map": str(new_content)}
         mind_map_text = json.dumps(mind_map_json, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, mind_map_text)
+        GCS_SERVICE.upload_json_string(bucket_name, blob_name, mind_map_text)
         updated_content = mind_map_text
     elif kind == "key_moments":
         # from update_LLM_btn  -> new_content is a string
@@ -1606,7 +1667,7 @@ def update_LLM_content(video_id, new_content, kind):
             key_moments_list = new_content
         key_moments_json = {"key_moments": key_moments_list}
         key_moments_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, key_moments_text)
+        GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_text)
         updated_content = key_moments_text
     elif kind == "transcript":
         if isinstance(new_content, str):
@@ -1614,7 +1675,7 @@ def update_LLM_content(video_id, new_content, kind):
         else:
             transcript_json = new_content
         transcript_text = json.dumps(transcript_json, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, transcript_text)
+        GCS_SERVICE.upload_json_string(bucket_name, blob_name, transcript_text)
         updated_content = transcript_text
     elif kind == "questions":
         # from update_LLM_btn  -> new_content is a string
@@ -1624,7 +1685,7 @@ def update_LLM_content(video_id, new_content, kind):
         else:
             questions_json = new_content
         questions_text = json.dumps(questions_json, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, questions_text)
+        GCS_SERVICE.upload_json_string(bucket_name, blob_name, questions_text)
         updated_content = questions_text
     elif kind == "questions_answers":
         # from update_LLM_btn  -> new_content is a string
@@ -1634,7 +1695,7 @@ def update_LLM_content(video_id, new_content, kind):
         else:
             questions_answers_json = new_content
         questions_answers_text = json.dumps(questions_answers_json, ensure_ascii=False, indent=2)
-        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, questions_answers_text)
+        GCS_SERVICE.upload_json_string(bucket_name, blob_name, questions_answers_text)
         updated_content = questions_answers_text
 
     print(f"{kind} 已更新到GCS")
@@ -1688,7 +1749,6 @@ def create_LLM_content(video_id, df_string, kind):
 def reading_passage_add_latex_version(video_id):
     # 確認 GCS 是否有 reading_passage.json
     print("===reading_passage_convert_to_latex===")
-    gcs_client = GCS_CLIENT
     bucket_name = 'video_ai_assistant'
     file_name = f'{video_id}_reading_passage.json'
     blob_name = f"{video_id}/{file_name}"
@@ -1701,7 +1761,7 @@ def reading_passage_add_latex_version(video_id):
         
     # 逐字稿已存在，下载逐字稿内容
     print("reading_passage 已存在于GCS中，轉換 Latex 模式")
-    reading_passage_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+    reading_passage_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
     reading_passage_json = json.loads(reading_passage_text)
     original_reading_passage = reading_passage_json["reading_passage"]
     sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
@@ -1734,14 +1794,13 @@ def reading_passage_add_latex_version(video_id):
     # 另存為 reading_passage_latex.json
     new_file_name = f'{video_id}_reading_passage_latex.json'
     new_blob_name = f"{video_id}/{new_file_name}"
-    upload_file_to_gcs_with_json_string(gcs_client, bucket_name, new_blob_name, reading_passage_text)
+    GCS_SERVICE.upload_json_string(bucket_name, new_blob_name, reading_passage_text)
     
     return new_reading_passage
 
 def summary_add_markdown_version(video_id):
     # 確認 GCS 是否有 summary.json
     print("===summary_convert_to_markdown===")
-    gcs_client = GCS_CLIENT
     bucket_name = 'video_ai_assistant'
     file_name = f'{video_id}_summary.json'
     blob_name = f"{video_id}/{file_name}"
@@ -1754,7 +1813,7 @@ def summary_add_markdown_version(video_id):
         
     # 逐字稿已存在，下载逐字稿内容
     print("summary 已存在于GCS中，轉換 Markdown 模式")
-    summary_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+    summary_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
     summary_json = json.loads(summary_text)
     original_summary = summary_json["summary"]
     sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
@@ -1803,7 +1862,7 @@ def summary_add_markdown_version(video_id):
     # 另存為 summary_markdown.json
     new_file_name = f'{video_id}_summary_markdown.json'
     new_blob_name = f"{video_id}/{new_file_name}"
-    upload_file_to_gcs_with_json_string(gcs_client, bucket_name, new_blob_name, summary_text)
+    GCS_SERVICE.upload_json_string(bucket_name, new_blob_name, summary_text)
 
     return new_summary
 
@@ -1827,7 +1886,7 @@ def get_meta_data(video_id, source="gcs"):
         else:
             # meta_data已存在，下载内容
             print("meta_data已存在于GCS中")
-            meta_data_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
+            meta_data_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
             meta_data_json = json.loads(meta_data_text)
 
     # meta_data_json grade 數字轉換成文字
@@ -1855,7 +1914,6 @@ def get_ai_content(password, video_id, df_string, topic, grade, level, specific_
     verify_password(password)
     if source == "gcs":
         print("===get_ai_content on gcs===")
-        gcs_client = GCS_CLIENT
         bucket_name = 'video_ai_assistant'
         file_name = f'{video_id}_ai_content_list.json'
         blob_name = f"{video_id}/{file_name}"
@@ -1865,11 +1923,11 @@ def get_ai_content(password, video_id, df_string, topic, grade, level, specific_
             # 先建立一個 ai_content_list.json
             ai_content_list = []
             ai_content_text = json.dumps(ai_content_list, ensure_ascii=False, indent=2)
-            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, ai_content_text)
+            GCS_SERVICE.upload_json_string(bucket_name, blob_name, ai_content_text)
             print("ai_content_list [] 已上傳到GCS")
 
         # 此時 ai_content_list 已存在
-        ai_content_list_string = download_blob_to_string(gcs_client, bucket_name, blob_name)
+        ai_content_list_string = GCS_SERVICE.download_as_string(bucket_name, blob_name)
         ai_content_list = json.loads(ai_content_list_string)
         # by key 找到 ai_content （topic, grade, level, specific_feature, content_type）
         target_kvs = {
@@ -1896,7 +1954,7 @@ def get_ai_content(password, video_id, df_string, topic, grade, level, specific_
 
             ai_content_list.append(ai_content_json)
             ai_content_text = json.dumps(ai_content_list, ensure_ascii=False, indent=2)
-            upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, ai_content_text)
+            GCS_SERVICE.upload_json_string(bucket_name, blob_name, ai_content_text)
             print("ai_content已上傳到GCS")
         else:
             ai_content_json = ai_content_json[-1]
@@ -1909,30 +1967,26 @@ def generate_ai_content(password, df_string, topic, grade, level, specific_featu
     verify_password(password)
     material = EducationalMaterial(df_string, topic, grade, level, specific_feature, content_type)
     prompt = material.generate_content_prompt()
-    user_content = material.build_user_content()
-    messages = material.build_messages(user_content)
-    ai_model_name = "gpt-4-turbo"
-    request_payload = {
-        "model": ai_model_name,
-        "messages": messages,
-        "max_tokens": 4000  # 举例，实际上您可能需要更详细的配置
-    }
-    ai_content = material.send_ai_request(OPEN_AI_CLIENT, request_payload)
+    try:
+        ai_content = material.get_ai_content(OPEN_AI_CLIENT, ai_type="openai")
+    except Exception as e:
+        error_msg = f" {video_id} OPEN AI 生成教學素材錯誤: {str(e)}"
+        print("===generate_ai_content error===")
+        print(error_msg)
+        print("===generate_ai_content error===")
+        ai_content = material.get_ai_content(BEDROCK_CLIENT, ai_type="bedrock")
+
     return ai_content, prompt
 
 def generate_exam_fine_tune_result(password, exam_result_prompt , df_string_output, exam_result, exam_result_fine_tune_prompt):
     verify_password(password)
     material = EducationalMaterial(df_string_output, "", "", "", "", "")
-    user_content = material.build_fine_tune_user_content(exam_result_prompt, exam_result, exam_result_fine_tune_prompt)
-    messages = material.build_messages(user_content)
-    ai_model_name = "gpt-4-turbo"
-    request_payload = {
-        "model": ai_model_name,
-        "messages": messages,
-        "max_tokens": 4000  # 举例，实际上您可能需要更详细的配置
-    }
-    ai_content = material.send_ai_request(OPEN_AI_CLIENT, request_payload)
-    return ai_content
+    try:
+        fine_tuned_ai_content = material.get_fine_tuned_ai_content(OPEN_AI_CLIENT, "openai", exam_result_prompt, exam_result, exam_result_fine_tune_prompt)
+    except:
+        fine_tuned_ai_content = material.get_fine_tuned_ai_content(BEDROCK_CLIENT, "bedrock", exam_result_prompt, exam_result, exam_result_fine_tune_prompt)
+
+    return fine_tuned_ai_content
 
 def return_original_exam_result(exam_result_original):
     return exam_result_original
@@ -2001,17 +2055,42 @@ def chat_with_ai(ai_name, password, video_id, user_data, trascript_state, key_mo
         error_msg = "此次對話超過上限（對話一輪10次）"
         raise gr.Error(error_msg)
 
-    if not ai_name in ["jutor", "claude3", "groq"]:
-        ai_name = "jutor"
-
-    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 = ""
+    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",
+            "ai_client": GROQ_CLIENT,
+            "ai_model_name": "groq_llama3",
+        },
+        "lili": {
+            "ai_name": "lili",
+            "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,
+            "ai_model_name": "groq_mixtral",
+        }
+    }
+    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)
@@ -2038,14 +2117,14 @@ def chat_with_ai(ai_name, password, video_id, user_data, trascript_state, key_mo
         "content_subject": content_subject,
         "content_grade": content_grade,
         "jutor_chat_key": JUTOR_CHAT_KEY,
-        "ai_name": ai_name,
+        "ai_model_name": ai_model_name,
         "ai_client": ai_client,
         "instructions": instructions
     }
 
     try:
         chatbot = Chatbot(chatbot_config)
-        response_completion = chatbot.chat(user_message, chat_history, socratic_mode, ai_name)
+        response_completion = chatbot.chat(user_message, chat_history, socratic_mode, ai_model_name)
     except Exception as e:
         print(f"Error: {e}")
         response_completion = "學習精靈有點累，請稍後再試！"
@@ -2359,19 +2438,35 @@ def create_thread_id():
     return thread_id
 
 def chatbot_select(chatbot_name):
-    chatbot_select_accordion_visible = gr.update(open=False)
+    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)
+    ai_name_update = gr.update(value="foxcat")
 
     if chatbot_name == "chatbot_open_ai":
         chatbot_open_ai_visible = gr.update(visible=True)
     elif chatbot_name == "chatbot_open_ai_streaming":
         chatbot_open_ai_streaming_visible = gr.update(visible=True)
-    elif chatbot_name == "chatbot_jutor":
+    else:
         chatbot_jutor_visible = gr.update(visible=True)
+        ai_name_update = gr.update(value=chatbot_name) 
         
-    return chatbot_select_accordion_visible, chatbot_open_ai_visible, chatbot_open_ai_streaming_visible, chatbot_jutor_visible
+    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
+
+def update_avatar_images(avatar_images, maimai_chatbot_description_value):
+    value = [[
+        "請問你是誰？",
+        maimai_chatbot_description_value
+    ]]
+    ai_chatbot_update = gr.update(avatar_images=avatar_images, value=value)
+    return ai_chatbot_update
+
+def show_all_chatbot_accordion():
+    chatbot_select_accordion_visible = gr.update(visible=True)
+    all_chatbot_select_btn_visible = gr.update(visible=False)
+    return chatbot_select_accordion_visible, all_chatbot_select_btn_visible
 
 # --- Slide mode ---
 def update_slide(direction):
@@ -2538,6 +2633,28 @@ HEAD = """
             }
         }
     </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:
@@ -2556,8 +2673,12 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         key_moments_state = gr.State()  # 使用 gr.State 存储 key_moments
         streaming_chat_thread_id_state = gr.State()  # 使用 gr.State 存储 streaming_chat_thread_id
     with gr.Tab("AI小精靈"):
-        with gr.Accordion("選擇 AI 小精靈", open=True) as chatbot_select_accordion:
+        with gr.Row():
+            all_chatbot_select_btn = gr.Button("選擇 AI 小精靈 👈", elem_id="all_chatbot_select_btn", visible=False, variant="secondary", size="sm")
+        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
@@ -2585,22 +2706,52 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     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"):
-                    jutor_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2019/11/%E5%9B%9B%E6%A0%BC%E6%95%85%E4%BA%8B-04.jpg"
-                    jutor_chatbot_description = """Hi，我們是【梨梨、麥麥、狐狸貓】，\n
+                    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])
+                    foxcat_chatbot_description = """Hi，我是【狐狸貓】，\n
                     也可以陪你一起學習本次的內容，有什麼問題都可以問我喔！\n
                     🤔 如果你不知道怎麼發問，可以點擊左下方的問題一、問題二、問題三，我會幫你生成問題！\n
                     🗣️ 也可以點擊右下方用語音輸入，我會幫你轉換成文字，厲害吧！\n
                     🔠 或是直接鍵盤輸入你的問題，我會盡力回答你的問題喔！\n
-                    💤 精靈們體力都有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！\n
+                    💤 精靈們體力都有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
+                    """
+                    foxcat_chatbot_name = gr.State("foxcat")
+                    gr.Image(value=foxcat_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
+                    foxcat_chatbot_select_btn = gr.Button("👆選擇【狐狸貓】", visible=True, variant="primary", elem_classes="chatbot_select_btn")
+                    foxcat_chatbot_description_value = gr.Markdown(value=foxcat_chatbot_description, visible=True)
+                # 梨梨
+                with gr.Column(scale=1, variant="panel"): 
+                    lili_chatbot_avatar_url = "https://junyitopicimg.s3.amazonaws.com/live/v1283-new-topic-44-icon.png?v=20230529071206714"
+                    lili_avatar_images = gr.State([user_avatar, lili_chatbot_avatar_url])
+                    lili_chatbot_description = """你好，我是溫柔的【梨梨】， \n
+                        很高興可以在這裡陪伴你學習。如果你有任何疑問，請隨時向我提出哦！ \n
+                        🤔 如果你在思考如何提問，可以嘗試點擊下方的「問題一」、「問題二」或「問題三」，我會為你生成一些問題來幫助你啟動思考。 \n
+                        🗣️ 你也可以使用右下角的語音輸入功能，讓我幫你將語音轉化為文字，這樣可以更加方便快捷。\n
+                        🔠 當然，你也可以直接通過鍵盤輸入你的問題，我將盡我所能為你提供答案。\n
+                        💤 請理解，即使是我們這些精靈，也有疲憊的時候，每次學習後我能回答的問題有限。如果達到上限，讓我稍作休息之後再繼續回答你的問題吧！
                     """
-                    chatbot_jutor_name = gr.State("chatbot_jutor")
-                    gr.Image(value=jutor_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
-                    chatbot_jutor_select_btn = gr.Button("👆選擇【梨梨、麥麥、狐狸貓】", elem_id="jutor_chatbot_btn", visible=True, variant="primary")
-                    gr.Markdown(value=jutor_chatbot_description, visible=True)
+                    lili_chatbot_name = gr.State("lili")
+                    gr.Image(value=lili_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
+                    lili_chatbot_select_btn = gr.Button("👆選擇【梨梨】", visible=True, variant="primary", elem_classes="chatbot_select_btn")
+                    lili_chatbot_description_value = gr.Markdown(value=lili_chatbot_description, visible=True)
+                # 麥麥
+                with gr.Column(scale=1, variant="panel"): 
+                    maimai_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/07/%E6%80%9D%E8%80%83%E5%8A%9B%E8%B6%85%E4%BA%BA%E5%BE%BD%E7%AB%A0_%E5%B7%A5%E4%BD%9C%E5%8D%80%E5%9F%9F-1-%E8%A4%87%E6%9C%AC-150x150.png"
+                    maimai_avatar_images = gr.State([user_avatar, maimai_chatbot_avatar_url])
+                    maimai_chatbot_description = """Hi，我是迷人的【麥麥】，\n
+                        我在這裡等著和你一起探索新知，任何疑問都可以向我提出！\n
+                        🤔 如果你不知道從���裡開始，試試左下方的「問題一」、「問題二」、「問題三」，我會為你提供一些啟發思考的問題。\n
+                        🗣️ 你也可以利用右下角的語音輸入功能，讓我將你的語音轉成文字，是不是很酷？\n
+                        🔠 當然，你也可以直接透過鍵盤向我發問，我會全力以赴來回答你的每一個問題。\n
+                        💤 我們這些精靈也需要休息，每次學習我們只能回答十個問題，當達到上限時，請給我一點時間充電再繼續。
+                    """
+                    maimai_chatbot_name = gr.State("maimai")
+                    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():
-                user_avatar = "https://em-content.zobj.net/source/google/263/flushed-face_1f633.png"
                 bot_avatar = "https://junyitopicimg.s3.amazonaws.com/s4byy--icon.jpe?v=20200513013523726"
                 latex_delimiters = [{"left": "$", "right": "$", "display": False}]
                 chatbot_greeting = [[
@@ -2659,14 +2810,17 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     💤 精靈們體力都有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
                     """,
                 ]]
-                ai_chatbot_bot_avatar = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2019/11/%E5%9B%9B%E6%A0%BC%E6%95%85%E4%BA%8B-04.jpg"
-                ai_name = gr.Dropdown(label="選擇 AI 助理", choices=[
-                    # ("梨梨","jutor"), 
-                    ("麥麥","claude3"), 
-                    ("狐狸貓","groq")], 
-                        value="claude3"
+                ai_name = gr.Dropdown(
+                    label="選擇 AI 助理", 
+                    choices=[
+                        ("梨梨","lili"), 
+                        ("麥麥","maimai"), 
+                        ("狐狸貓","foxcat")
+                    ], 
+                    value="foxcat",
+                    visible=False
                 )
-                ai_chatbot = gr.Chatbot(avatar_images=[user_avatar, ai_chatbot_bot_avatar], label="ai_chatbot", show_share_button=False, likeable=True, show_label=False, latex_delimiters=latex_delimiters, value=ai_chatbot_greeting)
+                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:
@@ -2700,7 +2854,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                         with gr.Row():
                             worksheet_content_type_name = gr.Textbox(value="worksheet", visible=False)
                             worksheet_algorithm = gr.Dropdown(label="選擇教學策略或理論", choices=["Bloom認知階層理論", "Polya數學解題法", "CRA教學法"], value="Bloom認知階層理論", visible=False)
-                            worksheet_content_btn = gr.Button("生成學習單 📄", variant="primary", visible=False)
+                            worksheet_content_btn = gr.Button("生成學習單 📄", variant="primary", visible=True)
                         with gr.Accordion("微調", open=False):
                             worksheet_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
                             worksheet_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
@@ -2721,7 +2875,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                         with gr.Row():
                             lesson_plan_content_type_name = gr.Textbox(value="lesson_plan", visible=False)                    
                             lesson_plan_time = gr.Slider(label="選擇課程時間(分鐘)", minimum=10, maximum=120, step=5, value=40)
-                            lesson_plan_btn = gr.Button("生成教案 📕", variant="primary", visible=False)
+                            lesson_plan_btn = gr.Button("生成教案 📕", variant="primary", visible=True)
                         with gr.Accordion("微調", open=False):
                             lesson_plan_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
                             lesson_plan_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
@@ -2742,7 +2896,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                         with gr.Row():
                             exit_ticket_content_type_name = gr.Textbox(value="exit_ticket", visible=False)
                             exit_ticket_time = gr.Slider(label="選擇出場券時間(分鐘)", minimum=5, maximum=10, step=1, value=8)
-                            exit_ticket_btn = gr.Button("生成出場券 🎟️", variant="primary", visible=False)
+                            exit_ticket_btn = gr.Button("生成出場券 🎟️", variant="primary", visible=True)
                         with gr.Accordion("微調", open=False):
                             exit_ticket_exam_result_fine_tune_prompt = gr.Textbox(label="根據結果，輸入你想更改的想法")
                             exit_ticket_exam_result_fine_tune_btn = gr.Button("微調結果", variant="primary")
@@ -2861,25 +3015,58 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
             mind_map_html = gr.HTML()
        
     # --- Event ---
-    # CHATBOT SELECT
+    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_accordion, chatbot_open_ai, chatbot_open_ai_streaming, chatbot_jutor]
+        outputs=chatbot_select_outputs
     )
     chatbot_open_ai_streaming_select_btn.click(
         chatbot_select,
         inputs=[chatbot_open_ai_streaming_name],
-        outputs=[chatbot_select_accordion, chatbot_open_ai, chatbot_open_ai_streaming, chatbot_jutor]
+        outputs=chatbot_select_outputs
     ).then(
         create_thread_id,
         inputs=[],
         outputs=[streaming_chat_thread_id_state]
     )
-    chatbot_jutor_select_btn.click(
+    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=[chatbot_jutor_name],
-        outputs=[chatbot_select_accordion, chatbot_open_ai, chatbot_open_ai_streaming, chatbot_jutor]
+        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 模式
@@ -2895,31 +3082,24 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         outputs=[msg]
     )
     # OPENAI ASSISTANT CHATBOT 連接按鈕點擊事件
-    btn_1_chat_with_opan_ai_assistant_input =[password, video_id, user_data, thread_id, trascript_state, key_moments, btn_1, chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn]
-    btn_2_chat_with_opan_ai_assistant_input =[password, video_id, user_data, thread_id, trascript_state, key_moments, btn_2, chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn]
-    btn_3_chat_with_opan_ai_assistant_input =[password, video_id, user_data, thread_id, trascript_state, key_moments, btn_3, chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn]
-    btn_1.click(
-        chat_with_opan_ai_assistant,
-        inputs=btn_1_chat_with_opan_ai_assistant_input, 
-        outputs=[msg, chatbot, thread_id],
-        scroll_to_output=True
-    )
-    btn_2.click(
-        chat_with_opan_ai_assistant,
-        inputs=btn_2_chat_with_opan_ai_assistant_input, 
-        outputs=[msg, chatbot, thread_id],
-        scroll_to_output=True
-    )
-    btn_3.click(
-        chat_with_opan_ai_assistant,
-        inputs=btn_3_chat_with_opan_ai_assistant_input, 
-        outputs=[msg, chatbot, thread_id],
-        scroll_to_output=True
+    def setup_question_button_click(button, inputs_list, outputs_list, chat_func, scroll_to_output=True):
+        button.click(
+        chat_func,
+        inputs=inputs_list,
+        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)
+
+    # 為生成問題按鈕設定特殊的點擊事件
     btn_create_question.click(
         change_questions, 
-        inputs = [password, df_string_output], 
-        outputs = [btn_1, btn_2, btn_3]
+        inputs=[password, df_string_output], 
+        outputs=question_buttons
     )
 
     # 其他精靈 ai_chatbot 模式
@@ -2930,27 +3110,11 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         scroll_to_output=True
     )
     # 其他精靈 ai_chatbot 连接按钮点击事件
-    ai_chatbot_question_1_chat_with_ai_input =[ai_name, password, video_id, user_data, trascript_state, key_moments, ai_chatbot_question_1, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn]
-    ai_chatbot_question_2_chat_with_ai_input =[ai_name, password, video_id, user_data, trascript_state, key_moments, ai_chatbot_question_2, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn]
-    ai_chatbot_question_3_chat_with_ai_input =[ai_name, password, video_id, user_data, trascript_state, key_moments, ai_chatbot_question_3, ai_chatbot, content_subject, content_grade, questions_answers_json, ai_chatbot_socratic_mode_btn]
-    ai_chatbot_question_1.click(
-        chat_with_ai,
-        inputs=ai_chatbot_question_1_chat_with_ai_input,
-        outputs=[ai_msg, ai_chatbot],
-        scroll_to_output=True
-    )
-    ai_chatbot_question_2.click(
-        chat_with_ai,
-        inputs=ai_chatbot_question_2_chat_with_ai_input,
-        outputs=[ai_msg, ai_chatbot],
-        scroll_to_output=True
-    )
-    ai_chatbot_question_3.click(
-        chat_with_ai,
-        inputs=ai_chatbot_question_3_chat_with_ai_input,
-        outputs=[ai_msg, ai_chatbot],
-        scroll_to_output=True
-    )
+    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])
@@ -3016,246 +3180,301 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         inputs=update_state_inputs,
         outputs=update_state_outputs
     )
-    
 
-    # 当输入网页链接时触发
-    # web_link.change(process_web_link, inputs=web_link, outputs=[btn_1, btn_2, btn_3, df_summarise, df_string_output])
-
-    # reading_passage event
-    # reading_passage_text_to_latex.click(
-    #     reading_passage_add_latex_version,
-    #     inputs=[video_id],
-    #     outputs=[reading_passage_text]
-    # )
-    reading_passage_get_button.click(
-        get_LLM_content,
-        inputs=[video_id, reading_passage_kind],
-        outputs=[reading_passage_text]
-    )
-    reading_passage_create_button.click(
-        create_LLM_content,
-        inputs=[video_id, df_string_output, reading_passage_kind],
-        outputs=[reading_passage_text]
-    )
-    reading_passage_delete_button.click(
-        delete_LLM_content,
-        inputs=[video_id, reading_passage_kind],
-        outputs=[reading_passage_text]
-    )
-    reading_passage_edit_button.click(
-        enable_edit_mode,
-        inputs=[],
-        outputs=[reading_passage_text]
-    )
-    reading_passage_update_button.click(
-        update_LLM_content,
-        inputs=[video_id, reading_passage_text, reading_passage_kind],
-        outputs=[reading_passage_text]
-    )
 
-    # summary event
-    # summary_to_markdown.click(
-    #     summary_add_markdown_version,
-    #     inputs=[video_id],
-    #     outputs=[summary_text]
-    # )
-    summary_get_button.click(
-        get_LLM_content,
-        inputs=[video_id, summary_kind],
-        outputs=[summary_text]
-    )
-    summary_create_button.click(
-        create_LLM_content,
-        inputs=[video_id, df_string_output, summary_kind],
-        outputs=[summary_text]
-    )
-    summary_delete_button.click(
-        delete_LLM_content,
-        inputs=[video_id, summary_kind],
-        outputs=[summary_text]
-    )
-    summary_edit_button.click(
-        enable_edit_mode,
-        inputs=[],
-        outputs=[summary_text]
-    )
-    summary_update_button.click(
-        update_LLM_content,
-        inputs=[video_id, summary_text, summary_kind],
-        outputs=[summary_text]
-    )
-
-    # transcript event
-    transcript_get_button.click(
-        get_LLM_content,
-        inputs=[video_id, transcript_kind],
-        outputs=[df_string_output]
-    )
-    transcript_create_button.click(
-        create_LLM_content,
-        inputs=[video_id, df_string_output, transcript_kind],
-        outputs=[df_string_output]
-    )
-    transcript_delete_button.click(
-        delete_LLM_content,
-        inputs=[video_id, transcript_kind],
-        outputs=[df_string_output]
-    )
-    transcript_edit_button.click(
-        enable_edit_mode,
-        inputs=[],
-        outputs=[df_string_output]
-    )
-    transcript_update_button.click(
-        update_LLM_content,
-        inputs=[video_id, df_string_output, transcript_kind],
-        outputs=[df_string_output]
-    )
-    
-    # key_moments event
-    key_moments_get_button.click(
-        get_LLM_content,
-        inputs=[video_id, key_moments_kind],
-        outputs=[key_moments]
-    )
-    key_moments_create_button.click(
-        create_LLM_content,
-        inputs=[video_id, df_string_output, key_moments_kind],
-        outputs=[key_moments]
-    )
-    key_moments_delete_button.click(
-        delete_LLM_content,
-        inputs=[video_id, key_moments_kind],
-        outputs=[key_moments]
-    )
-    key_moments_edit_button.click(
-        enable_edit_mode,
-        inputs=[],
-        outputs=[key_moments]
-    )
-    key_moments_update_button.click(
-        update_LLM_content,
-        inputs=[video_id, key_moments, key_moments_kind],
-        outputs=[key_moments]
-    )
-    
-    # question_list event
-    questions_get_button.click(
-        get_LLM_content,
-        inputs=[video_id, questions_kind],
-        outputs=[questions_json]
-    )
-    questions_create_button.click(
-        create_LLM_content,
-        inputs=[video_id, df_string_output, questions_kind],
-        outputs=[questions_json]
-    )
-    questions_delete_button.click(
-        delete_LLM_content,
-        inputs=[video_id, questions_kind],
-        outputs=[questions_json]
-    )
-    questions_edit_button.click(
-        enable_edit_mode,
-        inputs=[],
-        outputs=[questions_json]
-    )
-    questions_update_button.click(
-        update_LLM_content,
-        inputs=[video_id, questions_json, questions_kind],
-        outputs=[questions_json]
-    ) 
-    # questions_answers event
-    questions_answers_get_button.click(
-        get_LLM_content,
-        inputs=[video_id, questions_answers_kind],
-        outputs=[questions_answers_json]
-    )
-    questions_answers_create_button.click(
-        create_LLM_content,
-        inputs=[video_id, df_string_output, questions_answers_kind],
-        outputs=[questions_answers_json]
-    )
-    questions_answers_delete_button.click(
-        delete_LLM_content,
-        inputs=[video_id, questions_answers_kind],
-        outputs=[questions_answers_json]
-    )
-    questions_answers_edit_button.click(
-        enable_edit_mode,
-        inputs=[],
-        outputs=[questions_answers_json]
-    )
-    questions_answers_update_button.click(
-        update_LLM_content,
-        inputs=[video_id, questions_answers_json, questions_answers_kind],
-        outputs=[questions_answers_json]
-    )
-
-
-    # 教師版
-    worksheet_content_btn.click(
-        get_ai_content,
-        inputs=[password, video_id, df_string_output, content_subject, content_grade, content_level, worksheet_algorithm, worksheet_content_type_name],
-        outputs=[worksheet_exam_result_original, worksheet_exam_result, worksheet_prompt, worksheet_exam_result_prompt]
-    )
-    lesson_plan_btn.click(
-        get_ai_content,
-        inputs=[password, video_id, df_string_output, content_subject, content_grade, content_level, lesson_plan_time, lesson_plan_content_type_name],
-        outputs=[lesson_plan_exam_result_original, lesson_plan_exam_result, lesson_plan_prompt, lesson_plan_exam_result_prompt]
-    )
-    exit_ticket_btn.click(
-        get_ai_content,
-        inputs=[password, video_id, df_string_output, content_subject, content_grade, content_level, exit_ticket_time, exit_ticket_content_type_name],
-        outputs=[exit_ticket_exam_result_original, exit_ticket_exam_result, exit_ticket_prompt, exit_ticket_exam_result_prompt]
-    )
+    # --- CRUD admin ---
+    def setup_content_buttons(buttons_config):
+        for config in buttons_config:
+            button = config['button']
+            action = config['action']
+            inputs = config['inputs']
+            outputs = config['outputs']
+            button.click(
+                fn=action,
+                inputs=inputs,
+                outputs=outputs
+            )
 
-    # 生成結果微調
-    worksheet_exam_result_fine_tune_btn.click(
-        generate_exam_fine_tune_result,
-        inputs=[password, worksheet_exam_result_prompt, df_string_output, worksheet_exam_result, worksheet_exam_result_fine_tune_prompt],
-        outputs=[worksheet_exam_result]
-    )
-    worksheet_download_exam_result_button.click(
-        download_exam_result,
-        inputs=[worksheet_exam_result],
-        outputs=[worksheet_exam_result_word_link]
-    )
-    worksheet_exam_result_retrun_original.click(
-        return_original_exam_result,
-        inputs=[worksheet_exam_result_original],
-        outputs=[worksheet_exam_result]
-    )
-    lesson_plan_exam_result_fine_tune_btn.click(
-        generate_exam_fine_tune_result,
-        inputs=[password, lesson_plan_exam_result_prompt, df_string_output, lesson_plan_exam_result, lesson_plan_exam_result_fine_tune_prompt],
-        outputs=[lesson_plan_exam_result]
-    )
-    lesson_plan_download_exam_result_button.click(
-        download_exam_result,
-        inputs=[lesson_plan_exam_result],
-        outputs=[lesson_plan_exam_result_word_link]
-    )
-    lesson_plan_exam_result_retrun_original.click(
-        return_original_exam_result,
-        inputs=[lesson_plan_exam_result_original],
-        outputs=[lesson_plan_exam_result]
-    )
-    exit_ticket_exam_result_fine_tune_btn.click(
-        generate_exam_fine_tune_result,
-        inputs=[password, exit_ticket_exam_result_prompt, df_string_output, exit_ticket_exam_result, exit_ticket_exam_result_fine_tune_prompt],
-        outputs=[exit_ticket_exam_result]
-    )
-    exit_ticket_download_exam_result_button.click(
-        download_exam_result,
-        inputs=[exit_ticket_exam_result],
-        outputs=[exit_ticket_exam_result_word_link]
-    )
-    exit_ticket_exam_result_retrun_original.click(
-        return_original_exam_result,
-        inputs=[exit_ticket_exam_result_original],
-        outputs=[exit_ticket_exam_result]
-    )
+    content_buttons_config = [
+        # Transcript actions
+        {
+            'button': transcript_get_button,
+            'action': get_LLM_content,
+            'inputs': [video_id, transcript_kind],
+            'outputs': [df_string_output]
+        },
+        {
+            'button': transcript_create_button,
+            'action': create_LLM_content,
+            'inputs': [video_id, df_string_output, transcript_kind],
+            'outputs': [df_string_output]
+        },
+        {
+            'button': transcript_delete_button,
+            'action': delete_LLM_content,
+            'inputs': [video_id, transcript_kind],
+            'outputs': [df_string_output]
+        },
+        {
+            'button': transcript_edit_button,
+            'action': enable_edit_mode,
+            'inputs': [],
+            'outputs': [df_string_output]
+        },
+        {
+            'button': transcript_update_button,
+            'action': update_LLM_content,
+            'inputs': [video_id, df_string_output, transcript_kind],
+            'outputs': [df_string_output]
+        },
+        # Reading passage actions
+        {
+            'button': reading_passage_get_button,
+            'action': get_LLM_content,
+            'inputs': [video_id, reading_passage_kind],
+            'outputs': [reading_passage_text]
+        },
+        {
+            'button': reading_passage_create_button,
+            'action': create_LLM_content,
+            'inputs': [video_id, df_string_output, reading_passage_kind],
+            'outputs': [reading_passage_text]
+        },
+        {
+            'button': reading_passage_delete_button,
+            'action': delete_LLM_content,
+            'inputs': [video_id, reading_passage_kind],
+            'outputs': [reading_passage_text]
+        },
+        {
+            'button': reading_passage_edit_button,
+            'action': enable_edit_mode,
+            'inputs': [],
+            'outputs': [reading_passage_text]
+        },
+        {
+            'button': reading_passage_update_button,
+            'action': update_LLM_content,
+            'inputs': [video_id, reading_passage_text, reading_passage_kind],
+            'outputs': [reading_passage_text]
+        },
+        # Summary actions
+        {
+            'button': summary_get_button,
+            'action': get_LLM_content,
+            'inputs': [video_id, summary_kind],
+            'outputs': [summary_text]
+        },
+        {
+            'button': summary_create_button,
+            'action': create_LLM_content,
+            'inputs': [video_id, df_string_output, summary_kind],
+            'outputs': [summary_text]
+        },
+        {
+            'button': summary_delete_button,
+            'action': delete_LLM_content,
+            'inputs': [video_id, summary_kind],
+            'outputs': [summary_text]
+        },
+        {
+            'button': summary_edit_button,
+            'action': enable_edit_mode,
+            'inputs': [],
+            'outputs': [summary_text]
+        },
+        {
+            'button': summary_update_button,
+            'action': update_LLM_content,
+            'inputs': [video_id, summary_text, summary_kind],
+            'outputs': [summary_text]
+        },
+        # Key moments actions
+        {
+            'button': key_moments_get_button,
+            'action': get_LLM_content,
+            'inputs': [video_id, key_moments_kind],
+            'outputs': [key_moments]
+        },
+        {
+            'button': key_moments_create_button,
+            'action': create_LLM_content,
+            'inputs': [video_id, df_string_output, key_moments_kind],
+            'outputs': [key_moments]
+        },
+        {
+            'button': key_moments_delete_button,
+            'action': delete_LLM_content,
+            'inputs': [video_id, key_moments_kind],
+            'outputs': [key_moments]
+        },
+        {
+            'button': key_moments_edit_button,
+            'action': enable_edit_mode,
+            'inputs': [],
+            'outputs': [key_moments]
+        },
+        {
+            'button': key_moments_update_button,
+            'action': update_LLM_content,
+            'inputs': [video_id, key_moments, key_moments_kind],
+            'outputs': [key_moments]
+        },
+        # Questions actions
+        {
+            'button': questions_get_button,
+            'action': get_LLM_content,
+            'inputs': [video_id, questions_kind],
+            'outputs': [questions_json]
+        },
+        {
+            'button': questions_create_button,
+            'action': create_LLM_content,
+            'inputs': [video_id, df_string_output, questions_kind],
+            'outputs': [questions_json]
+        },
+        {
+            'button': questions_delete_button,
+            'action': delete_LLM_content,
+            'inputs': [video_id, questions_kind],
+            'outputs': [questions_json]
+        },
+        {
+            'button': questions_edit_button,
+            'action': enable_edit_mode,
+            'inputs': [],
+            'outputs': [questions_json]
+        },
+        {
+            'button': questions_update_button,
+            'action': update_LLM_content,
+            'inputs': [video_id, questions_json, questions_kind],
+            'outputs': [questions_json]
+        },
+        # Questions answers actions
+        {
+            'button': questions_answers_get_button,
+            'action': get_LLM_content,
+            'inputs': [video_id, questions_answers_kind],
+            'outputs': [questions_answers_json]
+        },
+        {
+            'button': questions_answers_create_button,
+            'action': create_LLM_content,
+            'inputs': [video_id, df_string_output, questions_answers_kind],
+            'outputs': [questions_answers_json]
+        },
+        {
+            'button': questions_answers_delete_button,
+            'action': delete_LLM_content,
+            'inputs': [video_id, questions_answers_kind],
+            'outputs': [questions_answers_json]
+        },
+        {
+            'button': questions_answers_edit_button,
+            'action': enable_edit_mode,
+            'inputs': [],
+            'outputs': [questions_answers_json]
+        },
+        {
+            'button': questions_answers_update_button,
+            'action': update_LLM_content,
+            'inputs': [video_id, questions_answers_json, questions_answers_kind],
+            'outputs': [questions_answers_json]
+        },
+    ]
+    setup_content_buttons(content_buttons_config)
+
+    # --- Education Material ---
+    def setup_education_buttons(buttons_config):
+        for config in buttons_config:
+            button = config["button"]
+            action = config["action"]
+            inputs = config["inputs"]
+            outputs = config["outputs"]
+            button.click(
+                fn=action,
+                inputs=inputs,
+                outputs=outputs
+            )
+    education_buttons_config = [
+        # 學習單相關按鈕
+        {
+            "button": worksheet_content_btn,
+            "action": get_ai_content,
+            "inputs": [password, video_id, df_string_output, content_subject, content_grade, content_level, worksheet_algorithm, worksheet_content_type_name],
+            "outputs": [worksheet_exam_result_original, worksheet_exam_result, worksheet_prompt, worksheet_exam_result_prompt]
+        },
+        {
+            "button": worksheet_exam_result_fine_tune_btn,
+            "action": generate_exam_fine_tune_result,
+            "inputs": [password, worksheet_exam_result_prompt, df_string_output, worksheet_exam_result, worksheet_exam_result_fine_tune_prompt],
+            "outputs": [worksheet_exam_result]
+        },
+        {
+            "button": worksheet_download_exam_result_button,
+            "action": download_exam_result,
+            "inputs": [worksheet_exam_result],
+            "outputs": [worksheet_exam_result_word_link]
+        },
+        {
+            "button": worksheet_exam_result_retrun_original,
+            "action": return_original_exam_result,
+            "inputs": [worksheet_exam_result_original],
+            "outputs": [worksheet_exam_result]
+        },
+        # 教案相關按鈕
+        {
+            "button": lesson_plan_btn,
+            "action": get_ai_content,
+            "inputs": [password, video_id, df_string_output, content_subject, content_grade, content_level, lesson_plan_time, lesson_plan_content_type_name],
+            "outputs": [lesson_plan_exam_result_original, lesson_plan_exam_result, lesson_plan_prompt, lesson_plan_exam_result_prompt]
+        },
+        {
+            "button": lesson_plan_exam_result_fine_tune_btn,
+            "action": generate_exam_fine_tune_result,
+            "inputs": [password, lesson_plan_exam_result_prompt, df_string_output, lesson_plan_exam_result, lesson_plan_exam_result_fine_tune_prompt],
+            "outputs": [lesson_plan_exam_result]
+        },
+        {
+            "button": lesson_plan_download_exam_result_button,
+            "action": download_exam_result,
+            "inputs": [lesson_plan_exam_result],
+            "outputs": [lesson_plan_exam_result_word_link]
+        },
+        {
+            "button": lesson_plan_exam_result_retrun_original,
+            "action": return_original_exam_result,
+            "inputs": [lesson_plan_exam_result_original],
+            "outputs": [lesson_plan_exam_result]
+        },
+        # 出場券相關按鈕
+        {
+            "button": exit_ticket_btn,
+            "action": get_ai_content,
+            "inputs": [password, video_id, df_string_output, content_subject, content_grade, content_level, exit_ticket_time, exit_ticket_content_type_name],
+            "outputs": [exit_ticket_exam_result_original, exit_ticket_exam_result, exit_ticket_prompt, exit_ticket_exam_result_prompt]
+        },
+        {
+            "button": exit_ticket_exam_result_fine_tune_btn,
+            "action": generate_exam_fine_tune_result,
+            "inputs": [password, exit_ticket_exam_result_prompt, df_string_output, exit_ticket_exam_result, exit_ticket_exam_result_fine_tune_prompt],
+            "outputs": [exit_ticket_exam_result]
+        },
+        {
+            "button": exit_ticket_download_exam_result_button,
+            "action": download_exam_result,
+            "inputs": [exit_ticket_exam_result],
+            "outputs": [exit_ticket_exam_result_word_link]
+        },
+        {
+            "button": exit_ticket_exam_result_retrun_original,
+            "action": return_original_exam_result,
+            "inputs": [exit_ticket_exam_result_original],
+            "outputs": [exit_ticket_exam_result]
+        }
+    ]
+    setup_education_buttons(education_buttons_config)
 
     # init_params
     init_outputs = [

chatbot.py

@@ -39,10 +39,11 @@ class Chatbot:
         return key_moments_text
 
 
-    def chat(self, user_message, chat_history, socratic_mode=False, service_type='jutor'):
+    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
-        if service_type in ['jutor', 'groq', 'claude3']:
+        service_type_list = ['openai', 'claude3', 'groq_llama3', 'groq_mixtral']
+        if service_type in service_type_list:
             response_text = self.chat_with_service(service_type, system_prompt, messages)
             return response_text
         else:
@@ -66,10 +67,12 @@ class Chatbot:
         return messages
 
     def chat_with_service(self, service_type, system_prompt, messages):
-        if service_type == 'jutor':
+        if service_type == 'openai':
             return self.chat_with_jutor(system_prompt, messages)
-        elif service_type == 'groq':
-            return self.chat_with_groq(system_prompt, messages)
+        elif service_type == 'groq_llama3':
+            return self.chat_with_groq(service_type, system_prompt, messages)
+        elif service_type == 'groq_mixtral':
+            return self.chat_with_groq(service_type, system_prompt, messages)
         elif service_type == 'claude3':
             return self.chat_with_claude3(system_prompt, messages)
         else:
@@ -83,6 +86,8 @@ class Chatbot:
             "x-api-key": self.jutor_chat_key,
         }
         model = "gpt-4-turbo"
+        print("======model======")
+        print(model)
         # model = "gpt-3.5-turbo-0125"
         data = {
             "data": {
@@ -99,11 +104,19 @@ class Chatbot:
         response_completion = response_data['data']['choices'][0]['message']['content'].strip()
         return response_completion
 
-    def chat_with_groq(self, system_prompt, messages):
+    def chat_with_groq(self, model_name, system_prompt, messages):
         # system_prompt insert to messages 的最前面 {"role": "system", "content": system_prompt}
         messages.insert(0, {"role": "system", "content": system_prompt})
+        model_name_dict = {
+            "groq_llama3": "llama3-70b-8192",
+            "groq_mixtral": "mixtral-8x7b-32768"
+        }
+        model = model_name_dict.get(model_name)
+        print("======model======")
+        print(model)
+
         request_payload = {
-            "model": "mixtral-8x7b-32768",
+            "model": model,
             "messages": messages,
             "max_tokens": 500  # 設定一個較大的值，可根據需要調整
         }
@@ -118,6 +131,8 @@ class Chatbot:
         
         model_id = "anthropic.claude-3-sonnet-20240229-v1:0"
         # model_id = "anthropic.claude-3-haiku-20240307-v1:0"
+        print("======model_id======")
+        print(model_id)
         kwargs = {
             "modelId": model_id,
             "contentType": "application/json",
@@ -129,7 +144,6 @@ class Chatbot:
                 "messages": messages
             })
         }
-        print(messages)
         # 建立 message API，讀取回應
         bedrock_client = self.ai_client
         response = bedrock_client.invoke_model(**kwargs)

educational_material.py

@@ -32,6 +32,115 @@ class EducationalMaterial:
         self.content_type = content_type  # 'worksheet' or 'lesson_plan'
         self.system_content = "你是一個擅長資料分析跟影片教學備課的老師，請精讀資料文本，自行判斷資料的種類，使用 zh-TW，遇到數學符號或是敘述請用 Latex 語法($...$)，例如：$x^2$。"
 
+    def get_ai_content(self, AI_Client ,ai_type="openai"):
+        system_content = self.system_content
+        user_content = self._build_user_content()
+        if ai_type.lower() == "openai":
+            return self.send_openai_request(AI_Client, system_content, user_content)
+        elif ai_type.lower() == "bedrock":
+            return self.send_bedrock_request(AI_Client, system_content, user_content)
+        else:
+            raise ValueError("Unsupported AI type. Please choose 'openai' or 'redrock'.")
+
+    def _build_user_content(self):
+        if self.content_type == 'worksheet':
+            specific_feature_text = f"理論模型: {self.specific_feature}"
+        elif self.content_type == 'lesson_plan':
+            specific_feature_text = f"時間: {self.specific_feature} 分鐘"
+        elif self.content_type == 'exit_ticket':
+            specific_feature_text = f"時間: {self.specific_feature} 分鐘"
+
+        # 根据属性构建用户内容
+        user_content = f"""
+            課程脈絡 or 逐字稿:{self.context}
+            主題：{self.topic}
+            年級：{self.grade}
+            難度：{self.level}
+            {specific_feature_text}
+            
+            請根據逐字稿進行以下工作：
+            - 不要提到 【逐字稿】 這個詞，直接給出內容即可
+            - 遇到數學符號或是敘述請用 Latex 語法($...$)，例如：$x^2$。
+            - 如果是中文素材，請嚴格使用 zh-TW
+            - 請用 {self.grade} 年級的口吻，不要用太難的詞彙
+            - {self.generate_content_prompt()}
+        """
+        print("====User content====")
+        print(user_content)
+        print("====User content====")
+        return user_content
+
+    def get_fine_tuned_ai_content(self, ai_client, ai_type, original_prompt, result, fine_tune_prompt):
+        system_content = self.system_content
+        user_content = self._build_fine_tune_user_content(original_prompt, result, fine_tune_prompt)
+        if ai_type.lower() == "openai":
+            return self.send_openai_request(ai_client, system_content, user_content)
+        elif ai_type.lower() == "bedrock":
+            return self.send_bedrock_request(ai_client, system_content, user_content)
+        else:
+            raise ValueError("Unsupported AI type. Please choose 'openai' or 'redrock'.")
+    
+    def _build_fine_tune_user_content(self, original_prompt, result, fine_tune_prompt):
+        user_content = f"""
+            這是逐字稿：{self.context}
+            ---
+            這是預設的 prompt
+            {original_prompt}
+            ---
+            產生了以下的結果：
+            {result}
+            ---
+            但我不是很滿意，請根據以下的調整，產生新的結果
+            {fine_tune_prompt}
+        """
+        return user_content
+
+    def send_openai_request(self, AI_Client, system_content, user_content):
+        OPEN_AI_CLIENT = AI_Client
+        messages = [{"role": "system", "content": system_content}, {"role": "user", "content": user_content}]
+        request_payload = {
+            "model": "gpt-4-turbo",
+            "messages": messages,
+            "max_tokens": 512,
+            "temperature": 0.9,
+            "stream": False,
+        }
+        try:
+            response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+            return response.choices[0].message.content.strip()
+        except Exception as e:
+            print(f"OpenAI failed: {e}")
+            raise  # Optionally re-raise the exception if fallback is not desired
+
+    def send_bedrock_request(self, AI_Client, system_content, user_content):
+        BEDROCK_CLIENT = AI_Client
+        #REDROCK
+        messages = [
+            {"role": "user", "content": user_content}
+        ]
+        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": 4000,
+                "system": system_content,
+                "messages": messages
+            })
+        }
+        
+        try:
+            response = response = BEDROCK_CLIENT.invoke_model(**kwargs)
+            response_body = json.loads(response.get('body').read())
+            response_content = response_body.get('content')[0].get('text')
+            return response_content
+        except Exception as e:
+            print(f"Bedrock failed: {e}")
+            raise
+
     def _prepare_context(self, context):
         context_json = json.loads(context)
         processed_context = ""
@@ -420,67 +529,6 @@ class EducationalMaterial:
         """
         return exit_ticket_prompt
 
-    def create_ai_content(self, ai_client, request_payload):
-        user_content = self.build_user_content()
-        messages = self.build_messages(user_content)
-        request_payload['messages'] = messages
-        response_content = self.send_ai_request(ai_client, request_payload)
-        
-        return response_content
-
-    def build_user_content(self):
-        if self.content_type == 'worksheet':
-            specific_feature_text = f"理論模型: {self.specific_feature}"
-        elif self.content_type == 'lesson_plan':
-            specific_feature_text = f"時間: {self.specific_feature} 分鐘"
-        elif self.content_type == 'exit_ticket':
-            specific_feature_text = f"時間: {self.specific_feature} 分鐘"
-
-        # 根据属性构建用户内容
-        user_content = f"""
-            課程脈絡 or 逐字稿:{self.context}
-            主題：{self.topic}
-            年級：{self.grade}
-            難度：{self.level}
-            {specific_feature_text}
-            
-            請根據逐字稿進行以下工作：
-            - 不要提到 【逐字稿】 這個詞，直接給出內容即可
-            - 遇到數學符號或是敘述請用 Latex 語法($...$)，例如：$x^2$。
-            - 如果是中文素材，請嚴格使用 zh-TW
-            - 請用 {self.grade} 年級的口吻，不要用太難的詞彙
-            - {self.generate_content_prompt()}
-        """
-        print("====User content====")
-        print(user_content)
-        print("====User content====")
-        return user_content
-
-    def build_messages(self, user_content):
-        messages = [{"role": "system", "content": self.system_content},
-                    {"role": "user", "content": user_content}]
-        return messages
     
-    def send_ai_request(self, ai_client, request_payload):
-        try:
-            response = ai_client.chat.completions.create(**request_payload)
-            response_content = response.choices[0].message.content.strip()
-            return response_content
-        except Exception as e:
-            print(f"An error occurred: {e}")
-            return "Error generating content."
 
-    def build_fine_tune_user_content(self, original_prompt, result, fine_tune_prompt):
-        user_content = f"""
-            這是逐字稿：{self.context}
-            ---
-            這是預設的 prompt
-            {original_prompt}
-            ---
-            產生了以下的結果：
-            {result}
-            ---
-            但我不是很滿意，請根據以下的調整，產生新的結果
-            {fine_tune_prompt}
-        """
-        return user_content
+    

storage_service.py

@@ -24,6 +24,12 @@ class GoogleCloudStorage:
         blob.upload_from_string(content)
         print(f"String content uploaded to {destination_blob_name} in GCS.")
         return None
+    
+    def upload_json_string(self, bucket_name, destination_blob_name, json_data):
+        """Uploads a JSON string to a specified GCS bucket."""
+        blob = self.client.bucket(bucket_name).blob(destination_blob_name)
+        blob.upload_from_string(json_data, content_type='application/json')
+        print(f"JSON string uploaded to {destination_blob_name} in GCS.")
 
     def download_as_string(self, bucket_name, source_blob_name):
         blob = self.client.bucket(bucket_name).blob(source_blob_name)
@@ -42,3 +48,8 @@ class GoogleCloudStorage:
         self.upload_file(bucket_name, file_name, file_path)
         self.make_blob_public(bucket_name, file_name)
         return self.get_public_url(bucket_name, file_name)
+    
+    def delete_blob(self, bucket_name, blob_name):
+        blob = self.client.bucket(bucket_name).blob(blob_name)
+        blob.delete()
+        print(f"Blob {blob_name} deleted from {bucket_name}.")