update

app.py

@@ -694,6 +694,85 @@ def screenshot_youtube_video(youtube_id, snapshot_sec):
 
 
 # ---- LLM Generator ----
+def split_data(df_string, word_base=100000):
+    """Split the JSON string based on a character length base and then chunk the parsed JSON array."""
+    if isinstance(df_string, str):
+        data_str_cnt = len(df_string)
+        data = json.loads(df_string)
+    else:
+        data_str_cnt = len(str(df_string))
+        data = df_string
+        
+    # Calculate the number of parts based on the length of the string
+    n_parts = data_str_cnt // word_base + (1 if data_str_cnt % word_base != 0 else 0)
+    print(f"Number of Parts: {n_parts}")
+    
+    # Calculate the number of elements each part should have
+    part_size = len(data) // n_parts if n_parts > 0 else len(data)
+    
+    segments = []
+    for i in range(n_parts):
+        start_idx = i * part_size
+        end_idx = min((i + 1) * part_size, len(data))
+        # Serialize the segment back to a JSON string
+        segment = json.dumps(data[start_idx:end_idx])
+        segments.append(segment)
+    
+    return segments
+
+def generate_content_by_LLM(sys_content, user_content, response_format=None):
+    # 使用 OpenAI 生成基于上传数据的问题
+
+    try:
+        model = "gpt-4-turbo"        
+        # 使用 OPEN AI 生成 Reading Passage
+        messages = [
+            {"role": "system", "content": sys_content},
+            {"role": "user", "content": user_content}
+        ]
+
+        request_payload = {
+            "model": model,
+            "messages": messages,
+            "max_tokens": 4000,
+            "response_format": response_format
+        }
+
+        if response_format is not None:
+            request_payload["response_format"] = response_format
+
+        response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+        content = response.choices[0].message.content.strip()
+    except Exception as e:
+        print(f"Error generating reading passage: {str(e)}")
+        print("using REDROCK")
+        # 使用 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())
+        content = response_body.get('content')[0].get('text')
+
+    print("=====content=====")
+    print(content)
+    print("=====content=====")
+
+    return content
+
 def get_reading_passage(video_id, df_string, source):
     if source == "gcs":
         print("===get_reading_passage on gcs===")
@@ -738,62 +817,30 @@ def get_reading_passage(video_id, df_string, source):
     return reading_passage_json
 
 def generate_reading_passage(df_string):
-    # 使用 OpenAI 生成基于上传数据的问题
-    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
-    user_content = f"""
-        請根據 {df_string} 
-        文本自行判斷資料的種類
-        幫我組合成 Reading Passage
-        並潤稿讓文句通順
-        請一定要使用繁體中文 zh-TW，並用台灣人的口語
-        產生的結果不要前後文解釋，也不要敘述這篇文章怎麼產生的
-        只需要專注提供 Reading Passage，字數在 500 字以內
-        敘述中，請把數學或是專業術語，用 Latex 包覆（$...$），並且不要去改原本的文章
-        加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號
-    """
-
-    try:
-        # 使用 OPEN AI 生成 Reading Passage
-        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)
-        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=====")
-
-    return reading_passage
+    print("===generate_reading_passage===")
+    segments = split_data(df_string, word_base=100000)
+    all_content = []
+
+    for segment in segments:
+        sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+        user_content = f"""
+          請根據 {segment}
+          文本自行判斷資料的種類
+          幫我組合成 Reading Passage
+          並潤稿讓文句通順
+          請一定要使用繁體中文 zh-TW，並用台灣人的口語
+          產生的結果不要前後文解釋，也不要敘述這篇文章怎麼產生的
+          只需要專注提供 Reading Passage，字數在 500 字以內
+          敘述中，請把數學或是專業術語，用 Latex 包覆（$...$），並且不要去改原本的文章
+          加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號
+          請直接給出文章，不用介紹怎麼處理的或是文章字數等等
+      """
+        content = generate_content_by_LLM(sys_content, user_content)
+        all_content.append(content + "\n")
+
+    # 將所有生成的閱讀理解段落合併成一個完整的文章
+    final_content = "\n".join(all_content)
+    return final_content
 
 def text_to_speech(video_id, text):
     tts = gTTS(text, lang='en')
