update

app.py

@@ -72,7 +72,6 @@ else:
 
 TRANSCRIPTS = []
 CURRENT_INDEX = 0
-VIDEO_ID = ""
 
 OPEN_AI_CLIENT = OpenAI(api_key=OPEN_AI_KEY)
 GROQ_CLIENT = Groq(api_key=GROQ_API_KEY)
@@ -373,6 +372,9 @@ def get_transcript(video_id):
     for language in languages:
         try:
             transcript = YouTubeTranscriptApi.get_transcript(video_id, languages=[language])
+            print("===transcript===")
+            print(transcript)
+            print("===transcript===")
             return transcript  # 成功獲取字幕，直接返回結果
         except NoTranscriptFound:
             continue  # 當前語言的字幕沒有找到，繼續嘗試下一個語言
@@ -413,73 +415,33 @@ def generate_transcription(video_id):
         chunk_path = f"{OUTPUT_PATH}/{video_id}_part_{i}.{codec_name}"
         chunk.export(chunk_path, format=codec_name)
 
-        with open(chunk_path, "rb") as chunk_file:
-            response = OPEN_AI_CLIENT.audio.transcriptions.create(
-                model="whisper-1",
-                file=chunk_file,
-                response_format="verbose_json",
-                timestamp_granularities=["segment"],
-                prompt="Transcribe the following audio file. if chinese, please using 'language: zh-TW' ",
-            )
-            
-            # Adjusting the timestamps for the chunk based on its position in the full audio
-            adjusted_segments = [{
-                'text': segment['text'],
-                'start': math.ceil(segment['start'] + start_time / 1000.0),  # Converting milliseconds to seconds
-                'end': math.ceil(segment['end'] + start_time / 1000.0),
-                'duration': math.ceil(segment['end'] - segment['start'])
-            } for segment in response.segments]
-
-            transcription.extend(adjusted_segments)
+        try:
+            with open(chunk_path, "rb") as chunk_file:
+                response = OPEN_AI_CLIENT.audio.transcriptions.create(
+                    model="whisper-1",
+                    file=chunk_file,
+                    response_format="verbose_json",
+                    timestamp_granularities=["segment"],
+                    prompt="Transcribe the following audio file. if content is chinese, please using 'language: zh-TW' ",
+                )
+                
+                # Adjusting the timestamps for the chunk based on its position in the full audio
+                adjusted_segments = [{
+                    'text': segment['text'],
+                    'start': math.ceil(segment['start'] + start_time / 1000.0),  # Converting milliseconds to seconds
+                    'end': math.ceil(segment['end'] + start_time / 1000.0),
+                    'duration': math.ceil(segment['end'] - segment['start'])
+                } for segment in response.segments]
+
+                transcription.extend(adjusted_segments)
+        except Exception as e:
+            print(f"Error processing chunk {i}: {str(e)}")
 
         # Remove temporary chunk files after processing
         os.remove(chunk_path)
 
     return transcription
  
-def process_transcript_and_screenshots(video_id):
-    print("====process_transcript_and_screenshots====")
-
-    # Drive
-    service = init_drive_service()
-    parent_folder_id = '1GgI4YVs0KckwStVQkLa1NZ8IpaEMurkL'
-    folder_id = create_folder_if_not_exists(service, video_id, parent_folder_id)
-    
-    # 逐字稿文件名
-    file_name = f'{video_id}_transcript.json'
-    # 检查逐字稿是否存在
-    exists, file_id = check_file_exists(service, folder_id, file_name)
-    if not exists:
-        # 从YouTube获取逐字稿并上传
-        transcript = get_transcript(video_id)
-        if transcript:
-            print("成功獲取字幕")
-        else:
-            print("沒有找到字幕")
-        transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
-        file_id = upload_content_directly(service, file_name, folder_id, transcript_text)
-        print("逐字稿已上传到Google Drive")
-    else:
-        # 逐字稿已存在，下载逐字稿内容
-        print("逐字稿已存在于Google Drive中")
-        transcript_text = download_file_as_string(service, file_id)
-        transcript = json.loads(transcript_text)
-
-    # 处理逐字稿中的每个条目，检查并上传截图
-    for entry in transcript:
-        if 'img_file_id' not in entry:
-            screenshot_path = screenshot_youtube_video(video_id, entry['start'])
-            img_file_id = upload_img_directly(service, f"{video_id}_{entry['start']}.jpg", folder_id, screenshot_path)
-            set_public_permission(service, img_file_id)
-            entry['img_file_id'] = img_file_id
-            print(f"截图已上传到Google Drive: {img_file_id}")
-    
-    # 更新逐字稿文件
-    updated_transcript_text = json.dumps(transcript, ensure_ascii=False, indent=2)
-    update_file_on_drive(service, file_id, updated_transcript_text)
-    print("逐字稿已更新，包括截图链接")
-    return transcript
-
 def process_transcript_and_screenshots_on_gcs(video_id):
     print("====process_transcript_and_screenshots_on_gcs====")
     # GCS
@@ -492,6 +454,7 @@ def process_transcript_and_screenshots_on_gcs(video_id):
     is_new_transcript = False
     is_transcript_exists = GCS_SERVICE.check_file_exists(bucket_name, transcript_blob_name)
     if not is_transcript_exists:
+        print("逐字稿文件不存在于GCS中，重新建立")
         # 从YouTube获取逐字稿并上传
         try:
             transcript = get_transcript(video_id)
