From da1a41cdad067a532d3ba251d94c2cc21bfe53ed Mon Sep 17 00:00:00 2001
From: st2411020204 <st2411020204@gitea.local>
Date: Thu, 8 Jan 2026 21:04:51 +0800
Subject: [PATCH] =?UTF-8?q?docs:=20=E6=9B=B4=E6=96=B0README=E5=92=8C?=
 =?UTF-8?q?=E7=AC=94=E8=AE=B0=E6=95=B0=E6=8D=AE=E6=96=87=E4=BB=B6?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

更新README.md中的开发心得部分，添加了关于AI学习报告功能的描述并优化了段落结构。同时调整notes_data.json中的标签和分类格式，添加新分类"1"。
---
 README.md         |    6 +-
 note_organizer.py | 1112 +++++++++++++++++++++++++++++----------------
 notes_data.json   |   11 +-
 3 files changed, 736 insertions(+), 393 deletions(-)

diff --git a/README.md b/README.md
index 5cec0ef..0954e90 100644
--- a/README.md
+++ b/README.md
@@ -20,9 +20,11 @@
 
 ## 四、开发心得
 
-在开发这个学习笔记整理器的过程中，我们深刻体会到了技术与需求之间的平衡。这个项目的目的是为了帮助学生更好地管理和查询学习笔记，让学习变得更加高效有序。我们面向的主要是在校学生，他们需要记录大量的学习内容，我们希望能提供给他们一个有效的整理和检索工具。项目功能包括笔记的创建、编辑、删除、分类管理、标签系统、智能搜索、内容提炼以及导入导出等核心功能，力求为学生们提供一个简单易用的笔记管理平台。
+在开发这个学习笔记整理器的过程中，我们深刻体会到了技术与需求之间的平衡。这个项目的目的是为了帮助学生更好地管理和查询学习笔记，让学习变得更加高效有序。我们面向的主要是在校学生，他们需要记录大量的学习内容，我们希望能提供给他们一个有效的整理和检索工具。项目功能包括笔记的创建、编辑、删除、分类管理、标签系统、智能搜索、内容提炼以及导入导出等核心功能，同时也利用ai为项目增加了一个“ai学习报告”的功能，力求为学生们提供一个简单易用的笔记管理平台。
 
-最初我们考虑使用Chainlit框架，因为它在AI交互方面表现突出，但在实际开发过程中发现，虽然Chainlit在对话式交互上有优势，但在笔记管理功能上显得不够完善，而且智能搜索的效果也没有达到预期。为了让搜索更加智能，我们尝试了各种prompt设计，包括语义搜索的prompt，要求AI根据用户查询理解意图而非简单关键词匹配；概括提取的prompt，让AI对搜索结果进行智能总结和关键点提取；意图识别的prompt，用于判断用户是想创建、编辑还是删除笔记；删除意图的prompt，区分删除单个笔记、删除所有笔记还是删除某个分类的笔记；以及笔记识别的prompt，让AI从多个笔记中找到用户指定的目标。这些prompt设计经过多次调整，包括改变temperature参数、调整max_tokens长度、优化system prompt的表述方式，但效果始终不尽如人意，AI经常误解用户意图或返回不相关的内容。
+最初我们考虑使用Chainlit框架，因为它在AI交互方面表现突出，但在实际开发过程中发现，虽然Chainlit在对话式交互上有优势，但在笔记管理功能上显得不够完善，而且智能搜索的效果也没有达到预期。
+
+为了让搜索更加智能，我们尝试了各种prompt设计，包括语义搜索的prompt，要求AI根据用户查询理解意图而非简单关键词匹配；概括提取的prompt，让AI对搜索结果进行智能总结和关键点提取；意图识别的prompt，用于判断用户是想创建、编辑还是删除笔记；删除意图的prompt，区分删除单个笔记、删除所有笔记还是删除某个分类的笔记；以及笔记识别的prompt，让AI从多个笔记中找到用户指定的目标。这些prompt设计经过多次调整，包括改变temperature参数、调整max_tokens长度、优化system prompt的表述方式，但效果始终不尽如人意，AI经常误解用户意图或返回不相关的内容。
 
 最终我们意识到单纯依赖AI并不能解决所有问题，于是转向了更传统但更可靠的解决方案。在搜索功能上，我们结合了关键词匹配和简单的语义分析，虽然不如纯AI搜索那么智能，但准确性和稳定性大大提升。在笔记管理方面，我们采用了传统的CRUD操作配合Streamlit的交互组件，让用户能够通过直观的界面进行操作，而不是完全依赖自然语言交互。这种混合模式既保留了AI的辅助功能，又确保了核心功能的可靠性。经过反复比较和测试，最终选择了Streamlit框架，它在界面设计和功能实现上更加成熟，能够更好地满足我们的需求。
 
diff --git a/note_organizer.py b/note_organizer.py
index af70a94..030c4f6 100644
--- a/note_organizer.py
+++ b/note_organizer.py
@@ -4,10 +4,46 @@ import json
 import os
 import re
 from collections import Counter
+import requests
+from dotenv import load_dotenv
 
 # 1. 页面配置
 st.set_page_config(page_title="学习笔记整理器", page_icon="📚", layout="wide")
 
+# 加载环境变量
+load_dotenv()
+
+# DeepSeek API配置
+DEEPSEEK_API_KEY = os.getenv("DEEPSEEK_API_KEY")
+DEEPSEEK_API_URL = "https://api.deepseek.com/v1/chat/completions"
+
+# 常量定义
+DATETIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+def call_deepseek_api(messages, model="deepseek-chat", temperature=0.7, max_tokens=2000):
+    """调用DeepSeek API"""
+    try:
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {DEEPSEEK_API_KEY}"
+        }
+        
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens
+        }
+        
+        response = requests.post(DEEPSEEK_API_URL, headers=headers, json=payload, timeout=30)
+        response.raise_for_status()
+        
+        result = response.json()
+        return result["choices"][0]["message"]["content"]
+    except Exception as e:
+        st.error(f"AI API调用失败: {str(e)}")
+        return None
+
 # 添加自定义CSS样式
 st.markdown("""
 <style>
@@ -151,6 +187,9 @@ st.markdown("""
 
 st.title("📚 学习笔记整理器")
 
+# 创建主标签页
+tab_notes, tab_report = st.tabs(["📝 笔记管理", "🤖 AI学习报告"])
+
 # 文本提炼函数
 def extract_key_content(content, max_sentences=3, max_keywords=5):
     """提炼笔记的关键内容"""
@@ -188,6 +227,170 @@ def extract_key_content(content, max_sentences=3, max_keywords=5):
         "keywords": keywords
     }
 
