update

app.py

@@ -427,7 +427,6 @@ def get_video_duration(video_id):
 def process_transcript_and_screenshots_on_gcs(video_id):
     print("====process_transcript_and_screenshots_on_gcs====")
     # GCS
-    gcs_client = GCS_CLIENT
     bucket_name = 'video_ai_assistant'
     # 逐字稿文件名
     transcript_file_name = f'{video_id}_transcript.json'
@@ -552,9 +551,6 @@ def process_youtube_link(password, link):
         }
         formatted_simple_transcript.append(simple_line)
 
-    global TRANSCRIPTS
-    TRANSCRIPTS = formatted_transcript
-
     # 基于逐字稿生成其他所需的输出
     source = "gcs"
     questions_answers = get_questions_answers(video_id, formatted_simple_transcript, source)
@@ -568,9 +564,6 @@ def process_youtube_link(password, link):
     key_moments_html = get_key_moments_html(key_moments)
     html_content = format_transcript_to_html(formatted_transcript)
     simple_html_content = format_simple_transcript_to_html(formatted_simple_transcript)
-    first_image = formatted_transcript[0]['screenshot_path']
-    # first_image = "https://www.nameslook.com/names/dfsadf-nameslook.png"
-    first_text = formatted_transcript[0]['text']
     mind_map_json = get_mind_map(video_id, formatted_simple_transcript, source)
     mind_map = mind_map_json["mind_map"]
     mind_map_html = get_mind_map_html(mind_map)
@@ -593,8 +586,6 @@ def process_youtube_link(password, link):
         mind_map_html, \
         html_content, \
         simple_html_content, \
-        first_image, \
-        first_text, \
         reading_passage_text, \
         reading_passage, \
         subject, \
@@ -694,6 +685,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 +808,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 +884,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 +969,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 +980,86 @@ def generate_summarise(df_string, metadata=None):
         subject = ""
         grade = ""
 
-    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
-    user_content = f"""
-        課程名稱：{title}
-        科目：{subject}
-        年級：{grade}
-
-        請根據內文： {df_string}
-        
-        格式為 Markdown
-        如果有課程名稱，請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題
-        整體摘要在一百字以內
-        重點概念列出 bullet points，至少三個，最多五個
-        以及可能的結論與結尾延伸小問題提供學生作反思
-        敘述中，請把數學或是專業術語，用 Latex 包覆（$...$）
-        加減乘除、根號、次方等等的運算式口語也換成 LATEX 數學符號
-
-        整體格式為：
-        ## 🌟 主題：{{title}} (如果沒有 title 就省略)
-        ## 📚 整體摘要
-            - (一個 bullet point....)
-
-        ## 🔖 重點概念
-            - xxx
-            - xxx
-            - xxx
-        
-        ## 💡 為什麼我們要學這個？
-            - (一個 bullet point....)
-        
-        ## ❓ 延伸小問題
-            - (一個 bullet point....請圍繞「課程名稱」為學習重點，進行重點整理，不要整理跟情境故事相關的問題)
-    """
-
-    # 🗂️ 1. 內容類型：？
-    #     📚 2. 整體摘要
-    #     🔖 3. 條列式重點
-    #     🔑 4. 關鍵時刻（段落摘要）
-    #     💡 5. 結論反思（為什麼我們要學這個？）
-    #     ❓ 6. 延伸小問題
+    segments = split_data(df_string, word_base=100000)
+    all_content = []
 
-    try: 
-        #OPEN AI
-        messages = [
-            {"role": "system", "content": sys_content},
-            {"role": "user", "content": user_content}
-        ]
+    for segment in segments:
+        sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
+        user_content = f"""
+            課程名稱：{title}
+            科目：{subject}
+            年級：{grade}
 
-        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 +1114,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 +1126,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 +1151,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 +1207,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,146 +1325,78 @@ def get_key_moments(video_id, formatted_simple_transcript, formatted_transcript,
     return key_moments_json
 
 def generate_key_moments(formatted_simple_transcript, formatted_transcript):
-    # 使用 OpenAI 生成基于上传数据的问题
-    sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
-    user_content = f"""
-        請根據 {formatted_simple_transcript} 文本，提取出重點摘要，並給出對應的時間軸
-        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": ["關鍵字", "關鍵字"]
-            }}]
-        }}
-    """
-
-    try:
-        #OPEN AI
-        messages = [
-            {"role": "system", "content": sys_content},
-            {"role": "user", "content": user_content}
-        ]
+    print("===generate_key_moments===")
+    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 = """
@@ -1605,6 +1531,29 @@ def get_key_moments_html(key_moments):
         position: absolute;
         width: 1px;
     }