@@ -567,11 +530,8 @@ def process_youtube_link(password, link):
     # 使用 YouTube API 获取逐字稿
     # 假设您已经获取了 YouTube 视频的逐字稿并存储在变量 `transcript` 中
     video_id = extract_youtube_id(link)
-    global VIDEO_ID
-    VIDEO_ID = video_id
     
     try:
-        # transcript = process_transcript_and_screenshots(video_id)
         transcript = process_transcript_and_screenshots_on_gcs(video_id)
     except Exception as e:
         error_msg = f" {video_id} 逐字稿錯誤: {str(e)}"
@@ -579,17 +539,14 @@ def process_youtube_link(password, link):
         print(error_msg)
         raise gr.Error(error_msg)
 
+    original_transcript = json.dumps(transcript, ensure_ascii=False, indent=2)
     formatted_transcript = []
     formatted_simple_transcript =[]
-    screenshot_paths = []
     for entry in transcript:
         start_time = format_seconds_to_time(entry['start'])
         end_time = format_seconds_to_time(entry['start'] + entry['duration'])
         embed_url = get_embedded_youtube_link(video_id, entry['start'])
         img_file_id = entry['img_file_id']
-        # img_file_id =""
-        # 先取消 Google Drive 的图片
-        # screenshot_path = f"https://lh3.googleusercontent.com/d/{img_file_id}=s4000"
         screenshot_path = img_file_id
         line = {
             "start_time": start_time,
@@ -606,7 +563,6 @@ def process_youtube_link(password, link):
             "text": entry['text']
         }
         formatted_simple_transcript.append(simple_line)
-        screenshot_paths.append(screenshot_path)
 
     global TRANSCRIPTS
     TRANSCRIPTS = formatted_transcript
@@ -614,11 +570,12 @@ def process_youtube_link(password, link):
     # 基于逐字稿生成其他所需的输出
     source = "gcs"
     questions = get_questions(video_id, formatted_simple_transcript, source)
-    formatted_transcript_json = json.dumps(formatted_transcript, ensure_ascii=False, indent=2)
+    questions_json = json.dumps(questions, ensure_ascii=False, indent=2)
     summary_json = get_video_id_summary(video_id, formatted_simple_transcript, source)
     summary = summary_json["summary"]
     key_moments_json = get_key_moments(video_id, formatted_simple_transcript, formatted_transcript, source)
     key_moments = key_moments_json["key_moments"]
+    key_moments_text = json.dumps(key_moments, ensure_ascii=False, indent=2)
     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)
@@ -636,11 +593,13 @@ def process_youtube_link(password, link):
 
     # 确保返回与 UI 组件预期匹配的输出
     return video_id, \
+        questions_json, \
         questions[0] if len(questions) > 0 else "", \
         questions[1] if len(questions) > 1 else "", \
         questions[2] if len(questions) > 2 else "", \
-        formatted_transcript_json, \
+        original_transcript, \
         summary, \
+        key_moments_text, \
         key_moments_html, \
         mind_map, \
         mind_map_html, \
@@ -652,6 +611,37 @@ def process_youtube_link(password, link):
         subject, \
         grade
             
+def create_formatted_simple_transcript(transcript):
+    formatted_simple_transcript = []
+    for entry in transcript:
+        start_time = format_seconds_to_time(entry['start'])
+        end_time = format_seconds_to_time(entry['start'] + entry['duration'])
+        line = {
+            "start_time": start_time,
+            "end_time": end_time,
+            "text": entry['text']
+        }
+        formatted_simple_transcript.append(line)
+    return formatted_simple_transcript
+
+def create_formatted_transcript(video_id, transcript):
+    formatted_transcript = []
+    for entry in transcript:
+        start_time = format_seconds_to_time(entry['start'])
+        end_time = format_seconds_to_time(entry['start'] + entry['duration'])
+        embed_url = get_embedded_youtube_link(video_id, entry['start'])
+        img_file_id = entry['img_file_id']
+        screenshot_path = img_file_id
+        line = {
+            "start_time": start_time,
+            "end_time": end_time,
+            "text": entry['text'],
+            "embed_url": embed_url,
+            "screenshot_path": screenshot_path
+        }
+        formatted_transcript.append(line)
+    return formatted_transcript
+
 def format_transcript_to_html(formatted_transcript):
     html_content = ""
     for entry in formatted_transcript:
@@ -1088,6 +1078,22 @@ def get_key_moments(video_id, formatted_simple_transcript, formatted_transcript,
             print("key_moments已存在于GCS中")
             key_moments_text = download_blob_to_string(gcs_client, bucket_name, blob_name)
             key_moments_json = json.loads(key_moments_text)
+             # 檢查 key_moments 是否有 keywords
+            print("===檢查 key_moments 是否有 keywords===")
+            has_keywords_added = False
+            for key_moment in key_moments_json["key_moments"]:
+                if "keywords" not in key_moment:
+                    transcript = key_moment["transcript"]
+                    key_moment["keywords"] = generate_key_moments_keywords(transcript)
+                    print("===keywords===")
+                    print(key_moment["keywords"])
+                    print("===keywords===")
+                    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)
+                key_moments_json = json.loads(key_moments_text)
 
     elif source == "drive":
         print("===get_key_moments on drive===")