+# 辅助函数：获取所有标签
+def get_all_tags():
+    """获取所有笔记中的标签"""
+    return list(set(tag for note in st.session_state.notes for tag in note.get("tags", [])))
+
+# 辅助函数：筛选笔记
+def filter_notes(notes, search_query="", search_scope="全部", filter_category="全部", filter_tag="全部"):
+    """根据条件筛选笔记"""
+    filtered = []
+    for note in notes:
+        # 分类筛选
+        category_match = filter_category == "全部" or note["category"] == filter_category
+        
+        # 标签筛选
+        tag_match = filter_tag == "全部" or filter_tag in note.get("tags", [])
+        
+        # 关键词搜索（根据选择范围）
+        search_match = True
+        if search_query:
+            query = search_query.lower()
+            if search_scope == "全部":
+                search_match = (
+                    query in note["title"].lower() or
+                    query in note["content"].lower() or
+                    query in note["category"].lower() or
+                    any(query in tag.lower() for tag in note.get("tags", []))
+                )
+            elif search_scope == "仅标题":
+                search_match = query in note["title"].lower()
+            elif search_scope == "仅内容":
+                search_match = query in note["content"].lower()
+            elif search_scope == "仅类型":
+                search_match = query in note["category"].lower()
+            elif search_scope == "仅标签":
+                search_match = any(query in tag.lower() for tag in note.get("tags", []))
+        
+        if category_match and tag_match and search_match:
+            filtered.append(note)
+    
+    return filtered
+
+# 辅助函数：格式化标签HTML
+def format_tags_html(tags, style="default"):
+    """格式化标签为HTML"""
+    if style == "default":
+        return " ".join([f'<span style="background-color: #e1f5fe; color: #01579b; padding: 2px 8px; border-radius: 4px; margin-right: 5px; font-size: 12px;">{tag}</span>' for tag in tags])
+    elif style == "preview":
+        return " ".join([f'<span style="background-color: #fff3e0; color: #e65100; padding: 2px 8px; border-radius: 4px; margin-right: 5px; font-size: 12px;">{tag}</span>' for tag in tags])
+    return ""
+
+# 辅助函数：排序笔记
+def sort_notes(notes, sort_by="最新"):
+    """根据指定方式排序笔记"""
+    sorted_notes = notes.copy()
+    if sort_by == "最新":
+        sorted_notes.sort(key=lambda x: x["created_at"], reverse=True)
+    elif sort_by == "最旧":
+        sorted_notes.sort(key=lambda x: x["created_at"])
+    elif sort_by == "标题A-Z":
+        sorted_notes.sort(key=lambda x: x["title"].lower())
+    elif sort_by == "标题Z-A":
+        sorted_notes.sort(key=lambda x: x["title"].lower(), reverse=True)
+    elif sort_by == "类型A-Z":
+        sorted_notes.sort(key=lambda x: x["category"].lower())
+    elif sort_by == "类型Z-A":
+        sorted_notes.sort(key=lambda x: x["category"].lower(), reverse=True)
+    return sorted_notes
+
+# AI学习报告生成函数
+def generate_study_report(notes):
+    """生成AI学习报告"""
+    if not notes:
+        return None
+    
+    # 统计分析
+    total_notes = len(notes)
+    categories = {}
+    all_tags = []
+    total_content_length = 0
+    notes_summary = []
+    
+    for note in notes:
+        # 分类统计
+        cat = note['category']
+        categories[cat] = categories.get(cat, 0) + 1
+        
+        # 标签统计
+        all_tags.extend(note.get('tags', []))
+        
+        # 内容长度统计
+        total_content_length += len(note['content'])
+        
+        # 收集笔记摘要（用于AI分析）
+        notes_summary.append({
+            "title": note['title'],
+            "category": note['category'],
+            "tags": note.get('tags', []),
+            "content_length": len(note['content']),
+            "created_at": note.get('created_at', '')
+        })
+    
+    # 标签频率统计
+    tag_counts = Counter(all_tags)
+    top_tags = tag_counts.most_common(10)
+    
+    # 使用DeepSeek API生成智能学习建议
+    ai_suggestions = []
+    
+    if DEEPSEEK_API_KEY:
+        with st.spinner("🤖 AI正在分析您的学习数据..."):
+            # 构建AI分析的prompt
+            system_prompt = """你是一位专业的学习顾问，擅长分析学生的学习笔记并提供个性化的学习建议。
+请根据提供的笔记数据，生成3-5条具体、实用的学习建议。
+建议应该包括：
+1. 学习方法和策略
+2. 知识体系的构建
+3. 学习重点和方向
+4. 改进建议
+每条建议应该简洁明了，不超过50字，使用emoji开头。"""
+
+            user_prompt = f"""请分析以下学习笔记数据，并给出个性化学习建议：
+
+笔记总数：{total_notes}
+分类统计：{categories}
+热门标签：{tag_counts.most_common(5)}
+总字数：{total_content_length}
+平均每条笔记字数：{int(total_content_length/total_notes) if total_notes > 0 else 0}
+
+笔记概览：
+{json.dumps(notes_summary[:10], ensure_ascii=False, indent=2)}
+
+请基于以上数据，给出3-5条具体的学习建议。"""
+
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+            
+            ai_response = call_deepseek_api(messages, temperature=0.8, max_tokens=500)
+            
+            if ai_response:
+                ai_suggestions = ai_response.strip().split('\n')
+                ai_suggestions = [s.strip() for s in ai_suggestions if s.strip()]
+            else:
+                st.error("❌ AI生成建议失败，请检查API配置或稍后重试")
+    
+    # 生成学习进度报告
+    report = {
+        "总览": {
+            "笔记总数": total_notes,
+            "分类数量": len(categories),
+            "标签总数": len(set(all_tags)),
+            "总字数": total_content_length,
+            "平均每条笔记字数": int(total_content_length/total_notes) if total_notes > 0 else 0
+        },
+        "分类统计": categories,
+        "热门标签": top_tags,
+        "学习建议": ai_suggestions,
+        "生成时间": datetime.now().strftime(DATETIME_FORMAT),
+        "AI生成": len(ai_suggestions) > 0 and DEEPSEEK_API_KEY is not None
+    }
+    
+    return report
+
 # 2. 数据持久化函数
 def save_notes():
     """保存笔记到 JSON 文件"""
@@ -219,196 +422,165 @@ if "categories" not in st.session_state:
 if "editing_note" not in st.session_state:
     st.session_state.editing_note = None
 
+# 初始化清空确认状态
+if "confirm_clear" not in st.session_state:
+    st.session_state.confirm_clear = False
+
 # 4. 左侧侧边栏 - 添加笔记和管理类型