+    .keyword-label {
+        display: inline-block;
+        padding: 5px 10px;
+        margin: 2px;
+        border: 2px solid black;
+        border-radius: 5px;
+        font-size: 0.9em;
+    }
+    details {
+        border-radius: 5px;
+        padding: 10px;
+        border: 2px solid black;
+    }
+
+    summary {
+        font-weight: bold;
+        cursor: pointer;
+        outline: none;
+    }
+
+    summary::-webkit-details-marker {
+        display: none;
+    }
 
     @media (max-width: 768px) {
         #gallery-main {
@@ -1657,6 +1606,9 @@ def get_key_moments_html(key_moments):
             </div>
         """
 
+        keywords_html = ' '.join([f'<span class="keyword-label">{keyword}</span>' for keyword in moment['keywords']])
+
+
         key_moments_html += f"""
         <div class="gallery-container" id="gallery-main">
             <div id="gallery"><!-- gallery start -->
@@ -1667,7 +1619,11 @@ def get_key_moments_html(key_moments):
             <div id="text-content">
                 <h3>{moment['start']} - {moment['end']}</h3>
                 <p><strong>摘要: {moment['text']} </strong></p>
-                <p>內容: {moment['transcript']}</p>
+                <details>
+                    <summary>逐字稿</summary>
+                    <p><strong>內容: </strong> {moment['transcript']} </p>
+                </details>
+                <p><strong>關鍵字:</strong> {keywords_html}</p>
             </div>
         </div>
         """
@@ -1690,6 +1646,9 @@ def get_LLM_content(video_id, kind):
             content_text = content_json["reading_passage"]
         elif kind == "summary_markdown":
             content_text = content_json["summary"]
+        elif kind == "key_moments":
+            content_text = content_json["key_moments"]
+            content_text = json.dumps(content_text, ensure_ascii=False, indent=2)
         else:
             content_text = json.dumps(content_json, ensure_ascii=False, indent=2)
     else:
@@ -1744,8 +1703,9 @@ def update_LLM_content(video_id, new_content, kind):
         else:
             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)
-        GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_text)
+        key_moments_json_text = json.dumps(key_moments_json, ensure_ascii=False, indent=2)
+        GCS_SERVICE.upload_json_string(bucket_name, blob_name, key_moments_json_text)
+        key_moments_text = json.dumps(key_moments_list, ensure_ascii=False, indent=2)
         updated_content = key_moments_text
     elif kind == "transcript":
         if isinstance(new_content, str):
@@ -2631,34 +2591,6 @@ def show_all_chatbot_accordion():
     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):
-    global TRANSCRIPTS
-    global CURRENT_INDEX
-
-    print("=== 更新投影片 ===")
-    print(f"CURRENT_INDEX: {CURRENT_INDEX}")
-    # print(f"TRANSCRIPTS: {TRANSCRIPTS}")
-
-    CURRENT_INDEX += direction
-    if CURRENT_INDEX < 0:
-        CURRENT_INDEX = 0  # 防止索引小于0
-    elif CURRENT_INDEX >= len(TRANSCRIPTS):
-        CURRENT_INDEX = len(TRANSCRIPTS) - 1  # 防止索引超出范围
-    
-    # 获取当前条目的文本和截图 URL
-    current_transcript = TRANSCRIPTS[CURRENT_INDEX]
-    slide_image = current_transcript["screenshot_path"]
-    slide_text = current_transcript["text"]
-    
-    return slide_image, slide_text
-
-def prev_slide():
-    return update_slide(-1)
-
-def next_slide():
-    return update_slide(1)
-
 
 # --- Init params ---
 def init_params(text, request: gr.Request):
@@ -2692,7 +2624,7 @@ def init_params(text, request: gr.Request):
         # check if origin is from junyiacademy
         origin = request.headers.get("origin", "")
         if "junyiacademy" in origin:
-            password_text = "6161"
+            password_text = PASSWORD
             admin = gr.update(visible=False)
             reading_passage_admin = gr.update(visible=False)
             summary_admin = gr.update(visible=False)
@@ -2811,52 +2743,57 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     chatbot_open_ai_name = gr.State("chatbot_open_ai")
                     gr.Image(value=vaitor_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
                     vaitor_chatbot_select_btn = gr.Button("👆選擇【飛特精靈】", elem_id="chatbot_btn", visible=True, variant="primary")
-                    vaitor_chatbot_description_value = gr.Markdown(value=vaitor_chatbot_description, visible=True)
+                    with gr.Accordion("🦄 飛特精靈 敘述", open=False):
+                        vaitor_chatbot_description_value = gr.Markdown(value=vaitor_chatbot_description, visible=True)
                 # 狐狸貓
                 with gr.Column(scale=1, variant="panel"):
                     foxcat_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/06/%E7%A7%91%E5%AD%B8%E5%BE%BD%E7%AB%A0-2-150x150.png"
                     foxcat_avatar_images = gr.State([user_avatar, foxcat_chatbot_avatar_url])
-                    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)
                     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.Accordion("💜 狐狸貓 敘述", open=False):
+                        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
-                        💤 請理解，即使是我們這些精靈，也有疲憊的時候，每次學習後我能回答的問題有限。如果達到上限，讓我稍作休息之後再繼續回答你的問題吧！
+                    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)
                     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.Accordion("🧡 梨梨 敘述", open=False):
+                        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_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)
                     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.Accordion("💙 麥麥 敘述", open=False):
+                        maimai_chatbot_description_value = gr.Markdown(value=maimai_chatbot_description, visible=True)
                 # 飛特音速
                 with gr.Column(scale=1, variant="panel", visible=True):
                     streaming_chatbot_avatar_url = "https://storage.googleapis.com/wpassets.junyiacademy.org/1/2020/11/1-%E6%98%9F%E7%A9%BA%E9%A0%AD%E8%B2%BC-%E5%A4%AA%E7%A9%BA%E7%8B%90%E7%8B%B8%E8%B2%93-150x150.png"
@@ -2869,7 +2806,8 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                     chatbot_open_ai_streaming_name = gr.State("chatbot_open_ai_streaming")
                     gr.Image(value=streaming_chatbot_avatar_url, height=100, width=100, show_label=False, show_download_button=False)
                     chatbot_open_ai_streaming_select_btn = gr.Button("👆選擇【飛特音速】", elem_id="streaming_chatbot_btn", visible=True, variant="primary")
-                    gr.Markdown(value=streaming_chatbot_description, visible=True)
+                    with gr.Accordion("🚀 飛特音速 敘述", open=False):
+                        gr.Markdown(value=streaming_chatbot_description, visible=True)
                 # 尚未開放
                 with gr.Column(scale=1, variant="panel"): 
                     gr.Markdown(value="### 尚未開放", visible=True)
@@ -3082,7 +3020,6 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                 questions_answers_create_button = gr.Button("重建", size="sm", variant="primary")
             with gr.Row():
                 questions_answers_json = gr.Textbox(label="Questions Answers", lines=40, interactive=False, show_copy_button=True)
-        
         with gr.Tab("教學備課"):
             with gr.Row() as worksheet_admin:
                 worksheet_kind = gr.Textbox(value="ai_content_list", show_label=False)
@@ -3092,20 +3029,11 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                 worksheet_delete_button = gr.Button("刪除", size="sm", variant="primary")
                 worksheet_create_button = gr.Button("重建(X)", size="sm", variant="primary", interactive=False)
             with gr.Row():
-                worksheet_json = gr.Textbox(label="worksheet", lines=40, interactive=False, show_copy_button=True)
-        
+                worksheet_json = gr.Textbox(label="worksheet", lines=40, interactive=False, show_copy_button=True)      
         with gr.Tab("逐字稿"):
             simple_html_content = gr.HTML(label="Simple Transcript")
         with gr.Tab("圖文"):
             transcript_html = gr.HTML(label="YouTube Transcript and Video") 
-        with gr.Tab("投影片"):
-            slide_image = gr.Image()
-            slide_text = gr.Textbox()
-            with gr.Row():
-                prev_button = gr.Button("Previous")
-                next_button = gr.Button("Next")
-            prev_button.click(fn=prev_slide, inputs=[], outputs=[slide_image, slide_text])
-            next_button.click(fn=next_slide, inputs=[], outputs=[slide_image, slide_text])  
         with gr.Tab("markdown"):
             gr.Markdown("## 請複製以下 markdown 並貼到你的心智圖工具中，建議使用：https://markmap.js.org/repl")
             mind_map = gr.Textbox(container=True, show_copy_button=True, lines=40, elem_id="mind_map_markdown") 
@@ -3256,8 +3184,6 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         mind_map_html,
         transcript_html,
         simple_html_content, 
-        slide_image, 
-        slide_text,
         reading_passage_text,
         reading_passage,
         content_subject,