@@ -1117,20 +1123,21 @@ def generate_key_moments(formatted_simple_transcript, formatted_transcript):
     sys_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請精讀資料文本，自行判斷資料的種類，使用 zh-TW"
     user_content = f"""
         請根據 {formatted_simple_transcript} 文本，提取出重點摘要，並給出對應的時間軸
-        重點摘要的「關鍵時刻」加上截圖資訊
         1. 小範圍切出不同段落的相對應時間軸的重點摘要，
         2. 每一小段最多不超過 1/5 的總內容，也就是大約 3~5段的重點（例如五～十分鐘的影片就一段大約1~2分鐘，最多三分鐘，但如果是超過十分鐘的影片，那一小段大約 2~3分鐘，以此類推）
         3. 注意不要遺漏任何一段時間軸的內容 從零秒開始
         4. 如果頭尾的情節不是重點，就併入到附近的段落，特別是打招呼或是介紹人物就是不重要的情節
         5. transcript 逐字稿的集合（要有合理的標點符號)，要完整跟原來的一樣，不要省略
         以這種方式分析整個文本，從零秒開始分析，直到結束。這很重要
+        6. 關鍵字從transcript  extract to keyword，保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式
+        7. text, transcript, keywords please use or transfer zh-TW, it's very important
 
         並用 JSON 格式返回 key_moments:[{{
             "start": "00:00", 
-            "end": "00:00", 
+            "end": "01:00", 
             "text": "逐字稿的重點摘要",
             "transcript": "逐字稿的集合（要有合理的標點符號)，要完整跟原來的一樣，不要省略",
-            "images": 截圖的連結們 list
+            "keywords": ["關鍵字", "關鍵字"]
         }}]
     """
     messages = [
@@ -1148,6 +1155,8 @@ def generate_key_moments(formatted_simple_transcript, formatted_transcript):
 
     try:
         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)}"
@@ -1168,6 +1177,28 @@ def generate_key_moments(formatted_simple_transcript, formatted_transcript):
 
     return key_moments
 