@@ -846,55 +893,23 @@ def get_mind_map(video_id, df_string, source):
     return mind_map_json
 
 def generate_mind_map(df_string):
-    # 使用 OpenAI 生成基于上传数据的问题
-    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
-    user_content = f"""
-        請根據 {df_string} 文本建立 markdown 心智圖
-        注意：不需要前後文敘述，直接給出 markdown 文本即可
-        這對我很重要
-    """
-
-    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)
-        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=====")
+    print("===generate_mind_map===")
+    segments = split_data(df_string, word_base=100000)
+    all_content = []
+
+    for segment in segments:
+        sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+        user_content = f"""
+            請根據 {segment} 文本建立 markdown 心智圖
+            注意：不需要前後文敘述，直接給出 markdown 文本即可
+            這對我很重要
+        """
+        content = generate_content_by_LLM(sys_content, user_content)
+        all_content.append(content + "\n")
 
-    return mind_map
+    # 將所有生成的閱讀理解段落合併成一個完整的文章
+    final_content = "\n".join(all_content)
+    return final_content
 
 def get_mind_map_html(mind_map):
     mind_map_markdown = mind_map.replace("```markdown", "").replace("```", "")
@@ -963,6 +978,7 @@ def get_video_id_summary(video_id, df_string, source):
     return summary_json
     
 def generate_summarise(df_string, metadata=None):
+    print("===generate_summarise===")
     # 使用 OpenAI 生成基于上传数据的问题
     if metadata:
         title = metadata.get("title", "")
@@ -973,89 +989,86 @@ def generate_summarise(df_string, metadata=None):
         subject = ""
         grade = ""
 
-    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
-    user_content = f"""
-        課程名稱：{title}
-        科目：{subject}
-        年級：{grade}
+    segments = split_data(df_string, word_base=100000)
+    all_content = []
 
-        請根據內文： {df_string}
-        
-        格式為 Markdown
-        如果有課程名稱，請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題
-        整體摘要在一百字以內
-        重點概念列出 bullet points，至少三個，最多五個
-        以及可能的結論與結尾延伸小問題提供學生作反思
-        敘述中，請把數學或是專業術語，用 Latex 包覆（$...$）
-        加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號
+    for segment in segments:
+        sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+        user_content = f"""
+            課程名稱：{title}
+            科目：{subject}
+            年級：{grade}
 