-with st.sidebar:
-    st.header("📝 添加笔记")
-    
-    # 笔记标题
-    title = st.text_input("标题", placeholder="输入笔记标题")
-    
-    # 分类选择（支持自定义）
-    category = st.selectbox(
-        "选择分类",
-        st.session_state.categories,
-        help="选择笔记的分类"
-    )
-    
-    # 自定义分类输入
-    new_category = st.text_input(
-        "或创建新分类",
-        placeholder="输入新分类名称，按回车添加",
-        key="new_category_input"
-    )
-    
-    # 添加新分类按钮
-    if st.button("➕ 添加新分类"):
-        if new_category and new_category not in st.session_state.categories:
-            st.session_state.categories.append(new_category)
-            save_notes()
-            st.success(f"已添加新分类：{new_category}")
-            st.rerun()
-        elif new_category in st.session_state.categories:
-            st.warning("该分类已存在")
-    
-    # 笔记内容
-    content = st.text_area(
-        "笔记内容",
-        placeholder="输入笔记内容...",
-        height=200
-    )
-    
-    # 标签输入
-    tags_input = st.text_input(
-        "标签",
-        placeholder="输入标签，用逗号分隔 (例如: 重要, 复习, 考试)",
-        help="为笔记添加多个标签，便于分类和搜索"
-    )
-    tags = [tag.strip() for tag in tags_input.split(",") if tag.strip()]
-    
-    # 实时预览提炼结果
-    if content and len(content.strip()) > 10:
-        with st.expander("🔍 预览提炼结果", expanded=False):
-            extracted = extract_key_content(content)
-            st.markdown("**摘要预览：**")
-            st.info(extracted['summary'])
-            st.markdown("**关键词预览：**")
-            if extracted['keywords']:
-                keywords_html = " ".join([f'<span style="background-color: #fff3e0; color: #e65100; padding: 2px 8px; border-radius: 4px; margin-right: 5px; font-size: 12px;">{kw}</span>' for kw in extracted['keywords']])
-                st.markdown(keywords_html, unsafe_allow_html=True)
-    
-    # 添加按钮
-    if st.button("添加笔记", type="primary"):
-        if title and content:
-            note = {
-                "id": len(st.session_state.notes) + 1,
-                "title": title,
-                "category": category,
-                "content": content,
-                "tags": tags,
-                "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-            }
-            st.session_state.notes.append(note)
-            save_notes()
-            st.success("笔记添加成功！")
-        else:
-            st.warning("请填写标题和内容")
-    
-    st.divider()
-    
-    # 显示所有分类
-    st.subheader("📂 所有分类")
-    for cat in st.session_state.categories:
-        st.markdown(f"- {cat}")
+with tab_notes:
+    with st.sidebar:
+        st.header("📝 添加笔记")
+        
+        # 笔记标题
+        title = st.text_input("标题", placeholder="输入笔记标题")
+        
+        # 分类选择（支持自定义）
+        category = st.selectbox(
+            "选择分类",
+            st.session_state.categories,
+            help="选择笔记的分类"
+        )
+        
+        # 自定义分类输入
+        new_category = st.text_input(
+            "或创建新分类",
+            placeholder="输入新分类名称，按回车添加",
+            key="new_category_input"
+        )
+        
+        # 添加新分类按钮
+        if st.button("➕ 添加新分类"):
+            if new_category and new_category not in st.session_state.categories:
+                st.session_state.categories.append(new_category)
+                save_notes()
+                st.success(f"已添加新分类：{new_category}")
+                st.rerun()
+            elif new_category in st.session_state.categories:
+                st.warning("该分类已存在")
+        
+        # 笔记内容
+        content = st.text_area(
+            "笔记内容",
+            placeholder="输入笔记内容...",
+            height=200
+        )
+        
+        # 标签输入
+        tags_input = st.text_input(
+            "标签",
+            placeholder="输入标签，用逗号分隔 (例如: 重要, 复习, 考试)",
+            help="为笔记添加多个标签，便于分类和搜索"
+        )
+        tags = [tag.strip() for tag in tags_input.split(",") if tag.strip()]
+        
+        # 实时预览提炼结果
+        if content and len(content.strip()) > 10:
+            with st.expander("🔍 预览提炼结果", expanded=False):
+                extracted = extract_key_content(content)
+                st.markdown("**摘要预览：**")
+                st.info(extracted['summary'])
+                st.markdown("**关键词预览：**")
+                if extracted['keywords']:
+                    keywords_html = format_tags_html(extracted['keywords'], style="preview")
+                    st.markdown(keywords_html, unsafe_allow_html=True)
+        
+        # 添加按钮
+        if st.button("添加笔记", type="primary"):
+            if title and content:
+                note = {
+                    "id": len(st.session_state.notes) + 1,
+                    "title": title,
+                    "category": category,
+                    "content": content,
+                    "tags": tags,
+                    "created_at": datetime.now().strftime(DATETIME_FORMAT),
+                    "updated_at": datetime.now().strftime(DATETIME_FORMAT)
+                }
+                st.session_state.notes.append(note)
+                save_notes()
+                st.success("笔记添加成功！")
+            else:
+                st.warning("请填写标题和内容")
+        
+        st.divider()
+        
+        # 显示所有分类
+        st.subheader("📂 所有分类")
+        for cat in st.session_state.categories:
+            st.markdown(f"- {cat}")
 
-# 5. 主界面 - 笔记展示和搜索
-st.header("📖 我的笔记")
+    # 5. 主界面 - 笔记展示和搜索
+    st.header("📖 我的笔记")
 
-# 搜索和排序区域
-col1, col2, col3, col4, col5 = st.columns([2, 1, 1, 1, 1])
+    # 搜索和排序区域
+    col1, col2, col3, col4, col5 = st.columns([2, 1, 1, 1, 1])
 
-with col1:
-    # 搜索关键词
-    search_query = st.text_input(
-        "🔍 搜索关键词",
-        placeholder="输入关键词...",
-        help="支持模糊搜索"
-    )
+    with col1:
+        # 搜索关键词
+        search_query = st.text_input(
+            "🔍 搜索关键词",
+            placeholder="输入关键词...",
+            help="支持模糊搜索"
+        )
 
-with col2:
-    # 搜索范围选择
-    search_scope = st.selectbox(
-        "搜索范围",
-        ["全部", "仅标题", "仅内容", "仅类型", "仅标签"],
-        help="选择搜索的范围"
-    )
+    with col2:
+        # 搜索范围选择
+        search_scope = st.selectbox(
+            "搜索范围",
+            ["全部", "仅标题", "仅内容", "仅类型", "仅标签"],
+            help="选择搜索的范围"
+        )
 
-with col3:
-    # 分类筛选
-    filter_category = st.selectbox(
-        "筛选分类",
-        ["全部"] + st.session_state.categories,
-        help="按分类筛选笔记"
-    )
-
-with col4:
-    # 标签筛选
-    all_tags = list(set(tag for note in st.session_state.notes for tag in note.get("tags", [])))
-    filter_tag = st.selectbox(
-        "筛选标签",
-        ["全部"] + sorted(all_tags),
-        help="按标签筛选笔记"
-    )
-
-with col5:
-    # 排序方式
-    sort_by = st.selectbox(
-        "排序方式",
-        ["最新", "最旧", "标题A-Z", "标题Z-A", "类型A-Z", "类型Z-A"],
-        help="选择笔记的排序方式"
-    )
-
-# 批量提炼功能
-st.divider()
-col_batch1, col_batch2 = st.columns([3, 1])
-with col_batch1:
-    st.markdown("### ✨ 批量提炼")
-with col_batch2:
-    if st.button("🔄 提炼所有笔记", key="batch_extract"):
-        for note in st.session_state.notes:
-            if len(note['content'].strip()) > 10:
-                extracted = extract_key_content(note['content'])
-                st.session_state[f'extracted_{note["id"]}'] = extracted
-        st.success(f"已提炼 {len(st.session_state.notes)} 条笔记的关键内容！")
-        st.rerun()
-
-# 6. 显示笔记
-if st.session_state.notes:
-    # 筛选和搜索逻辑
-    filtered_notes = []
-    for note in st.session_state.notes:
+    with col3:
         # 分类筛选
-        category_match = filter_category == "全部" or note["category"] == filter_category
-        
+        filter_category = st.selectbox(
+            "筛选分类",
+            ["全部"] + st.session_state.categories,
+            help="按分类筛选笔记"
+        )
+
+    with col4:
         # 标签筛选
-        tag_match = filter_tag == "全部" or filter_tag in note.get("tags", [])
-        
-        # 关键词搜索（根据选择范围）
-        search_match = True
-        if search_query:
-            query = search_query.lower()
-            if search_scope == "全部":
-                search_match = (
-                    query in note["title"].lower() or
-                    query in note["content"].lower() or
-                    query in note["category"].lower() or
-                    any(query in tag.lower() for tag in note.get("tags", []))
-                )
-            elif search_scope == "仅标题":
-                search_match = query in note["title"].lower()
-            elif search_scope == "仅内容":
-                search_match = query in note["content"].lower()
-            elif search_scope == "仅类型":
-                search_match = query in note["category"].lower()
-            elif search_scope == "仅标签":
-                search_match = any(query in tag.lower() for tag in note.get("tags", []))
-        
-        if category_match and tag_match and search_match:
-            filtered_notes.append(note)
-    
-    # 排序逻辑
-    if sort_by == "最新":
-        filtered_notes.sort(key=lambda x: x["created_at"], reverse=True)
-    elif sort_by == "最旧":
-        filtered_notes.sort(key=lambda x: x["created_at"])
-    elif sort_by == "标题A-Z":
-        filtered_notes.sort(key=lambda x: x["title"].lower())
-    elif sort_by == "标题Z-A":
-        filtered_notes.sort(key=lambda x: x["title"].lower(), reverse=True)
-    elif sort_by == "类型A-Z":
-        filtered_notes.sort(key=lambda x: x["category"].lower())
-    elif sort_by == "类型Z-A":
-        filtered_notes.sort(key=lambda x: x["category"].lower(), reverse=True)
+        all_tags = get_all_tags()
+        filter_tag = st.selectbox(
+            "筛选标签",
+            ["全部"] + sorted(all_tags),
+            help="按标签筛选笔记"
+        )
+
+    with col5:
+        # 排序方式
+        sort_by = st.selectbox(
+            "排序方式",
+            ["最新", "最旧", "标题A-Z", "标题Z-A", "类型A-Z", "类型Z-A"],
+            help="选择笔记的排序方式"
+        )
+
+    # 批量提炼功能
+    st.divider()
+    col_batch1, col_batch2 = st.columns([3, 1])
+    with col_batch1:
+        st.markdown("### ✨ 批量提炼")
+    with col_batch2:
+        if st.button("🔄 提炼所有笔记", key="batch_extract"):
+            for note in st.session_state.notes:
+                if len(note['content'].strip()) > 10:
+                    extracted = extract_key_content(note['content'])
+                    st.session_state[f'extracted_{note["id"]}'] = extracted
+            st.success(f"已提炼 {len(st.session_state.notes)} 条笔记的关键内容！")
+            st.rerun()
+
+    # 6. 显示笔记
+if st.session_state.notes:
+    # 使用辅助函数进行筛选和排序
+    filtered_notes = filter_notes(
+        st.session_state.notes,
+        search_query=search_query,
+        search_scope=search_scope,
+        filter_category=filter_category,
+        filter_tag=filter_tag
+    )
+    filtered_notes = sort_notes(filtered_notes, sort_by)
     
     # 显示筛选结果
     if filtered_notes:
@@ -449,7 +621,7 @@ if st.session_state.notes:
                                 note['category'] = edit_category
                                 note['content'] = edit_content
                                 note['tags'] = edit_tags_list
-                                note['updated_at'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                                note['updated_at'] = datetime.now().strftime(DATETIME_FORMAT)
                                 st.session_state.editing_note = None
                                 save_notes()
                                 st.success("笔记已更新！")
@@ -466,7 +638,7 @@ if st.session_state.notes:
                         
                         # 显示标签
                         if note.get("tags"):
-                            tags_html = " ".join([f'<span style="background-color: #e1f5fe; color: #01579b; padding: 2px 8px; border-radius: 4px; margin-right: 5px; font-size: 12px;">{tag}</span>' for tag in note["tags"]])
+                            tags_html = format_tags_html(note["tags"])
                             st.markdown(f"**标签：** {tags_html}", unsafe_allow_html=True)
                         
                         st.markdown(f"**创建时间：** {note['created_at']}")
@@ -487,7 +659,7 @@ if st.session_state.notes:
                                 st.info(extracted['summary'])
                                 st.markdown("**关键词：**")
                                 if extracted['keywords']:
-                                    keywords_html = " ".join([f'<span style="background-color: #fff3e0; color: #e65100; padding: 2px 8px; border-radius: 4px; margin-right: 5px; font-size: 12px;">{kw}</span>' for kw in extracted['keywords']])
+                                    keywords_html = format_tags_html(extracted['keywords'], style="preview")
                                     st.markdown(keywords_html, unsafe_allow_html=True)
                                 else:
                                     st.warning("未找到关键词")
@@ -507,231 +679,393 @@ if st.session_state.notes:
                                 st.session_state.editing_note = None
                                 save_notes()
                                 st.rerun()
+        else:
+            st.info("没有找到匹配的笔记")
     else:
-        st.warning("没有找到匹配的笔记")
-else:
-    st.info("还没有笔记，请在左侧添加您的第一条笔记！")
+        st.info("还没有笔记，请在左侧添加您的第一条笔记！")
 
-# 7. 统计信息
-st.divider()
-st.subheader("📊 统计信息")
+    # 7. 统计信息
+    st.divider()
+    st.subheader("📊 统计信息")
 
-# 笔记和分类统计
-col_stats1, col_stats2 = st.columns(2)
-with col_stats1:
-    st.metric("总笔记数", len(st.session_state.notes))
-with col_stats2:
-    all_tags = list(set(tag for note in st.session_state.notes for tag in note.get("tags", [])))
-    st.metric("总标签数", len(all_tags))
+    # 笔记和分类统计
+    col_stats1, col_stats2 = st.columns(2)
+    with col_stats1:
+        st.metric("总笔记数", len(st.session_state.notes))
+    with col_stats2:
+        all_tags = get_all_tags()
+        st.metric("总标签数", len(all_tags))
 
-# 分类统计
-st.markdown("### 分类统计")
-cat_stat_cols = st.columns(min(5, len(st.session_state.categories)))
-for i, cat in enumerate(st.session_state.categories):
-    if i < len(cat_stat_cols):
-        with cat_stat_cols[i]:
-            count = len([n for n in st.session_state.notes if n["category"] == cat])
-            st.metric(cat, count)
+    # 分类统计
+    st.markdown("### 分类统计")
+    cat_stat_cols = st.columns(min(5, len(st.session_state.categories)))
+    for i, cat in enumerate(st.session_state.categories):
+        if i < len(cat_stat_cols):
+            with cat_stat_cols[i]:
+                count = len([n for n in st.session_state.notes if n["category"] == cat])
+                st.metric(cat, count)
 
-# 标签统计
-if all_tags:
-    st.markdown("### 标签统计")
-    tag_stat_cols = st.columns(min(5, len(all_tags)))
-    for i, tag in enumerate(sorted(all_tags)):
-        if i < len(tag_stat_cols):
-            with tag_stat_cols[i]:
-                count = len([n for n in st.session_state.notes if tag in n.get("tags", [])])
-                st.metric(tag, count)
+    # 标签统计
+    if all_tags:
+        st.markdown("### 标签统计")
+        tag_stat_cols = st.columns(min(5, len(all_tags)))
+        for i, tag in enumerate(sorted(all_tags)):
+            if i < len(tag_stat_cols):
+                with tag_stat_cols[i]:
+                    count = len([n for n in st.session_state.notes if tag in n.get("tags", [])])
+                    st.metric(tag, count)
 
-# 8. 数据管理
-st.divider()
-st.subheader("💾 数据管理")
+    # 8. 数据管理
+    st.divider()
+    st.subheader("💾 数据管理")
 
-# 导入JSON文件
-st.markdown("### 📥 导入笔记")
-tab_json, tab_txt = st.tabs(["JSON文件", "文本文件"])
+    # 导入JSON文件
+    st.markdown("### 📥 导入笔记")
+    tab_json, tab_txt = st.tabs(["JSON文件", "文本文件"])
 
-with tab_json:
-    uploaded_file = st.file_uploader("选择JSON文件", type=['json'], help="选择之前导出的JSON文件", key="json_uploader")
+    with tab_json:
+        uploaded_file = st.file_uploader("选择JSON文件", type=['json'], help="选择之前导出的JSON文件", key="json_uploader")
 
-    if uploaded_file is not None:
-        try:
-            # 读取并解析JSON文件
-            import_data = json.load(uploaded_file)
-            
-            # 显示导入预览
-            st.info(f"文件包含 {len(import_data.get('notes', []))} 条笔记")
-            
-            # 显示笔记列表预览
-            with st.expander("📋 查看文件内容", expanded=False):
-                for i, note in enumerate(import_data.get('notes', [])[:5]):
-                    st.markdown(f"**{i+1}. {note.get('title', '无标题')}**")
-                    st.markdown(f"   分类: {note.get('category', '未知')}")
-                    st.markdown(f"   时间: {note.get('created_at', '未知')}")
-                    st.markdown("---")
+        if uploaded_file is not None:
+            try:
+                # 读取并解析JSON文件
+                import_data = json.load(uploaded_file)
                 
-                if len(import_data.get('notes', [])) > 5:
-                    st.info(f"还有 {len(import_data.get('notes', [])) - 5} 条笔记...")
+                # 显示导入预览
+                st.info(f"文件包含 {len(import_data.get('notes', []))} 条笔记")
+                
+                # 显示笔记列表预览
+                with st.expander("📋 查看文件内容", expanded=False):
+                    for i, note in enumerate(import_data.get('notes', [])[:5]):
+                        st.markdown(f"**{i+1}. {note.get('title', '无标题')}**")
+                        st.markdown(f"   分类: {note.get('category', '未知')}")
+                        st.markdown(f"   时间: {note.get('created_at', '未知')}")
+                        st.markdown("---")
+                    
+                    if len(import_data.get('notes', [])) > 5:
+                        st.info(f"还有 {len(import_data.get('notes', [])) - 5} 条笔记...")
+                
+                # 导入选项
+                col_merge, col_replace = st.columns(2)
+                with col_merge:
+                    if st.button("🔄 合并导入", type="primary", key="merge_json"):
+                        # 合并导入：保留现有笔记，添加新笔记
+                        new_notes = import_data.get('notes', [])
+                        for note in new_notes:
+                            note['id'] = len(st.session_state.notes) + 1
+                            st.session_state.notes.append(note)
+                        
+                        # 合并分类
+                        new_categories = import_data.get('categories', [])
+                        for cat in new_categories:
+                            if cat not in st.session_state.categories:
+                                st.session_state.categories.append(cat)
+                        
+                        save_notes()
+                        st.success(f"成功导入 {len(new_notes)} 条笔记！")
+                        st.rerun()
+                
+                with col_replace:
+                    if st.button("⚠️ 替换导入", key="replace_json"):
+                        # 替换导入：清空现有笔记，导入新笔记
+                        st.session_state.notes = import_data.get('notes', [])
+                        st.session_state.categories = import_data.get('categories', ["编程", "数学", "英语", "其他"])
+                        st.session_state.editing_note = None
+                        save_notes()
+                        st.success(f"成功替换为 {len(st.session_state.notes)} 条笔记！")
+                        st.rerun()
             
-            # 导入选项
-            col_merge, col_replace = st.columns(2)
-            with col_merge:
-                if st.button("🔄 合并导入", type="primary", key="merge_json"):
-                    # 合并导入：保留现有笔记，添加新笔记
-                    new_notes = import_data.get('notes', [])
-                    for note in new_notes:
-                        note['id'] = len(st.session_state.notes) + 1
-                        st.session_state.notes.append(note)
-                    
-                    # 合并分类
-                    new_categories = import_data.get('categories', [])
-                    for cat in new_categories:
-                        if cat not in st.session_state.categories:
-                            st.session_state.categories.append(cat)
-                    
+            except Exception as e:
+                st.error(f"文件解析失败: {str(e)}")
+
+    with tab_txt:
+        # 导入文本文件
+        txt_file = st.file_uploader("选择文本文件", type=['txt'], help="选择要导入的文本文件", key="txt_uploader")
+        
+        if txt_file is not None:
+            try:
+                # 读取文本文件内容
+                content = txt_file.read().decode('utf-8')
+                
+                # 显示文件内容预览
+                st.info(f"文件大小: {len(content)} 字符")
+                with st.expander("📋 查看文件内容", expanded=False):
+                    st.text(content[:1000])
+                    if len(content) > 1000:
+                        st.info(f"还有 {len(content) - 1000} 个字符...")
+                
+                # 设置导入参数
+                col_title, col_cat = st.columns(2)
+                with col_title:
+                    import_title = st.text_input("笔记标题", value=txt_file.name.replace('.txt', ''), help="为导入的笔记设置标题")
+                with col_cat:
+                    import_category = st.selectbox("笔记分类", st.session_state.categories)
+                
+                # 导入按钮
+                if st.button("📥 导入文本文件", type="primary"):
+                    note = {
+                        "id": len(st.session_state.notes) + 1,
+                        "title": import_title,
+                        "category": import_category,
+                        "content": content,
+                        "created_at": datetime.now().strftime(DATETIME_FORMAT),
+                        "updated_at": datetime.now().strftime(DATETIME_FORMAT)
+                    }
+                    st.session_state.notes.append(note)
                     save_notes()
-                    st.success(f"成功导入 {len(new_notes)} 条笔记！")
+                    st.success(f"成功导入笔记：{import_title}")
                     st.rerun()
             
-            with col_replace:
-                if st.button("⚠️ 替换导入", key="replace_json"):
-                    # 替换导入：清空现有笔记，导入新笔记
-                    st.session_state.notes = import_data.get('notes', [])
-                    st.session_state.categories = import_data.get('categories', ["编程", "数学", "英语", "其他"])
-                    st.session_state.editing_note = None
-                    save_notes()
-                    st.success(f"成功替换为 {len(st.session_state.notes)} 条笔记！")
-                    st.rerun()
-        
-        except Exception as e:
-            st.error(f"文件解析失败: {str(e)}")
+            except Exception as e:
+                st.error(f"文件读取失败: {str(e)}")
 
-with tab_txt:
-    # 导入文本文件
-    txt_file = st.file_uploader("选择文本文件", type=['txt'], help="选择要导入的文本文件", key="txt_uploader")
-    
-    if txt_file is not None:
-        try:
-            # 读取文本文件内容
-            content = txt_file.read().decode('utf-8')
-            
-            # 显示文件内容预览
-            st.info(f"文件大小: {len(content)} 字符")
-            with st.expander("📋 查看文件内容", expanded=False):
-                st.text(content[:1000])
-                if len(content) > 1000:
-                    st.info(f"还有 {len(content) - 1000} 个字符...")
-            
-            # 设置导入参数
-            col_title, col_cat = st.columns(2)
-            with col_title:
-                import_title = st.text_input("笔记标题", value=txt_file.name.replace('.txt', ''), help="为导入的笔记设置标题")
-            with col_cat:
-                import_category = st.selectbox("笔记分类", st.session_state.categories)
-            
-            # 导入按钮
-            if st.button("📥 导入文本文件", type="primary"):
-                note = {
-                    "id": len(st.session_state.notes) + 1,
-                    "title": import_title,
-                    "category": import_category,
-                    "content": content,
-                    "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                    "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                }
-                st.session_state.notes.append(note)
-                save_notes()
-                st.success(f"成功导入笔记：{import_title}")
-                st.rerun()
-        
-        except Exception as e:
-            st.error(f"文件读取失败: {str(e)}")
+    st.divider()
 
-st.divider()
+    # 导出功能
+    st.markdown("### 📤 导出笔记")
+    export_tab_json, export_tab_txt = st.tabs(["JSON格式", "文本格式"])
 
-# 导出功能
-st.markdown("### 📤 导出笔记")
-export_tab_json, export_tab_txt = st.tabs(["JSON格式", "文本格式"])
-
-with export_tab_json:
-    if st.button("📤 导出为JSON", key="export_json"):
-        st.download_button(
-            label="下载 JSON 文件",
-            data=json.dumps({"notes": st.session_state.notes, "categories": st.session_state.categories}, ensure_ascii=False, indent=2),
-            file_name=f"notes_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
-            mime="application/json"
-        )
-
-with export_tab_txt:
-    # 导出选项
-    export_option = st.radio("导出选项", ["导出所有笔记", "导出单个笔记"])
-    
-    if export_option == "导出所有笔记":
-        if st.button("📤 导出所有笔记为文本", type="primary", key="export_all_txt"):
-            # 合并所有笔记为一个文本文件
-            all_content = "=" * 50 + "\n"
-            all_content += f"学习笔记备份 - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
-            all_content += "=" * 50 + "\n\n"
-            
-            for note in st.session_state.notes:
-                all_content += "-" * 40 + "\n"
-                all_content += f"标题: {note['title']}\n"
-                all_content += f"分类: {note['category']}\n"
-                all_content += f"创建时间: {note['created_at']}\n"
-                all_content += "-" * 40 + "\n\n"
-                all_content += note['content'] + "\n\n"
-            
+    with export_tab_json:
+        if st.button("📤 导出为JSON", key="export_json"):
             st.download_button(
-                label="下载文本文件",
-                data=all_content,
-                file_name=f"notes_all_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
-                mime="text/plain"
+                label="下载 JSON 文件",
+                data=json.dumps({"notes": st.session_state.notes, "categories": st.session_state.categories}, ensure_ascii=False, indent=2),
+                file_name=f"notes_backup_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json",
+                mime="application/json"
             )
-    
-    else:
-        # 导出单个笔记
-        if st.session_state.notes:
-            note_titles = [f"{note['id']}. {note['title']}" for note in st.session_state.notes]
-            selected_note = st.selectbox("选择要导出的笔记", note_titles)
-            
-            if st.button("📤 导出选中笔记", type="primary", key="export_single_txt"):
-                # 找到选中的笔记
-                note_id = int(selected_note.split('.')[0])
-                note = next((n for n in st.session_state.notes if n['id'] == note_id), None)
+
+    with export_tab_txt:
+        # 导出选项
+        export_option = st.radio("导出选项", ["导出所有笔记", "导出单个笔记"])
+        
+        if export_option == "导出所有笔记":
+            if st.button("📤 导出所有笔记为文本", type="primary", key="export_all_txt"):
+                # 合并所有笔记为一个文本文件
+                all_content = "=" * 50 + "\n"
+                all_content += f"学习笔记备份 - {datetime.now().strftime(DATETIME_FORMAT)}\n"
+                all_content += "=" * 50 + "\n\n"
                 
-                if note:
-                    # 格式化笔记内容
-                    note_content = "=" * 50 + "\n"
-                    note_content += f"标题: {note['title']}\n"
-                    note_content += f"分类: {note['category']}\n"
-                    note_content += f"创建时间: {note['created_at']}\n"
-                    if 'updated_at' in note:
-                        note_content += f"更新时间: {note['updated_at']}\n"
-                    note_content += "=" * 50 + "\n\n"
-                    note_content += note['content']
+                for note in st.session_state.notes:
+                    all_content += "-" * 40 + "\n"
+                    all_content += f"标题: {note['title']}\n"
+                    all_content += f"分类: {note['category']}\n"
+                    all_content += f"创建时间: {note['created_at']}\n"
+                    all_content += "-" * 40 + "\n\n"
+                    all_content += note['content'] + "\n\n"
+                
+                st.download_button(
+                    label="下载文本文件",
+                    data=all_content,
+                    file_name=f"notes_all_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
+                    mime="text/plain"
+                )
+        
+        else:
+            # 导出单个笔记
+            if st.session_state.notes:
+                note_titles = [f"{note['id']}. {note['title']}" for note in st.session_state.notes]
+                selected_note = st.selectbox("选择要导出的笔记", note_titles)
+                
+                if st.button("📤 导出选中笔记", type="primary", key="export_single_txt"):
+                    # 找到选中的笔记
+                    note_id = int(selected_note.split('.')[0])
+                    note = next((n for n in st.session_state.notes if n['id'] == note_id), None)
                     
-                    st.download_button(
-                        label="下载文本文件",
-                        data=note_content,
-                        file_name=f"note_{note['id']}_{note['title']}.txt",
-                        mime="text/plain"
-                    )
-        else:
-            st.info("没有笔记可导出")
+                    if note:
+                        # 格式化笔记内容
+                        note_content = "=" * 50 + "\n"
+                        note_content += f"标题: {note['title']}\n"
+                        note_content += f"分类: {note['category']}\n"
+                        note_content += f"创建时间: {note['created_at']}\n"
+                        if 'updated_at' in note:
+                            note_content += f"更新时间: {note['updated_at']}\n"
+                        note_content += "=" * 50 + "\n\n"
+                        note_content += note['content']
+                        
+                        st.download_button(
+                            label="下载文本文件",
+                            data=note_content,
+                            file_name=f"note_{note['id']}_{note['title']}.txt",
+                            mime="text/plain"
+                        )
+            else:
+                st.info("没有笔记可导出")
 
-st.divider()
+    st.divider()
 
-# 清空功能
-col_clear = st.columns(1)[0]
-with col_clear:
-    if st.button("🗑️ 清空所有笔记"):
-        if st.session_state.notes:
-            st.warning("⚠️ 此操作不可恢复！")
-            if st.button("确认清空"):
-                st.session_state.notes = []
-                st.session_state.editing_note = None
-                save_notes()
-                st.success("所有笔记已清空！")
-                st.rerun()
+    # 清空功能
+    col_clear = st.columns(1)[0]
+    with col_clear:
+        if not st.session_state.confirm_clear:
+            if st.button("🗑️ 清空所有笔记"):
+                if st.session_state.notes:
+                    st.session_state.confirm_clear = True
+                    st.rerun()
+                else:
+                    st.info("没有笔记可清空")
         else:
-            st.info("没有笔记可清空")
+            st.warning("⚠️ 确定要清空所有笔记吗？此操作不可恢复！")
+            col_confirm, col_cancel_clear = st.columns(2)
+            with col_confirm:
+                if st.button("✅ 确认清空", type="primary"):
+                    st.session_state.notes = []
+                    st.session_state.editing_note = None
+                    st.session_state.confirm_clear = False
+                    save_notes()
+                    st.success("所有笔记已清空！")
+                    st.rerun()
+            with col_cancel_clear:
+                if st.button("❌ 取消"):
+                    st.session_state.confirm_clear = False
+                    st.rerun()
+
+# AI学习报告标签页
+with tab_report:
+    st.header("🤖 AI学习报告")
+    st.markdown("根据您的笔记生成个性化的学习报告和建议")
+    
+    # 筛选选项
+    st.divider()
+    st.subheader("📊 筛选笔记")
+    
+    col_report1, col_report2, col_report3 = st.columns(3)
+    
+    with col_report1:
+        # 分类筛选
+        report_category = st.selectbox(
+            "筛选分类",
+            ["全部"] + st.session_state.categories,
+            help="选择要分析的分类"
+        )
+    
+    with col_report2:
+        # 标签筛选
+        all_tags = get_all_tags()
+        report_tag = st.selectbox(
+            "筛选标签",
+            ["全部"] + sorted(all_tags),
+            help="选择要分析的标签"
+        )
+    
+    with col_report3:
+        # 时间范围筛选
+        report_time_range = st.selectbox(
+            "时间范围",
+            ["全部时间", "最近7天", "最近30天", "最近90天"],
+            help="选择分析的时间范围"
+        )
+    
+    # 生成报告按钮
+    st.divider()
+    if st.button("🚀 生成学习报告", type="primary"):
+        # 筛选笔记
+        filtered_notes = []
+        for note in st.session_state.notes:
+            # 分类筛选
+            category_match = report_category == "全部" or note["category"] == report_category
+            
+            # 标签筛选
+            tag_match = report_tag == "全部" or report_tag in note.get("tags", [])
+            
+            # 时间筛选
+            time_match = True
+            if report_time_range != "全部时间":
+                try:
+                    note_date = datetime.strptime(note["created_at"], DATETIME_FORMAT)
+                    now = datetime.now()
+                    if report_time_range == "最近7天":
+                        time_match = (now - note_date).days <= 7
+                    elif report_time_range == "最近30天":
+                        time_match = (now - note_date).days <= 30
+                    elif report_time_range == "最近90天":
+                        time_match = (now - note_date).days <= 90
+                except Exception as e:
+                    time_match = True
+            
+            if category_match and tag_match and time_match:
+                filtered_notes.append(note)
+        
+        # 生成报告
+        if filtered_notes:
+            report = generate_study_report(filtered_notes)
+            
+            # 显示报告
+            st.success(f"✅ 基于筛选后的 {len(filtered_notes)} 条笔记生成报告")
+            
+            # 总览部分
+            st.divider()
+            st.subheader("📈 学习总览")
+            col_overview1, col_overview2, col_overview3 = st.columns(3)
+            with col_overview1:
+                st.metric("笔记总数", report["总览"]["笔记总数"])
+            with col_overview2:
+                st.metric("总字数", report["总览"]["总字数"])
+            with col_overview3:
+                st.metric("平均字数", report["总览"]["平均每条笔记字数"])
+            
+            # 分类统计
+            if report["分类统计"]:
+                st.divider()
+                st.subheader("📂 分类分布")
+                cat_cols = st.columns(min(4, len(report["分类统计"])))
+                for i, (cat, count) in enumerate(report["分类统计"].items()):
+                    if i < len(cat_cols):
+                        with cat_cols[i]:
+                            st.metric(cat, count)
+            
+            # 热门标签
+            if report["热门标签"]:
+                st.divider()
+                st.subheader("🏷️ 热门标签")
+                tag_cols = st.columns(min(5, len(report["热门标签"])))
+                for i, (tag, count) in enumerate(report["热门标签"]):
+                    if i < len(tag_cols):
+                        with tag_cols[i]:
+                            st.metric(tag, count)
+            
+            # 学习建议
+            if report["学习建议"]:
+                st.divider()
+                st.subheader("💡 AI学习建议")
+                for i, suggestion in enumerate(report["学习建议"], 1):
+                    st.info(f"{i}. {suggestion}")
+            
+            # 导出报告
+            st.divider()
+            if st.button("📥 导出报告"):
+                report_text = "=" * 60 + "\n"
+                report_text += "AI学习报告\n"
+                report_text += f"生成时间: {report['生成时间']}\n"
+                report_text += "=" * 60 + "\n\n"
+                
+                report_text += "【学习总览】\n"
+                report_text += f"笔记总数: {report['总览']['笔记总数']}\n"
+                report_text += f"分类数量: {report['总览']['分类数量']}\n"
+                report_text += f"标签总数: {report['总览']['标签总数']}\n"
+                report_text += f"总字数: {report['总览']['总字数']}\n"
+                report_text += f"平均每条笔记字数: {report['总览']['平均每条笔记字数']}\n\n"
+                
+                report_text += "【分类统计】\n"
+                for cat, count in report["分类统计"].items():
+                    report_text += f"{cat}: {count}条\n"
+                report_text += "\n"
+                
+                report_text += "【热门标签】\n"
+                for tag, count in report["热门标签"]:
+                    report_text += f"{tag}: {count}次\n"
+                report_text += "\n"
+                
+                report_text += "【AI学习建议】\n"
+                for i, suggestion in enumerate(report["学习建议"], 1):
+                    report_text += f"{i}. {suggestion}\n"
+                
+                st.download_button(
+                    label="下载学习报告",
+                    data=report_text,
+                    file_name=f"study_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.txt",
+                    mime="text/plain"
+                )
+        else:
+            st.warning("⚠️ 没有找到符合条件的笔记，请调整筛选条件")
+    else:
+        st.info("👆 请选择筛选条件后点击生成报告按钮")
diff --git a/notes_data.json b/notes_data.json
index edca3e7..046e444 100644
--- a/notes_data.json
+++ b/notes_data.json
@@ -104,7 +104,13 @@
       "content": "中国古典诗词是中华文化的瑰宝，承载着数千年的历史与智慧。从《诗经》的质朴纯真，到唐诗的辉煌灿烂，再到宋词的婉约豪放，诗词艺术在中国文学史上占据着极其重要的地位。\n\n诗歌的起源可以追溯到远古时期，先民们在劳动和生活中创造了最初的歌谣。这些歌谣经过长期的传承和演变，逐渐形成了具有固定格式的诗歌。《诗经》是中国最早的诗歌总集，收录了从西周初期到春秋中叶的305篇诗歌，分为风、雅、颂三个部分。《诗经》中的诗歌以四言为主，运用了赋、比、兴的表现手法，开创了中国诗歌的现实主义传统。\n\n汉代乐府诗继承了《诗经》的现实主义精神，反映了当时的社会生活和人民的思想感情。《古诗十九首》是汉代文人五言诗的代表作，语言质朴自然，情感真挚深沉，被誉为\"五言之冠冕\"。这些诗歌为后来诗歌的发展奠定了坚实的基础。\n\n唐代是中国诗歌发展的黄金时代，涌现出了李白、杜甫、白居易等一大批杰出的诗人。李白的诗歌豪放飘逸，想象奇特，充满了浪漫主义色彩。他的《将进酒》\"君不见黄河之水天上来，奔流到海不复回\"气势磅礴，展现了他豪迈不羁的性格。杜甫的诗歌沉郁顿挫，关注民生疾苦，被称为\"诗圣\"。他的《春望》\"国破山河在，城春草木深\"表达了对国家命运的忧虑。白居易的诗歌通俗易懂，关注社会现实，他的《长恨歌》\"在天愿作比翼鸟，在地愿为连理枝\"传唱千古。\n\n宋词是中国诗歌的另一种重要形式，分为豪放派和婉约派两大流派。苏轼是豪放派的代表人物，他的词作气势磅礴，意境开阔。他的《念奴娇·赤壁怀古》\"大江东去，浪淘尽，千古风流人物\"展现了豪迈的气概。李清照是婉约派的代表人物，她的词作细腻婉约，情感真挚。她的《声声慢》\"寻寻觅觅，冷冷清清，凄凄惨惨戚戚\"表达了她内心的愁苦。\n\n中国古典诗词的艺术特色主要体现在以下几个方面：一是意境深远，诗人通过生动的意象和精妙的语言，营造出深远的艺术境界；二是语言精炼，诗词要求字斟句酌，每一个字都要发挥最大的表现力；三是韵律优美，诗词讲究平仄和对仗，读起来朗朗上口；四是情感真挚，诗人将自己的真情实感融入诗中，使读者产生共鸣。\n\n诗歌的创作技巧丰富多彩，包括比喻、拟人、夸张、对偶、排比等多种修辞手法。比喻可以使抽象的事物变得具体形象，如\"问君能有几多愁，恰似一江春水向东流\"。拟人可以使事物具有人的情感和动作，如\"感时花溅泪，恨别鸟惊心\"。夸张可以突出事物的特征，如\"飞流直下三千尺，疑是银河落九天\"。对偶可以使诗歌更加工整优美，如\"两个黄鹂鸣翠柳，一行白鹭上青天\"。\n\n中国古典诗词蕴含着深刻的思想内涵。许多诗歌表达了诗人对国家和人民的关怀，如杜甫的\"安得广厦千万间，大庇天下寒士俱欢颜\"。有些诗歌表达了诗人对人生的感悟，如苏轼的\"人有悲欢离合，月有阴晴圆缺，此事古难全\"。还有些诗歌表达了诗人对自然的热爱，如王维的\"空山新雨后，天气晚来秋\"。\n\n学习古典诗词，不仅可以提高我们的文学素养，还可以陶冶我们的情操，丰富我们的精神世界。通过阅读和欣赏古典诗词，我们可以感受到古人的智慧和情感，体会到中华文化的博大精深。古典诗词是我们民族的精神财富，值得我们认真学习和传承。\n\n在现代社会，古典诗词依然具有重要的意义。它可以帮助我们更好地理解传统文化，增强文化自信。它可以提高我们的审美能力和语言表达能力。它还可以帮助我们缓解压力，陶冶情操。因此，我们应该重视古典诗词的学习和传承，让这一优秀的文化遗产在新时代焕发出新的光彩。",
       "created_at": "2026-01-08 16:00:00",
       "updated_at": "2026-01-08 16:00:00",
-      "tags": ["诗词", "文学", "文化", "艺术", "经典"]
+      "tags": [
+        "诗词",
+        "文学",
+        "文化",
+        "艺术",
+        "经典"
+      ]
     }
   ],
   "categories": [
@@ -112,6 +118,7 @@
     "数学",
     "英语",
     "其他",
-    "语文"
+    "语文",
+    "1"
   ]
 }
\ No newline at end of file