+def generate_key_moments_keywords(transcript):
+    system_content = "你是一個擅長資料分析跟影片教學的老師，user 為學生，請根據以下文本提取關鍵字"
+    user_content = f"""transcript  extract to keyword
+        保留專家名字、專業術語、年份、數字、期刊名稱、地名、數學公式、數學表示式、物理化學符號，
+        不用給上下文，直接給出關鍵字，使用 zh-TW，用逗號分隔， example: 關鍵字1, 關鍵字2
+        transcript：{transcript}
+    """
+    messages = [
+        {"role": "system", "content": system_content},
+        {"role": "user", "content": user_content}
+    ]
+    request_payload = {
+        "model": "gpt-4-1106-preview",
+        "messages": messages,
+        "max_tokens": 100,
+    }
+
+    response = OPEN_AI_CLIENT.chat.completions.create(**request_payload)
+    keywords = response.choices[0].message.content.strip().split(", ")
+    
+    return keywords
+
 def get_key_moments_html(key_moments):
     css = """
     <style>
@@ -1380,11 +1411,11 @@ def delete_LLM_content(video_id, kind):
     bucket_name = 'video_ai_assistant'
     file_name = f'{video_id}_{kind}.json'
     blob_name = f"{video_id}/{file_name}"
-    # 检查 reading_passage 是否存在
+    # 检查 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)
-        print("reading_passage已从GCS中删除")
+        print(f"{file_name}已从GCS中删除")
     return gr.update(value="", interactive=False)
 
 def update_LLM_content(video_id, new_content, kind):
@@ -1398,28 +1429,82 @@ def update_LLM_content(video_id, new_content, kind):
         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)
+        updated_content = reading_passage_text
     elif kind == "summary":
         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)
+        updated_content = summary_text
     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)
+        updated_content = mind_map_text
+    elif kind == "key_moments":
+        # from update_LLM_btn  -> new_content is a string
+        # create_LLM_content -> new_content is a list
+        if isinstance(new_content, str):
+            key_moments_list = json.loads(new_content)
+        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)
+        upload_file_to_gcs_with_json_string(gcs_client, bucket_name, blob_name, key_moments_text)
+        updated_content = key_moments_text
+    elif kind == "transcript":
+        if isinstance(new_content, str):
+            transcript_json = json.loads(new_content)
+        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)
+        updated_content = transcript_text
+    elif kind == "questions":
+        # from update_LLM_btn  -> new_content is a string
+        # create_LLM_content -> new_content is a list
+        if isinstance(new_content, str):
+            questions_json = json.loads(new_content)
+        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)
+        updated_content = questions_text
 
     print(f"{kind} 已更新到GCS")
-    return gr.update(value=new_content, interactive=False)
+    return gr.update(value=updated_content, interactive=False)
 
 def create_LLM_content(video_id, df_string, kind):
     print(f"===create_{kind}===")
+    print(f"video_id: {video_id}")
+
     if kind == "reading_passage":
         content = generate_reading_passage(df_string)
+        update_LLM_content(video_id, content, kind)
     elif kind == "summary":
         content = generate_summarise(df_string)
+        update_LLM_content(video_id, content, kind)
     elif kind == "mind_map":
         content = generate_mind_map(df_string)
+        update_LLM_content(video_id, content, kind)
+    elif kind == "key_moments":
+        if isinstance(df_string, str):
+            transcript = json.loads(df_string)
+        else:
+            transcript = df_string
+        formatted_simple_transcript = create_formatted_simple_transcript(transcript)
+        formatted_transcript = create_formatted_transcript(video_id, transcript)
+        content = generate_key_moments(formatted_simple_transcript, formatted_transcript)
+        update_LLM_content(video_id, content, kind)
+        content = json.dumps(content, ensure_ascii=False, indent=2)
+    elif kind == "transcript":
+        content = process_transcript_and_screenshots_on_gcs(video_id)
+        update_LLM_content(video_id, content, kind)
+        content = json.dumps(content, ensure_ascii=False, indent=2)
+    elif kind == "questions":
+        content = generate_questions(df_string)
+        update_LLM_content(video_id, content, kind)
+        content = json.dumps(content, ensure_ascii=False, indent=2)
 
-    update_LLM_content(video_id, content, kind)
     return gr.update(value=content, interactive=False)
 
 
@@ -1565,7 +1650,27 @@ def download_exam_result(content):
     return word_path
 
 # ---- Chatbot ----
-def chat_with_ai(ai_name, password, video_id, trascript, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
+def get_instructions(content_subject, content_grade, key_moments):
+    instructions = f"""
+        subject: {content_subject}
+        grade: {content_grade}
+        context: {key_moments}
+        Assistant Role: you are a {content_subject} teacher
+        User Role: {content_grade} th-grade student.
+        Method: Socratic style, guide thinking, no direct answers. this is very important, please be seriously following.
+        Language: Traditional Chinese ZH-TW (it's very important), suitable for {content_grade} th-grade level.
+        Response: 
+        - Single question, under 100 characters
+        - include math symbols (use LaTeX $ to cover before and after)
+        - hint with video timestamp which format 【參考：00:00:00】. 
+        - Sometimes encourage user by Taiwanese style with relaxing atmosphere.
+        - if user ask questions not include in context, 
+        - just tell them to ask the question in context and give them example question.
+        Restrictions: Answer within video content, no external references
+    """
+    return instructions
+
+def chat_with_ai(ai_name, password, video_id, trascript_state, key_moments, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
     verify_password(password)
 
     if chat_history is not None and len(chat_history) > 10:
@@ -1578,18 +1683,42 @@ def chat_with_ai(ai_name, password, video_id, trascript, user_message, chat_hist
         ai_client = BEDROCK_CLIENT
     elif ai_name == "groq":
         ai_client = GROQ_CLIENT
+    if isinstance(trascript_state, str):
+        simple_transcript = json.loads(trascript_state)
+    else:
+        simple_transcript = trascript_state
   
+    if isinstance(key_moments, str):
+        key_moments_json = json.loads(key_moments)
+    else:
+        key_moments_json = key_moments
+    # key_moments_json remove images
+    for moment in key_moments_json:
+        moment.pop('images', None)
+        moment.pop('end', None)
+        moment.pop('text', None)
+    key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
+
+    instructions = get_instructions(content_subject, content_grade, key_moments_text)
+
     chatbot_config = {
         "video_id": video_id,
-        "trascript": trascript,
+        "transcript": simple_transcript,
+        "key_moments": key_moments,
         "content_subject": content_subject,
         "content_grade": content_grade,
         "jutor_chat_key": JUTOR_CHAT_KEY,
         "ai_name": ai_name,
-        "ai_client": ai_client
+        "ai_client": ai_client,
+        "instructions": instructions
     }
-    chatbot = Chatbot(chatbot_config)
-    response_completion = chatbot.chat(user_message, chat_history, socratic_mode, ai_name)
+
+    try:
+        chatbot = Chatbot(chatbot_config)
+        response_completion = chatbot.chat(user_message, chat_history, socratic_mode, ai_name)
+    except Exception as e:
+        print(f"Error: {e}")
+        response_completion = "學習精靈有點累，請稍後再試！"
 
     try:
         # 更新聊天历史
@@ -1606,7 +1735,7 @@ def chat_with_ai(ai_name, password, video_id, trascript, user_message, chat_hist
         print(f"Error: {e}")
         return "请求失败，请稍后再试！", chat_history
 
-def chat_with_opan_ai_assistant(password, youtube_id, thread_id, trascript, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
+def chat_with_opan_ai_assistant(password, youtube_id, thread_id, trascript_state, key_moments, user_message, chat_history, content_subject, content_grade, socratic_mode=False):
     verify_password(password)
 
     # 先計算 user_message 是否超過 500 個字
@@ -1620,43 +1749,34 @@ def chat_with_opan_ai_assistant(password, youtube_id, thread_id, trascript, user
         raise gr.Error(error_msg)
 
     try:
-        assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq"
+        assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq" #GPT 4 turbo
+        # assistant_id = "asst_5SaUElqvL3U0ybSi9PRM8x3P" #GPT 3.5 turbo
+
         client = OPEN_AI_CLIENT
         # 直接安排逐字稿資料 in instructions
-        trascript_json = json.loads(trascript)
+        if isinstance(trascript_state, str):
+            trascript_json = json.loads(trascript_state)
+        else:
+            trascript_json = trascript_state
         # 移除 embed_url, screenshot_path
         for entry in trascript_json:
-            entry.pop('embed_url', None)
-            entry.pop('screenshot_path', None)
-        trascript_text = json.dumps(trascript_json, ensure_ascii=False, indent=2)
-
-        instructions = f"""
-            科目：{content_subject}
-            年級：{content_grade}
-            逐字稿資料：{trascript_text}
-            -------------------------------------
-            你是一個專業的{content_subject}老師， user 為{content_grade}的學生
-            socratic_mode = {socratic_mode}
-            if socratic_mode is True，
-            - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-            - 一次只問一個問題，字數在100字以內
-            - 不要直接給予答案，讓學生自己思考
-            - 但可以給予一些提示跟引導��例如給予影片的時間軸，讓學生自己去找答案
-            
-            if socratic_mode is False，
-            - 直接回答學生問題，字數在100字以內
-
-            rule:
-            - 請一定要用繁體中文回答 zh-TW，並用台灣人的口語表達，回答時不用特別說明這是台灣人的語氣，也不用說這是「台語的說法」
-            - 不用提到「逐字稿」這個詞，用「內容」代替
-            - 如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-            - 或者你可以反問學生一些問題，幫助學生更好的理解資料，字數在100字以內
-            - 如果學生的問題與資料文本無關，請告訴學生你「無法回答超出影片範圍的問題」，並告訴他可以怎麼問什麼樣的問題（一個就好）
-            - 只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
-            - 回答範圍一定要在逐字稿資料內，不要引用其他資料，請嚴格執行
-            - 並在重複問句後給予學生鼓勵，讓學生有學習的動力
-            - 請用 {content_grade} 的學生能懂的方式回答
-        """
+            entry.pop('end_time', None)
+        trascript_text = json.dumps(trascript_json, ensure_ascii=False)
+
+        if isinstance(key_moments, str):
+            key_moments_json = json.loads(key_moments)
+        else:
+            key_moments_json = key_moments
+        # key_moments_json remove images
+        for moment in key_moments_json:
+            moment.pop('images', None)
+            moment.pop('end', None)
+            moment.pop('text', None)
+        key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
+        
+        instructions = get_instructions(content_subject, content_grade, key_moments_text)
+        print("=== instructions ===")
+        print(instructions)
 
         # 创建线程
         if not thread_id:
@@ -1665,11 +1785,18 @@ def chat_with_opan_ai_assistant(password, youtube_id, thread_id, trascript, user
         else:
             thread = client.beta.threads.retrieve(thread_id)
         
+        user_msg_note = """\n (請一定要用繁體中文回答 zh-TW，
+            請嚴格遵循instructions，擔任一位蘇格拉底家教，
+            並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，
+            不用提到「逐字稿」這個詞，用「內容」代替)，
+            回答時請用數學符號代替文字（Latex 用 $ 字號 render)
+        """
+        user_msg_note = user_msg_note.replace(" ","").replace("\n","")
         # 向线程添加用户的消息
         client.beta.threads.messages.create(
             thread_id=thread.id,
             role="user",
-            content=user_message + "/n (請一定要用繁體中文回答 zh-TW，並用台灣人的禮貌口語表達，回答時不要特別說明這是台灣人的語氣，不用提到「逐字稿」這個詞，用「內容」代替)，回答時請用數學符號代替文字（Latex 用 $ 字號 render)"
+            content=user_message + user_msg_note
         )
 
         # 运行助手，生成响应
@@ -1773,7 +1900,7 @@ def poll_run_status(run_id, thread_id, timeout=600, poll_interval=5):
     
     return run.status
 
-def streaming_chat_with_open_ai(user_message, chat_history, password, thread_id, trascript, content_subject, content_grade):
+def streaming_chat_with_open_ai(user_message, chat_history, password, thread_id, trascript, key_moments, content_subject, content_grade):
     verify_password(password)
 
     print("===streaming_chat_with_open_ai===")
@@ -1789,50 +1916,29 @@ def streaming_chat_with_open_ai(user_message, chat_history, password, thread_id,
         error_msg = "此次對話超過上限"
         raise gr.Error(error_msg)
 
-    # fake data
-    socratic_mode = True
-
     try:
-        assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq"
+        assistant_id = "asst_kmvZLNkDUYaNkMNtZEAYxyPq" #GPT 4 turbo
+        # assistant_id = "asst_5SaUElqvL3U0ybSi9PRM8x3P" #GPT 3.5 turbo
         client = OPEN_AI_CLIENT
         # 直接安排逐字稿資料 in instructions
-        trascript_json = json.loads(trascript)
-        # 移除 embed_url, screenshot_path
-        for entry in trascript_json:
-            entry.pop('embed_url', None)
-            entry.pop('screenshot_path', None)
-        trascript_text = json.dumps(trascript_json, ensure_ascii=False, indent=2)
+        if isinstance(trascript, str):
+            trascript_json = json.loads(trascript)
+        else:
+            trascript_json = trascript
+        trascript_text = json.dumps(trascript_json, ensure_ascii=False)
         # trascript_text 移除 \n, 空白
         trascript_text = trascript_text.replace("\n", "").replace(" ", "")
 
-        instructions = f"""
-            科目：{content_subject}
-            年級：{content_grade}
-            逐字稿資料：{trascript_text}
-            -------------------------------------
-            你是一個專業的{content_subject}老師， user 為{content_grade}的學生
-            socratic_mode = {socratic_mode}
-            if socratic_mode is True，
-            - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-            - 一次只問一個問題，字數在100字以內
-            - 不要直接給予答案，讓學生自己思考
-            - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
-            
-            if socratic_mode is False，
-            - 直接回答學生問題，字數在100字以內
-
-            rule:
-            - 請一定要用繁體中文回答 zh-TW，並用台灣人的口語表達，回答時不用特別說明這是台灣人的語氣，也不用說這是「台語的說法」
-            - 不用提到「逐字稿」這個詞，用「內容」代替
-            - 如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-            - 或者你可以反問學生一些問題，幫助學生更好的理解資料，字數在100字以內
-            - 如果學生的問題與資料文本無關，請告訴學生你「無法回答超出影片範圍的問題」，並告訴他可以怎麼問什麼樣的問題（一個就好）
-            - 只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
-            - 回答範圍一定要在逐字稿資料內，不要引用其他資料，請嚴格執行
-            - 並在重複問句後給予學生鼓勵，讓學生有學習的動力
-            - 請用 {content_grade} 的學生能懂的方式回答
-        """
+        if isinstance(key_moments, str):
+            key_moments_json = json.loads(key_moments)
+        else:
+            key_moments_json = key_moments
+        # key_moments_json remove images
+        for moment in key_moments_json:
+            moment.pop('images', None)
+        key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
 
+        instructions = get_instructions(content_subject, content_grade, key_moments_text)
         # 创建线程
         if not thread_id:
             thread = client.beta.threads.create()
@@ -1933,18 +2039,22 @@ def init_params(text, request: gr.Request):
 
     return admin, reading_passage_admin, summary_admin, see_detail, password_text, youtube_link
 
-def update_state(content_subject, content_grade, trascript, question_1, question_2, question_3):
+def update_state(content_subject, content_grade, trascript, key_moments, question_1, question_2, question_3):
     # inputs=[content_subject, content_grade, df_string_output],
     # outputs=[content_subject_state, content_grade_state, trascript_state]
     content_subject_state = content_subject
     content_grade_state = content_grade
-    trascript_state = trascript
+    trascript_json = json.loads(trascript)
+    formatted_simple_transcript = create_formatted_simple_transcript(trascript_json)
+    trascript_state = formatted_simple_transcript
+    key_moments_state = key_moments
     streaming_chat_thread_id_state = create_thread_id()
     ai_chatbot_question_1 = question_1
     ai_chatbot_question_2 = question_2
     ai_chatbot_question_3 = question_3
 
-    return content_subject_state, content_grade_state, trascript_state, streaming_chat_thread_id_state, \
+    return content_subject_state, content_grade_state, trascript_state, key_moments_state, \
+        streaming_chat_thread_id_state, \
         ai_chatbot_question_1, ai_chatbot_question_2, ai_chatbot_question_3
 
 
@@ -2016,7 +2126,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
     with gr.Row() as admin:
         password = gr.Textbox(label="Password", type="password", elem_id="password_input", visible=True)
         youtube_link = gr.Textbox(label="Enter YouTube Link", elem_id="youtube_link_input", visible=True)
-        video_id = gr.Textbox(label="video_id", visible=False)
+        video_id = gr.Textbox(label="video_id", visible=True)
         # file_upload = gr.File(label="Upload your CSV or Word file", visible=False)
         # web_link = gr.Textbox(label="Enter Web Page Link", visible=False)
         user_data = gr.Textbox(label="User Data", elem_id="user_data_input", visible=True)
@@ -2025,6 +2135,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         content_subject_state = gr.State()  # 使用 gr.State 存储 content_subject
         content_grade_state = gr.State()  # 使用 gr.State 存储 content_grade
         trascript_state = gr.State()  # 使用 gr.State 存储 trascript
+        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.Row():
@@ -2042,12 +2153,12 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                         btn_3 = gr.Button("問題一")
                         gr.Markdown("### 重新生成問題")
                         btn_create_question = gr.Button("生成其他問題", variant="primary")
-                    openai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath")
+                    openai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath", max_length=60)
                 with gr.Row():
                     msg = gr.Textbox(label="訊息",scale=3)
                     send_button = gr.Button("送出", variant="primary", scale=1)
             with gr.Tab("飛特音速"):
-                additional_inputs = [password, streaming_chat_thread_id_state, trascript_state, content_subject_state, content_grade_state]
+                additional_inputs = [password, streaming_chat_thread_id_state, trascript_state, key_moments_state, content_subject_state, content_grade_state]
                 streaming_chat = gr.ChatInterface(
                     fn=streaming_chat_with_open_ai,
                     additional_inputs=additional_inputs,
@@ -2066,11 +2177,10 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                         ai_chatbot_question_1 = gr.Button("問題一")
                         ai_chatbot_question_2 = gr.Button("問題一")
                         ai_chatbot_question_3 = gr.Button("問題一")
-                    ai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath")
+                    ai_chatbot_audio_input = gr.Audio(sources=["microphone"], type="filepath", max_length=60)
                 with gr.Row():
-                    ai_msg = gr.Textbox(label="Message",scale=3)
-                    ai_send_button = gr.Button("Send", variant="primary",scale=1)    
-            
+                    ai_msg = gr.Textbox(label="訊息輸入",scale=3)
+                    ai_send_button = gr.Button("送出", variant="primary",scale=1)              
     with gr.Tab("文章模式"):
         with gr.Row() as reading_passage_admin:
             reading_passage_kind = gr.Textbox(value="reading_passage", show_label=False)
@@ -2094,7 +2204,6 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
     with gr.Tab("關鍵時刻"):
         with gr.Row():
             key_moments_html = gr.HTML(value="")
-
     with gr.Tab("教學備課"):
         with gr.Row():
             content_subject = gr.Dropdown(label="選擇主題", choices=["數學", "自然", "國文", "英文", "社會","物理", "化學", "生物", "地理", "歷史", "公民"], value="", visible=False)             
@@ -2182,8 +2291,33 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
                 #     metacognition_content_btn = gr.Button("生成後設認知問題")
 
     with gr.Accordion("See Details", open=False) as see_details:
-        with gr.Tab("本文"):
-            df_string_output = gr.Textbox(lines=40, label="Data Text")
+        with gr.Tab("逐字稿本文"):
+            with gr.Row() as transcript_admmin:
+                transcript_kind = gr.Textbox(value="transcript", show_label=False)
+                transcript_edit_button = gr.Button("編輯", size="sm", variant="primary")
+                transcript_update_button = gr.Button("更新", size="sm", variant="primary")
+                transcript_delete_button = gr.Button("刪除", size="sm", variant="primary")
+                transcript_create_button = gr.Button("建立", size="sm", variant="primary")
+            with gr.Row():
+                df_string_output = gr.Textbox(lines=40, label="Data Text", interactive=False, show_copy_button=True)
+        with gr.Tab("關鍵時刻本文"):
+            with gr.Row() as key_moments_admin:
+                key_moments_kind = gr.Textbox(value="key_moments", show_label=False)
+                key_moments_edit_button = gr.Button("編輯", size="sm", variant="primary")
+                key_moments_update_button = gr.Button("更新", size="sm", variant="primary")
+                key_moments_delete_button = gr.Button("刪除", size="sm", variant="primary")
+                key_moments_create_button = gr.Button("建立", size="sm", variant="primary")
+            with gr.Row():
+                key_moments = gr.Textbox(label="Key Moments", lines=40, interactive=False, show_copy_button=True)
+        with gr.Tab("問題本文"):
+            with gr.Row() as question_list_admin:
+                questions_kind = gr.Textbox(value="questions", show_label=False)
+                questions_edit_button = gr.Button("編輯", size="sm", variant="primary")
+                questions_update_button = gr.Button("更新", size="sm", variant="primary")
+                questions_delete_button = gr.Button("刪除", size="sm", variant="primary")
+                questions_create_button = gr.Button("建立", size="sm", variant="primary")
+            with gr.Row():
+                questions_json = gr.Textbox(label="Questions", lines=40, interactive=False, show_copy_button=True)
         with gr.Tab("逐字稿"):
             simple_html_content = gr.HTML(label="Simple Transcript")
         with gr.Tab("圖文"):
@@ -2206,7 +2340,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
     # OPENAI ASSISTANT CHATBOT 模式
     send_button.click(
         chat_with_opan_ai_assistant,
-        inputs=[password, video_id, thread_id, df_string_output, msg, chatbot, content_subject, content_grade, socratic_mode_btn],
+        inputs=[password, video_id, thread_id, trascript_state, key_moments, msg, chatbot, content_subject, content_grade, socratic_mode_btn],
         outputs=[msg, chatbot, thread_id]
     )
     openai_chatbot_audio_input.change(
@@ -2215,9 +2349,9 @@ 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, thread_id, df_string_output, btn_1, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
-    btn_2_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, df_string_output, btn_2, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
-    btn_3_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, df_string_output, btn_3, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
+    btn_1_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, trascript_state, key_moments, btn_1, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
+    btn_2_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, trascript_state, key_moments, btn_2, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
+    btn_3_chat_with_opan_ai_assistant_input =[password, video_id, thread_id, trascript_state, key_moments, btn_3, chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
     btn_1.click(
         chat_with_opan_ai_assistant,
         inputs=btn_1_chat_with_opan_ai_assistant_input, 
@@ -2242,13 +2376,13 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
     # ai_chatbot 模式
     ai_send_button.click(
         chat_with_ai,
-        inputs=[ai_name, password, video_id, df_string_output, ai_msg, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn],
+        inputs=[ai_name, password, video_id, trascript_state, key_moments, ai_msg, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn],
         outputs=[ai_msg, ai_chatbot]
     )
     # ai_chatbot 连接按钮点击事件
-    ai_chatbot_question_1_chat_with_ai_input =[ai_name, password, video_id, df_string_output, ai_chatbot_question_1, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
-    ai_chatbot_question_2_chat_with_ai_input =[ai_name, password, video_id, df_string_output, ai_chatbot_question_2, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
-    ai_chatbot_question_3_chat_with_ai_input =[ai_name, password, video_id, df_string_output, ai_chatbot_question_3, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
+    ai_chatbot_question_1_chat_with_ai_input =[ai_name, password, video_id, trascript_state, key_moments, ai_chatbot_question_1, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
+    ai_chatbot_question_2_chat_with_ai_input =[ai_name, password, video_id, trascript_state, key_moments, ai_chatbot_question_2, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
+    ai_chatbot_question_3_chat_with_ai_input =[ai_name, password, video_id, trascript_state, key_moments, ai_chatbot_question_3, ai_chatbot, content_subject, content_grade, ai_chatbot_socratic_mode_btn]
     ai_chatbot_question_1.click(
         chat_with_ai,
         inputs=ai_chatbot_question_1_chat_with_ai_input,
@@ -2272,11 +2406,13 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
     process_youtube_link_inputs = [password, youtube_link]
     process_youtube_link_outputs = [
         video_id,
+        questions_json,
         btn_1, 
         btn_2, 
         btn_3, 
         df_string_output, 
         df_summarise,
+        key_moments,
         key_moments_html,
         mind_map, 
         mind_map_html,
@@ -2292,6 +2428,7 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         content_subject,
         content_grade,
         df_string_output,
+        key_moments,
         btn_1, 
         btn_2, 
         btn_3
@@ -2299,7 +2436,8 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
     update_state_outputs = [
         content_subject_state, 
         content_grade_state, 
-        trascript_state, 
+        trascript_state,
+        key_moments_state,
         streaming_chat_thread_id_state,
         ai_chatbot_question_1,
         ai_chatbot_question_2,
@@ -2374,6 +2512,72 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue=gr.themes.colors.orange, seconda
         outputs=[df_summarise]
     )
 
+    # transcript event
+    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_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_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]
+    ) 
+
     # 教師版
     worksheet_content_btn.click(
         get_ai_content,

chatbot.py

@@ -8,65 +8,46 @@ class Chatbot:
         self.content_subject = config.get('content_subject')
         self.content_grade = config.get('content_grade')
         self.jutor_chat_key = config.get('jutor_chat_key')
-        self.transcript_text = self.get_transcript_text(config.get('trascript'))
+        self.transcript_text = self.get_transcript_text(config.get('transcript'))
+        self.key_moments_text = self.get_key_moments_text(config.get('key_moments'))
         self.ai_name = config.get('ai_name')
         self.ai_client = config.get('ai_client')
+        self.instructions = config.get('instructions')
 
     def get_transcript_text(self, transcript_data):
-        transcript_json = json.loads(transcript_data)
+        if isinstance(transcript_data, str):
+            transcript_json = json.loads(transcript_data)
+        else:
+            transcript_json = transcript_data
         for entry in transcript_json:
-            entry.pop('embed_url', None)
-            entry.pop('screenshot_path', None)
+            entry.pop('end_time', None)
         transcript_text = json.dumps(transcript_json, ensure_ascii=False)
         return transcript_text
+    
+    def get_key_moments_text(self, key_moments_data):
+        if isinstance(key_moments_data, str):
+            key_moments_json = json.loads(key_moments_data)
+        else:
+            key_moments_json = key_moments_data
+        # key_moments_json remove images
+        for moment in key_moments_json:
+            moment.pop('images', None)
+            moment.pop('end', None)
+            moment.pop('transcript', None)
+            
+        key_moments_text = json.dumps(key_moments_json, ensure_ascii=False)
+        return key_moments_text
+
 
     def chat(self, user_message, chat_history, socratic_mode=False, service_type='jutor'):
         messages = self.prepare_messages(chat_history, user_message)
-        system_prompt = self.prepare_system_prompt(socratic_mode)
+        system_prompt = self.instructions
         if service_type in ['jutor', 'groq', 'claude3']:
             response_text = self.chat_with_service(service_type, system_prompt, messages)
             return response_text
         else:
             raise gr.Error("不支持此服務")
 
-    def prepare_system_prompt(self, socratic_mode):
-        content_subject = self.content_subject
-        content_grade = self.content_grade
-        video_id = self.video_id
-        trascript_text = self.transcript_text
-        socratic_mode = str(socratic_mode)
-        ai_name = self.ai_name
-        system_prompt = f"""
-            科目：{content_subject}
-            年級：{content_grade}
-            逐字稿資料：{trascript_text}
-            -------------------------------------
-            你是一個專業的{content_subject}老師， user 為{content_grade}的學生
-            socratic_mode = {socratic_mode}
-            if socratic_mode is True，
-            - 請用蘇格拉底式的提問方式，引導學生思考，並且給予學生一些提示
-            - 一次只問一個問題，字數在100字以內
-            - 不要直接給予答案，讓學生自己思考
-            - 但可以給予一些提示跟引導，例如給予影片的時間軸，讓學生自己去找答案
-            
-            if socratic_mode is False，
-            - 直接回答學生問題，字數在100字以內
-
-            rule:
-            - 請一定要用繁體中文回答 zh-TW，並用台灣人的口語表達，回答時不用特別說明這是台灣人的語氣，也不用說這是「台語的說法」
-            - 不用提到「逐字稿」這個詞
-            - 如果學生問了一些問題你無法判斷，請告訴學生你無法判斷，並建議學生可以問其他問題
-            - 或者你可以反問學生一些問題，幫助學生更好的理解資料，字數在100字以內
-            - 如果學生的問題與資料文本無關，請告訴學生你「無法回答超出影片範圍的問題」，並告訴他可以怎麼問什麼樣的問題（一個就好）
-            - 只要是參考逐字稿資料，請在回答的最後標註【參考資料：（分）：（秒）】
-            - 回答範圍一定要在逐字稿資料內，不要引用其他資料，請嚴格執行
-            - 並在重複問句後給予學生鼓勵，讓學生有學習的動力
-            - 請用 {content_grade} 的學生能懂的方式回答
-            - 回答時數學式請用數學符號代替文字（Latex 用 $ 字號 render)
-        """
-
-        return system_prompt
-
     def prepare_messages(self, chat_history, user_message):
         messages = []
         if chat_history is not None:
@@ -101,12 +82,14 @@ class Chatbot:
             "Content-Type": "application/json",
             "x-api-key": self.jutor_chat_key,
         }
+        model = "gpt-4-1106-preview"
+        # model = "gpt-3.5-turbo-0125"
         data = {
             "data": {
                 "messages": messages,
                 "max_tokens": 512,
                 "temperature": 0.9,
-                "model": "gpt-4-1106-preview",
+                "model": model,
                 "stream": False,
             }
         }