-        整體格式為：
-        ## 🌟 主題：{{title}} (如果沒有 title 就省略)
-        ## 📚 整體摘要
-            - (一個 bullet point....)
-
-        ## 🔖 重點概念
-            - xxx
-            - xxx
-            - xxx
-        
-        ## 💡 為什麼我們要學這個？
-            - (一個 bullet point....)
-        
-        ## ❓ 延伸小問題
-            - (一個 bullet point....請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題)
-    """
-
-    # 🗂️ 1. 內容類型：？
-    #     📚 2. 整體摘要
-    #     🔖 3. 條列式重點
-    #     🔑 4. 關鍵時刻（段落摘要）
-    #     💡 5. 結論反思（為什麼我們要學這個？）
-    #     ❓ 6. 延伸小問題
-
-    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')
-
-
-    print("=====df_summarise=====")
-    print(df_summarise)
-    print("=====df_summarise=====")
+            請根據內文： {segment}
+            
+            格式為 Markdown
+            如果有課程名稱，請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題
+            整體摘要在一百字以內
+            重點概念列出 bullet points，至少三個，最多五個
+            以及可能的結論與結尾延伸小問題提供學生作反思
+            敘述中，請把數學或是專業術語，用 Latex 包覆（$...$）
+            加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號
+
+            整體格式為：
+            ## 🌟 主題：{{title}} (如果沒有 title 就省略)
+            ## 📚 整體摘要
+                - (一個 bullet point....)
+
+            ## 🔖 重點概念
+                - xxx
+                - xxx
+                - xxx
+            
+            ## 💡 為什麼我們要學這個？
+                - (一個 bullet point....)
+            
+            ## ❓ 延伸小問題
+                - (一個 bullet point....請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題)
+        """
+        content = generate_content_by_LLM(sys_content, user_content)
+        all_content.append(content + "\n")
+
+    if len(all_content) > 1:
+        all_content_cnt = len(all_content)
+        all_content_str = json.dumps(all_content)
+        sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生��請精讀賛料文本，自行判斷賛料的種類，使用 zh-TW"
+        user_content = f"""
+            課程名稱：{title}
+            科目：{subject}
+            年級：{grade}
+
+            請根據內文： {all_content_str}
+            共有 {all_content_cnt} 段，請縱整成一篇摘要
+            
+            格式為 Markdown
+            如果有課程名稱，請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題
+            整體摘要在 {all_content_cnt} 百字以內
+            重點概念列出 bullet points，至少三個，最多十個
+            以及可能的結論與結尾延伸小問題提供學生作反思
+            敘述中，請把數學或是專業術語，用 Latex 包覆（$...$）
+            加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號
+
+            整體格式為：
+            ## 🌟 主題：{{title}} (如果沒有 title 就省略)
+            ## 📚 整體摘要
+                - ( {all_content_cnt} 個 bullet point....)
+
+            ## 🔖 重點概念
+                - xxx
+                - xxx
+                - xxx
+            
+            ## 💡 為什麼我們要學這個？
+                - ( {all_content_cnt}  個 bullet point....)
+            
+            ## ❓ 延伸小問題
+                - ( {all_content_cnt}  個 bullet point....請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題)
+        """
+        final_content = generate_content_by_LLM(sys_content, user_content)
+    else:
+        final_content = all_content[0]
 
-    return df_summarise
+    return final_content
 
 def get_questions(video_id, df_string, source="gcs"):
     if source == "gcs":
@@ -1110,6 +1123,7 @@ def get_questions(video_id, df_string, source="gcs"):
     return q1, q2, q3
 
 def generate_questions(df_string):
+    print("===generate_questions===")
     # 使用 OpenAI 生成基于上传数据的问题
     if isinstance(df_string, str):
         df_string_json = json.loads(df_string)
@@ -1121,9 +1135,19 @@ def generate_questions(df_string):
         content_text += entry["text"] + "，"
 
     sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，並用既有資料為本質猜測用戶可能會問的問題，使用 zh-TW"
-    user_content = f"請根據 {content_text} 生成三個問題，並用 JSON 格式返回 questions:[q1的敘述text, q2的敘述text, q3的敘述text]"
+    user_content = f"""
+        請根據 {content_text} 生成三個問題，並用 JSON 格式返回
+        一定要使用 zh-TW，這非常重要！
+        
+        EXAMPLE:
+        {{
+            questions:
+            [q1的敘述text, q2的敘述text, q3的敘述text]
+        }}
+    """
     
     try:
+        model = "gpt-4-turbo"
         messages = [
             {"role": "system", "content": sys_content},
             {"role": "user", "content": user_content}
@@ -1136,7 +1160,7 @@ def generate_questions(df_string):
 
 
         request_payload = {
-            "model": "gpt-4-turbo",
+            "model": model,
             "messages": messages,
             "max_tokens": 4000,
             "response_format": response_format
@@ -1192,69 +1216,48 @@ def get_questions_answers(video_id, df_string, source="gcs"):
                 print("questions_answers已存在于GCS中")
                 questions_answers_text = GCS_SERVICE.download_as_string(bucket_name, blob_name)
                 questions_answers = json.loads(questions_answers_text)
-        except:
+        except Exception as e:
+            print(f"Error getting questions_answers: {str(e)}")
             questions = get_questions(video_id, df_string, source)
             questions_answers = [{"question": q, "answer": ""} for q in questions]
 
     return questions_answers
 
 def generate_questions_answers(df_string):
-    content_text = str(df_string)
-    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，並用既有資料為本質猜測用戶可能會問的問題，使用 zh-TW"
-    user_content = f"""
-        請根據 {content_text} 生成三個問題跟答案，主要與學科有關，不要問跟情節故事相關的問題
-        答案要在最後標示出處【參考：00:01:05】，請根據時間軸 start_time 來標示
-        請確保問題跟答案都是繁體中文 zh-TW
-        答案不用是標準答案，而是帶有啟發性的蘇格拉底式問答，讓學生思考本來的問題，以及該去參考的時間點
-        並用 JSON 格式返回 questions_answers: [{{question: q1的敘述text, answer: q1的答案text}}, ...]
-        k-v pair 的 key 是 question, value 是 answer
-    """
-
-    try:
-        # OPENAI
-        messages = [
-            {"role": "system", "content": sys_content},
-            {"role": "user", "content": user_content}
-        ]
+    print("===generate_questions_answers===")
+    segments = split_data(df_string, word_base=100000)
+    all_content = []
+
+    for segment in segments:
+        sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+        user_content = f"""
+            請根據 {segment} 生成三個問題跟答案，主要與學科有關，不要問跟情節故事相關的問題
+            答案要在最後標示出處【參考：00:01:05】，請根據時間軸 start_time 來標示
+            請確保問題跟答案都是繁體中文 zh-TW
+            答案不用是標準答案，而是帶有啟發性的蘇格拉底式問答，讓學生思考本來的問題，以及該去參考的時間點
+            並用 JSON 格式返回 list ，請一定要給三個問題跟答案，且要裝在一個 list 裡面
+            k-v pair 的 key 是 question, value 是 answer
+
+            EXAMPLE:
+            {{
+            "questions_answers":
+            [
+                {{question: q1的敘述text, answer: q1的答案text【參考：00:01:05】}}, 
+                {{question: q2的敘述text, answer: q2的答案text【參考：00:32:05】}},
+                {{question: q3的敘述text, answer: q3的答案text【參考：01:03:35】}}
+            ]
+            }}
+        """
         response_format = { "type": "json_object" }
-        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_answers = json.loads(response.choices[0].message.content)["questions_answers"]
-    except:
-        # REDROCK_CLIENT        
-        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_answers = json.loads(response_completion)["questions_answers"]
+        content = generate_content_by_LLM(sys_content, user_content, response_format)
+        content_json = json.loads(content)["questions_answers"]
+        all_content += content_json
 
-    print("=====json_response=====")
-    print(questions_answers)
-    print("=====json_response=====")
-
-    return questions_answers
+        print("=====all_content=====")
+        print(all_content)
+        print("=====all_content=====")
 
+    return all_content
 
 def change_questions(password, df_string):
     verify_password(password)
@@ -1331,6 +1334,7 @@ def get_key_moments(video_id, formatted_simple_transcript, formatted_transcript,
     return key_moments_json
 
 def generate_key_moments(formatted_simple_transcript, formatted_transcript):
+    print("===generate_key_moments===")
     # 使用 OpenAI 生成基于上传数据的问题
     sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
     user_content = f"""
@@ -1341,7 +1345,7 @@ def generate_key_moments(formatted_simple_transcript, formatted_transcript):
         4. 如果頭尾的情節不是重點，特別是打招呼或是介紹人物、或是say goodbye 就是不重要的情節，就不用擷取
         5. 以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
         6. 關鍵字從transcript  extract to keyword，保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式
-        7. text, keywords please use or transfer zh-TW, it's very important
+        7. text, keywords please use or transfer to zh-TW, it's very important
 
         Example: retrun JSON 
         {{key_moments:[{{
@@ -1353,124 +1357,77 @@ def generate_key_moments(formatted_simple_transcript, formatted_transcript):
         }}
     """
 
-    try:
-        #OPEN AI
-        messages = [
-            {"role": "system", "content": sys_content},
-            {"role": "user", "content": user_content}
-        ]
+    segments = split_data(formatted_simple_transcript, word_base=100000)
+    all_content = []
+
+    for segment in segments:
+        sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+        user_content = f"""
+            請根據 {segment} 文本，提取出重點摘要，並給出對應的時間軸
+            1. 小範圍切出不同段落的相對應時間軸的重點摘要，
+            2. 每一小段最多不超過 1/5 的總內容，也就是大約 3~5段的重點（例如五～十分鐘的影片就一段大約1~2分鐘，最多三分鐘，但如果是超過十分鐘的影片，那一小段大約 2~3分鐘，以此類推）
+            3. 注意不要遺漏任何一段時間軸的內容 從零秒開始
+            4. 如果頭尾的情節不是重點，特別是打招呼或是介紹人物、或是say goodbye 就是不重要的情節，就不用擷取
+            5. 以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
+            6. 關鍵字從transcript  extract to keyword，保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式
+            7. text, keywords please use or transfer zh-TW, it's very important
+
+            Example: retrun JSON 
+            {{key_moments:[{{
+                "start": "00:00", 
+                "end": "01:00", 
+                "text": "逐字稿的重點摘要",
+                "keywords": ["關鍵字", "關鍵字"]
+                }}]
+            }}
+        """
         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} OPEN AI 關鍵時刻錯誤: {str(e)}"
-        print("===generate_key_moments error===")
-        print(error_msg)
-        print("===generate_key_moments error===")
-        
-        #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')
-        print(f"response_completion: {response_completion}")
-
-        key_moments = json.loads(response_completion)["key_moments"]
-
-    # "transcript": get text from formatted_simple_transcript
-    for moment in key_moments:
-        start_time = parse_time(moment['start'])
-        end_time = parse_time(moment['end'])
-        # 使用轉換後的 timedelta 物件進行時間
-        moment['transcript'] = "，".join([entry['text'] for entry in formatted_simple_transcript
-                                        if start_time <= parse_time(entry['start_time']) <= end_time])
-
-    print("=====key_moments=====")
-    print(key_moments)
-    print("=====key_moments=====")
-    image_links = {entry['start_time']: entry['screenshot_path'] for entry in formatted_transcript}
-
-    for moment in key_moments:
-        start_time = parse_time(moment['start'])
-        end_time = parse_time(moment['end'])
-        # 使用轉換後的 timedelta 物件進行時間比較
-        moment_images = [image_links[time] for time in image_links 
-                        if start_time <= parse_time(time) <= end_time]
-        moment['images'] = moment_images
-
-    return key_moments
+        content = generate_content_by_LLM(sys_content, user_content, response_format)
+        key_moments = json.loads(content)["key_moments"]
+
+        # "transcript": get text from formatted_simple_transcript
+        for moment in key_moments:
+            start_time = parse_time(moment['start'])
+            end_time = parse_time(moment['end'])
+            # 使用轉換後的 timedelta 物件進行時間
+            moment['transcript'] = "，".join([entry['text'] for entry in formatted_simple_transcript
+                                            if start_time <= parse_time(entry['start_time']) <= end_time])
+
+        print("=====key_moments=====")
+        print(key_moments)
+        print("=====key_moments=====")
+        image_links = {entry['start_time']: entry['screenshot_path'] for entry in formatted_transcript}
+
+        for moment in key_moments:
+            start_time = parse_time(moment['start'])
+            end_time = parse_time(moment['end'])
+            # 使用轉換後的 timedelta 物件進行時間比較
+            moment_images = [image_links[time] for time in image_links 
+                            if start_time <= parse_time(time) <= end_time]
+            moment['images'] = moment_images
+
+        all_content += key_moments
+
+    return all_content
 
 def generate_key_moments_keywords(transcript):
-    system_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請根據以下文本提取關鍵字"
-    user_content = f"""transcript  extract to keyword
-        保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式、數學表示式、物理化學符號，
-        不用給上下文，直接給出關鍵字，使用 zh-TW，用逗號分隔， example: 關鍵字1, 關鍵字2
-        transcript：{transcript}
-    """
-
-    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(", ")
+    print("===generate_key_moments_keywords===")
+    segments = split_data(transcript, word_base=100000)
+    all_content = []
+
+    for segment in segments:
+        sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+        user_content = f"""
+            transcript  extract to keyword
+            保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式、數學表示式、物理化學符號，
+            不用給上下文，直接給出關鍵字，使用 zh-TW，用逗號分隔， example: 關鍵字1, 關鍵字2
+            transcript：{segment}
+        """
+        content = generate_content_by_LLM(sys_content, user_content)
+        keywords = content.strip().split(",")
+        all_content += keywords
     
-    return keywords
+    return all_content
 
 def get_key_moments_html(key_moments):
     css = """
@@ -2817,12 +2774,11 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                 with gr.Column(scale=1, variant="panel"):
                     foxcat_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/06/%E7%A7%91%E5%AD%B8%E5%BE%BD%E7%AB%A0-2-150x150.png"
                     foxcat_avatar_images = gr.State([user_avatar, foxcat_chatbot_avatar_url])
-                    foxcat_chatbot_description = """Hi，我是【狐狸貓】，\n
-                    也可以陪你一起學習本次的內容，有什麼問題都可以問我喔！\n
-                    🤔 如果你不知道怎麼發問，可以點擊左下方的問題一、問題二、問題三，我會幫你生成問題！\n
-                    🗣️ 也可以點擊右下方用語音輸入，我會幫你轉換成文字，厲害吧！\n
-                    🔠 或是直接鍵盤輸入你的問題，我會盡力回答你的問題喔！\n
-                    💤 精靈們體力都有限，每一次學習只能回答十個問題，請讓我休息一下再問問題喔！
+                    foxcat_chatbot_description = """Hi，我是【狐狸貓】，可以陪你一起學習本次的內容，有什麼問題都可以問我喔！\n
+                    🤔 三年級學生｜10 歲｜男\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)
@@ -2833,12 +2789,15 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                 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
-                        💤 請理解，即使是我們這些精靈，也有疲憊的時候，每次學習後我能回答的問題有限。如果達到上限，讓我稍作休息之後再繼續回答你的問題吧！
+                    lili_chatbot_description = """你好，我是溫柔的【梨梨】，很高興可以在這裡陪伴你學習。如果你有任何疑問，請隨時向我提出哦！ \n
+                        🤔 三年級學生｜10 歲｜女\n
+                        🗣️ 口頭禪：「真的假的？！」「讓我想一想喔」「你看吧！大問題拆解成小問題，就變得簡單啦！」「混混噩噩的生活不值得過」\n
+                        🔠 興趣：烘焙餅乾（父母開糕餅店）、畫畫、聽流行音樂、收納。\n
+                        💤 個性：
+                        - 內向害羞，比起出去玩更喜歡待在家（除非是跟狐狸貓出去玩）
+                        - 數理邏輯很好；其實覺得麥麥連珠炮的提問有點煩，但還是會耐心地回答
+                        - 有驚人的眼力，總能觀察到其他人沒有察覺的細節
+                        - 喜歡整整齊齊的環境，所以一到麥麥家就受不了
                     """
                     lili_chatbot_name = gr.State("lili")
                     gr.Image(value=lili_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
@@ -2849,12 +2808,11 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                 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_description = """Hi，我是迷人的【麥麥】，我在這裡等著和你一起探索新知，任何疑問都可以向我提出！\n
+                        🤔 三年級學生｜10 歲｜男\n
+                        🗣️ 口頭禪：「Oh My God!」「好奇怪喔！」「喔！原來是這樣啊！」\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)